stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/guides/005010/element_reqs.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-
-  module Guides
-    module FiftyTen
-
-      #
-      # @see X222.pdf 2.2 Implementation Usage
-      #
-      module ElementReqs
-
-        # Declares that this element must always be sent. Required elements
-        # within Situational segments when the segment occurs.
-        #
-        # Similarly, required component elements within situational composite
-        # elements only occur when the composite element occurs.
-        Required = Schema::ElementReq.new(true,  false, "R")
-
-        # Use of this element varies, depending on data content and business
-        # context as described in the defining rule. The defining rule is
-        # documented in a Situational Rule attached to the element.
-        #
-        # There are two forms of Situational Rules. The first is "Required when
-        # <condition>. If not required by <condition>, the element may be
-        # provided at the discretion of the sender, but it cannot be required or
-        # requested by the receiver.'
-        #
-        # The other form is "Required when <condition>. If not required by
-        # <condition>, do not send". The element described by the rule cannot
-        # occur except when the condition holds.
-        Situational = Schema::ElementReq.new(false, false, "S")
-
-        # This element must never be sent.
-        NotUsed = Schema::ElementReq.new(false, true,  "N")
-
-      end
-
-    end
-  end
-end

data/lib/stupidedi/guides/005010/guide_builder.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-
-  module Guides
-    module FiftyTen
-
-      #
-      # {GuideBuilder} is a simple DSL for construction an implementation guide.
-      #
-      module GuideBuilder
-      end
-
-      class << GuideBuilder
-
-        # @return [Schema::TransactionSetDef]
-        def build(transaction_set_def, *table_defs)
-          table_defs.each do |t|
-            next unless t.repeatable?
-
-            search = [t.header_segment_uses, t.loop_defs, t.trailer_segment_uses]
-            search.each do |s|
-              opt, req = s.split_until(&:optional?)
-              prefix   = opt.concat(req.take(1))
-
-              if x = prefix.find(&:repeatable?)
-                raise Exceptions::InvalidSchemaError,
-                  "#{x.id} is an entry point into #{t.id}. Both are marked " +
-                  "repeatable, but only one should be repeatable to avoid "  +
-                  "generating an ambiguous grammar. You probably want to "   +
-                  "change the repeat count of #{x.id}"
-              end
-
-              break if req.present?
-            end
-          end
-
-          transaction_set_def.copy(:table_defs => table_defs)
-        end
-
-        # @group Element Constraints
-        #######################################################################
-
-        # @param [String, ...] values
-        def Values(*values)
-          [:Values, values]
-        end
-
-        # @param [Integer] n
-        def MaxLength(n)
-          [:MaxLength, n]
-        end
-
-        # @param [Integer] n
-        def MaxPrecision(n)
-          [:MaxPrecision, n]
-        end
-
-        # @endgroup
-        #######################################################################
-
-        # @group Definition Constructors
-        #######################################################################
-
-        # @param [Schema::ElementReq] requirement
-        # @param [String] name
-        def Element(requirement, name, *constraints)
-          [:Element, requirement, name, constraints]
-        end
-
-        # @return [SegmentUse]
-        def Segment(position, segment_def, name, requirement, repeat_count, *elements)
-          unless elements.length == segment_def.element_uses.length
-            raise Exceptions::InvalidSchemaError,
-              "segment #{segment_def.id} has #{segment_def.element_uses.length}" +
-              " elements but #{elements.length} arguments were specified"
-          end
-
-          element_index = "00"
-          element_uses  = elements.zip(segment_def.element_uses).map do |e, u|
-            e_tag, e_requirement, e_name, e_arguments = e
-            # element_index.succ!
-            element_index = element_index.succ
-
-            unless e_tag == :Element
-              raise Exceptions::InvalidSchemaError,
-                "given argument for #{segment_def.id}#{element_index} must be Element(...)"
-            end
-
-            if u.composite?
-              e_repeat_count, e_arguments = e_arguments.partition{|x| x.is_a?(Schema::RepeatCount) }
-
-              changes = Hash.new
-              changes[:requirement] = e_requirement
-
-              if e_repeat_count.length == 1
-                changes[:repeat_count] = e_repeat_count.head
-              elsif e_repeat_count.length > 1
-                raise Exceptions::InvalidSchemaError,
-                  "more than one RepeatCount was specified"
-              end
-
-              unless e_requirement.forbidden?
-                unless e_arguments.length == u.definition.component_uses.length
-                  raise Exceptions::InvalidSchemaError,
-                    "composite element #{u.definition.id} at #{segment_def.id}" +
-                    "#{element_index} has #{u.definition.component_uses.length}" +
-                    " component elements but #{e_arguments.length} were given"
-                end
-
-                # ComponentElementUses
-                component_index = "00"
-                component_uses  = e_arguments.zip(u.definition.component_uses).map do |e1, c|
-                  c_tag, c_requirement, c_name, c_arguments = e1
-                  # component_index.succ!
-                  component_index = component_index.succ
-
-                  unless c_tag == :Element
-                    raise Exceptions::InvalidSchemaError,
-                      "given argument for #{segment_def.id}#{element_index}" +
-                      "-#{component_index} must be Element(...)"
-                  end
-
-                  mod_element(c, c_requirement, c_name, c_arguments)
-                end
-
-                changes[:definition] = u.definition.copy(:name           => e_name,
-                                                         :component_uses => component_uses)
-              else
-                changes[:definition] = u.definition.copy(:name => e_name)
-              end
-
-              u.copy(changes)
-            else
-              mod_element(u, e_requirement, e_name, e_arguments)
-            end
-          end
-
-          segment_def.copy(:name => name).
-            copy(:element_uses => element_uses).
-            use(position, requirement, repeat_count)
-        end
-
-        # @endgroup
-        #######################################################################
-
-       private
-
-        # @return [Schema::SimpleElementUse]
-        def mod_element(element_use, requirement, name, arguments)
-          unless requirement.is_a?(Schema::ElementReq)
-            raise Exceptions::InvalidSchemaError,
-              "first argument to Element must be a Schema::ElementReq but got #{requirement.inspect}"
-          end
-
-          unless name.is_a?(String)
-            raise Exceptions::InvalidSchemaError,
-              "element name must be a String"
-          end
-
-          changes = Hash.new # changes to SegmentUse
-          dhanges = Hash.new # changes to SegmentDef
-
-          changes[:requirement] = requirement
-          changes[:definition]  = element_use.definition.copy(:name => name)
-
-          repeat_count = arguments.select{|x| x.is_a?(Schema::RepeatCount) }
-
-          if repeat_count.length == 1
-            changes[:repeat_count] = repeat_count.head
-          elsif repeat_count.length > 1
-            raise Exceptions::InvalidSchemaError,
-              "more than one RepeatCount specified for this Element"
-          end
-
-          allowed_values = arguments.select{|x| x.is_a?(Array) and x.head == :Values }
-
-          if allowed_values.length == 1
-            changes[:allowed_values] = element_use.allowed_values.replace(allowed_values.head.last)
-          elsif allowed_values.length > 1
-            raise Exceptions::InvalidSchemaError,
-              "more than one Values specified for this Element"
-          end
-
-          max_length = arguments.select{|x| x.is_a?(Array) and x.head == :MaxLength }
-
-          if max_length.length == 1
-            dhanges[:max_length] = max_length.head.last
-          elsif max_length.length > 1
-            raise Exceptions::InvalidSchemaError,
-              "more than one MaxLength specified for this Element"
-          end
-
-          if dhanges.empty?
-            element_use.copy(changes)
-          else
-            element_use.copy(changes.merge(:definition =>
-              element_use.definition.copy(dhanges)))
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/stupidedi/guides/005010/segment_reqs.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-
-  module Guides
-    module FiftyTen
-
-      #
-      # @see X222.pdf 2.2 Implementation Usage
-      #
-      module SegmentReqs
-
-        # Declares that this segment must always be sent. Required segments
-        # within Situational loops only occur when the loop occurs.
-        Required = Schema::SegmentReq.new(true,  false, "R")
-
-        # Use of this segment varies, depending on data content and business
-        # context as described in the defining rule. The defining rule is
-        # documented in a Situational Rule attached to the segment.
-        #
-        # There are two forms of Situational Rules. The first is "Required when
-        # <condition>. If not required by <condition>, the segment may be
-        # provided at the discretion of the sender, but it cannot be required or
-        # requested by the receiver.'
-        #
-        # The other form is "Required when <condition>. If not required by
-        # <condition>, do not send". The segment described by the rule cannot
-        # occur except when the condition holds.
-        Situational = Schema::SegmentReq.new(false, false, "S")
-
-      end
-
-    end
-  end
-end

data/lib/stupidedi/schema/element_def.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  module Schema
-
-    class AbstractElementDef < AbstractDef
-      include Inspect
-
-      # @return [String]
-      attr_reader :id
-
-      # @return [String]
-      attr_reader :name
-
-      # @return [String]
-      attr_reader :description
-
-      abstract :simple?
-
-      abstract :composite?
-
-      # @return [AbstractSet<CodeList>]
-      abstract :code_lists
-
-      def element?
-        true
-      end
-    end
-
-    #
-    # @see X222 B.1.1.3.1 Data Element
-    #
-    class SimpleElementDef < AbstractElementDef
-
-      # @return [SimpleElementUse, ComponentElementUse]
-      abstract :parent
-
-      # @return [SimpleElementVal]
-      abstract :empty, :args => %w(position)
-
-      # @return [SimpleElementVal]
-      abstract :value, :args => %w(object position)
-
-      # @return [SimpleElementVal]
-      abstract :parse, :args => %w(string position)
-
-      # @return true
-      def simple?
-        true
-      end
-
-      # @return false
-      def composite?
-        false
-      end
-
-      # @return [SimpleElementUse]
-      def simple_use(requirement, repeat_count, parent = nil)
-        SimpleElementUse.new(self, requirement, repeat_count, Sets.universal, parent)
-      end
-
-      # @return [ComponentElementUse]
-      def component_use(requirement, parent = nil)
-        ComponentElementUse.new(self, requirement, Sets.universal, parent)
-      end
-
-      # This is overridden (if needed) by the concrete subclasses. Specifically
-      # the "ID" element types have an extra attribute to link the CodeList.
-      #
-      # @return [AbstractSet<CodeList>]
-      def code_lists(subset = Sets.universal)
-        Sets.empty
-      end
-    end
-
-    #
-    # @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