stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/schema/abstract_element_def.rb

@@ -0,0 +1,35 @@
+# 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
+
+      # @return [String]
+      def descriptor
+        "element #{id} #{description}".strip
+      end
+
+      def element?
+        true
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/abstract_element_use.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class AbstractElementUse < AbstractUse
+      include Inspect
+
+      def_delegators :requirement, :forbidden?, :required?, :optional?
+
+      def_delegators :definition, :code_lists
+
+      # @return [Symbol]
+      abstract :id
+
+      # @return [String]
+      abstract :name
+
+      # @return [String]
+      abstract :description
+
+      # @return [ElementReq]
+      abstract :requirement
+
+      # @return [SimpleElementDef, CompositeElementDef]
+      abstract :definition
+
+      abstract :simple?
+
+      abstract :component?
+
+      # @return [SimpleElementVal, CompositeElementVal]
+      def empty(position)
+        definition.empty(self, position)
+      end
+
+      # @return [SimpleElementVal, CompositeElementVal]
+      def value(object, position)
+        definition.value(object, self, position)
+      end
+
+      def composite?
+        not simple?
+      end
+    end
+  end
+end

data/lib/stupidedi/schema/abstract_use.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
     class AbstractUse
-
       def usage?
         true
       end
@@ -15,6 +12,12 @@ module Stupidedi
         true
       end
 
+      # @return [Symbol]
+      abstract :id
+
+      # @return [String]
+      abstract :descriptor
+
       #
       #########################################################################
 
@@ -72,6 +75,5 @@ module Stupidedi
         false
       end
     end
-
   end
 end

data/lib/stupidedi/schema/code_list.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
     class CodeList
       include Inspect
 
@@ -15,7 +13,6 @@ module Stupidedi
       end
 
       class Internal < CodeList
-
         def_delegators :@hash, :at, :defined_at?
 
         def initialize(hash)
@@ -54,7 +51,6 @@ module Stupidedi
       end
 
       class External < CodeList
-
         # @return [String]
         attr_reader :id
 
@@ -82,6 +78,12 @@ module Stupidedi
 
       # @return [CodeList::Internal]
       def build(hash)
+        # @todo: deprecate
+        CodeList::Internal.new(hash)
+      end
+
+      # @return [CodeList::Internal]
+      def internal(hash)
         CodeList::Internal.new(hash)
       end
 
@@ -93,6 +95,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
-
   end
 end

data/lib/stupidedi/schema/component_element_use.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Schema
+    class ComponentElementUse < AbstractElementUse
+      # @return [SimpleElementDef]
+      attr_reader :definition
+
+      def_delegators :definition, :id, :name, :description
+
+      # @return [ElementReq]
+      attr_reader :requirement
+
+      # @return [CompositeElementDef]
+      attr_reader :parent
+
+      # @return [AbstractSet]
+      attr_reader :allowed_values
+
+      def initialize(definition, requirement, allowed_values, parent)
+        @definition, @requirement, @allowed_values, @parent =
+          definition, requirement, 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 [ComponentElementUse]
+      def copy(changes =  {})
+        ComponentElementUse.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:requirement, @requirement),
+          changes.fetch(:allowed_values, @allowed_values),
+          changes.fetch(:parent, @parent)
+      end
+
+      # @return [String]
+      def descriptor
+        n = parent.parent.parent.element_uses.index{|u| u.eql?(parent.parent) } + 1
+        m = parent.component_uses.index{|u| u.eql?(self) } + 1
+        "element #{parent.parent.parent.id}#{"%02d-%02d" % [n, m]} #{definition.name}".strip
+      end
+
+      # @return false
+      def repeatable?
+        false
+      end
+
+      # @return true
+      def simple?
+        true
+      end
+
+      # @return true
+      def component?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("ComponentElementUse")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @definition
+          q.text ","
+          q.breakable
+          q.pp @requirement
+        end
+      end
+    end
+  end
+end

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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Schema
-
+    #
     # The 5010 X12 "condition designator"s include
     #   M - Mandatory
     #   O - Optional
@@ -24,7 +23,6 @@ module Stupidedi
     # @see X222.pdf 2.2.1 Industry Usage
     #
     class ElementReq
-
       def initialize(required, forbidden, to_s)
         @required, @forbidden, @to_s =
           required, forbidden, to_s
@@ -55,6 +53,5 @@ module Stupidedi
         @to_s
       end
     end
-
   end
 end