stupidedi 1.1.0

data/spec/examples/stupidedi/sets/null_set.example

@@ -0,0 +1,2 @@
+require "spec_helper"
+

data/spec/examples/stupidedi/sets/relative_set.example

@@ -0,0 +1,2 @@
+require "spec_helper"
+

data/spec/examples/stupidedi/sets/universal_set.example

@@ -0,0 +1 @@
+require "spec_helper"

data/spec/examples/stupidedi/versions/005010/element_types/an.example

@@ -0,0 +1,201 @@
+require "spec_helper"
+
+describe Stupidedi::Versions::FunctionalGroups::FiftyTen::ElementTypes do
+  describe "StringVal" do
+
+    let(:x5010) { Stupidedi::Versions::FunctionalGroups::FiftyTen }
+    let(:types) { x5010::ElementTypes }
+    let(:req)   { x5010::ElementReqs }
+    let(:rep)   { Stupidedi::Schema::RepeatCount }
+
+    # Dummy element definition E1: min/max length 4/10
+    let(:eldef) { types::AN.new(:E1, "String Element", 4, 10) }
+    let(:eluse) { eldef.simple_use(req::Mandatory, rep.bounded(1)) }
+
+    # Dummy file position
+    let(:position) { Stupidedi::Reader::Position.new(100, 4, 19, "test.x12") }
+
+    context "Invalid" do
+    end
+
+    context "Empty" do
+      let(:el) { eluse.value("", position) }
+
+      describe "#position" do
+        specify { el.position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { el.should be_empty }
+      end
+
+      describe "#valid?" do
+        specify { el.should be_valid }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_short }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_long }
+      end
+
+      describe "#map" do
+        specify { el.map { "abc" }.should == "abc" }
+        specify { el.map { "abc" }.should be_string }
+      end
+
+      describe "#to_s" do
+        specify { el.to_s.should == "" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { el.to_x12(true).should == "" }
+          specify { el.to_x12(true).should be_a(String) }
+        end
+
+        context "without truncation" do
+          specify { el.to_x12(false).should == "" }
+          specify { el.to_x12(false).should be_a(String) }
+        end
+      end
+
+      describe "#==" do
+        specify { el.should == el }
+        specify { el.should == "" }
+        specify { el.should == eluse.value("", position) }
+      end
+    end
+
+    context "NonEmpty" do
+      describe "#position" do
+        specify { eluse.value("ABC", position).position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { eluse.value("ABC", position).should_not be_empty }
+      end
+
+      describe "#valid?" do
+        specify { eluse.value("ABC", position).should be_valid }
+      end
+
+      describe "#too_short?" do
+        specify { eluse.value("A", position).should be_too_short }
+        specify { eluse.value("ABCD", position).should_not be_too_short }
+        specify { eluse.value("ABCDEFGHIJ", position).should_not be_too_short }
+        specify { eluse.value("ABCDEFGHIJK", position).should_not be_too_short }
+      end
+
+      describe "#too_long?" do
+        specify { eluse.value("A", position).should_not be_too_long }
+        specify { eluse.value("ABCD", position).should_not be_too_long }
+        specify { eluse.value("ABCDEFGHIJ", position).should_not be_too_long }
+        specify { eluse.value("ABCDEFGHIJK", position).should be_too_long }
+      end
+
+      describe "#to_d" do
+        specify { eluse.value("1.3", position).to_d.should == "1.3".to_d }
+      end
+
+      describe "#to_f" do
+        specify { eluse.value("1.3", position).to_f.should == "1.3".to_f }
+      end
+
+      describe "#to_s" do
+        specify { eluse.value("abc", position).to_s.should be_a(String) }
+        specify { eluse.value("abc", position).to_s.should == "abc" }
+        specify { eluse.value(" abc ", position).to_s.should == " abc" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { eluse.value("a", position).to_x12(true).should == "a   " }
+          specify { eluse.value(" a", position).to_x12(true).should == " a  " }
+          specify { eluse.value("a"*10, position).to_x12(true).should == "a"*10 }
+          specify { eluse.value("a"*11, position).to_x12(true).should == "a"*10 }
+        end
+
+        context "without truncation" do
+          specify { eluse.value("a", position).to_x12(false).should == "a   " }
+          specify { eluse.value(" a", position).to_x12(false).should == " a  " }
+          specify { eluse.value("a"*10, position).to_x12(false).should == "a"*10 }
+          specify { eluse.value("a"*11, position).to_x12(false).should == "a"*11 }
+        end
+      end
+
+      describe "#length" do
+        specify { eluse.value("abc", position).length.should == 3 }
+        specify { eluse.value("abc ", position).length.should == 3 }
+        specify { eluse.value(" abc", position).length.should == 4 }
+        specify { eluse.value(" abc ", position).length.should == 4 }
+      end
+
+      describe "#=~" do
+        specify { eluse.value("abc", position).should =~ /b/ }
+      end
+
+      describe "#map" do
+        specify { eluse.value("abc", position).map(&:upcase).should == "ABC" }
+        specify { eluse.value("abc", position).map(&:upcase).should be_string }
+      end
+
+      describe "#to_date" do
+        context "D8" do
+          subject { eluse.value("20110713", position) }
+          specify { subject.to_date("D8").should be_a(Date) }
+          specify { subject.to_date("D8").year.should == 2011 }
+          specify { subject.to_date("D8").month.should == 7 }
+          specify { subject.to_date("D8").day.should == 13 }
+        end
+
+        context "RD8 start..stop" do
+          subject { eluse.value("20080304-20110713", position) }
+          specify { subject.to_date("RD8").should be_a(Range) }
+
+          specify { subject.to_date("RD8").first.should be_a(Date) }
+          specify { subject.to_date("RD8").first.year.should == 2008 }
+          specify { subject.to_date("RD8").first.month.should == 3 }
+          specify { subject.to_date("RD8").first.day.should == 4 }
+
+          specify { subject.to_date("RD8").last.should be_a(Date) }
+          specify { subject.to_date("RD8").last.year.should == 2011 }
+          specify { subject.to_date("RD8").last.month.should == 7 }
+          specify { subject.to_date("RD8").last.day.should == 13 }
+        end
+
+        context "RD8 stop..start" do
+          subject { eluse.value("20110713-20080304", position) }
+          specify { subject.to_date("RD8").should be_a(Range) }
+
+          specify { subject.to_date("RD8").last.should be_a(Date) }
+          specify { subject.to_date("RD8").last.year.should == 2008 }
+          specify { subject.to_date("RD8").last.month.should == 3 }
+          specify { subject.to_date("RD8").last.day.should == 4 }
+
+          specify { subject.to_date("RD8").first.should be_a(Date) }
+          specify { subject.to_date("RD8").first.year.should == 2011 }
+          specify { subject.to_date("RD8").first.month.should == 7 }
+          specify { subject.to_date("RD8").first.day.should == 13 }
+        end
+      end
+
+      describe "#==" do
+        specify { eluse.value("ABC", position).should_not == "" }
+        specify { eluse.value("ABC", position).should_not == "ABC " }
+        specify { eluse.value("ABC", position).should_not == " ABC" }
+        specify { eluse.value("ABC", position).should_not == " ABC " }
+
+        specify { eluse.value("ABC", position).should == "ABC" }
+        specify { eluse.value("ABC", position).should ==
+                  eluse.value("ABC", position) }
+        specify { eluse.value("ABC ", position).should == "ABC" }
+        specify { eluse.value(" ABC", position).should == " ABC" }
+        specify { eluse.value(" ABC ", position).should == " ABC" }
+      end
+    end
+
+  end
+end

data/spec/examples/stupidedi/versions/005010/element_types/dt.example

@@ -0,0 +1,258 @@
+require "spec_helper"
+
+describe Stupidedi::Versions::FunctionalGroups::FiftyTen::ElementTypes do
+  describe "DateVal" do
+
+    let(:x5010) { Stupidedi::Versions::FunctionalGroups::FiftyTen }
+    let(:types) { x5010::ElementTypes }
+    let(:req)   { x5010::ElementReqs }
+    let(:rep)   { Stupidedi::Schema::RepeatCount }
+
+    # Dummy element definition E1: min/max length 8/8
+    let(:eldef) { types::DT.new(:E1, "Date Element", 8, 8) }
+    let(:eluse) { eldef.simple_use(req::Mandatory, rep.bounded(1)) }
+
+    # Dummy file position
+    let(:position) { Stupidedi::Reader::Position.new(100, 4, 19, "test.x12") }
+
+    context "Invalid" do
+      let(:el) { eluse.value("20090230", position) }
+
+      describe "#position" do
+        specify { el.position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { el.should_not be_empty }
+      end
+
+      describe "#valid?" do
+        specify { el.should_not be_valid }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_short }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_long }
+      end
+    end
+
+    context "Empty" do
+      let(:el) { eluse.value("", position) }
+
+      describe "#position" do
+        specify { el.position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { el.should be_empty }
+      end
+
+      describe "#valid?" do
+        specify { el.should be_valid }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_short }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_long }
+      end
+
+      describe "#map" do
+        specify { el.map { "20110713" }.should be_date }
+        specify { el.map { "20110713" }.should == "20110713" }
+
+        specify { el.map { nil }.should == nil }
+        specify { el.map { nil }.should be_date }
+      end
+
+      describe "#to_s" do
+        specify { el.to_s.should == "" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { el.to_x12(true).should == "" }
+          specify { el.to_x12(true).should be_a(String) }
+        end
+
+        context "without truncation" do
+          specify { el.to_x12(false).should == "" }
+          specify { el.to_x12(false).should be_a(String) }
+        end
+      end
+
+      describe "#==" do
+        specify { el.should == el }
+        specify { el.should == nil }
+        specify { el.should == eluse.value("", position) }
+      end
+    end
+
+    context "NonEmpty" do
+      describe "#position" do
+        specify { eluse.value("20110713", position).position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { eluse.value("20110713", position).should_not be_empty }
+      end
+
+      describe "#too_short?" do
+        specify { eluse.value("110713", position).should be_too_short }
+        specify { eluse.value("20110713", position).should_not be_too_short }
+      end
+
+      describe "#too_long?" do
+        specify { eluse.value("20110713", position).should_not be_too_long }
+        specify { eluse.value("920110713", position).should be_too_long }
+      end
+
+      describe "#to_s" do
+        specify { eluse.value("20110713", position).to_s.should be_a(String) }
+        specify { eluse.value("20110713", position).to_s.should == "2011-07-13" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { eluse.value("20110713", position).to_x12(true).should == "20110713" }
+          specify { eluse.value("920110713", position).to_x12(true).should == "20110713" }
+        end
+
+        context "without truncation" do
+          specify { eluse.value("20110713", position).to_x12(false).should == "20110713" }
+          specify { eluse.value("920110713", position).to_x12(false).should == "920110713" }
+        end
+      end
+
+      describe "#map" do
+        specify { eluse.value("20110713", position).map{|d| "" }.should be_empty }
+        specify { eluse.value("20110713", position).map{|d| Date.today }.should_not be_empty }
+        specify { eluse.value("20110713", position).map{|d| Date.today }.should_not be_invalid }
+      end
+
+      describe "#to_time" do
+        before do
+          @time = Time.now.utc
+          @date = @time.to_date
+        end
+
+        specify { eluse.value(@time, position).to_time(@time.hour, @time.min, @time.sec).to_i.should == @time.to_i }
+        specify { eluse.value(@date, position).to_time(@time.hour, @time.min, @time.sec).to_i.should == @time.to_i }
+
+        specify { eluse.value(@date, position).to_time(@time.hour, @time.min).to_date.should == @date }
+        specify { eluse.value(@date, position).to_time(@time.hour).to_date.should == @date }
+        specify { eluse.value(@date, position).to_time.to_date.should == @date }
+      end
+
+      describe "#oldest" do
+        let(:el) { eluse.value(Date.today, position) }
+        specify  { el.future.should == el }
+        specify  { el.oldest(Date.today >> 1).should == el }
+        specify  { el.oldest(Date.today >> 1).should == el }
+      end
+
+      describe "#newest" do
+        let(:el) { eluse.value(Date.today, position) }
+        specify  { el.past.should == el }
+        specify  { el.oldest(Date.today << 1).should == el }
+        specify  { el.oldest(Date.today >> 1).should == el }
+      end
+
+      describe "#==" do
+        before do
+          @time = Time.now.utc
+          @date = @time.to_date
+        end
+
+        specify { eluse.value(@time, position).should == @date }
+        specify { eluse.value(@time, position).should == @time }
+        specify { eluse.value(@date, position).should == @time }
+        specify { eluse.value(@date, position).should == @date }
+      end
+
+      describe "relational operators" do
+        before do
+          @time = Time.now.utc
+          @date = @time.to_date
+        end
+
+        specify { eluse.value(@date + 1, position).should > @date }
+        specify { eluse.value(@date + 1, position).should > @time }
+
+        specify { eluse.value(@date + 1, position).should >= @date }
+        specify { eluse.value(@date + 1, position).should >= @time }
+
+        specify { eluse.value(@date + 1, position).should_not == @date }
+        specify { eluse.value(@date + 1, position).should_not == @time }
+
+        specify { eluse.value(@date - 1, position).should < @date }
+        specify { eluse.value(@date - 1, position).should < @time }
+
+        specify { eluse.value(@date - 1, position).should <= @date }
+        specify { eluse.value(@date - 1, position).should <= @time }
+
+        specify { eluse.value(@date - 1, position).should_not == @date }
+        specify { eluse.value(@date - 1, position).should_not == @time }
+      end
+
+      # The Date and Time classes don't support type coercion until Ruby 1.9
+      describe "relational operators", :ruby => "1.9" do
+        before do
+          @time = Time.now.utc
+          @date = @time.to_date
+        end
+
+        specify { @date.should < eluse.value(@date + 1, position) }
+        specify { @time.should < eluse.value(@date + 1, position) }
+
+        specify { @date.should <= eluse.value(@date + 1, position) }
+        specify { @time.should <= eluse.value(@date + 1, position) }
+
+        specify { @time.should_not == eluse.value(@date + 1, position) }
+        specify { @date.should_not == eluse.value(@date + 1, position) }
+
+        specify { @date.should > eluse.value(@date - 1, position) }
+        specify { @time.should > eluse.value(@date - 1, position) }
+
+        specify { @date.should >= eluse.value(@date - 1, position) }
+        specify { @time.should >= eluse.value(@date - 1, position) }
+
+        specify { @date.should_not == eluse.value(@date - 1, position) }
+        specify { @time.should_not == eluse.value(@date - 1, position) }
+      end
+
+      describe "arithmatic operators" do
+        before do
+          @time = Time.now.utc
+          @date = @time.to_date
+        end
+
+        specify { (eluse.value(@date, position) + 1).should == (@date + 1) }
+        specify { (eluse.value(@date, position) >> 1).should == (@date >> 1) }
+        specify { (eluse.value(@date, position) << 1).should == (@date << 1) }
+
+        context :ruby => "1.9" do
+          specify { eluse.value(@date, position).next_month.should == @date.next_month }
+          specify { eluse.value(@date, position).prev_month.should == @date.prev_month }
+          specify { eluse.value(@date, position).next_year.should == @date.next_year }
+          specify { eluse.value(@date, position).prev_year.should == @date.prev_year }
+        end
+
+        specify { eluse.value(@date, position).succ.should == @date.succ }
+        specify { eluse.value(@date, position).next.should == @date.next }
+        specify { eluse.value(@date, position).start.should == @date.start }
+
+        specify { eluse.value(@date, position).to_s.should == @date.to_s }
+      end
+
+    end
+
+  end
+end
+
+

data/spec/examples/stupidedi/versions/005010/element_types/id.example

@@ -0,0 +1,192 @@
+require "spec_helper"
+
+describe Stupidedi::Versions::FunctionalGroups::FiftyTen::ElementTypes do
+  describe "IdentifierVal" do
+
+    let(:x5010) { Stupidedi::Versions::FunctionalGroups::FiftyTen }
+    let(:types) { x5010::ElementTypes }
+    let(:req)   { x5010::ElementReqs }
+    let(:rep)   { Stupidedi::Schema::RepeatCount }
+
+    # Dummy element definition E1: min/max length 4/10
+    let(:eldef) { types::ID.new(:E1, "Qualifier Element", 2, 4) }
+    let(:eluse) { eldef.simple_use(req::Mandatory, rep.bounded(1)) }
+
+    # Dummy file position
+    let(:position) { Stupidedi::Reader::Position.new(100, 4, 19, "test.x12") }
+
+    context "Invalid" do
+      let(:el) do
+        invalid = "whatever" 
+        class << invalid; undef_method :to_s; end
+        eluse.value(invalid, position)
+      end
+
+      describe "#position" do
+        specify { el.position.should == position }
+      end
+
+      describe "#valid?" do
+        specify { el.should_not be_valid }
+      end
+
+      describe "#empty?" do
+        specify { el.should_not be_empty }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_short }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_long }
+      end
+
+      describe "#map" do
+        specify { el.map { "xx" }.should be_id }
+        specify { el.map { "xx" }.should == "xx" }
+
+        specify { el.map { nil }.should == "" }
+        specify { el.map { nil }.should be_id }
+      end
+
+      describe "#to_s" do
+        specify { el.to_s.should == "" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { el.to_x12(true).should == "" }
+          specify { el.to_x12(true).should be_a(String) }
+        end
+
+        context "without truncation" do
+          specify { el.to_x12(false).should == "" }
+          specify { el.to_x12(false).should be_a(String) }
+        end
+      end
+    end
+
+    context "Empty" do
+      let(:el) { eluse.value("", position) }
+
+      describe "#position" do
+        specify { el.position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { el.should be_empty }
+      end
+
+      describe "#valid?" do
+        specify { el.should be_valid }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_short }
+      end
+
+      describe "#too_short?" do
+        specify { el.should_not be_too_long }
+      end
+
+      describe "#map" do
+        specify { el.map { "xx" }.should be_id }
+        specify { el.map { "xx" }.should == "xx" }
+
+        specify { el.map { nil }.should == "" }
+        specify { el.map { nil }.should be_id }
+      end
+
+      describe "#to_s" do
+        specify { el.to_s.should == "" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { el.to_x12(true).should == "" }
+          specify { el.to_x12(true).should be_a(String) }
+        end
+
+        context "without truncation" do
+          specify { el.to_x12(false).should == "" }
+          specify { el.to_x12(false).should be_a(String) }
+        end
+      end
+
+      describe "#==" do
+        specify { el.should == el }
+        specify { el.should == "" }
+        specify { el.should == eluse.value("", position) }
+      end
+    end
+
+    context "NonEmpty" do
+      describe "#position" do
+        specify { eluse.value("ABC", position).position.should == position }
+      end
+
+      describe "#empty?" do
+        specify { eluse.value("ABC", position).should_not be_empty }
+      end
+
+      describe "#too_short?" do
+        specify { eluse.value("A", position).should be_too_short }
+        specify { eluse.value("AB", position).should_not be_too_short }
+        specify { eluse.value("ABCD", position).should_not be_too_short }
+        specify { eluse.value("ABCDEF", position).should_not be_too_short }
+      end
+
+      describe "#too_long?" do
+        specify { eluse.value("A", position).should_not be_too_long }
+        specify { eluse.value("AB", position).should_not be_too_long }
+        specify { eluse.value("ABCD", position).should_not be_too_long }
+        specify { eluse.value("ABCDEF", position).should be_too_long }
+      end
+
+      describe "#to_s" do
+        specify { eluse.value("abc", position).to_s.should be_a(String) }
+        specify { eluse.value("abc", position).to_s.should == "abc" }
+        specify { eluse.value(" abc ", position).to_s.should == " abc" }
+      end
+
+      describe "#to_x12" do
+        context "with truncation" do
+          specify { eluse.value("a", position).to_x12(true).should == "a " }
+          specify { eluse.value(" a", position).to_x12(true).should == " a" }
+          specify { eluse.value("ab", position).to_x12(true).should == "ab" }
+          specify { eluse.value("abcd", position).to_x12(true).should == "abcd" }
+          specify { eluse.value("abcdef", position).to_x12(true).should == "abcd" }
+        end
+
+        context "without truncation" do
+          specify { eluse.value("a", position).to_x12(false).should == "a " }
+          specify { eluse.value(" a", position).to_x12(false).should == " a" }
+          specify { eluse.value("ab", position).to_x12(false).should == "ab" }
+          specify { eluse.value("abcdef", position).to_x12(false).should == "abcdef" }
+        end
+      end
+
+      describe "#map" do
+        specify { eluse.value("abc", position).map(&:upcase).should == "ABC" }
+        specify { eluse.value("abc", position).map(&:upcase).should be_id }
+      end
+
+      describe "#==" do
+        specify { eluse.value("ABC", position).should_not == "" }
+        specify { eluse.value("ABC", position).should_not == "ABC " }
+        specify { eluse.value("ABC", position).should_not == " ABC" }
+        specify { eluse.value("ABC", position).should_not == " ABC " }
+
+        specify { eluse.value("ABC", position).should == "ABC" }
+        specify { eluse.value("ABC", position).should ==
+                  eluse.value("ABC", position) }
+        specify { eluse.value("ABC ", position).should == "ABC" }
+        specify { eluse.value(" ABC", position).should == " ABC" }
+        specify { eluse.value(" ABC ", position).should == " ABC" }
+      end
+    end
+
+  end
+end
+