tediparse 2.0.0

data/lib/stupidedi/schema/generation/interchange_generator.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Generates an interchange (ISA/IEA envelope) file. Detects the component
+      # separator from ISA element positions and whether the release supports a
+      # repetition separator (I65 in ISA11), and emits replace_separators.
+      class InterchangeGenerator
+        include Support
+
+        WORDS = {
+          "0" => "Oh",  "1" => "One", "2" => "Two",   "3" => "Three", "4" => "Four",
+          "5" => "Five", "6" => "Six", "7" => "Seven", "8" => "Eight", "9" => "Nine"
+        }.freeze
+
+        def initialize(release, namespace: "Edi")
+          @release = release
+          @namespace = namespace
+        end
+
+        def generate
+          validate_release!
+          build_ruby_content
+        end
+
+        def output_path
+          "#{namespace_path}/interchanges/#{interchange_file_name}.rb"
+        end
+
+        private
+
+        attr_reader :release
+
+        def release_code
+          release.code
+        end
+
+        # Convert "00401" -> "FourOhOne", "00406" -> "FourOhSix", "00501" -> "FiveOhOne"
+        # Ignore leading zeros, then convert remaining digits to words.
+        def interchange_module_name
+          significant = interchange_version_code.sub(/^0+/, "")
+          significant.chars.map { |d| WORDS[d] }.join
+        end
+
+        # Convert "FourOhOne" -> "four_oh_one"
+        def interchange_file_name
+          underscore(interchange_module_name)
+        end
+
+        def isa_segment
+          @isa_segment ||= release.segments.find { |s| s.code == "ISA" } ||
+            raise(ArgumentError, "Release #{release_code} has no ISA segment")
+        end
+
+        def has_repetition_separator?
+          position_11_use = isa_segment.element_uses.find { |eu| eu.position == 11 }
+          return false unless position_11_use
+
+          position_11_use.element.code == "I65"
+        end
+
+        def separators_method
+          if has_repetition_separator?
+            "Stupidedi::Reader::Separators.new(isa.element(16).to_s, isa.element(11).to_s, nil, nil)"
+          else
+            "Stupidedi::Reader::Separators.new(isa.element(16).to_s, nil, nil, nil)"
+          end
+        end
+
+        def replace_separators_method
+          isa_element_count = isa_segment.element_uses.size
+          rewrite_repetition = has_repetition_separator?
+
+          element_refs = (1..isa_element_count).map do |i|
+            suffix =
+              if i == isa_element_count
+                # Last element (ISA16) carries the component separator.
+                ".copy(:value => separators.component)]"
+              elsif rewrite_repetition && i == 11
+                # ISA11 carries the repetition separator on releases that use one
+                # (I65), matching the reference spec/support/synthetic envelope.
+                ".copy(:value => separators.repetition),"
+              else
+                ","
+              end
+
+            "               isa.element(#{i})#{suffix}"
+          end
+
+          <<~RUBY.strip
+            # @return [SegmentVal]
+                    def replace_separators(isa, separators)
+                      isa.copy \\
+                        :separators => separators,
+                        :children   =>
+                          [#{element_refs.first.strip}
+            #{element_refs[1..].join("\n")}
+                    end
+          RUBY
+        end
+
+        def build_ruby_content
+          <<~RUBY
+            # frozen_string_literal: true
+            require "tediparse"
+
+            module #{namespace}
+              module Interchanges
+                module #{interchange_module_name}
+                  s = Stupidedi::Schema
+                  r = #{namespace}::#{version_module}::ElementReqs
+                  sd = #{namespace}::#{version_module}::SegmentDefs
+
+                  InterchangeDef = Class.new(s::InterchangeDef) do
+                    # @return [Values::InterchangeVal]
+                    def empty(separators)
+                      Stupidedi::Values::InterchangeVal.new(self, [], separators)
+                    end
+
+                    # @return [Module]
+                    def segment_dict
+                      #{namespace}::#{version_module}::SegmentDefs
+                    end
+
+                    # @return [Reader::Separators]
+                    def separators(isa)
+                      #{separators_method}
+                    end
+
+                    #{replace_separators_method}
+                  end.new "#{interchange_version_code}",
+                    [ sd::ISA.use(1, r::Mandatory, s::RepeatCount.bounded(1)),
+                      sd::TA1.use(4, r::Optional,  s::RepeatCount.unbounded) ],
+                    [ sd::IEA.use(5, r::Mandatory, s::RepeatCount.bounded(1)) ]
+
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/generation/master_loader_generator.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Generates an optional master loader (e.g. edi.rb) that requires the whole
+      # generated tree in dependency order, so a non-Rails consumer can pull in
+      # the entire grammar with a single `require "edi"`.
+      #
+      # Like the registration generator it is a whole-tree artifact: it scans an
+      # ordered list of roots and unions the releases found (earlier roots shadow
+      # later ones per release), so a run can scan [staging, out] and require the
+      # freshly generated release together with releases already under out.
+      #
+      # Not emitted by default - it adds a file the Rails-autoloaded layout does
+      # not need. Pass master_loader: true (or --master-loader) to include it.
+      class MasterLoaderGenerator
+        include Support
+
+        # @param roots [String, Array<String>] one or more base directories.
+        def initialize(roots:, namespace: "Edi")
+          @roots = Array(roots)
+          @namespace = namespace
+        end
+
+        def generate
+          build_ruby_content
+        end
+
+        def output_path
+          "#{namespace_path}.rb"
+        end
+
+        private
+
+        attr_reader :roots
+
+        def namespace_roots
+          roots.map { |r| File.join(r, namespace_path) }
+        end
+
+        # [[dir_name, version_dir_path], ...] sorted by dir name, each release
+        # once, earlier roots shadowing later ones.
+        def version_dirs
+          seen = {}
+          dirs = []
+          namespace_roots.each do |base|
+            Dir.glob(File.join(base, "*")).each do |dir|
+              next unless File.directory?(dir)
+
+              dir_name = File.basename(dir)
+              next unless VERSION_MODULES.value?(camelize(dir_name))
+              next if seen[dir_name]
+
+              seen[dir_name] = true
+              dirs << [dir_name, dir]
+            end
+          end
+          dirs.sort_by(&:first)
+        end
+
+        def interchange_basenames
+          names = {}
+          namespace_roots.each do |base|
+            Dir.glob(File.join(base, "interchanges", "*.rb")).each do |path|
+              names[File.basename(path, ".rb")] ||= true
+            end
+          end
+          names.keys.sort
+        end
+
+        def registration_present?
+          namespace_roots.any? { |base| File.exist?(File.join(base, "stupidedi_registration.rb")) }
+        end
+
+        def require_lines
+          lines = []
+
+          # Version loaders first - they set up the per-version autoloads that the
+          # interchange and standards files (and the registration) depend on.
+          version_dirs.each do |dir_name, _|
+            lines << require_line("#{namespace_path}/#{dir_name}")
+          end
+
+          # Interchange envelopes.
+          interchange_basenames.each do |basename|
+            lines << require_line("#{namespace_path}/interchanges/#{basename}")
+          end
+
+          # Transaction-set standards.
+          version_dirs.each do |dir_name, dir|
+            Dir.glob(File.join(dir, "standards", "*.rb")).sort.each do |file|
+              lines << require_line("#{namespace_path}/#{dir_name}/standards/#{File.basename(file, '.rb')}")
+            end
+          end
+
+          # Registration last.
+          lines << require_line("#{namespace_path}/stupidedi_registration") if registration_present?
+
+          lines
+        end
+
+        def require_line(path)
+          %(require "#{path}")
+        end
+
+        def build_ruby_content
+          <<~RUBY
+            # frozen_string_literal: true
+
+            # Auto-generated by Stupidedi::Schema::Generation::MasterLoaderGenerator
+            # Requires the full generated grammar tree in dependency order.
+            require "tediparse"
+
+            #{require_lines.join("\n")}
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/generation/models.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Plain-Ruby value objects mirroring the shape of the X12 standard data.
+      #
+      # These are the seam between the input reader (Layer A) and the grammar
+      # generators (Layer B): the FlatFileReader populates them, the generators
+      # consume them. They carry no database or persistence concerns. Any source
+      # that builds objects responding to these methods can drive the generators.
+      #
+      # The reader always populates every field (collections default to []), so
+      # the structs need no custom initializers — keeping them compatible across
+      # the supported Ruby range (2.6+).
+      module Models
+        # A whole X12 release: its elements (simple + composite), its segments,
+        # and its transaction sets.
+        Release = Struct.new(:code, :elements, :segments, :transaction_sets, keyword_init: true)
+
+        # A data element or composite (distinguished by #is_composite).
+        # Simple elements carry x12_type/min_length/max_length/digits and, for
+        # ID elements, element_codes. Composites carry component_uses.
+        Element = Struct.new(
+          :code, :name, :description, :x12_type, :is_composite,
+          :min_length, :max_length, :digits, :element_codes, :component_uses,
+          keyword_init: true
+        )
+
+        # A single code-list entry for an ID element.
+        ElementCode = Struct.new(:code, :name, :paragraph, :partition, keyword_init: true)
+
+        # A component element used within a composite definition.
+        ComponentUse = Struct.new(:position, :requirement, :element, keyword_init: true)
+
+        # A segment definition with its ordered element uses and syntax notes.
+        Segment = Struct.new(:code, :name, :purpose, :element_uses, :syntax_notes, keyword_init: true)
+
+        # An element referenced from a specific position within a segment.
+        # #max_reps is the element's repetition count: an integer for a bounded
+        # repeat, or nil for unbounded (">1"). A non-repeating element use is 1.
+        ElementUse = Struct.new(:position, :requirement, :element, :max_reps, keyword_init: true)
+
+        # A segment syntax rule (P/R/C/E/L) over a set of element positions.
+        SyntaxNote = Struct.new(:condition_type, :element_positions, :description, keyword_init: true)
+
+        # A transaction set: its functional group id, code, name, owning release,
+        # and ordered table definitions.
+        TransactionSet = Struct.new(:code, :func_group, :name, :release, :table_definitions, keyword_init: true)
+
+        # A heading/detail/summary table. #area is the lowercase enum name
+        # ("heading"/"detail"/"summary"); #name is the display name. #children is
+        # a mixed, ordered list of SegmentUse and LoopDefinition.
+        TableDefinition = Struct.new(:area, :name, :position, :children, keyword_init: true) do
+          def ordered_children
+            # Index tiebreaker keeps ordering deterministic if two children ever
+            # share a position (Ruby's sort_by is not stable).
+            children.each_with_index.sort_by { |child, i| [child.position, i] }.map(&:first)
+          end
+        end
+
+        # A loop within a table or another loop. #children nests recursively.
+        # #max_reps is nil for unbounded.
+        LoopDefinition = Struct.new(:identifier, :max_reps, :position, :children, keyword_init: true) do
+          def ordered_children
+            children.each_with_index.sort_by { |child, i| [child.position, i] }.map(&:first)
+          end
+
+          def segment_use?
+            false
+          end
+        end
+
+        # A segment referenced from a specific position within a table or loop.
+        # #x12_sequence is the (string) sequence number from the standard, which
+        # takes precedence over #position when present.
+        SegmentUse = Struct.new(:segment, :x12_sequence, :position, :requirement, :max_reps, keyword_init: true) do
+          def segment_use?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/generation/module_loader_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Generates the top-level per-version loader file (e.g. forty_ten.rb) with
+      # autoload statements in dependency order.
+      class ModuleLoaderGenerator
+        include Support
+
+        # Autoload order matters - dependencies must be loaded first
+        AUTOLOAD_MODULES = %w[
+          ElementReqs
+          ElementTypes
+          SegmentReqs
+          SyntaxNotes
+          ElementDefs
+          SegmentDefs
+          FunctionalGroupDef
+        ].freeze
+
+        def initialize(release, namespace: "Edi")
+          @release = release
+          @namespace = namespace
+        end
+
+        def generate
+          validate_release!
+          build_ruby_content
+        end
+
+        def output_path
+          "#{namespace_path}/#{underscore(version_module)}.rb"
+        end
+
+        private
+
+        attr_reader :release
+
+        def release_code
+          release.code
+        end
+
+        def build_ruby_content
+          base_path = "#{namespace_path}/#{underscore(version_module)}"
+          autoloads = AUTOLOAD_MODULES.map do |mod|
+            file_name = underscore(mod)
+            padding = " " * (18 - mod.length)
+            "    autoload :#{mod},#{padding}\"#{base_path}/#{file_name}\""
+          end
+
+          <<~RUBY
+            # frozen_string_literal: true
+            module #{namespace}
+              module #{version_module}
+            #{autoloads.join("\n")}
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/generation/registration_generator.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Generates stupidedi_registration.rb. Does not read X12 data - instead it
+      # scans already-generated files and emits a register(config) method plus
+      # INTERCHANGE_VERSIONS / FUNCTIONAL_GROUP_VERSIONS constants.
+      #
+      # The registration is a *whole-tree* artifact: it must list every release
+      # present in the output tree, not just one. It therefore scans an ordered
+      # list of roots and unions the releases it finds. Earlier roots shadow
+      # later ones per release, so a run can scan [staging, out] and aggregate
+      # the freshly generated release (in staging) with the releases already
+      # committed under out, without listing either twice.
+      class RegistrationGenerator
+        include Support
+
+        WORDS_TO_DIGITS = {
+          "Oh" => "0",  "One" => "1", "Two" => "2",   "Three" => "3", "Four" => "4",
+          "Five" => "5", "Six" => "6", "Seven" => "7", "Eight" => "8", "Nine" => "9"
+        }.freeze
+
+        # @param roots [String, Array<String>] one or more base directories (each
+        #   containing <namespace_path>/...). Earlier roots win per release.
+        def initialize(roots:, namespace: "Edi")
+          @roots = Array(roots)
+          @namespace = namespace
+          @registrations = {
+            interchanges: {},
+            functional_groups: {},
+            transaction_sets: {}
+          }
+        end
+
+        def generate
+          scan_existing_definitions
+          build_ruby_content
+        end
+
+        def output_path
+          "#{namespace_path}/stupidedi_registration.rb"
+        end
+
+        private
+
+        attr_reader :registrations, :roots
+
+        def namespace_roots
+          roots.map { |r| File.join(r, namespace_path) }
+        end
+
+        # Yields each release's version directory once, with earlier roots
+        # shadowing later ones for the same release.
+        def each_version_dir
+          seen = {}
+          namespace_roots.each do |base|
+            Dir.glob(File.join(base, "*")).each do |dir|
+              next unless File.directory?(dir)
+
+              dir_name = File.basename(dir)
+              version_module = camelize(dir_name)
+              next unless VERSION_MODULES.value?(version_module)
+              next if seen[dir_name]
+
+              seen[dir_name] = true
+              yield dir, version_module, module_to_release_code(version_module)
+            end
+          end
+        end
+
+        def scan_existing_definitions
+          scan_transaction_sets
+          scan_functional_groups
+          scan_interchanges
+        end
+
+        def scan_transaction_sets
+          each_version_dir do |version_dir, version_module, release_code|
+            Dir.glob(File.join(version_dir, "standards", "*.rb")).each do |path|
+              match = File.basename(path).match(/\A([A-Z]{2})(\d{3})\.rb\z/)
+              next unless match
+
+              func_group = match[1]
+              ts_code = match[2]
+              # A "TS" prefix encodes a nil/empty functional group (see
+              # DefinitionGenerator#constant_name).
+              constant_name = "#{namespace}::#{version_module}::Standards::#{func_group}#{ts_code}"
+              reg_func_group = func_group == "TS" ? nil : func_group
+
+              (registrations[:transaction_sets][release_code] ||= []) << {
+                func_group: reg_func_group,
+                ts_code: ts_code,
+                constant: constant_name
+              }
+            end
+          end
+
+          # Sort transaction sets within each release (handle nil func_group)
+          registrations[:transaction_sets].each_value do |ts_list|
+            ts_list.sort_by! { |ts| [ts[:func_group] || "ZZ", ts[:ts_code]] }
+          end
+        end
+
+        def scan_functional_groups
+          each_version_dir do |version_dir, version_module, release_code|
+            next unless File.exist?(File.join(version_dir, "functional_group_def.rb"))
+
+            registrations[:functional_groups][release_code] =
+              "#{namespace}::#{version_module}::FunctionalGroupDef"
+          end
+        end
+
+        def scan_interchanges
+          namespace_roots.each do |base|
+            Dir.glob(File.join(base, "interchanges", "*.rb")).each do |path|
+              module_name = camelize(File.basename(path, ".rb"))
+              interchange_code = interchange_module_to_code(module_name)
+
+              # ||= so an earlier root (e.g. staging) wins on collision.
+              registrations[:interchanges][interchange_code] ||=
+                "#{namespace}::Interchanges::#{module_name}::InterchangeDef"
+            end
+          end
+        end
+
+        def module_to_release_code(version_module)
+          VERSION_MODULES.key(version_module)
+        end
+
+        # Convert "FourOhOne" -> "00401", "FiveOhOne" -> "00501"
+        def interchange_module_to_code(module_name)
+          result = module_name.dup
+          WORDS_TO_DIGITS.each do |word, digit|
+            result = result.gsub(word, digit)
+          end
+          # Pad to 5 digits with leading zeros (interchange codes are 5 chars)
+          result.rjust(5, "0")
+        end
+
+        def build_ruby_content
+          lines = []
+          lines << "# frozen_string_literal: true"
+          lines << ""
+          lines << "# Auto-generated by Stupidedi::Schema::Generation::RegistrationGenerator"
+          lines << "# DO NOT EDIT MANUALLY"
+          lines << ""
+          lines << "module #{namespace}"
+          lines << "  module StupidediRegistration"
+          lines << build_version_constants
+          lines << ""
+          lines << "    def self.register(config)"
+          lines << "      register_interchanges(config)"
+          lines << "      register_functional_groups(config)"
+          lines << "      register_transaction_sets(config)"
+          lines << "    end"
+          lines << ""
+          lines << build_interchange_registration
+          lines << ""
+          lines << build_functional_group_registration
+          lines << ""
+          lines << build_transaction_set_registration
+          lines << "  end"
+          lines << "end"
+          lines.join("\n") + "\n"
+        end
+
+        def build_version_constants
+          interchange_codes = registrations[:interchanges].keys.sort
+          functional_group_codes = registrations[:functional_groups].keys.sort
+
+          lines = []
+          lines << "    INTERCHANGE_VERSIONS = %w[#{interchange_codes.join(' ')}].freeze"
+          lines << "    FUNCTIONAL_GROUP_VERSIONS = %w[#{functional_group_codes.join(' ')}].freeze"
+          lines.join("\n")
+        end
+
+        def build_interchange_registration
+          lines = []
+          lines << "    def self.register_interchanges(config)"
+          lines << "      config.interchange.customize do |x|"
+
+          registrations[:interchanges].keys.sort.each do |code|
+            constant = registrations[:interchanges][code]
+            lines << "        x.register(\"#{code}\") { #{constant} }"
+          end
+
+          lines << "      end"
+          lines << "    end"
+          lines.join("\n")
+        end
+
+        def build_functional_group_registration
+          lines = []
+          lines << "    def self.register_functional_groups(config)"
+          lines << "      config.functional_group.customize do |x|"
+
+          registrations[:functional_groups].keys.sort.each do |code|
+            constant = registrations[:functional_groups][code]
+            lines << "        x.register(\"#{code}\") { #{constant} }"
+          end
+
+          lines << "      end"
+          lines << "    end"
+          lines.join("\n")
+        end
+
+        def build_transaction_set_registration
+          lines = []
+          lines << "    def self.register_transaction_sets(config)"
+          lines << "      config.transaction_set.customize do |x|"
+
+          registrations[:transaction_sets].keys.sort.each do |release_code|
+            ts_list = registrations[:transaction_sets][release_code]
+            ts_list.each do |ts|
+              # Skip transaction sets without a functional group - they can't be registered
+              next if ts[:func_group].nil?
+
+              lines << "        x.register(\"#{release_code}\", \"#{ts[:func_group]}\", \"#{ts[:ts_code]}\") { #{ts[:constant]} }"
+            end
+          end
+
+          lines << "      end"
+          lines << "    end"
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end