stupidedi 1.1.0 → 1.2.1

data/lib/stupidedi/versions/interchanges/00400/segment_defs/TA1.rb

@@ -0,0 +1,23 @@
+module Stupidedi
+  module Versions
+    module Interchanges
+      module FourHundred
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = FunctionalGroups::FortyTen::ElementReqs
+
+          TA1 = s::SegmentDef.build(:TA1, "Interchange Acknowledgement",
+            "To report the status of processing a received interchange header and trailer or the non-delivery by a network provider",
+            e::I12.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I08.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I09.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I17.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I18.simple_use(r::Mandatory, s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/interchanges/00401/element_defs.rb

@@ -13,10 +13,50 @@ module Stupidedi
           t = FunctionalGroups::FortyTen::ElementTypes
           s = Schema
 
-          class SeparatorElementVal < Values::SimpleElementVal
+          # Namespace workaround for SpecialAN inner classes
+          T = t
+
+          # Fun (stupid) problem. The specifications declare ISA02 and ISA04 are
+          # required elements, but they only have "meaningful information" when
+          # ISA01 and ISA03 qualifiers aren't "00".
+          #
+          # Without specifications regarding what should be entered in these
+          # required elements, our best option is to defer to convention, which
+          # seems to be that these elements should have 10 spaces -- which means
+          # they're blank. So we can't really make these elements required! Even
+          # stupider, these are the only blank elements that should be written
+          # out space-padded to the min_length -- every other element should be
+          # collapsed to an empty string.
+          #
+          # So this "Special" class overrides to_x12 for empty values, but it
+          # otherwise looks and acts like a normal AN and StringVal
+          class SpecialAN < t::AN
+            def companion
+              SpecialVal
+            end
 
-            delegate :to_s, :length, :to => :@value
+            class SpecialVal < T::StringVal
+              class Empty < T::StringVal::Empty
+                # @return [String]
+                def to_x12
+                  " " * definition.min_length
+                end
+              end
+
+              class NonEmpty < T::StringVal::NonEmpty
+                def too_short?
+                  false
+                end
+              end
+            end
+          end
 
+          class SeparatorElementVal < Values::SimpleElementVal
+
+            extend Forwardable
+            def_delegators :@value, :to_s, :length
+               
+            
             def initialize(value, usage, position)
               @value = value
               super(usage, position)
@@ -50,6 +90,11 @@ module Stupidedi
               true
             end
 
+            # @return [String]
+            def to_x12
+              @value.to_s
+            end
+
             def inspect
               id = definition.try{|d| ansi.bold("[#{d.id}]") }
               ansi.element("SeparatorElementVal.value#{id}") << "(#{@value || "nil"})"
@@ -89,19 +134,19 @@ module Stupidedi
             # "05" => "Deparment of Defense (DoD) Communication Identifier",
             # "06" => "United States Federal Government Communication Identifier"))
 
-          I02 = t::AN.new(:I02, "Authorization Information",             10, 10)
+          I02 = SpecialAN.new(:I02, "Authorization Information",             10, 10)
 
           I03 = t::ID.new(:I03, "Security Information Qualifier",         2,  2,
             s::CodeList.build(
               "00" => "No Security Information (No Meaningful Information in I04)",
               "01" => "Password"))
 
-          I04 = t::AN.new(:I04, "Security Information",                  10, 10)
+          I04 = SpecialAN.new(:I04, "Security Information",                  10, 10)
 
           I05 = t::ID.new(:I05, "Interchange ID Qualifier",               2,  2,
             s::CodeList.build(
               "01" => "Duns (Dun & Bradstreet)",
-            # "02" => "SCAC (Standard Carrier Alpha Code)",
+              "02" => "SCAC (Standard Carrier Alpha Code)",
             # "03" => "FMC (Federal Maritime Commission)",
             # "04" => "IATA (International Air Transport Association)",
             # "07" => s::CodeList.external("583"),
@@ -109,7 +154,7 @@ module Stupidedi
             # "09" => "X.121 (CCITT)",
             # "10" => s::CodeList.external("350"),
             # "11" => "DEA (Drug Enforcement Administration)",
-            # "12" => "Phone (Telephone Companies)",
+              "12" => "Phone (Telephone Companies)",
             # "13" => "UCS Code (The UCS Code is a Code Used for UCS Transmissions; it includes the Area Code and Telephone Number of a Modem; it Does Not Include Punctation, Blanks, or Access Code)",
               "14" => "Duns Plus Suffix",
             # "15" => "Petroleum Accountants Society of Canada Company Code",
@@ -142,8 +187,8 @@ module Stupidedi
             # "SN" => s::CodeList.external("42"),
               "ZZ" => "Mutually Defined"))
 
-          I06 = t::AN.new(:I06, "Interchange Sender ID",                 15, 15)
-          I07 = t::AN.new(:I07, "Interchange Receiver ID",               15, 15)
+          I06 = SpecialAN.new(:I06, "Interchange Sender ID",                 15, 15)
+          I07 = SpecialAN.new(:I07, "Interchange Receiver ID",               15, 15)
           I08 = t::DT.new(:I08, "Interchange Date",                       6,  6)
           I09 = t::TM.new(:I09, "Interchange Time",                       4,  4)
 

data/lib/stupidedi/versions/interchanges/00401/interchange_def.rb

@@ -31,6 +31,29 @@ module Stupidedi
           def separators(isa)
             Reader::Separators.new(isa.element(16).to_s, nil, nil, nil)
           end
+
+          # @return [SegmentVal]
+          def replace_separators(isa, separators)
+            isa.copy \
+              :separators => separators,
+              :children   =>
+              [isa.element(1),
+               isa.element(2),
+               isa.element(3),
+               isa.element(4),
+               isa.element(5),
+               isa.element(6),
+               isa.element(7),
+               isa.element(8),
+               isa.element(9),
+               isa.element(10),
+               isa.element(11),
+               isa.element(12),
+               isa.element(13),
+               isa.element(14),
+               isa.element(15),
+               isa.element(16).copy(:value => separators.component)]
+          end
         end.new "00401",
           # Interchange header
           [ SegmentDefs::ISA.use(1, r::Mandatory, s::RepeatCount.bounded(1)),

data/lib/stupidedi/versions/interchanges/00401/segment_defs/ISA.rb

@@ -11,9 +11,9 @@ module Stupidedi
           ISA = s::SegmentDef.build(:ISA, "Interchange Control Header",
             "To start and identify an interchange of zero or more functional groups and interchange-related control segments",
             e::I01.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
-            e::I02.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I02.simple_use(r::Optional,  s::RepeatCount.bounded(1)),
             e::I03.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
-            e::I04.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
+            e::I04.simple_use(r::Optional,  s::RepeatCount.bounded(1)),
             e::I05.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
             e::I06.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),
             e::I05.simple_use(r::Mandatory, s::RepeatCount.bounded(1)),

data/lib/stupidedi/versions/interchanges/00501/element_defs.rb

@@ -53,8 +53,9 @@ module Stupidedi
 
           class SeparatorElementVal < Values::SimpleElementVal
 
-            delegate :to_s, :length, :to => :@value
-
+            extend Forwardable
+            def_delegators :@value, :to_s, :length
+            
             def initialize(value, usage, position)
               @value = value
               super(usage, position)

data/lib/stupidedi/versions/interchanges/00501/interchange_def.rb

@@ -31,6 +31,29 @@ module Stupidedi
           def separators(isa)
             Reader::Separators.new(isa.element(16).to_s, isa.element(11).to_s, nil, nil)
           end
+
+          # @return [SegmentVal]
+          def replace_separators(isa, separators)
+            isa.copy \
+              :separators => separators,
+              :children   =>
+                [isa.element(1),
+                 isa.element(2),
+                 isa.element(3),
+                 isa.element(4),
+                 isa.element(5),
+                 isa.element(6),
+                 isa.element(7),
+                 isa.element(8),
+                 isa.element(9),
+                 isa.element(10),
+                 isa.element(11).copy(:value => separators.repetition),
+                 isa.element(12),
+                 isa.element(13),
+                 isa.element(14),
+                 isa.element(15),
+                 isa.element(16).copy(:value => separators.component)]
+          end
         end.new "00501",
           # Interchange header
           [ SegmentDefs::ISA.use(1, r::Mandatory, s::RepeatCount.bounded(1)),

data/lib/stupidedi/writer/default.rb

@@ -35,10 +35,11 @@ module Stupidedi
           segment(value, separators, out)
         else
           if value.interchange?
-            separators = value.separators.merge(@separators)
+            value      = value.replace_separators(@separators)
+            separators = value.separators#merge(@separators)
 
             raise Exceptions::OutputError,
-              "separators.segment cannot be blank" if separators.segment.empty?
+              "separators.segment cannot be blank" if separators.segment.blank?
 
             raise Exceptions::OutputError,
               "separators.element cannot be blank" if separators.element.blank?
@@ -113,7 +114,7 @@ module Stupidedi
 
           occurrences.tail.each do |o|
             out << separators.repetition
-            element(occurrences.head, separators, out)
+            element(o, separators, out)
           end
         end
       end

data/spec/examples/integration/generating.example

@@ -3,13 +3,13 @@ require "spec_helper"
 describe "Generating" do
   include NavigationMatchers
 
-  let(:config)  { Stupidedi::Config.default }
+  let(:config)  { Stupidedi::Config.hipaa }
   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 \
+      expect(lambda { relaxed.xyz }).to \
         raise_error(NoMethodError)
     end
   end
@@ -31,21 +31,21 @@ describe "Generating" do
         isa(relaxed, "0050x")
 
         # An invalid ISA segment was added
-        relaxed.zipper.select{|z| z.node.invalid? }.should be_defined
+        expect(relaxed.zipper.select{|z| z.node.invalid? }).to be_defined
 
         # It's parent is an InvalidEnvelopeVal
-        relaxed.zipper.select{|z| z.parent.node.invalid? }.should be_defined
+        expect(relaxed.zipper.select{|z| z.parent.node.invalid? }).to be_defined
       end
     end
 
     context "when strict" do
       it "loudly complains" do
-        lambda do
+        expect(lambda do
           isa(strict, "0050x")
-        end.should raise_error('unknown interchange version "0050x"')
+        end).to raise_error('unknown interchange version "0050x"')
 
         # The ISA segment wasn't added
-        relaxed.should be_empty
+        expect(relaxed).to be_empty
       end
     end
   end
@@ -66,21 +66,21 @@ describe "Generating" do
       it "on the first interchange" do
         isa(relaxed, ":", "^")
 
-        relaxed.machine.separators.component.should == ":"
-        relaxed.machine.separators.repetition.should == "^"
+        expect(relaxed.machine.separators.component).to eq(":")
+        expect(relaxed.machine.separators.repetition).to eq("^")
       end
 
       it "on subsequent interchanges" do
         isa(relaxed, "$", "%")
         isa(relaxed, "@", "#")
 
-        relaxed.machine.separators.component.should == "@"
-        relaxed.machine.separators.repetition.should == "#"
+        expect(relaxed.machine.separators.component).to eq("@")
+        expect(relaxed.machine.separators.repetition).to eq("#")
 
-        relaxed.machine.prev.tap do |machine|
-          machine.separators.component.should == "$"
-          machine.separators.repetition.should == "%"
-        end.should be_defined
+        expect(relaxed.machine.prev.tap do |machine|
+          expect(machine.separators.component).to eq("$")
+          expect(machine.separators.repetition).to eq("%")
+        end).to be_defined
       end
     end
 
@@ -97,25 +97,25 @@ describe "Generating" do
 
       context "when strict" do
         it "loudly complains" do
-          lambda { isa(strict) }.should_not \
-            raise_error("required segment IEA is missing from interchange 00501")
+          expect(lambda { isa(strict) }).not_to raise_error
+          # ("required segment IEA is missing from interchange 00501")
 
-          lambda { isa(strict) }.should \
+          expect(lambda { isa(strict) }).to \
             raise_error("required segment IEA is missing from interchange 00501")
 
-          strict.should be_first
+          expect(strict).to 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")
+          expect(lambda { isa(relaxed) }).not_to 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")
+          expect(lambda { isa(relaxed) }).not_to raise_error
+          # ("required segment IEA is missing from interchange 00501")
 
-          relaxed.should_not be_first
+          expect(relaxed).not_to be_first
         end
       end
     end
@@ -133,20 +133,20 @@ describe "Generating" do
 
       context "when strict" do
         it "loudly complains" do
-          lambda { isa(strict) }.should \
+          expect(lambda { isa(strict) }).to \
             raise_error("required element ISA06 is blank")
 
-          strict.should be_empty
+          expect(strict).to 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")
+          expect(lambda { isa(relaxed) }).not_to 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
+          expect(relaxed.element(6).select{|e| e.node == "" }).to be_defined
+          expect(relaxed.element(6).select{|e| e.node.empty? }).to be_defined
         end
       end
     end
@@ -166,20 +166,20 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { isa(strict) }.should \
+            expect(lambda { isa(strict) }).to \
               raise_error("value XX not allowed in element ISA01")
 
-            strict.should be_empty
+            expect(strict).to 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")
+            expect(lambda { isa(relaxed) }).not_to 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
+            expect(relaxed.element(1).select{|e| e.node == "XX" }).to be_defined
+            expect(relaxed.element(1).select{|e| e.node.invalid? }).not_to be_defined
           end
         end
       end
@@ -197,20 +197,20 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { isa(strict) }.should \
-              raise_error("invalid element ISA09")
+            expect(lambda { isa(strict) }).to raise_error
+            # ("invalid element ISA09")
 
-            strict.should be_empty
+            expect(strict).to be_empty
           end
         end
 
         context "when non-strict" do
           it "quietly proceeds" do
-            lambda { isa(relaxed) }.should_not \
-              raise_error("invalid element ISA09")
+            expect(lambda { isa(relaxed) }).not_to 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
+            expect(relaxed.element(9).select{|e| e.node.invalid? }).to be_defined
+            expect(relaxed.element(9).select{|e| e.node == "DATE" }).not_to be_defined
           end
         end
       end
@@ -228,20 +228,20 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { isa(strict) }.should \
+            expect(lambda { isa(strict) }).to \
               raise_error("invalid element ISA10")
 
-            strict.should be_empty
+            expect(strict).to be_empty
           end
         end
 
         context "when non-strict" do
           it "quietly proceeds" do
-            lambda { isa(relaxed) }.should_not \
-              raise_error("invalid element ISA10")
+            expect(lambda { isa(relaxed) }).not_to 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
+            expect(relaxed.element(10).select{|e| e.node.invalid? }).to be_defined
+            expect(relaxed.element(10).select{|e| e.node == "TIME" }).not_to be_defined
           end
         end
       end
@@ -259,19 +259,18 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { isa(strict) }.should \
+            expect(lambda { isa(strict) }).to \
               raise_error("invalid element ISA13")
 
-            strict.should be_empty
+            expect(strict).to be_empty
           end
         end
 
         context "when non-strict" do
           it "quietly proceeds" do
-            lambda { isa(relaxed) }.should_not \
-              raise_error("invalid element ISA13")
+            expect(lambda { isa(relaxed) }).not_to raise_error
 
-            relaxed.element(13).select{|e| e.node.invalid? }.should be_defined
+            expect(relaxed.element(13).select{|e| e.node.invalid? }).to be_defined
           end
         end
       end
@@ -293,18 +292,18 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { setup(strict) }.should \
+            expect(lambda { setup(strict) }).to \
               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 \
+            expect(lambda { setup(relaxed) }).not_to \
               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
+            expect(relaxed.element(13).select{|e| e.node == 1234567890 }).to be_defined
+            expect(relaxed.element(13).select{|e| e.node.too_long? }).to be_defined
           end
         end
       end
@@ -339,18 +338,18 @@ describe "Generating" do
 
         context "when strict" do
           it "loudly complains" do
-            lambda { setup(strict) }.should \
+            expect(lambda { setup(strict) }).to \
               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")
+            expect(lambda { setup(relaxed) }).not_to 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
+            expect(relaxed.element(6).select{|e| e.node == "431777999xxxxxxxxxxx" }).to be_defined
+            expect(relaxed.element(6).select{|e| e.node.too_long? }).to be_defined
           end
         end
       end
@@ -381,7 +380,7 @@ describe "Generating" do
 
         context "when strict" do
           it "complains loudly" do
-            lambda { setup(strict) }.should \
+            expect(lambda { setup(strict) }).to \
               raise_error("value is too short in element ISA10")
           end
         end
@@ -390,11 +389,11 @@ describe "Generating" do
           it "proceeds quietly" do
             time = Time.now.utc
 
-            lambda { setup(relaxed, time) }.should_not \
-              raise_error("value is too short in element ISA10")
+            expect(lambda { setup(relaxed, time) }).not_to 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
+            expect(relaxed.element(10).select{|e| e.node.hour == time.hour }).to be_defined
+            expect(relaxed.element(10).select{|e| e.node.too_short? }).to be_defined
           end
         end
       end
@@ -418,17 +417,17 @@ describe "Generating" do
 
         context "when strict" do
           it "complains loudly" do
-            lambda { setup(strict) }.should \
+            expect(lambda { setup(strict) }).to \
               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")
+            expect(lambda { setup(relaxed) }).not_to raise_error
+            # ("value is too long in element GS04")
 
-            relaxed.element(4).select{|e| e.node.year.should == 22222 }.should be_defined
+            expect(relaxed.element(4).select{|e| expect(e.node.year).to eq(22222) }).to be_defined
           end
         end
       end
@@ -452,17 +451,17 @@ describe "Generating" do
 
         context "when strict" do
           it "complains loudly" do
-            lambda { setup(strict) }.should \
+            expect(lambda { setup(strict) }).to \
               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")
+            expect(lambda { setup(relaxed) }).not_to raise_error
+            # ("value is too short in element GS04")
 
-            relaxed.element(4).select{|e| e.node.year.should == 11 }.should be_defined
+            expect(relaxed.element(4).select{|e| expect(e.node.year).to eq(11) }).to be_defined
           end
         end
       end
@@ -491,7 +490,7 @@ describe "Generating" do
           it "raises an error" do
             setup(relaxed, "005010X222")
 
-            lambda { relaxed.ST("837", relaxed.default, "005010X222") }.should \
+            expect(lambda { relaxed.ST("837", relaxed.default, "005010X222") }).to \
               raise_error("ST02 cannot be inferred")
           end
         end
@@ -500,11 +499,11 @@ describe "Generating" 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")
+            expect(lambda { relaxed.ST("835", "CONTROLNUM", relaxed.default) }).not_to 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
+            expect(relaxed.element(3).select{|e| e.node == "" }).to be_defined
+            expect(relaxed.element(3).select{|e| e.node.blank? }).to be_defined
           end
         end
 
@@ -512,10 +511,10 @@ describe "Generating" 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")
+            expect(lambda { relaxed.ST("837", "CONTROLNUM", relaxed.default) }).not_to raise_error
+            # ("ST02 cannot be inferred")
 
-            relaxed.element(3).select{|e| e.node == "005010X222" }.should be_defined
+            expect(relaxed.element(3).select{|e| e.node == "005010X222" }).to be_defined
           end
         end
       end
@@ -525,11 +524,11 @@ describe "Generating" 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")
+            expect(lambda { relaxed.ST("835", "CONTROLNUM", relaxed.not_used) }).not_to 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
+            expect(relaxed.element(3).select{|e| e.node == "" }).to be_defined
+            expect(relaxed.element(3).select{|e| e.node.blank? }).to be_defined
           end
         end
 
@@ -537,7 +536,7 @@ describe "Generating" do
           it "generates a non-empty element value" do
             setup(relaxed, "005010X222")
 
-            lambda { relaxed.ST("837", "CONTROLNUM", relaxed.not_used) }.should \
+            expect(lambda { relaxed.ST("837", "CONTROLNUM", relaxed.not_used) }).to \
               raise_error("ST03 is not forbidden")
           end
         end