gen.rb

require 'stupidedi'
require 'nokogiri'
require 'pp'

class Gen
  def run(name, guide)

    builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
      xml['medi'].edimap("xmlns:medi" => "http://www.milyn.org/schema/edi-message-mapping-1.6.xsd") {
        xml['medi'].description('name' => guide.name, 'version' => 1.0)
        xml['medi'].delimiters('segment' => '~', 'field' => "*", 'component' => ":", 'sub-component' => "")

        xml['medi'].segments('xmltag' => 'edi', 'name' => "#{guide.functional_group}#{guide.id}", 'ignoreUnmappedSegments' => true) {
          xml['medi'].segmentGroup('xmltag' => 'transaction', 'minOccurs' => 1, 'maxOccurs' => -1) {
            guide.table_defs.each do |table_def|
              do_table_def(xml, table_def)
            end
          }
        }
      }
    end

    xml = builder.to_xml(indent: 4)

    File.open("src/main/resources/#{name}.xml", 'w') do |file|
      file.write xml
    end
  end

  private

  def do_table_def(xml, table_def)
    table_def.header_segment_uses.each do |header_segment_use|
      do_segment_use(xml, header_segment_use)
    end

    table_def.loop_defs.each do |loop_def|
      do_loop_def(xml, loop_def)
    end
  end

  def do_segment_use(xml, segment_use)
    if segment_use.definition.element_uses.size > 0 && (segment_use.definition.element_uses[0].methods.include? :allowed_values)
      p segment_use.definition.id.to_s
      p segment_use.definition.element_uses[0].definition.id.to_s
      p segment_use.definition.element_uses[0].allowed_values
      p "==="
    end

    xml['medi'].segment('segcode' => segment_use.definition.id.to_s,
                        'xmltag' => segment_use.definition.id.to_s.downcase,
                        'name' => segment_use.definition.name,
                        'description' => segment_use.definition.purpose,
                        'truncatable' => true,
                        'ignoreUnmappedFields' => true,
                        'minOccurs' => segment_use.requirement.required? ? 1 : 0,
                        'maxOccurs' => segment_use.repeat_count.inspect == '>1' ? -1 : segment_use.repeat_count.inspect) do
      segment_use.definition.element_uses.each do |element_use|
        do_element_use(xml, element_use)
      end
    end
  end

  def do_loop_def(xml, loop_def)

    xml['medi'].segmentGroup('xmltag' => loop_def.id.gsub(' ', '-').downcase,
                             'minOccurs' => loop_def.requirement.required? ? 1 : 0,
                             'maxOccurs' => loop_def.repeat_count.inspect == '>1' ? -1 : loop_def.repeat_count.inspect) {
      loop_def.header_segment_uses.each do |header_segment_use|
        do_segment_use(xml, header_segment_use)
      end

      loop_def.loop_defs.each do |l|
        do_loop_def(xml, l)
      end
    }
  end

  def get_type(n)
    r = n.class.name.split('::').last

    case r
    when 'DT'
      'Date'
    when 'R'
      'Float'
    when 'AN'
      'String'
    when 'ID'
      'String'
    #when 'TM'
    when 'Nn'
      'Integer'
    else
      'String'
    end
  end

  def format_type(n)
    r = n.class.name.split('::').last
    return 'format=yyyyMMdd' if r == 'DT'
    nil
  end

  def do_element_use(xml, element_use)

    if element_use.definition.composite?

      xml['medi'].field('xmltag' => element_use.definition.id,
                        'name' => element_use.definition.name,
                        'required' => element_use.requirement.required?,
                        'truncatable' => true) {
        element_use.definition.component_uses.each do |component_use|

          type = get_type(component_use.definition)
          typef = format_type(component_use.definition)

          xml['medi'].component('xmltag' => component_use.definition.id,
                                'name' => component_use.definition.name,
                                'required' => component_use.requirement.required?,
                                'minLength' => component_use.definition.min_length,
                                'maxLength' => component_use.definition.max_length,
                                'dataType' => type,
                                'dataTypeParameters' => typef)
        end
      }
      return
    end

    type = get_type(element_use.definition)
    typef = format_type(element_use.definition)

    xml['medi'].field('xmltag' => element_use.definition.id,
                      'name' => element_use.definition.name,
                      'required' => element_use.requirement.required?,
                      'minLength' => element_use.definition.min_length,
                      'maxLength' => element_use.definition.max_length,
                      'dataType' => type,
                      'dataTypeParameters' => typef)
  end
end

klasses = [
  #[ "004010", "HP", "835", Stupidedi::Versions::FunctionalGroups::FortyTen::TransactionSetDefs::HP835 ],
  #[ "005010", "HN", "277", Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HN277 ],
  #[ "005010", "HP", "835", Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HP835 ],
  #[ "005010", "HC", "837", Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HC837 ],
  #[ "005010", "FA", "999", Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::FA999 ],

  [ "004010X091A1", "HP", "835", Stupidedi::Guides::FortyTen::X091A1::HP835 ],
  [ "005010X214",   "HN", "277", Stupidedi::Guides::FiftyTen::X214::HN277 ],
  [ "005010X221",   "HP", "835", Stupidedi::Guides::FiftyTen::X221::HP835 ],
  [ "005010X222",   "HC", "837", Stupidedi::Guides::FiftyTen::X222::HC837P ],
  [ "005010X231",   "FA", "999", Stupidedi::Guides::FiftyTen::X231::FA999 ],
  [ "005010X221A1", "HP", "835", Stupidedi::Guides::FiftyTen::X221A1::HP835 ],
  [ "005010X222A1", "HC", "837", Stupidedi::Guides::FiftyTen::X222A1::HC837P ],
  [ "005010X231A1", "FA", "999", Stupidedi::Guides::FiftyTen::X231A1::FA999 ],

  #[ "004010", "PO", "850", Stupidedi::Contrib::FortyTen::Guides::PO850 ],
  #[ "004010", "OW", "940", Stupidedi::Contrib::FortyTen::Guides::OW940 ],
  #[ "004010", "AR", "943", Stupidedi::Contrib::FortyTen::Guides::AR943 ],
  #[ "004010", "RE", "944", Stupidedi::Contrib::FortyTen::Guides::RE944 ],
  #[ "004010", "SW", "945", Stupidedi::Contrib::FortyTen::Guides::SW945 ],
  #[ "004010", "SM", "204", Stupidedi::Contrib::FortyTen::Guides::SM204 ],
  #[ "004010", "QM", "214", Stupidedi::Contrib::FortyTen::Guides::QM214 ],
  #[ "004010", "GF", "990", Stupidedi::Contrib::FortyTen::Guides::GF990 ],
  #[ "004010", "SS", "862", Stupidedi::Contrib::FortyTen::Guides::SS862 ],
  #[ "004010", "PS", "830", Stupidedi::Contrib::FortyTen::Guides::PS830 ],
  #[ "004010", "SH", "856", Stupidedi::Contrib::FortyTen::Guides::SH856 ],
  #[ "004010", "SQ", "866", Stupidedi::Contrib::FortyTen::Guides::SQ866 ],
  #[ "004010", "FA", "997", Stupidedi::Contrib::FortyTen::Guides::FA997 ],
  #[ "004010", "SC", "832", Stupidedi::Contrib::FortyTen::Guides::SC832 ],

  #[ "002001", "SH", "856", Stupidedi::Contrib::TwoThousandOne::Guides::SH856 ],
  #[ "002001", "PO", "830", Stupidedi::Contrib::TwoThousandOne::Guides::PO830 ],
  #[ "002001", "FA", "997", Stupidedi::Contrib::TwoThousandOne::Guides::FA997 ],

  #[ "003010", "RA", "820", Stupidedi::Contrib::ThirtyTen::Guides::RA820 ],
  #[ "003010", "PO", "850", Stupidedi::Contrib::ThirtyTen::Guides::PO850 ],
  #[ "003010", "PC", "860", Stupidedi::Contrib::ThirtyTen::Guides::PC860 ],
  #[ "003010", "PS", "830", Stupidedi::Contrib::ThirtyTen::Guides::PS830 ],

  #[ "003040", "WA", "142", Stupidedi::Contrib::ThirtyForty::Guides::WA142 ],

  #[ "003050", "PO", "850", Stupidedi::Contrib::ThirtyFifty::Guides::PO850 ],
]

klasses.each do |klass|
  gen = Gen.new
  gen.run("#{klass[0]}#{klass[2]}", klass[3])
end

#Stupidedi::Config.hipaa.transaction_set.instance_variable_get(:@table).each do |key, value|
  #gen = Gen.new
  #gen.run(key, value.call.class)
  #exit
#end

#Stupidedi::Config.contrib.transaction_set.instance_variable_get(:@table).each do |key, value|
#  pp key
#  gen = Gen.new
#  gen.run(key, value.call)
#end


#p Stupidedi::Guides