stupidedi 1.2.20 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc8ac588bac665066d84b4df50b9641d94835f44671ad43a189bad11c6ad8101
-  data.tar.gz: e556a6c96516ee2bd4aae9b2fa5c969331e0ea1d1473e2f32e8f130bfda94989
+  metadata.gz: 1ebce60d52d11cc5d750be833dedaa9c143becc4bebfe15a4d4a91c7934ad08b
+  data.tar.gz: aea17d716ff7be4f11ddb26e1142edfb5a42d7be8ff33bf9faa0ad8a55cf6411
 SHA512:
-  metadata.gz: 9ba36f9939ce14183eb3211ca666115ee420f74f63549bbf751714e55a06f07c0eadfe580383209c5a451cb9d9e02d485efb3536a8a352d7a1214322738585fe
-  data.tar.gz: e68250deed4fc2f0e100cfbf696d3d7d7e419730561fed7cd05e886eccdd44dc450cc133ce9f3015d86a05537d62a99573825137fd05bd4eedddd924b5a1a6d4
+  metadata.gz: 0fb54dce8ae28fd125456dbd0d82aea49c8623b99d364b689853bd4567ff8284815241b5d223f695f9fe79e20fd72d6db4850f7be6b560c820c81dccd1588c8a
+  data.tar.gz: c9da5e9c52cbbd801b02a5d8aebf466c83fccfe8902ab6e91c538fc48ecb0f0868899d21b0f67216274227e9b1b16a9e3dae03bd11a53b4b63f31f4664dfed3c

data/README.md

@@ -6,7 +6,7 @@
 
 * [GitHub project](http://github.com/irobayna/stupidedi)
 * [Human Documentation](https://github.com/irobayna/stupidedi/tree/master/doc)
-* [API Documentation](http://rubydoc.info/github/irobayna/stupidedi/master/frames)
+* [API Documentation](http://rubydoc.info/github/kputnam/stupidedi/master/frames)
 
 Stupidedi is a high-quality library for parsing, generating, validating,
 and manipulating ASC X12 EDI documents. Very roughly, it's jQuery for
@@ -143,8 +143,8 @@ memory allocation. The steady increase in throughput on JRuby and Rubinus is
 probably attributable optimizations performed by the JIT compiler.
 
 Lastly, these results should approximate the performance of document generation
-with BuilderDSL, except BuilderDSL API should have less overhead, as it skips
-the tokenizer. On the other hand, BuilderDSL frequently queries the call stack
+with BuilderDsl, except BuilderdsL API should have less overhead, as it skips
+the tokenizer. On the other hand, BuilderDsl frequently queries the call stack
 to track provenance of elements in the parse tree. In common real-world use,
 custom application logic and database access are going to bottleneck performance,
 rather than Stupidedi.
@@ -233,13 +233,15 @@ Perform validation on a file
 
 ### Generating, Writing
 
+#### X12 Writer
+
 ```ruby
 require "stupidedi"
 
 # You can customize this to delegate to your own grammar definitions, if needed.
 config = Stupidedi::Config.hipaa
 
-b = Stupidedi::Builder::BuilderDsl.build(config)
+b = Stupidedi::Parser::BuilderDsl.build(config)
 
 # These methods perform error checking: number of elements, element types, min/max
 # length requirements, conditionally required elements, valid segments, number of
@@ -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,13 +317,23 @@ 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
 require "stupidedi"
 
 config = Stupidedi::Config.hipaa
-parser = Stupidedi::Builder::StateMachine.build(config)
+parser = Stupidedi::Parser.build(config)
 
 input  = if RUBY_VERSION > "1.8"
            File.open("spec/fixtures/X221-HP835/1-good.txt", :encoding => "ISO-8859-1")

data/Rakefile

@@ -4,101 +4,26 @@ relpath = abspath.relative_path_from(Pathname.pwd)
 
 task :default => :spec
 
-task :console do
-  exec(*%w(irb -I lib -r stupidedi))
-end
-
-begin
-  require "rspec/core/rake_task"
-
-  RSpec::Core::RakeTask.new do |t|
-    t.verbose = false
-
-    t.rspec_opts  = %w(--color --format p)
-    t.rspec_opts << "-I#{abspath}/spec"
-  end
-rescue LoadError => first
-  begin
-    require "spec/rake/spectask"
-
-    Spec::Rake::SpecTask.new do |t|
-      t.spec_opts << "--color"
-      t.spec_opts << "--format p"
-      t.libs << "#{abspath}/spec"
-    end
-  rescue LoadError => second
-    task :spec do
-      warn "couldn't load rspec version 1 or 2:"
-      warn "  #{first}"
-      warn "  #{second}"
-      exit 1
-    end
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose    = false
+  t.rspec_opts = %w(-w -rspec_helper)
+
+  if ENV.include?("CI") or ENV.include?("TRAVIS")
+    t.rspec_opts += %w(--format progress)
+  else
+    t.rspec_opts += %w(--format documentation)
   end
 end
 
-begin
-  require "rcov"
-
-  begin
-    require "rspec/core/rake_task"
-    RSpec::Core::RakeTask.new(:rcov) do |t|
-      t.rcov = true
-      t.rcov_opts = "--exclude spec/,gems/,00401"
-
-      t.verbose = false
-
-      t.rspec_opts  = %w(--color --format p)
-      t.rspec_opts << "-I#{abspath}/spec"
-    end
-  rescue LoadError => first
-    begin
-      require "spec/rake/spectask"
-      Spec::Rake::SpecTask.new(:rcov) do |t|
-        t.rcov = true
-        t.rcov_opts = %w(--exclude spec/,gems/)
-
-        t.spec_opts << "--color"
-        t.spec_opts << "--format=p"
-        t.libs << "#{abspath}/spec"
-      end
-    rescue LoadError => second
-      task :rcov do
-        warn "couldn't load rspec version 1 or 2:"
-        warn "  #{first}"
-        warn "  #{second}"
-        exit 1
-      end
-    end
-  end
-rescue LoadError => e
-  task :rcov do
-    warn "couldn't load rcov:"
-    warn "  #{e}"
-    exit 1
-  end
-end if RUBY_VERSION <= "1.9"
-
-if RUBY_VERSION >= "1.9"
-  # spec/spec_helper.rb will load SimpleCov
-  task :rcov => :spec do
-  end
+# Note options are loaded from .yardopts
+require "yard"
+YARD::Rake::YardocTask.new(:yard => :clobber_yard)
+task :clobber_yard do
+  rm_rf "#{relpath}/build/generated/doc"
+  mkdir_p "#{relpath}/build/generated/doc/images"
 end
 
-begin
-  require "yard"
-
-  # Note options are loaded from .yardopts
-  YARD::Rake::YardocTask.new(:yard => :clobber_yard)
-
-  task :clobber_yard do
-    rm_rf "#{relpath}/doc/generated"
-    mkdir_p "#{relpath}/doc/generated/images"
-  end
-
-rescue LoadError => e
-  task :yard do
-    warn "couldn't load yard:"
-    warn "  #{e}"
-    exit 1
-  end
+task :console do
+  exec(*%w(irb -I lib -r stupidedi))
 end

data/bin/edi-ed

@@ -2,28 +2,24 @@
 require "pathname"
 $:.unshift(File.expand_path("../../lib", Pathname.new(__FILE__).realpath))
 
-# Short-lived processes should win some peformance gains here
-GC.disable
-
 require "stupidedi"
 require "pp"
 
 # This will be auto-enabled when $stdout.tty?, but -C forces color output
 require "term/ansicolor" if ARGV.delete("-C")
 
-# config = Stupidedi::Config.default
-# config = Stupidedi::Config.contrib
 config = Stupidedi::Config.hipaa
 config.editor.tap do |c|
-  c.register(Stupidedi::Versions::Interchanges::FourOhOne::InterchangeDef) { Stupidedi::Editor::FiveOhOneEd }
-  c.register(Stupidedi::Versions::Interchanges::FiveOhOne::InterchangeDef) { Stupidedi::Editor::FiveOhOneEd }
-  c.register(Stupidedi::Versions::FunctionalGroups::FortyTen::FunctionalGroupDef) { Stupidedi::Editor::FiftyTenEd }
-  c.register(Stupidedi::Versions::FunctionalGroups::FiftyTen::FunctionalGroupDef) { Stupidedi::Editor::FiftyTenEd }
-  c.register(Stupidedi::Guides::FiftyTen::X222::HC837P) { Stupidedi::Editor::X222 }
-  c.register(Stupidedi::Guides::FiftyTen::X222A1::HC837P) { Stupidedi::Editor::X222 }
+  c.register(Stupidedi::Interchanges::FourOhOne::InterchangeDef) { Stupidedi::Editor::FiveOhOneEd }
+  c.register(Stupidedi::Interchanges::FiveOhOne::InterchangeDef) { Stupidedi::Editor::FiveOhOneEd }
+
+  c.register(Stupidedi::Versions::FortyTen::FunctionalGroupDef) { Stupidedi::Editor::FiftyTenEd }
+  c.register(Stupidedi::Versions::FiftyTen::FunctionalGroupDef) { Stupidedi::Editor::FiftyTenEd }
+
+  c.register(Stupidedi::TransactionSets::FiftyTen::Implementations::X222A1::HC837) { Stupidedi::Editor::X222 }
 end
 
-parser = Stupidedi::Builder::StateMachine.build(config)
+parser = Stupidedi::Parser.build(config)
 start  = Time.now
 
 ARGV.each do |path|

data/bin/edi-obfuscate

@@ -0,0 +1,111 @@
+#!/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_x12(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
+
+  case type
+  when /AN$/
+    e.copy(value: "_" * u.definition.min_length)
+  when "TM"
+    e.copy(value: "0" * u.definition.min_length)
+  when "DT"
+    e.copy(value: "0" * u.definition.min_length)
+  when "Nn", "R"
+    e.copy(value: "0" * u.definition.min_length)
+  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/bin/edi-pp

@@ -2,44 +2,50 @@
 require File.expand_path("../../lib/stupidedi", __FILE__)
 require "pp"
 
-# Short-lived processes should win some peformance gains here
-GC.disable
-
 # This will be auto-enabled when $stdout.tty?, but -C forces color output
 require "term/ansicolor" if ARGV.delete("-C")
+if idx = ARGV.index("--format")
+  ARGV.delete("--format")
+  format = ARGV.delete_at(idx)
+else
+  format = "tree"
+end
+
+unless %w(html tree x12).include?(format)
+  $stderr.puts "unrecognized format (expected html, tree, or x12)"
+  exit(1)
+end
 
 config = Stupidedi::Config.contrib(Stupidedi::Config.hipaa(Stupidedi::Config.default))
-parser = Stupidedi::Builder::StateMachine.build(config)
+parser = Stupidedi::Parser.build(config)
 start  = Time.now
-nondet = ARGV.delete('-N')
 
 ARGV.each do |path|
   # Reading the entire input at once is slightly faster than streaming
   # from a file handle.
+  #
   # content   = File.read(path, :encoding => "ISO-8859-1")
   # parser, r = parser.read(Stupidedi::Reader.build(content))
-
-  File.open(path) do |io|
-    parser, _result = parser.read(Stupidedi::Reader.build(io))
-  end
+  #
+  reader  = Stupidedi::Reader.build(File.read(path))
+  parser, = parser.read(reader)
 end
 
 stop = Time.now
 
-parser.zipper.map{|z| pp z.root.node }.explain do
-  # Multiple parse trees (non-deterministic state)
-  unless nondet
-    puts "Non-deterministic state"
-  else
-    puts "Non-deterministic states (#{parser.active.length}):"
-    puts "#{"-" * 70}\n\n"
-
-    parser.active.each do |state|
-      zipper = state.node.zipper
-      pp zipper.root.node
-      puts "\n#{"-" * 70}\n\n"
-    end
-  end
+case format
+when "tree"
+  parser.zipper.tap{|z| pp z.root.node }
+when "html"
+  Stupidedi::Writer::Claredi.new(parser.zipper.fetch.root.node).write($stdout)
+when "x12"
+  separators = Stupidedi::Reader::Separators.build \
+    :segment    => "~\n",
+    :element    => "*",
+    :component  => ":",
+    :repetition => "^"
+
+  Stupidedi::Writer::Default.new(parser.zipper.fetch.root, separators).write($stdout)
 end
 
 begin
@@ -47,7 +53,7 @@ begin
   b = parser.last
 
   a.flatmap{|a1| b.flatmap{|b1| a1.distance(b1) }}.
-    tap{|d| puts "#{d + 1} segments" }
+    tap{|d| $stderr.puts "#{d + 1} segments" }
 end
 
-puts "%0.3f seconds" % (stop - start)
+$stderr.puts "%0.3f seconds" % (stop - start)

data/lib/ruby/array.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
-
 module Stupidedi
   module Refinements
-
     refine Array do
       def blank?
         empty?
@@ -18,7 +16,7 @@ module Stupidedi
       #   [1, 2, 3].head  #=> 1
       #
       def head
-        raise IndexError, "head of empty list" if empty?
+        raise IndexError, "head of empty array" if empty?
         x, = self
         x
       end
@@ -224,6 +222,5 @@ module Stupidedi
         end
       end
     end
-
   end
 end