stupidedi 1.1.0

data/lib/stupidedi.rb

@@ -0,0 +1,66 @@
+require "bigdecimal"
+require "time"
+require "date"
+
+begin
+  require "term/ansicolor" if $stdout.tty?
+rescue LoadError
+  warn "terminal color disabled. gem install term-ansicolor to enable"
+end
+
+$:.unshift(File.expand_path("..", __FILE__))
+
+# Monkey patches
+
+#equire "ruby/exception"
+require "ruby/symbol"
+require "ruby/object"
+require "ruby/module"
+require "ruby/array"
+require "ruby/hash"
+require "ruby/enumerable"
+require "ruby/string"
+require "ruby/blank"
+require "ruby/to_d"
+require "ruby/to_date"
+require "ruby/to_time"
+require "ruby/try"
+require "ruby/instance_exec"
+
+module Stupidedi
+  autoload :Builder,      "stupidedi/builder"
+  autoload :Config,       "stupidedi/config"
+  autoload :Color,        "stupidedi/color"
+  autoload :Versions,     "stupidedi/versions"
+  autoload :Editor,       "stupidedi/editor"
+  autoload :Exceptions,   "stupidedi/exceptions"
+  autoload :Guides,       "stupidedi/guides"
+  autoload :Reader,       "stupidedi/reader"
+  autoload :Schema,       "stupidedi/schema"
+  autoload :Values,       "stupidedi/values"
+  autoload :Writer,       "stupidedi/writer"
+  autoload :Zipper,       "stupidedi/zipper"
+
+  autoload :Sets,             "stupidedi/sets"
+  autoload :Either,           "stupidedi/either"
+  autoload :Inspect,          "stupidedi/inspect"
+  autoload :TailCall,         "stupidedi/tail_call"
+  autoload :BlankSlate,       "stupidedi/blank_slate"
+  autoload :ThreadLocalVar,   "stupidedi/thread_local"
+  autoload :ThreadLocalHash,  "stupidedi/thread_local"
+
+  # We can use a much faster implementation provided by the "called_from"
+  # gem, but this only compiles against Ruby 1.8. Use this implementation
+  # when its available, but fall back to the slow Kernel.caller method if
+  # we have to
+  if RUBY_VERSION < "1.9"
+    require "called_from"
+    def self.caller(depth = 2)
+      ::Kernel.called_from(depth)
+    end
+  else
+    def self.caller(depth = 2)
+      ::Kernel.caller.at(depth - 1).try(:split, ":")
+    end
+  end
+end

data/spec/examples/integration/generating.example

@@ -0,0 +1,551 @@
+require "spec_helper"
+
+describe "Generating" do
+  include NavigationMatchers
+
+  let(:config)  { Stupidedi::Config.default }
+  let(:strict)  { Stupidedi::Builder::BuilderDsl.build(config, true)  }
+  let(:relaxed) { Stupidedi::Builder::BuilderDsl.build(config, false) }
+
+  context "unrecognized methods" do
+    it "raises an exception" do
+      lambda { relaxed.xyz }.should \
+        raise_error(NoMethodError)
+    end
+  end
+
+  context "unrecognized interchange version" do
+    def isa(dsl, version)
+      dsl.ISA("00", "",
+              "00", "",
+              "ZZ", "",
+              "ZZ", "",
+              Time.now.utc,
+              Time.now.utc,
+              "", version, 123456789, "1", "T", "")
+    end
+
+    context "when non-strict" do
+      it "quietly proceeds" do
+        # 0050x isn't configured
+        isa(relaxed, "0050x")
+
+        # An invalid ISA segment was added
+        relaxed.zipper.select{|z| z.node.invalid? }.should be_defined
+
+        # It's parent is an InvalidEnvelopeVal
+        relaxed.zipper.select{|z| z.parent.node.invalid? }.should be_defined
+      end
+    end
+
+    context "when strict" do
+      it "loudly complains" do
+        lambda do
+          isa(strict, "0050x")
+        end.should raise_error('unknown interchange version "0050x"')
+
+        # The ISA segment wasn't added
+        relaxed.should be_empty
+      end
+    end
+  end
+
+  context "interchange 00501" do
+    context "tracks separators" do
+      def isa(dsl, component = ":", repetition = "^")
+        dsl.ISA("00", "",
+                "00", "",
+                "ZZ", "431777999",
+                "ZZ", "133052274",
+                Time.now.utc,
+                Time.now.utc,
+                repetition, "00501", 123456789, "1", "T",
+                component)
+      end
+
+      it "on the first interchange" do
+        isa(relaxed, ":", "^")
+
+        relaxed.machine.separators.component.should == ":"
+        relaxed.machine.separators.repetition.should == "^"
+      end
+
+      it "on subsequent interchanges" do
+        isa(relaxed, "$", "%")
+        isa(relaxed, "@", "#")
+
+        relaxed.machine.separators.component.should == "@"
+        relaxed.machine.separators.repetition.should == "#"
+
+        relaxed.machine.prev.tap do |machine|
+          machine.separators.component.should == "$"
+          machine.separators.repetition.should == "%"
+        end.should be_defined
+      end
+    end
+
+    context "with missing IEA" do
+      def isa(dsl)
+        dsl.ISA("00", "",
+                "00", "",
+                "ZZ", "431777999",
+                "ZZ", "133052274",
+                Time.now.utc,
+                Time.now.utc,
+                "", "00501", 123456789, "1", "T", "")
+      end
+
+      context "when strict" do
+        it "loudly complains" do
+          lambda { isa(strict) }.should_not \
+            raise_error("required segment IEA is missing from interchange 00501")
+
+          lambda { isa(strict) }.should \
+            raise_error("required segment IEA is missing from interchange 00501")
+
+          strict.should be_first
+        end
+      end
+
+      context "when non-strict" do
+        it "quietly proceeds" do
+          lambda { isa(relaxed) }.should_not \
+            raise_error("required segment IEA is missing from interchange 00501")
+
+          lambda { isa(relaxed) }.should_not \
+            raise_error("required segment IEA is missing from interchange 00501")
+
+          relaxed.should_not be_first
+        end
+      end
+    end
+
+    context "with mising required elements" do
+      def isa(dsl)
+        dsl.ISA("00", "",
+                "00", "",
+                "ZZ", "",
+                "ZZ", "133052274",
+                Time.now.utc,
+                Time.now.utc,
+                "", "00501", 123456789, "1", "T", "")
+      end
+
+      context "when strict" do
+        it "loudly complains" do
+          lambda { isa(strict) }.should \
+            raise_error("required element ISA06 is blank")
+
+          strict.should be_empty
+        end
+      end
+
+      context "when non-strict" do
+        it "quietly proceeds" do
+          lambda { isa(relaxed) }.should_not \
+            raise_error("required element ISA06 is blank")
+
+          relaxed.element(6).select{|e| e.node == "" }.should be_defined
+          relaxed.element(6).select{|e| e.node.empty? }.should be_defined
+        end
+      end
+    end
+
+    context "invalid values" do
+
+      context "with disallowed ID values" do
+        def isa(dsl)
+          dsl.ISA("XX", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "", "00501", 123456789, "1", "T", "")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { isa(strict) }.should \
+              raise_error("value XX not allowed in element ISA01")
+
+            strict.should be_empty
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { isa(relaxed) }.should_not \
+              raise_error("value XX not allowed in element ISA01")
+
+            relaxed.element(1).select{|e| e.node == "XX" }.should be_defined
+            relaxed.element(1).select{|e| e.node.invalid? }.should_not be_defined
+          end
+        end
+      end
+
+      context "with invalid DT values" do
+        def isa(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  "DATE",
+                  Time.now.utc,
+                  "", "00501", 123456789, "1", "T", "")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { isa(strict) }.should \
+              raise_error("invalid element ISA09")
+
+            strict.should be_empty
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { isa(relaxed) }.should_not \
+              raise_error("invalid element ISA09")
+
+            relaxed.element(9).select{|e| e.node.invalid? }.should be_defined
+            relaxed.element(9).select{|e| e.node == "DATE" }.should_not be_defined
+          end
+        end
+      end
+
+      context "with invalid TM values" do
+        def isa(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  "TIME",
+                  "", "00501", 123456789, "1", "T", "")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { isa(strict) }.should \
+              raise_error("invalid element ISA10")
+
+            strict.should be_empty
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { isa(relaxed) }.should_not \
+              raise_error("invalid element ISA10")
+
+            relaxed.element(10).select{|e| e.node.invalid? }.should be_defined
+            relaxed.element(10).select{|e| e.node == "TIME" }.should_not be_defined
+          end
+        end
+      end
+
+      context "with invalid Nn values", :ruby => "1.8" do
+        def isa(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "", "00501", "1234ABC", "1", "T", "")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { isa(strict) }.should \
+              raise_error("invalid element ISA13")
+
+            strict.should be_empty
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { isa(relaxed) }.should_not \
+              raise_error("invalid element ISA13")
+
+            relaxed.element(13).select{|e| e.node.invalid? }.should be_defined
+          end
+        end
+      end
+
+    end
+
+    context "incorrect element lengths" do
+
+      context "with Nn elements that are too long" do
+        def setup(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "^", "00501", 1234567890, "1", "T", ":")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { setup(strict) }.should \
+              raise_error("value is too long in element ISA13")
+          end
+        end
+        
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { setup(relaxed) }.should_not \
+              raise_error
+
+            relaxed.element(13).select{|e| e.node == 1234567890 }.should be_defined
+            relaxed.element(13).select{|e| e.node.too_long? }.should be_defined
+          end
+        end
+      end
+
+      context "with Nn element that are too short" do
+        # I don't know of any Nn elements that have a min_length
+        # that isn't just 1. So the #too_short? method in FixnumVal
+        # don't bother testing and returns false in every case, for
+        # simplicity.
+      end
+
+      context "with R elements that are too long" do
+      end
+
+      context "with R elements that are too short" do
+        # I don't know of any R elements that have a min_length
+        # that isn't just 1. So the #too_short? method in FloatVal
+        # don't bother testing and returns false in every case, for
+        # simplicity.
+      end
+
+      context "with AN elements that are too long" do
+        def setup(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999xxxxxxxxxxx",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "^", "00501", 123456789, "1", "T", ":")
+        end
+
+        context "when strict" do
+          it "loudly complains" do
+            lambda { setup(strict) }.should \
+              raise_error("value is too long in element ISA06")
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { setup(relaxed) }.should_not \
+              raise_error("value is too long in element ISA06")
+
+            relaxed.element(6).select{|e| e.node == "431777999xxxxxxxxxxx" }.should be_defined
+            relaxed.element(6).select{|e| e.node.too_long? }.should be_defined
+          end
+        end
+      end
+
+      context "with AN elements that are too short" do
+        # I don't know of any AN elements that have a min_length
+        # that isn't just 1. But the #too_short? method in StringVal
+        # is correctly implemented
+      end
+
+      context "with TM elements that are too long" do
+        # Because TM definitions ensure max_length is 2, 4, or greater
+        # than 6 and because of the values are parsed into TimeVals, we
+        # can always safely truncate output to max_length. So there
+        # isn't a case where a TM element value is too long
+      end
+
+      context "with TM elements that are too short" do
+        def setup(dsl, time = Time.now.utc)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  time.hour.to_s,
+                  "^", "00501", 123456789, "1", "T", ":")
+        end
+
+        context "when strict" do
+          it "complains loudly" do
+            lambda { setup(strict) }.should \
+              raise_error("value is too short in element ISA10")
+          end
+        end
+
+        context "when non-strict" do
+          it "proceeds quietly" do
+            time = Time.now.utc
+
+            lambda { setup(relaxed, time) }.should_not \
+              raise_error("value is too short in element ISA10")
+
+            relaxed.element(10).select{|e| e.node.hour == time.hour }.should be_defined
+            relaxed.element(10).select{|e| e.node.too_short? }.should be_defined
+          end
+        end
+      end
+
+      context "with DT elements that are too long" do
+        def setup(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "^", "00501", 123456789, "1", "T", ":")
+
+          dsl.GS("HC",
+                 "SENDER ID",
+                 "RECEIVER ID",
+                 "222221105",
+                 Time.now.utc, "1", "X", "005010X222")
+        end
+
+        context "when strict" do
+          it "complains loudly" do
+            lambda { setup(strict) }.should \
+              raise_error("value is too long in element GS04")
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { setup(relaxed) }.should_not \
+              raise_error("value is too long in element GS04")
+
+            relaxed.element(4).select{|e| e.node.year.should == 22222 }.should be_defined
+          end
+        end
+      end
+
+      context "with DT elements that are too short" do
+        def setup(dsl)
+          dsl.ISA("00", "",
+                  "00", "",
+                  "ZZ", "431777999",
+                  "ZZ", "133052274",
+                  Time.now.utc,
+                  Time.now.utc,
+                  "^", "00501", 123456789, "1", "T", ":")
+
+          dsl.GS("HC",
+                 "SENDER ID",
+                 "RECEIVER ID",
+                 "110605",
+                 Time.now.utc, "1", "X", "005010X222")
+        end
+
+        context "when strict" do
+          it "complains loudly" do
+            lambda { setup(strict) }.should \
+              raise_error("value is too short in element GS04")
+          end
+        end
+
+        context "when non-strict" do
+          it "quietly proceeds" do
+            lambda { setup(relaxed) }.should_not \
+              raise_error("value is too short in element GS04")
+
+            relaxed.element(4).select{|e| e.node.year.should == 11 }.should be_defined
+          end
+        end
+      end
+
+    end
+
+    context "placeholder elements" do
+      def setup(dsl, ts)
+        dsl.ISA("00", "",
+                "00", "",
+                "ZZ", "431777999",
+                "ZZ", "133052274",
+                Time.now.utc,
+                Time.now.utc,
+                "^", "00501", 123456789, "1", "T", ":")
+
+        dsl.GS("HC",
+               "SENDER ID",
+               "RECEIVER ID",
+               Time.now.utc,
+               Time.now.utc, "1", "X", ts)
+      end
+
+      context "with default element placeholder" do
+        context "when value cannot be inferred" do
+          it "raises an error" do
+            setup(relaxed, "005010X222")
+
+            lambda { relaxed.ST("837", relaxed.default, "005010X222") }.should \
+              raise_error("ST02 cannot be inferred")
+          end
+        end
+
+        context "when blank value can be inferred" do
+          it "generates an empty element" do
+            setup(relaxed, "005010X221")
+
+            lambda { relaxed.ST("835", "CONTROLNUM", relaxed.default) }.should_not \
+              raise_error("ST02 cannot be inferred")
+
+            relaxed.element(3).select{|e| e.node == "" }.should be_defined
+            relaxed.element(3).select{|e| e.node.blank? }.should be_defined
+          end
+        end
+
+        context "when non-empty value can be inferred" do
+          it "generates a non-empty element value" do
+            setup(relaxed, "005010X222")
+
+            lambda { relaxed.ST("837", "CONTROLNUM", relaxed.default) }.should_not \
+              raise_error("ST02 cannot be inferred")
+
+            relaxed.element(3).select{|e| e.node == "005010X222" }.should be_defined
+          end
+        end
+      end
+
+      context "with not_used element placeholder" do
+        context "when element is declared forbidden" do
+          it "generates an empty element" do
+            setup(relaxed, "005010X221")
+
+            lambda { relaxed.ST("835", "CONTROLNUM", relaxed.not_used) }.should_not \
+              raise_error("ST03 is not forbidden")
+
+            relaxed.element(3).select{|e| e.node == "" }.should be_defined
+            relaxed.element(3).select{|e| e.node.blank? }.should be_defined
+          end
+        end
+
+        context "when element is not declared forbidden" do
+          it "generates a non-empty element value" do
+            setup(relaxed, "005010X222")
+
+            lambda { relaxed.ST("837", "CONTROLNUM", relaxed.not_used) }.should \
+              raise_error("ST03 is not forbidden")
+          end
+        end
+      end
+
+    end
+  end
+
+  context "interchange 00401" do
+  end
+end