stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/parser/states/transmission_state.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    class TransmissionState < AbstractState
+      # @return [Reader::Separators]
+      attr_reader :separators
+
+      # @return [Reader::SegmentDict]
+      attr_reader :segment_dict
+
+      # @return [InstructionTable]
+      attr_reader :instructions
+
+      # @return [Zipper::AbstractCursor]
+      attr_reader :zipper
+
+      # @return [Array<AbstractState>]
+      attr_reader :children
+
+      def initialize(separators, segment_dict, instructions, zipper, children)
+        @separators, @segment_dict, @instructions, @zipper, @children =
+          separators, segment_dict, instructions, zipper, children
+      end
+
+      # @return [TransmissionState]
+      def copy(changes = {})
+        TransmissionState.new \
+          changes.fetch(:separators, @separators),
+          changes.fetch(:segment_dict, @segment_dict),
+          changes.fetch(:instructions, @instructions),
+          changes.fetch(:zipper, @zipper),
+          changes.fetch(:children, @children)
+      end
+    end
+
+    class << TransmissionState
+      # @group Constructors
+      #########################################################################
+
+      # @return [Zipper::AbstractCursor]
+      def push(zipper, parent, segment_tok, segment_use, config)
+        zipper = zipper.append_child new(
+          parent.separators,
+          parent.segment_dict,
+          parent.instructions.push([
+            Instruction.new(:ISA, nil, 0, 0, InterchangeState)]),
+          parent.zipper.dangle.last,
+          [])
+
+        InterchangeState.push(zipper, zipper.node, segment_tok, segment_use, config)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/parser/tokenization.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Parser
+    module Tokenization
+      #########################################################################
+      # @group Element Constructors
+
+      # Generates a repeated element (simple or composite)
+      #
+      # @return [void]
+      def repeated(*elements)
+        [:repeated, elements, Reader::Position.caller(2)]
+      end
+
+      # Generates a composite element
+      #
+      # @return [void]
+      def composite(*components)
+        [:composite, components, Reader::Position.caller(2)]
+      end
+
+      #########################################################################
+      # @group Element Placeholders
+
+      # Generates a blank element
+      #
+      # @return [void]
+      def blank
+        [:blank, nil, Reader::Position.caller(2)]
+      end
+
+      # Generates a blank element and asserts that the element's usage
+      # requirement is `NOT USED`
+      #
+      # @see Schema::ElementReq#forbidden?
+      #
+      # @return [void]
+      def not_used
+        [:not_used, nil, Reader::Position.caller(2)]
+      end
+
+      # Generates the only possible value an element may have, which may
+      # be blank. An exception is thrown if the element's usage requirement
+      # is optional, or if there are more than one allowed non-blank values.
+      #
+      # @see Schema::SimpleElementUse#allowed_values
+      # @see Schema::ElementReq#forbidden?
+      #
+      # @return [void]
+      def default
+        [:default, nil, Reader::Position.caller(2)]
+      end
+
+      # @endgroup
+      #########################################################################
+
+    private
+
+      # @return [Reader::SegmentTok]
+      def mksegment_tok(segment_dict, id, elements, position)
+        id = id.to_sym
+        element_toks = []
+
+        unless segment_dict.defined_at?(id)
+          element_idx  = "00"
+          elements.each do |e_tag, e_val, e_position|
+            element_idx = element_idx.succ
+
+            # If the element is a regular Ruby value "ABC", the way this
+            # proc's arguments are assigned would be e_tag = "ABC", and
+            # e_val and e_position are nil. If the argument is a placeholder
+            # like #blank, #not_used, or #default is used, those methods return
+            # a triple that is deconstructed such that e_val is also nil.
+            #
+            # However, for #composite or #repeated, the triple is deconstructed
+            # such that e_val is an Array of other values, and isn't #nil?
+            unless e_val.nil?
+              raise ArgumentError,
+                "#{id}#{element_idx} is assumed to be a simple element"
+            end
+
+            element_toks << mksimple_tok(e_tag, e_position || position)
+          end
+        else
+          segment_def  = segment_dict.at(id)
+          element_uses = segment_def.element_uses
+
+          if elements.length > element_uses.length
+            raise ArgumentError,
+              "#{id} segment has only #{element_uses.length} elements"
+          end
+
+          element_idx  = "00"
+          elements.zip(element_uses) do |(e_tag, e_val, e_position), e_use|
+            element_idx = element_idx.succ
+            designator = "#{id}#{element_idx}"
+
+            if e_use.repeatable?
+              # Repeatable composite or non-composite
+              unless [:repeated, :blank, :not_used, nil].include?(e_tag)
+                raise ArgumentError,
+                  "#{designator} is a repeatable element"
+              end
+
+              element_toks << mkrepeated_tok(e_val || [], e_use, designator, e_position || position)
+            elsif e_use.composite?
+              unless [:composite, :not_used, :blank, nil].include?(e_tag)
+                raise ArgumentError,
+                  "#{id}#{element_idx} is a non-repeatable composite element"
+              end
+
+              element_toks << mkcomposite_tok(e_val || [], e_use, designator, e_position || position)
+            else
+              # The actual value is in e_tag
+              unless e_val.nil?
+                raise ArgumentError,
+                  "#{id}#{element_idx} is a non-repeatable simple element"
+              end
+
+              element_toks << mksimple_tok(e_tag, e_position || position)
+            end
+          end
+        end
+
+        Reader::SegmentTok.new(id, element_toks, position, nil)
+      end
+
+      # @return [Reader::RepeatedElementTok]
+      def mkrepeated_tok(elements, element_use, designator, position)
+        element_toks = []
+
+        if element_use.composite?
+          elements.each do |e_tag, e_val, e_position|
+            unless [:composite, :not_used, :blank, nil].include?(e_tag)
+              raise ArgumentError,
+                "#{designator} is a composite element"
+            end
+
+            element_toks << mkcomposite_tok(e_val || [], element_use, designator, e_position || position)
+          end
+        else
+          elements.each do |e_tag, e_val, e_position|
+            unless e_val.nil?
+              raise ArgumentError,
+                "#{designator} is a simple element"
+            end
+
+            element_toks << mksimple_tok(e_tag, e_position || position)
+          end
+        end
+
+        Reader::RepeatedElementTok.build(element_toks, position)
+      end
+
+      # @return [Reader::CompositeElementTok]
+      def mkcomposite_tok(components, composite_use, designator, position)
+        component_uses = composite_use.definition.component_uses
+
+        if components.length > component_uses.length
+          raise ArgumentError,
+            "#{designator} has only #{component_uses.length} components"
+        end
+
+        component_idx  = "0"
+        component_toks = []
+        component_uses.zip(components) do |c_use, (c_tag, c_val, c_position)|
+          component_idx = component_idx.succ
+          unless c_val.nil?
+            raise ArgumentError,
+              "#{designator}-#{component_idx} is a component element"
+          end
+
+          component_toks << mkcomponent_tok(c_tag, c_position || position)
+        end
+
+        Reader::CompositeElementTok.build(component_toks, position, nil)
+      end
+
+      # @return [Reader::ComponentElementTok]
+      def mkcomponent_tok(value, position)
+        Reader::ComponentElementTok.build(value, position, nil)
+      end
+
+      # @return [Reader::SimpleElementTok]
+      def mksimple_tok(value, position)
+        Reader::SimpleElementTok.build(value, position, nil)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/reader.rb

@@ -58,7 +58,6 @@ module Stupidedi
     #_CONTROL  = Regexp.new("[^#{Regexp.quote(H_EITHER.keys.join)}]")
 
     class << self
-
       # @group Constructors
       #########################################################################
 
@@ -118,6 +117,5 @@ module Stupidedi
         C_BYTES.split(//) - H_EITHER.keys
       end
     end
-
   end
 end

data/lib/stupidedi/reader/input.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Reader
-
     module Input
     end
 
@@ -29,6 +27,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
-
   end
 end

data/lib/stupidedi/reader/input/abstract_input.rb

@@ -3,14 +3,13 @@ module Stupidedi
   using Refinements
 
   module Reader
-
     #
     # Provides an abstract interface for a positioned cursor within an
     # element-based input stream. The main operations are implemented by the
     # {#take} and {#drop} methods.
     #
     # The {DelegatedInput} subclass wraps values that already implement the
-    # interface, like {String} and {Array}. The {FileInput} subclass wraps
+    # interface, like `String` and `Array`. The {FileInput} subclass wraps
     # opened `IO` streams like `File`, and possibly others.
     #
     # @example Reading the input
@@ -44,10 +43,10 @@ module Stupidedi
     #     in.column   #=> 1
     #   end
     #
-    # @note The monkey-patched classes {String} and {Array} provide compatible
+    # @note The `String` and `Array` refinements in `lib/ruby` provide compatible
     #   implementations of the abstract methods, so code written to target
-    #   this interface is backward-compatable with plain unwrapped {String}
-    #   and {Array} values.
+    #   this interface is backward-compatable with plain unwrapped `String`
+    #   and `Array` values.
     #
     class AbstractInput
       include Inspect
@@ -134,6 +133,5 @@ module Stupidedi
       # @return [Boolean]
       abstract :==, :args => %w(other)
     end
-
   end
 end

data/lib/stupidedi/reader/input/delegated_input.rb

@@ -3,9 +3,7 @@ module Stupidedi
   using Refinements
 
   module Reader
-
     class DelegatedInput < AbstractInput
-
       def initialize(delegate, offset = 0, line = 1, column = 1)
         @delegate, @offset, @line, @column =
           delegate, offset, line, column
@@ -35,11 +33,9 @@ module Stupidedi
       def_delegators :@delegate, :take
 
       # (see AbstractInput#at)
-
       def_delegators :@delegate, :at
 
       # (see AbstractInput#index)
-
       def_delegators :@delegate, :index
 
       # @group Advancing the Cursor
@@ -112,6 +108,5 @@ module Stupidedi
           changes.fetch(:column, @column)
       end
     end
-
   end
 end

data/lib/stupidedi/reader/input/file_input.rb

@@ -3,15 +3,13 @@ module Stupidedi
   using Refinements
 
   module Reader
-
     #
     # @note This class is not thread-safe. If more than one `Thread` has access
-    #   to the same instance, and they simultaneously call methods on that
-    #   instance, the methods may produce incorrect results and the object might
-    #   be left in an inconsistent state.
+    # to the same instance, and they simultaneously call methods on that
+    # instance, the methods may produce incorrect results and the object might
+    # be left in an inconsistent state.
     #
     class FileInput < AbstractInput
-
       # @return [IO]
       attr_reader :io
 
@@ -64,18 +62,18 @@ module Stupidedi
       end
 
       # (see AbstractInput#index)
-      def index(value)
+      def index(element)
         @io.seek(@offset)
-        length = value.length
+        length = element.length
 
-        # We need to start with value != buffer, and this is a reasonable guess
+        # We need to start with element != buffer, and this is a reasonable guess
         buffer = "\377" * length
 
         until @io.eof?
           buffer.slice!(0)
           buffer = buffer + @io.read(1)
 
-          if buffer == value
+          if buffer == element
             return @io.tell - @offset - length
           end
         end
@@ -90,7 +88,7 @@ module Stupidedi
 
         @io.seek(@offset)
         prefix = @io.read(n)
-        suffix = @io
+        # suffix = @io
 
         length = prefix.length
         count  = prefix.count("\n")
@@ -124,6 +122,7 @@ module Stupidedi
       ########################################################################
 
       # @return [void]
+      # :nocov:
       def pretty_print(q)
         q.text("FileInput")
         q.group(2, "(", ")") do
@@ -140,6 +139,7 @@ module Stupidedi
           q.text " at line #{@line}, column #{@column}, offset #{@offset}, file #{File.basename(@io.path)}"
         end
       end
+      # :nocov:
 
     private
 
@@ -153,6 +153,5 @@ module Stupidedi
           changes.fetch(:size, @size)
       end
     end
-
   end
 end

data/lib/stupidedi/reader/position.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
-
 module Stupidedi
   using Refinements
 
   module Reader
-
     class Position
-      include Inspect
-
       # @return [Integer]
       attr_reader :offset
 
@@ -33,13 +29,23 @@ module Stupidedi
           changes.fetch(:path, @path)
       end
 
+      def to_s
+        inspect
+      end
+
       # @return [String]
       def inspect
         if @path.present?
-          "file #{@path}, line #{@line}, column #{@column}"
+          parts = ["file #{@path}", "line #{@line}"]
         else
-          "line #{@line}, column #{@column}"
+          parts = ["line #{@line}"]
         end
+
+        if @column.present?
+          parts << "column #{@column}"
+        end
+
+        parts.join(", ")
       end
 
       # @return [void]
@@ -64,10 +70,9 @@ module Stupidedi
 
     class << Position
       def caller(offset = 1)
-        path, line, method = Stupidedi.caller(offset + 1)
+        path, line, = Stupidedi.caller(offset + 1)
         new(nil, line, nil, path)
       end
     end
-
   end
 end