stupidedi 1.3.23 → 1.4.0

data/spec/examples/stupidedi/reader_spec.rb

@@ -1,168 +0,0 @@
-# encoding: ISO-8859-1
-require "spec_helper"
-
-describe Stupidedi::Reader do
-
-  describe ".is_basic_character?(c)" do
-    def is_basic?(c)
-      Stupidedi::Reader.is_basic_character?(c)
-    end
-
-    it "excludes extended characters" do
-      b = Stupidedi::Reader.basic_characters
-      e = Stupidedi::Reader.extended_characters
-      (b - (b - e)).should be_empty
-    end
-
-    it "excludes control characters" do
-      b = Stupidedi::Reader.basic_characters
-      c = Stupidedi::Reader.control_characters
-      (b - (b - c)).should be_empty
-    end
-
-    it "includes uppercase letters" do
-      ('A'..'Z').each{|c| is_basic?(c).should be true }
-    end
-
-    it "includes digits 0-9" do
-      is_basic?('0').should be true
-      is_basic?('1').should be true
-      is_basic?('2').should be true
-      is_basic?('3').should be true
-      is_basic?('4').should be true
-      is_basic?('5').should be true
-      is_basic?('6').should be true
-      is_basic?('7').should be true
-      is_basic?('8').should be true
-      is_basic?('9').should be true
-    end
-
-    it "includes special characters" do
-      is_basic?('!').should be true
-      is_basic?('"').should be true
-      is_basic?('&').should be true
-      is_basic?("'").should be true
-      is_basic?('(').should be true
-      is_basic?(')').should be true
-      is_basic?('*').should be true
-      is_basic?('+').should be true
-      is_basic?(',').should be true
-      is_basic?('-').should be true
-      is_basic?('.').should be true
-      is_basic?('/').should be true
-      is_basic?(':').should be true
-      is_basic?(';').should be true
-      is_basic?('?').should be true
-      is_basic?('=').should be true
-    end
-
-    it "includes the space character" do
-      is_basic?(' ').should be true
-    end
-  end
-
-  describe ".is_extended_character?(c)" do
-    def is_extended?(c)
-      Stupidedi::Reader.is_extended_character?(c)
-    end
-
-    it "excludes basic characters" do
-      e = Stupidedi::Reader.extended_characters
-      b = Stupidedi::Reader.basic_characters
-      (e - (e - b)).should be_empty
-    end
-
-    it "excludes control characters" do
-      e = Stupidedi::Reader.extended_characters
-      c = Stupidedi::Reader.control_characters
-      (e - (e - c)).should be_empty
-    end
-
-    it "includes lowercase letters" do
-      ('a'..'z').each{|c| is_extended?(c).should be true }
-    end
-
-    it "includes other special characters" do
-      is_extended?('%').should be true
-      is_extended?('@').should be true
-      is_extended?('[').should be true
-      is_extended?(']').should be true
-      is_extended?('_').should be true
-      is_extended?('{').should be true
-      is_extended?('}').should be true
-      is_extended?('\\').should be true
-      is_extended?('|').should be true
-      is_extended?('<').should be true
-      is_extended?('>').should be true
-      is_extended?('~').should be true
-      is_extended?('^').should be true
-      is_extended?('`').should be true
-    end
-
-    it "includes national characters" do
-      is_extended?('#').should be true
-      is_extended?('$').should be true
-    end
-
-    it "includes select language characters" do
-      is_extended?('À')
-      is_extended?('Á')
-      is_extended?('Â')
-      is_extended?('Ä')
-      is_extended?('à')
-      is_extended?('á')
-      is_extended?('â')
-      is_extended?('ä')
-      is_extended?('È')
-      is_extended?('É')
-      is_extended?('Ê')
-      is_extended?('è')
-      is_extended?('é')
-      is_extended?('ê')
-      is_extended?('ë')
-      is_extended?('Ì')
-      is_extended?('Í')
-      is_extended?('Î')
-      is_extended?('ì')
-      is_extended?('í')
-      is_extended?('î')
-      is_extended?('ï')
-      is_extended?('Ò')
-      is_extended?('Ó')
-      is_extended?('Ô')
-      is_extended?('Ö')
-      is_extended?('ò')
-      is_extended?('ó')
-      is_extended?('ô')
-      is_extended?('ö')
-      is_extended?('Ù')
-      is_extended?('Ú')
-      is_extended?('Û')
-      is_extended?('Ü')
-      is_extended?('ù')
-      is_extended?('ú')
-      is_extended?('û')
-      is_extended?('ü')
-      is_extended?('Ç')
-      is_extended?('ç')
-      is_extended?('Ñ')
-      is_extended?('ñ')
-      is_extended?('¿')
-      is_extended?('¡')
-    end
-  end
-
-  describe ".is_control_character?" do
-    it "excludes basic characters" do
-      c = Stupidedi::Reader.control_characters
-      b = Stupidedi::Reader.basic_characters
-      (c - (c - b)).should be_empty
-    end
-
-    it "excludes extended characters" do
-      c = Stupidedi::Reader.control_characters
-      e = Stupidedi::Reader.extended_characters
-      (c - (c - e)).should be_empty
-    end
-  end
-end

data/spec/examples/stupidedi/versions/005010/element_types/an_spec.rb

@@ -1,202 +0,0 @@
-require "spec_helper"
-using Stupidedi::Refinements
-
-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_spec.rb

@@ -1,258 +0,0 @@
-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
-
-