tediparse 2.0.0

data/lib/stupidedi/schema/composite_element_def.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # @see X222 B.1.1.3.3 Composite Data Structure
+    #
+    class CompositeElementDef < AbstractElementDef
+      # @return [Array<ComponentElementUse>]
+      attr_reader :component_uses
+
+      # @return [Array<SyntaxNote>]
+      attr_reader :syntax_notes
+
+      # @return [CompositeElementUse]
+      attr_reader :parent
+
+      def initialize(id, name, description, component_uses, syntax_notes, parent)
+        @id, @name, @description, @component_uses, @syntax_notes, @parent =
+          id, name, description, component_uses, syntax_notes, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @component_uses = @component_uses.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [CompositeElementDef]
+      def copy(changes = {})
+        CompositeElementDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:name, @name),
+          changes.fetch(:description, @description),
+          changes.fetch(:component_uses, @component_uses),
+          changes.fetch(:syntax_notes, @syntax_notes),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return false
+      def simple?
+        false
+      end
+
+      # @return true
+      def composite?
+        true
+      end
+
+      # @return [CompositeElementUse]
+      def simple_use(requirement, repeat_count, parent = nil)
+        CompositeElementUse.new(self, requirement, repeat_count, parent)
+      end
+
+      # @return [CompositeElementVal]
+      def value(component_vals, usage, position)
+        Values::CompositeElementVal.new(component_vals, usage)
+      end
+
+      # @return [CompositeElementVal]
+      def empty(usage, position)
+        Values::CompositeElementVal.new([], usage)
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @component_uses.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("CompositeElementDef[#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @component_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << CompositeElementDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [CompositeElementDef]
+      def build(id, name, description, *args)
+        component_uses = args.take_while{|x| x.is_a?(AbstractElementUse) }
+        syntax_notes   = args.drop(component_uses.length)
+
+        new(id, name, description, component_uses, syntax_notes, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/schema/composite_element_use.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class CompositeElementUse < AbstractElementUse
+      # @return [CompositeElementDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :description
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [SegmentDef]
+      attr_reader :parent
+
+      def initialize(definition, requirement, repeat_count, parent)
+        @definition, @requirement, @repeat_count, @parent =
+          definition, requirement, repeat_count, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @definition = @definition.copy(:parent => self)
+        end
+      end
+
+      # @return [CompositeElementUse]
+      def copy(changes = {})
+        CompositeElementUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:repeat_count, @repeat_count),
+          changes.fetch(:parent, @parent)
+      end
+
+      def descriptor
+        n = parent.element_uses.index{|u| u.eql?(self) } + 1
+        "element #{parent.id}#{"%02d" % n} #{definition.name}".strip
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @return false
+      def simple?
+        false
+      end
+
+      # @return false
+      def component?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("CompositeElementUse")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @definition
+          q.text ","
+
+          q.breakable
+          q.pp @requirement
+          q.text ","
+
+          q.breakable
+          q.pp @repeat_count
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/element_req.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # The 5010 X12 "condition designator"s include
+    #   M - Mandatory
+    #   O - Optional
+    #   X - Relational
+    #
+    # Where "Relational" indicates this element is subject to relational
+    # conditions between two or more elements (encoded as a SyntaxNote)
+    #
+    # @see X222 B.1.1.3.9 Condition Designator
+    #
+    # The "Implementation Usage" from the 5010 HIPAA implementation guides
+    # have three descriptors:
+    #   REQUIRED
+    #   NOT USED
+    #   SITUATIONAL
+    #
+    # @see X222.pdf 2.2.1 Industry Usage
+    #
+    class ElementReq
+      def initialize(required, forbidden, to_s)
+        @required, @forbidden, @to_s =
+          required, forbidden, to_s
+      end
+
+      # True if the element's presence is unconditionally required
+      def required?
+        @required
+      end
+
+      # True if the element's presence is unconditionally forbidden
+      def forbidden?
+        @forbidden
+      end
+
+      # True if the element's presence is required conditionally
+      def optional?
+        not (@required or @forbidden)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text @to_s
+      end
+
+      # @return [String]
+      def inspect
+        @to_s
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/functional_group_def.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # X12 standards are released three times yearly. The version codes sent in
+    # the `GS08` and `ST03` elements encode the version (eg 004, 005), the
+    # release (eg 0040, 0050), the subrelease (00501, 00602) and the level
+    # (eg 005010)
+    #
+    # The release schedules look like this:
+    #
+    #               Approved by    Available      Ballot Results  Available for
+    #     Version   Subcommitees   for Ballot     Approved        Distribution
+    #     ---------------------------------------------------------------------
+    #      005010     Feb 03         Jun 03         Oct 03          Jan 04
+    #      005011     Jun 03         Oct 04         Feb 04          Mar 04
+    #      005012     Oct 03         Feb 04         Jun 04          Jul 04
+    #
+    #      005020     Feb 04         Jun 04         Oct 04          Jan 05
+    #      005021     Jun 04         Oct 04         Feb 05          Mar 05
+    #      005022     Oct 04         Feb 05         Jun 05          Jul 05
+    #
+    # @see http://www.disa.org/x12org/subcommittees/dev/pdf/X12RELEASESCHED.pdf
+    #
+    # @see X222.pdf B.1.1.3.13 Functional Group
+    # @see X222.pdf B.1.1.4.2 Functional Groups
+    #
+    class FunctionalGroupDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [Array<SegmentUses>]
+      attr_reader :header_segment_uses
+
+      # @return [Array<SegmentUses>]
+      attr_reader :trailer_segment_uses
+
+      # @return [Hash, Module]
+      abstract :segment_dict
+
+      def initialize(id, header_segment_uses, trailer_segment_uses)
+        @id, @header_segment_uses, @trailer_segment_uses =
+          id, header_segment_uses, trailer_segment_uses
+
+        @header_segment_uses  = header_segment_uses.map{|x| x.copy(:parent => self) }
+        @trailer_segment_uses = trailer_segment_uses.map{|x| x.copy(:parent => self) }
+      end
+
+      # @return [FunctionalGroupDef]
+      def copy(changes = {})
+        FunctionalGroupDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:header_segment_uses, @header_segment_uses),
+          changes.fetch(:trailer_segment_uses, @trailer_segment_uses)
+      end
+
+      # @return [String]
+      def descriptor
+        "transaction set #{id}"
+      end
+
+      def required?
+        false
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @header_segment_uses.head
+      end
+
+      # @return [Array<SegmentUse>]
+      def children
+        @header_segment_uses + @trailer_segment_uses
+      end
+
+      # @return [Values::FunctionalGroupVal]
+      def empty
+        Values::FunctionalGroupVal.new(self, [], [])
+      end
+
+      def functional_group?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>
+      def code_lists
+        children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("FunctionalGroupDef")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @header_segment_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+
+          unless q.current_group.first?
+            q.text ","
+            q.breakable
+          end
+          q.text "... (TRANSACTION SETS) ..."
+
+          @trailer_segment_uses.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Stupidedi
+  module Schema
+    module Generation
+      # Generates one transaction-set standard file (e.g. SM204.rb). Walks the
+      # transaction set's table definitions and recursively emits loops and
+      # segment uses. This is the heart of the grammar.
+      class DefinitionGenerator
+        include Support
+
+        AREA_METHODS = {
+          "heading" => "header",
+          "detail"  => "detail",
+          "summary" => "summary"
+        }.freeze
+
+        def initialize(transaction_set, namespace: "Edi")
+          @transaction_set = transaction_set
+          @namespace = namespace
+        end
+
+        def generate
+          validate_release!
+          build_ruby_content
+        end
+
+        def constant_name
+          func_group = transaction_set.func_group
+          code = transaction_set.code
+          # If func_group is nil/empty, prefix with 'TS' to create a valid Ruby constant
+          func_group = "TS" if func_group.nil? || func_group.empty?
+          "#{func_group}#{code}"
+        end
+
+        def output_path
+          "#{namespace_path}/#{underscore(version_module)}/standards/#{constant_name}.rb"
+        end
+
+        private
+
+        attr_reader :transaction_set
+
+        def release_code
+          transaction_set.release.code
+        end
+
+        def build_ruby_content
+          lines = []
+          lines << 'require "tediparse"'
+          lines << "if !defined?(#{namespace}::#{version_module}::Standards::#{constant_name})"
+          lines << "  module #{namespace}"
+          lines << "    module #{version_module}"
+          lines << "      module Standards"
+          lines << "        b = Stupidedi::TransactionSets::Builder"
+          lines << "        d = Stupidedi::Schema"
+          lines << "        r = #{namespace}::#{version_module}::SegmentReqs"
+          lines << "        s = #{namespace}::#{version_module}::SegmentDefs"
+          lines << build_transaction_set_definition
+          lines << "      end"
+          lines << "    end"
+          lines << "  end"
+          lines << "end"
+          lines.join("\n") + "\n"
+        end
+
+        def build_transaction_set_definition
+          tables = transaction_set.table_definitions.to_a
+          table_defs = tables.each_with_index.map do |table, index|
+            generate_table_def(table, is_last: index == tables.length - 1)
+          end
+
+          header = %[        #{constant_name} = b.build("#{transaction_set.func_group}", "#{transaction_set.code}", "#{transaction_set.name}",]
+          footer = "        )"
+
+          [header, *table_defs, footer].join("\n")
+        end
+
+        def generate_table_def(table, is_last:)
+          area_method = AREA_METHODS.fetch(table.area)
+          children = table.ordered_children
+
+          child_lines = children.each_with_index.map do |child, index|
+            child_is_last = index == children.length - 1
+            generate_child(child, indent_level: 6, is_last: child_is_last)
+          end
+
+          trailing_comma = is_last ? "" : ","
+          header = %[#{indent(5)}d::TableDef.#{area_method}("#{table.name}",]
+          footer = "#{indent(5)})#{trailing_comma}"
+
+          [header, *child_lines, footer].join("\n")
+        end
+
+        def generate_child(child, indent_level:, is_last:)
+          if child.segment_use?
+            generate_segment_use(child, indent_level: indent_level, is_last: is_last)
+          else
+            generate_loop_def(child, indent_level: indent_level, is_last: is_last)
+          end
+        end
+
+        def generate_loop_def(loop, indent_level:, is_last:)
+          children = loop.ordered_children
+          repeat_count = format_repeat_count(loop.max_reps)
+
+          child_lines = children.each_with_index.map do |child, index|
+            child_is_last = index == children.length - 1
+            generate_child(child, indent_level: indent_level + 1, is_last: child_is_last)
+          end
+
+          trailing_comma = is_last ? "" : ","
+          header = %[#{indent(indent_level)}d::LoopDef.build("#{loop.identifier}", #{repeat_count},]
+          footer = "#{indent(indent_level)})#{trailing_comma}"
+
+          [header, *child_lines, footer].join("\n")
+        end
+
+        def generate_segment_use(segment_use, indent_level:, is_last:)
+          segment_code = segment_use.segment.code
+          position = (segment_use.x12_sequence || segment_use.position).to_i
+          requirement = format_requirement(segment_use.requirement)
+          repeat_count = format_repeat_count(segment_use.max_reps)
+
+          trailing_comma = is_last ? "" : ","
+          "#{indent(indent_level)}s::#{segment_code}.use(#{position}, #{requirement}, #{repeat_count})#{trailing_comma}"
+        end
+
+        def format_repeat_count(max_reps)
+          if max_reps.nil?
+            "d::RepeatCount.unbounded"
+          else
+            "d::RepeatCount.bounded(#{max_reps})"
+          end
+        end
+      end
+    end
+  end
+end