tediparse 2.0.0

data/lib/stupidedi/schema/simple_element_use.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class SimpleElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :description
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [RepeatCount]
+      attr_reader :repeat_count
+
+      # @return [AbstractSet]
+      attr_reader :allowed_values
+
+      # @return [SegmentDef]
+      attr_reader :parent
+
+      def initialize(definition, requirement, repeat_count, allowed_values, parent)
+        @definition, @requirement, @repeat_count, @allowed_values, @parent =
+          definition, requirement, repeat_count, allowed_values, 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 [SimpleElementUse]
+      def copy(changes = {})
+        SimpleElementUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:repeat_count, @repeat_count),
+          changes.fetch(:allowed_values, @allowed_values),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return [String]
+      def descriptor
+        idx = parent.element_uses.index{|u| u.eql?(self) } + 1
+        "element #{parent.id}#{"%02d" % idx} #{definition.name}".strip
+      end
+
+      def repeatable?
+        @repeat_count.try{|r| r.include?(2) }
+      end
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return false
+      def component?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("SimpleElementUse")
+        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/syntax_note.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    #
+    # The 5010 X12 "condition code"s include
+    #   P - Paired or Multiple (if one then all)
+    #   R - Required (at least one)
+    #   E - Exclusion (no more than one)
+    #   C - Conditional (if first then all)
+    #   L - List Conditional (if first than at least one more)
+    #
+    # @see X222.pdf B.1.1.3.5 Syntax Notes
+    # @see X222.pdf B.1.1.3.9 Condition Designator
+    #
+    class SyntaxNote
+      # @return [Array<Integer>]
+      attr_reader :indexes
+
+      def initialize(indexes)
+        @indexes = indexes
+      end
+
+      # Returns the AbstractElementVals from the given segment or composite
+      # element that must be present, given the presence of other elements
+      #
+      # @return [Array<Zipper::AbstractCursor<Values::AbstractElementVal>>]
+      abstract :required, :args => %w(zipper)
+
+      # Returns the AbstractElementVals from the given segment or composite
+      # element that must not be present, given the presence of other elements
+      #
+      # @return [Array<Zipper::AbstractCursor<Values::AbstractElementVal>>]
+      abstract :forbidden, :args => %w(zipper)
+
+      # @return [String]
+      abstract :reason, :args => %w(zipper)
+
+      def satisfied?(zipper)
+        forbidden(zipper).all?{|c| c.node.blank? } and
+          required(zipper).all?{|c| c.node.present? }
+      end
+
+    private
+
+      def children(zipper)
+        indexes.map{|n| zipper.child(n - 1) }
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/table_def.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class TableDef < AbstractDef
+      # @return [String]
+      attr_reader :id
+
+      # @return [Array<SegmentUse, LoopDef>]
+      attr_reader :children
+
+      # @return [TransactionSetDef]
+      attr_reader :parent
+
+      # @return [Integer]
+      attr_reader :position
+
+      def initialize(id, position, children, parent)
+        @id, @position, @children, @parent =
+          id, position, children, parent
+
+        # Delay re-parenting until the entire definition tree has a root
+        # to prevent unnecessarily copying objects
+        unless parent.nil?
+          @children = @children.map{|x| x.copy(:parent => self) }
+        end
+      end
+
+      # @return [TableDef]
+      def copy(changes = {})
+        TableDef.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:position, @position),
+          changes.fetch(:children, @children),
+          changes.fetch(:parent, @parent)
+      end
+
+      # Returns segments before the first LoopDef.
+      # @deprecated Use {#children} instead. This method does not include
+      #   segments that appear between child loops in interleaved structures.
+      # @return [Array<SegmentUse>]
+      def header_segment_uses
+        @children.take_while{|x| x.is_a?(SegmentUse) }
+      end
+
+      # Returns all LoopDef children.
+      # @deprecated Use {#children} instead and filter with `select{|x| x.is_a?(LoopDef)}`.
+      # @return [Array<LoopDef>]
+      def loop_defs
+        @children.select{|x| x.is_a?(LoopDef) }
+      end
+
+      # Returns segments after the last LoopDef.
+      # @deprecated Use {#children} instead. This method does not include
+      #   segments that appear between child loops in interleaved structures.
+      # @return [Array<SegmentUse>]
+      def trailer_segment_uses
+        last_loop_idx = @children.rindex{|x| x.is_a?(LoopDef) }
+        return [] if last_loop_idx.nil?
+        @children.drop(last_loop_idx + 1).select{|x| x.is_a?(SegmentUse) }
+      end
+
+      # @return [String]
+      def descriptor
+        "table #{id}"
+      end
+
+      def repeatable?
+        header_segment_uses.empty? and
+          loop_defs.present?       and
+          loop_defs.head.repeatable?
+      end
+
+      def repeat_count
+        if repeatable?
+          RepeatCount.unbounded
+        else
+          RepeatCount.bounded(1)
+        end
+      end
+
+      def required?
+        entry_segment_uses.any?(&:required?)
+      end
+
+      # @return [Array<SegmentUse>]
+      def entry_segment_uses
+        uses = @children.map do |child|
+          if child.is_a?(SegmentUse)
+            child
+          else
+            child.entry_segment_use
+          end
+        end
+
+        # Up to and including the first required segment
+        suffix = uses.drop_while(&:optional?)
+
+        if suffix.present?
+          # Some segment(s) is required, so table can't start without it
+          position = suffix.map(&:position).min
+          uses.take_while{|u| u.position <= position }
+        else
+          # Nothing is required, table can begin at any of these
+          uses
+        end
+      end
+
+      # @return [Values::TableVal]
+      def empty
+        Values::TableVal.new(self, [])
+      end
+
+      def table?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @children.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("TableDef[#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << TableDef
+      # @group Constructors
+      #########################################################################
+
+      # @return [TableDef]
+      def header(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.header must be a String but got #{id.inspect}"
+        end
+
+        new(id, 1, children, nil)
+      end
+
+      # @return [TableDef]
+      def detail(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.detail must be a String but got #{id.inspect}"
+        end
+
+        new(id, 2, children, nil)
+      end
+
+      # @return [TableDef]
+      def summary(id, *children)
+        unless id.is_a?(String)
+          raise Exceptions::InvalidSchemaError,
+            "first argument to TableDef.summary must be a String but got #{id.inspect}"
+        end
+
+        new(id, 3, children, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/schema/transaction_set_def.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class TransactionSetDef < AbstractDef
+      include Inspect
+
+      # @return [String]
+      attr_reader :id
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :functional_group
+
+      # @return [Array<TableDef>]
+      attr_reader :table_defs
+
+      def initialize(functional_group, id, name, table_defs)
+        @functional_group, @id, @name, @table_defs =
+          functional_group, id, name, table_defs
+
+        @table_defs = table_defs.map{|x| x.copy(:parent => self) }
+      end
+
+      def copy(changes = {})
+        TransactionSetDef.new \
+          changes.fetch(:functional_group, @functional_group),
+          changes.fetch(:id, @id),
+          changes.fetch(:name, @name),
+          changes.fetch(:table_defs, @table_defs)
+      end
+
+      # @return [String]
+      def descriptor
+        "transaction set #{functional_group}#{id} #{name}"
+      end
+
+      # @return [Values::TransactionSetVal]
+      def empty
+        Values::TransactionSetVal.new(self, [])
+      end
+
+      # @return [SegmentUse]
+      def entry_segment_use
+        @table_defs.head.header_segment_uses.head
+      end
+
+      # @return [SegmentUse]
+      def first_segment_use
+        @table_defs.head.header_segment_uses.head
+      end
+
+      # @return [SegmentUse]
+      def last_segment_use
+        @table_defs.last.trailer_segment_uses.last
+      end
+
+      # @return [Array<TableDef>]
+      def children
+        @table_defs
+      end
+
+      def transaction?
+        true
+      end
+
+      # @return [AbstractSet<CodeList>]
+      def code_lists
+        @table_defs.map(&:code_lists).inject(&:|)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("TransactionSetDef[#{@functional_group}#{@id}]")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @table_defs.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+    end
+
+    class << TransactionSetDef
+      # @return [TransactionSetDef]
+      def build(functional_group, id, name, *table_defs)
+        table_defs.each.with_index do |t, k|
+          unless t.table?
+            if t.respond_to?(:pretty_inspect)
+              raise Exceptions::InvalidSchemaError,
+                "argument #{k+4} is not a TableDef: #{t.pretty_inspect}"
+            else
+              raise Exceptions::InvalidSchemaError,
+                "argument #{k+4} is not a TableDef: #{t.inspect}"
+            end
+          end
+
+          # next unless t.repeatable?
+
+          # [t.header_segment_uses, t.loop_defs, t.trailer_segment_uses].each do |s|
+          #   opt, req = s.split_until(&:optional?)
+          #   prefix   = opt.concat(req.take(1))
+
+          #   if x = prefix.find(&:repeatable?)
+          #     raise Exceptions::InvalidSchemaError,
+          #       %Q("#{x.id}" is an entry point into "#{t.id}", and both are marked
+          #       repeatable).join
+          #   end
+
+          #   break if req.present?
+          # end
+        end
+
+        new(functional_group, id, name, table_defs)
+      end
+    end
+  end
+end

data/lib/stupidedi/schema.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Schema
+    autoload :AbstractElementUse,   "stupidedi/schema/abstract_element_use"
+    autoload :AbstractUse,          "stupidedi/schema/abstract_use"
+    autoload :ComponentElementUse,  "stupidedi/schema/component_element_use"
+    autoload :CompositeElementUse,  "stupidedi/schema/composite_element_use"
+    autoload :SegmentUse,           "stupidedi/schema/segment_use"
+    autoload :SimpleElementUse,     "stupidedi/schema/simple_element_use"
+
+    autoload :AbstractDef,          "stupidedi/schema/abstract_def"
+    autoload :AbstractElementDef,   "stupidedi/schema/abstract_element_def"
+    autoload :CompositeElementDef,  "stupidedi/schema/composite_element_def"
+    autoload :FunctionalGroupDef,   "stupidedi/schema/functional_group_def"
+    autoload :InterchangeDef,       "stupidedi/schema/interchange_def"
+    autoload :LoopDef,              "stupidedi/schema/loop_def"
+    autoload :SegmentDef,           "stupidedi/schema/segment_def"
+    autoload :SimpleElementDef,     "stupidedi/schema/simple_element_def"
+    autoload :TableDef,             "stupidedi/schema/table_def"
+    autoload :TransactionSetDef,    "stupidedi/schema/transaction_set_def"
+
+    autoload :ElementReq,           "stupidedi/schema/element_req"
+    autoload :SegmentReq,           "stupidedi/schema/segment_req"
+    autoload :RepeatCount,          "stupidedi/schema/repeat_count"
+    autoload :SyntaxNote,           "stupidedi/schema/syntax_note"
+    autoload :CodeList,             "stupidedi/schema/code_list"
+
+    autoload :Generation,           "stupidedi/schema/generation"
+  end
+end

data/lib/stupidedi/sets.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require "cantor"
+
+module Stupidedi
+  using Refinements
+
+  module Sets
+  end
+
+  class << Sets
+    # @group Constructors
+    ###########################################################################
+
+    # @return [Cantor::AbstractSet]
+    def build(object)
+      Cantor.build(object)
+    end
+
+    # @return [Cantor::AbstractSet]
+    def complement(other)
+      Cantor.complement(other)
+    end
+
+    # @return [Cantor::UniversalSet]
+    def universal
+      Cantor.universal
+    end
+
+    # @return [Cantor::NullSet]
+    def empty
+      Cantor.empty
+    end
+
+    # @return [Cantor::AbsoluteSet]
+    def absolute(other, universe = other)
+      Cantor.absolute(other, universe)
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+end

data/lib/stupidedi/transaction_sets/builder/dsl.rb

@@ -0,0 +1,192 @@
+module Stupidedi
+  module TransactionSets
+    module Builder
+      class Dsl
+
+        ##
+        # Build a definition for a given document using DSL-style.
+        # DSL style is a bit easier to use than manually building a syntax tree.
+        def self.build(shortcode, code, name, &block)
+          body = DocumentBodyDSL.new(&block).tables
+          Builder.build(shortcode, code, name, *body)
+        end
+
+        private
+
+        ##
+        # Syntax for DSLs in which you can define elements.
+        module ElementSyntax
+
+          ##
+          # Define an element within this block
+          def element(*args)
+            add_element(Builder::Element(*args))
+          end
+
+          ##
+          # Define a composite element within this block, using a sub-block for the sub-elements
+          def composite(*args, &block)
+            subelements = SegmentBodyDSL.new(&block).elements
+            add_element(Builder::Element(*(args + subelements)))
+          end
+
+        end
+
+        ##
+        # Syntax for DSLs in which you can define segments.
+        module SegmentSyntax
+
+          def segment(pos, type, name, requirement, repeat, &block)
+            elements = SegmentBodyDSL.new(&block).elements
+            segment = Builder::Segment(
+              pos,
+              type,
+              name,
+              requirement,
+              repeat,
+              *elements
+            )
+
+            add_segment(segment)
+          end
+
+        end
+
+        ##
+        # Syntax for DSLs in which you can define loops.
+        module LoopSyntax
+
+          ##
+          # Define a loop within this block.
+          # The underscore is there because "loop" is a ruby keyword.
+          def loop_(name, repeat, &block)
+            body = LoopBodyDSL.new(&block).elements
+            add_loop(Schema::LoopDef.build(name, repeat, *body))
+          end
+
+        end
+
+        ##
+        # Syntax for DSLs in which you can define tables.
+        module TableSyntax
+
+          ##
+          # Define a header table within this block.
+          def table_header(name, &block)
+            add_table(Schema::TableDef.header(name, *get_table_contents(&block)))
+          end
+
+          ##
+          # Define a detail table within this block
+          def table_detail(name, &block)
+            add_table(Schema::TableDef.detail(name, *get_table_contents(&block)))
+          end
+
+          ##
+          # Helper method to get the body of a table.
+          def get_table_contents(&block)
+            TableBodyDSL.new(&block).elements
+          end
+
+        end
+
+        ##
+        # Syntax for DSLs in which you can define values lists.
+        module ValuesSyntax
+
+          def values(*args)
+            Builder::Values(*args)
+          end
+
+        end
+
+        ##
+        # A DSL for the body of a loop, which allows defining loops and segments
+        class LoopBodyDSL
+
+          include LoopSyntax
+          include SegmentSyntax
+
+          def initialize(&block)
+            @elements = []
+            instance_eval(&block)
+          end
+
+          attr_accessor :elements
+
+          def add_loop(loop_)
+            elements << loop_
+          end
+
+          def add_segment(segment)
+            elements << segment
+          end
+
+        end
+
+        ##
+        # A DSL for the body of a segment, which allows defining elements and using
+        # values lists.
+        class SegmentBodyDSL
+
+          include ElementSyntax
+          include ValuesSyntax
+
+          def initialize(&block)
+            @elements = []
+            instance_eval(&block)
+          end
+
+          def add_element(e)
+            @elements << e
+          end
+
+          attr_accessor :elements
+        end
+
+        ##
+        # A DSL for the body of a table, which allows defining segments and loops.
+        class TableBodyDSL
+
+          include LoopSyntax
+          include SegmentSyntax
+
+          def initialize(&block)
+            @elements = []
+            instance_eval(&block)
+          end
+
+          def add_loop(l)
+            @elements << l
+          end
+
+          def add_segment(segment)
+            @elements << segment
+          end
+
+          attr_accessor :elements
+        end
+
+        ##
+        # A DSL for the body of a document, which allows defining tables.
+        class DocumentBodyDSL
+
+          include TableSyntax
+
+          def initialize(&block)
+            @tables = []
+            instance_eval(&block)
+          end
+
+          attr_accessor :tables
+
+          def add_table(table)
+            tables << table
+          end
+
+        end
+
+      end
+    end
+  end
+end