stupidedi 1.2.20 → 1.3.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8ac588bac665066d84b4df50b9641d94835f44671ad43a189bad11c6ad8101
-  data.tar.gz: e556a6c96516ee2bd4aae9b2fa5c969331e0ea1d1473e2f32e8f130bfda94989
+  metadata.gz: dca3cbe38e197d5e24eb127bb9ea501a7417e8ebdef6ce29c0841cd8a7f618f8
+  data.tar.gz: d7d967d793ee60bed8b4f4794f1168a102c07369db5deb1814727ff14d6a4b4e
 SHA512:
-  metadata.gz: 9ba36f9939ce14183eb3211ca666115ee420f74f63549bbf751714e55a06f07c0eadfe580383209c5a451cb9d9e02d485efb3536a8a352d7a1214322738585fe
-  data.tar.gz: e68250deed4fc2f0e100cfbf696d3d7d7e419730561fed7cd05e886eccdd44dc450cc133ce9f3015d86a05537d62a99573825137fd05bd4eedddd924b5a1a6d4
+  metadata.gz: 075d7961db6721b5e60125c7a1fc98e58ed1a2847c55dce06c9ff138a0a0d745a95ca0d798e6c38923fbdfa250b60b6c026a4242fe308d7df170385b3b44ef9c
+  data.tar.gz: a899f00431881d6edd7cbf083c551f70af676bff1cc9b21df8dcbd9bc41723bf8dab402484f3a028b79b05c7abcbec745c3b95dd854c10a0c9337d62e03eb632

data/README.md

@@ -233,6 +233,8 @@ Perform validation on a file
 
 ### Generating, Writing
 
+#### X12 Writer
+
 ```ruby
 require "stupidedi"
 
@@ -301,7 +303,9 @@ b.machine.zipper.tap do |z|
 end
 ```
 
-Please note that two writers are available. As shown above `Stupidedi::Writer::Default` will output data encoded in plain x12 format. While `Stupidedi::Writer::Claredi` will output a formatted HTML string.
+#### HTML writer
+
+ As shown above `Stupidedi::Writer::Default` will output data encoded in plain x12 format. While `Stupidedi::Writer::Claredi` will output a formatted HTML string.
 
 `Stupidedi::Writer::Claredi#write` operates on `StringIO`.
 
@@ -313,6 +317,16 @@ b.machine.zipper.tap do |z|
 end
 ```
 
+#### Json (Hash)  Writer
+
+Converting the tree to a JSON document is intentionally not included in the library. However this still may be implemented utilizing the stupidedi API.
+
+[Here](https://github.com/irobayna/stupidedi/blob/master/notes/json_writer/json.rb) is one of the possible ways to implement this.
+
+The shown approach allows to define custom traversing logic for the nodes with ability to change hash keys and values to whatever is needed.
+
+Please refer to [this readme](https://github.com/irobayna/stupidedi/blob/master/notes/json_writer/json.MD) and [these nodes implementation](https://github.com/irobayna/stupidedi/blob/master/notes/json_writer/json/) for more information.
+
 ### Reading, Traversing
 
 ```ruby

data/bin/edi-obfuscate

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+#
+# This is a utility that will strip all free-form text (elements of type AN),
+# dates, and times from an X12 file. Strings are replaced with underscores,
+# dates are replaced with 2015-12-30, and times are replaced with 00:00:00.
+#
+# When -s is given, then unrecognized elements and segments will be suppressed
+# from the output.
+#
+# Otherwise, unrecognized segments or elements will cause an exception since it
+# is not possible to know if these should be obfuscated or not (they are invalid).
+#
+require File.expand_path("../../lib/stupidedi", __FILE__)
+
+require "stupidedi"
+require "pp"
+
+# Short-lived processes should win some peformance gains here
+GC.disable
+
+def main(argv)
+  strict = !argv.delete("-s")
+  config = Stupidedi::Config.default
+  reader = Stupidedi::Reader.build(File.open(argv[0]))
+
+  # First segment (ISA) specifies separators, used for parsing
+  result = reader.read_segment
+
+  result.tap do
+    lookup = result.remainder.segment_dict.push(
+      config.interchange.at(result.fetch.element_toks[11].value).segment_dict)
+
+    reader = result.remainder.copy(segment_dict: lookup)
+    delims = result.remainder.separators.copy(component: result.fetch.element_toks[15].value)
+    reader = reader.copy(separators: delims)
+
+    while result.defined?
+      result.tap do |token|
+        if token.id == :GS
+          gs08   = result.fetch.element_toks[7].value.slice(0, 6)
+          lookup = lookup.push(config.functional_group.at(gs08).segment_dict)
+          reader = reader.copy(segment_dict: lookup)
+        end
+
+        if lookup.defined_at?(token.id)
+          segment_def  = lookup.at(token.id)
+          element_toks = token.element_toks.zip(segment_def.element_uses).map.each_with_index do |(e, u), n|
+            if u.nil?
+              raise "unrecognized element: #{token.id}-#{"%02d" % n}" if strict
+
+              # This won't terminate the inner loop immediately, but if this
+              # element is unknown, it's because there were too many elements
+              # for the given segment. So all the extra elements at the end
+              # will still be skipped
+              next
+            elsif u.simple?
+              simple(e, u)
+            else
+              composite(e, u)
+            end
+          end.compact
+
+          puts token.copy(element_toks: element_toks).to_s(delims)
+        else
+          raise "unknown segment: #{token.id}" if strict
+          next
+        end
+      end
+
+      result = reader.read_segment
+      reader = result.remainder
+    end
+
+    result.explain{|msg| raise msg } if result.fatal?
+  end
+end
+
+def simple(e, u)
+  type = u.definition.class.name
+  type = (type || "?").split("::").last
+
+  # GS-08 and ST-03 are preserved, since these have special meaning to the parser
+  if e.blank? or [:E1705, :E480].include?(u.definition.id)
+    return e
+  end
+
+  if type.end_with?("AN")
+    e.copy(value: "_" * u.definition.min_length)
+  elsif type == "TM"
+    e.copy(value: "0" * e.value.length)
+  elsif type == "DT"
+    if e.value.length == 8
+      e.copy(value: "20151230")
+    else
+      e.copy(value: "151230")
+    end
+  else
+    e
+  end
+end
+
+def composite(e, u)
+  component_toks = []
+
+  e.component_toks.zip(u.definition.component_uses) do |ce, cu|
+    component_toks.push(simple(ce, cu))
+  end
+
+  e.copy(component_toks: component_toks)
+end
+
+main(ARGV)

data/lib/stupidedi/builder/generation.rb

@@ -7,21 +7,49 @@ module Stupidedi
 
     module Generation
 
-      # @return [(StateMachine, Either<Reader::TokenReader>)]
-      def read(reader)
-        machine = self
-        reader  = reader.read_segment
-
-        while reader.defined?
-          reader = reader.flatmap do |segment_tok, reader1|
-            machine, reader =
-              machine.insert(segment_tok, reader1)
+      # Consumes all input from `reader` and returns the updated
+      # {StateMachine} along with the result of the last attempt
+      # to read a segment.
+      #
+      # The `nondeterminism` argument specifies a limit on how many
+      # parse trees can be built simultaneously due to ambiguity in
+      # the input and/or specification. This prevents runaway memory
+      # CPU consumption (see GH-129), and will return a {Result.failure}
+      # once exceeded.
+      #
+      # The default value is 1, resulting in an error if any input
+      # is ambiguous.
+      #
+      # NOTE: The error is detected *after* the resources are already
+      # been consumed. The extra parse trees are returned (in memory)
+      # via the {StateMachine} to aide diagnosis.
+      #
+      # @return [(StateMachine, Reader::Result)]
+      def read(reader, options = {})
+        limit    = options.fetch(:nondeterminism, 1)
+        machine  = self
+        reader_e = reader.read_segment
+
+        while reader_e.defined?
+          reader_e = reader_e.flatmap do |segment_tok, reader|
+            machine, reader_ =
+              machine.insert(segment_tok, reader)
+
+            if machine.active.length <= limit
+              reader_.read_segment
+            else
+              matches = machine.active.map do |m|
+                segment_def = m.node.zipper.node.definition
+                "#{segment_def.id} #{segment_def.name}"
+              end.join(", ")
 
-            reader.read_segment
+              return machine,
+                Reader::Result.failure("too much non-determinism: #{matches}", reader_.input, true)
+            end
           end
         end
 
-        return machine, reader
+        return machine, reader_e
       end
 
       # @return [(StateMachine, Reader::TokenReader)]

data/lib/stupidedi/builder/navigation.rb

@@ -453,7 +453,7 @@ module Stupidedi
       # @return       [Either<Array<Object>>]
       def iterate(id, *elements)
         a = []
-        m = find(id, *elements)
+        m = __find(false, id, elements, true)
         return m unless m.defined?
 
         while m.defined?
@@ -485,10 +485,16 @@ module Stupidedi
     private
 
       # @return [Either<StateMachine>]
-      def __find(invalid, id, elements)
+      def __find(invalid, id, elements, assert_repeatable = false)
         reachable = false
         matches   = []
 
+        # Note op.segment_use.nil? is true when searching for ISA,
+        # GS, and ST, because we can't know the SegmentUse until we
+        # deconstruct the token and looked up the versions numbers
+        # in the Config. Nonetheless, we know ISA, GS, and ST can repeat
+        repeatable = [:ISA, :GS, :ST].include?(id)
+
         @active.each do |zipper|
           matched      = false
           filter_tok   = mksegment_tok(zipper.node.segment_dict, id, elements, nil)
@@ -515,6 +521,8 @@ module Stupidedi
             state = zipper
             value = zipper.node.zipper
 
+            repeatable ||= op_.segment_use.try(:repeatable?)
+
             # 1. Move upward (possibly zero times)
             op_.pop_count.times do
               value = value.up
@@ -625,6 +633,11 @@ module Stupidedi
           end
         end
 
+        if assert_repeatable and not repeatable
+          raise Exceptions::ParseError,
+            "#{id} segment is not repeatable"
+        end
+
         if not reachable
           raise Exceptions::ParseError,
             "#{id} segment cannot be reached from the current state"

data/lib/stupidedi/either.rb

@@ -131,7 +131,7 @@ module Stupidedi
 
       # @return [Boolean]
       def ==(other)
-        other.is_a?(Either) and other.select{|x| x == @value }.defined?
+        other.is_a?(self.class) and other.select{|x| x == @value }.defined?
       end
 
       # @return [void]

data/lib/stupidedi/reader/tokens/component_element_tok.rb

@@ -21,6 +21,14 @@ module Stupidedi
           value, position, remainder
       end
 
+      # @return [CompositeElementTok]
+      def copy(changes = {})
+        ComponentElementTok.new \
+          changes.fetch(:value, @value),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @remainder)
+      end
+
       def pretty_print(q)
         q.pp(:component.cons(@value.cons))
       end
@@ -40,6 +48,10 @@ module Stupidedi
       def composite?
         false
       end
+
+      def to_s(separators)
+        @value
+      end
     end
 
     class << ComponentElementTok

data/lib/stupidedi/reader/tokens/composite_element_tok.rb

@@ -21,6 +21,14 @@ module Stupidedi
           component_toks, position, remainder
       end
 
+      # @return [CompositeElementTok]
+      def copy(changes = {})
+        CompositeElementTok.new \
+          changes.fetch(:component_toks, @component_toks),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @remainder)
+      end
+
       def pretty_print(q)
         q.pp(:composite.cons(@component_toks))
       end
@@ -48,6 +56,15 @@ module Stupidedi
       def composite?
         true
       end
+
+      def to_s(separators)
+        if blank?
+          ""
+        else
+          cs = @component_toks.map{|x| x.to_s(separators) }
+          cs.join(separators.component)
+        end
+      end
     end
 
     class << CompositeElementTok

data/lib/stupidedi/reader/tokens/segment_tok.rb

@@ -24,17 +24,35 @@ module Stupidedi
           id, element_toks, position, remainder
       end
 
+      # @return [SegmentTok]
+      def copy(changes = {})
+        SegmentTok.new \
+          changes.fetch(:id, @id),
+          changes.fetch(:element_toks, @element_toks),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @remainder)
+      end
+
       def pretty_print(q)
         q.pp(:segment.cons(@id.cons(@element_toks)))
       end
 
       def blank?
-        @element_toks.all(&:blank?)
+        @element_toks.all?(&:blank?)
       end
 
       def present?
         not blank?
       end
+
+      def to_s(separators)
+        if blank?
+          "#{id}#{separators.segment}"
+        else
+          es = @element_toks.map{|x| x.to_s(separators) }
+          id.cons(es).join(separators.element) + separators.segment
+        end
+      end
     end
 
     class << SegmentTok

data/lib/stupidedi/reader/tokens/simple_element_tok.rb

@@ -21,6 +21,14 @@ module Stupidedi
           value, position, remainder
       end
 
+      # @return [SimpleElementTok]
+      def copy(changes = {})
+        SimpleElementTok.new \
+          changes.fetch(:value, @value),
+          changes.fetch(:position, @position),
+          changes.fetch(:remainder, @remainder)
+      end
+
       def pretty_print(q)
         q.pp(:simple.cons(@value.cons))
       end
@@ -48,6 +56,10 @@ module Stupidedi
       def composite?
         false
       end
+
+      def to_s(separators)
+        @value
+      end
     end
 
     class << SimpleElementTok

data/lib/stupidedi/values/functional_group_val.rb

@@ -92,7 +92,7 @@ module Stupidedi
 
       # @return [String]
       def inspect
-        ansi.envelope("Group") << "(#{@children.map(&:inspect).join(', ')})"
+        ansi.envelope("Group") + "(#{@children.map(&:inspect).join(', ')})"
       end
 
       def ==(other)

data/lib/stupidedi/values/interchange_val.rb

@@ -88,7 +88,7 @@ module Stupidedi
 
       # @return [String]
       def inspect
-        ansi.envelope("Interchange") << "(#{@children.map(&:inspect).join(', ')})"
+        ansi.envelope("Interchange") + "(#{@children.map(&:inspect).join(', ')})"
       end
 
       # @return [Boolean]

data/lib/stupidedi/values/loop_val.rb

@@ -59,7 +59,7 @@ module Stupidedi
 
       # @return [String]
       def inspect
-        ansi.loop("Loop") << "(#{@children.map(&:inspect).join(', ')})"
+        ansi.loop("Loop") + "(#{@children.map(&:inspect).join(', ')})"
       end
 
       # @return [Boolean]

data/lib/stupidedi/values/table_val.rb

@@ -55,7 +55,7 @@ module Stupidedi
 
       # @return [String]
       def inspect
-        ansi.table("Table") << "(#{@children.map(&:inspect).join(', ')})"
+        ansi.table("Table") + "(#{@children.map(&:inspect).join(', ')})"
       end
 
       # @return [Boolean]

data/lib/stupidedi/values/transaction_set_val.rb

@@ -55,7 +55,7 @@ module Stupidedi
 
       # @return [String]
       def inspect
-        ansi.envelope("Transaction") << "(#{@children.map(&:inspect).join(', ')})"
+        ansi.envelope("Transaction") + "(#{@children.map(&:inspect).join(', ')})"
       end
 
       # @return [Boolean]