ascii-data-tools 0.9

data/spec/ascii-data-tools/formatting_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+EXPECTED_FORMATTING_OF_FIXED_LENGTH_RECORD = <<STR
+Record 01 (ABC)
+01 field1  : [12345]-----
+02 field10 : [abc]-------
+03 field3  : [\\n]--------
+
+STR
+
+EXPECTED_FORMATTING_OF_UNNUMBERED_FIXED_LENGTH_RECORD = <<STR
+Record (ABC)
+01 field1  : [12345]-----
+02 field10 : [abc]-------
+03 field3  : [\\n]--------
+
+STR
+
+include RecordTypeHelpers
+
+def fixed_length_type
+  type("ABC") do
+    field 'field1',  :length => 5
+    field 'field10', :length => 3
+    field 'field3',  :length => 1
+  end
+end
+
+module AsciiDataTools
+  module Formatting
+    describe Formatter do
+      it "should format a fixed-length record" do
+        record = AsciiDataTools::Record::Record.new(fixed_length_type, ["12345", "abc", "\n"])
+        Formatter.new.format(record).should == EXPECTED_FORMATTING_OF_FIXED_LENGTH_RECORD
+      end
+    end
+    
+    describe FormatableType do
+      include RecordTypeHelpers
+      before do
+        @fields = [
+          make_field("field1",  :length => 5),
+          make_field("field10", :length => 3),
+          make_field("field3",  :length => 1)
+        ]
+        @type = Struct.new(:name, :fields, :length_of_longest_field_name).new("ABC", @fields, 7)
+        @type.extend(FormatableType)
+      end
+      
+      it "should format values" do
+        @type.format(1, ["12345", "abc", "\n"]).should == EXPECTED_FORMATTING_OF_FIXED_LENGTH_RECORD
+      end
+    end
+    
+    describe FormatableField do
+      include RecordTypeHelpers
+      before do
+        @field = make_field("field1", :length => 5)
+        @field.extend(FormatableField)
+      end
+      
+      it "should make a template for the longest field" do
+        @field.template(:position => 3, :longest_field_name => 7, :longest_field_length => 5).should == "03 field1  : [%s]-----"
+      end
+
+      it "should make a template for fields that are not the longest" do
+        @field.template(:position => 3, :longest_field_name => 7, :longest_field_length => 7).should == "03 field1  : [%s]-------"
+      end
+
+      it "should make a template for the last field (which has a newline in it)" do
+        field = make_field("NEWLINE",  :length => 1)
+        field.extend(FormatableField)
+        field.template(:position => 3,
+                       :longest_field_name => 7,
+                       :longest_field_length => 2,
+                       :last_field? => true).should == "03 NEWLINE : [%s]-----"
+      end
+      
+      it "should make a template for fields without lengths" do
+        field = mock("field", :name => "ABC")
+        field.extend(FormatableField)
+        field.template(:position => 3,
+                       :longest_field_name => 3,
+                       :longest_field_length => 2).should == "03 ABC : [%s]-----"
+      end
+    end
+    
+    describe UnnumberedFormatableType do
+      include RecordTypeHelpers
+      before do
+        @fields = [
+          make_field("field1",  :length => 5),
+          make_field("field10", :length => 3),
+          make_field("field3",  :length => 1)
+        ]
+        @type = Struct.new(:name, :fields, :length_of_longest_field_name).new("ABC", @fields, 7)
+        @type.extend(UnnumberedFormatableType)
+      end
+      
+      it "should format a record" do
+        # record = AsciiDataTools::Record::Record.new(fixed_length_type, ["12345", "abc", "\n"])
+        @type.format(1, ["12345", "abc", "\n"]).should == EXPECTED_FORMATTING_OF_UNNUMBERED_FIXED_LENGTH_RECORD
+      end
+    end
+  end
+end

data/spec/ascii-data-tools/record_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module AsciiDataTools
+  module Record
+    describe Record do
+      include AsciiDataTools::RecordType
+      it "should provide the type name" do
+        Record.new(mock(AsciiDataTools::RecordType::Type, :name => "ABC"), nil).type_name.should == "ABC"
+      end
+
+      it "should provide access to its contents" do
+        record = Record.new(mock(AsciiDataTools::RecordType::Type, :field_names => ["field1", "field2"]), ["xyz", "abc"])
+        record["field1"].should == "xyz"
+        record["field2"].should == "abc"        
+      end
+      
+      it "should be representable as an array" do
+        Record.new(mock(AsciiDataTools::RecordType::Type, :field_names => ["field1", "field2"]), ["xyz", "abc"]).to_a.should == [
+          ["field1", "xyz"],
+          ["field2", "abc"]
+        ]
+      end
+      
+      it "should have a string representation which includes the type name and key-value pairs" do
+        record_type = mock(AsciiDataTools::RecordType::Type, :name => "ABC", :field_names => ["field1", "field2"])
+        Record.new(record_type, ["xyz", "\n"]).to_s.should == 'ABC: field1 => "xyz", field2 => "\n"'
+      end
+      
+      it "should defer encoding to the record type" do
+        type = mock(AsciiDataTools::RecordType::Type)
+        type.should_receive(:encode).with(["abc", "xyz"]).and_return("encoded string")
+        Record.new(type, ["abc", "xyz"]).encode.should == "encoded string"
+      end
+      
+      it "should be comparable to other records" do
+        type = mock(AsciiDataTools::RecordType::Type, :field_names => ["field1", "field2"])
+        another_type = mock(AsciiDataTools::RecordType::Type, :field_names => ["field1", "field3"])
+        
+        Record.new(type, ["abc", "def"]).should == Record.new(type, ["abc", "def"])
+        Record.new(type, ["abc", "def"]).should_not == Record.new(another_type, ["abc", "def"])
+        Record.new(type, ["abc", "def"]).should_not == Record.new(type, ["abc", "xyz"])
+      end
+      
+      it "should raise an error when trying to access a non-existing field" do
+        lambda {Record.new(mock(AsciiDataTools::RecordType::Type, :field_names => ["existing"]), ["xyz"])['non-existing'] }.should raise_error(/non-existing.*does not exist/)
+      end
+    end
+  end
+end

data/spec/ascii-data-tools/record_type/builder_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module AsciiDataTools
+  module RecordType
+    module Builder
+      describe TypeBuilder do
+        include TypeBuilder
+        it "should create a type with the given name" do
+          build_type("ABC").name.should == "ABC"
+        end
+
+        it "should create a type which matches only for specific filenames (if given)" do
+          type = build_type("ABC", :applies_for_filenames_matching => /ABC/)
+          type.should be_able_to_decode(:ascii_string => "", :filename => "ABC.gz")
+          type.should_not be_able_to_decode(:ascii_string => "", :filename => "XYZ.gz")
+        end
+
+        context "for fixed-length types" do
+          before do
+            @record_type = build_type("ABC") do
+              field "RECORD_TYPE",   :length => 3,  :constrained_to => "ABC"
+              field "A_NUMBER",      :length => 16, :constrained_to => /123/
+              field "RECORD_NUMBER", :length => 5,  :normalised => true
+              field "END_OF_RECORD", :length => 1
+            end
+          end
+
+          it "should really build a fixed-length type" do
+            @record_type.should be_a(AsciiDataTools::RecordType::FixedLengthType)
+          end
+
+          it "should have the correct fields" do
+            @record_type.field_names.should == ["RECORD_TYPE", "A_NUMBER", "RECORD_NUMBER", "END_OF_RECORD"]
+          end
+
+          it "should have the correct length" do
+            @record_type.total_length_of_fields.should == 25
+          end
+
+          it "should have the correct constraints" do
+            @record_type.constraints_description.should == "RECORD_TYPE = ABC, A_NUMBER =~ /123/"
+          end
+        
+          it "should normalise fields" do
+            @record_type.field_with_name("RECORD_NUMBER").should be_normalised
+          end
+        end
+      
+        context "for csv types" do
+          before do
+            @record_type = build_type("ABC", :family => "csv", :divider => ";") do
+              field "RECORD_TYPE"
+              field "A_NUMBER"
+              field "RECORD_NUMBER"
+            end
+          end
+          
+          it "should really build a csv type" do
+            @record_type.should be_a(AsciiDataTools::RecordType::CsvType)
+          end
+          
+          it "should save the divider" do
+            @record_type.field_with_name(:divider).value.should == ";"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ascii-data-tools/record_type/decoder_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module AsciiDataTools
+  module RecordType
+    module Decoder
+      describe RecordDecoder do
+        include RecordTypeHelpers
+        before do
+          @fields = [
+            make_field("field100", :length => 3),
+            make_field("field1",   :length => 5),
+            make_field("field10",  :length => 1)
+          ]
+          @type = Struct.new(:content_fields, :fields_by_type).new(@fields, {:meta => fields do field(:filename, :constrained_to => /abc/) end})
+          @type.extend(RecordTypeHelpers)
+          @type.extend(FixedLengthRecordDecoder)
+        end
+      
+        it "should know whether a given string is decodable" do
+          @type.should be_able_to_decode(:ascii_string => "ABC12345\n")
+        end
+      
+        it "should decode records correctly" do
+          @type.decode(:ascii_string => "XYZ12345\n").values.should == ["XYZ", "12345", "\n"]
+        end
+      
+        it "should take into account constraints that are set on the fields" do
+          @type.content_fields[0].should_be_constrained_to("ABC")
+          @type.should be_able_to_decode(:ascii_string => "ABC12345\n")
+          @type.should_not be_able_to_decode(:ascii_string => "XYZ12345\n")
+        end
+      
+        it "should not match ascii strings that don't have the same length as the individual fields" do
+          @type.should_not be_able_to_decode(:ascii_string => "ABC1234\n")
+          @type.should_not be_able_to_decode(:ascii_string => "ABC123456\n")
+        end
+        
+        it "should not be able to decode if the filename field is not matching" do
+          @type.should be_able_to_decode(:ascii_string => "ABC12345\n")
+          @type.should be_able_to_decode(:ascii_string => "ABC12345\n", :filename => "abc")
+          @type.should_not be_able_to_decode(:ascii_string => "ABC12345\n", :filename => "def")
+        end
+      end
+      
+      describe CsvRecordDecoder do
+        include RecordTypeHelpers
+        before do
+          @fields = [
+            make_field("field1"),
+            make_field("field2"),
+            make_field("field3")
+          ]
+          @type = Struct.new(:content_fields).new(@fields)
+          @type.stub!(:field_with_name).with(:divider).and_return(mock("divider field", :value => ";"))
+          @type.extend(CsvRecordDecoder)
+        end
+        
+        it "should decode records correctly" do
+          @type.decode(:ascii_string => "X;Y;Z\n").values.should == ["X", "Y", "Z"]
+        end
+      end
+      
+      describe UnknownRecordDecoder do
+        it "should decode the entire ascii string into the UNKNOWN field" do
+          decoder = Struct.new(:field_names).new(["UNKNOWN"])
+          decoder.extend(UnknownRecordDecoder)
+          record = decoder.decode(:ascii_string => "any string\n")
+          record["UNKNOWN"].should == "any string\n"
+        end
+      end
+    end    
+  end
+end

data/spec/ascii-data-tools/record_type/encoder_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module AsciiDataTools
+  module RecordType
+    module Encoder
+      describe FixedLengthRecordEncoder do
+        before do
+          @type = Object.new
+          @type.extend(FixedLengthRecordEncoder)
+        end
+        
+        context "fixed length records" do
+          it "should pack the values of fixed length records back together" do
+            @type.encode(["123", "abc", "\n"]).should == "123abc\n"
+          end
+        end
+      end
+
+      describe CsvRecordEncoder do
+        before do
+          @type = Object.new
+          @type.stub!(:field_with_name).with(:divider).and_return(mock("divider field", :value => ";"))
+          @type.extend(CsvRecordEncoder)
+        end
+        
+        it "should pack the values of csv records back together" do
+          @type.encode(["123", "abc", "XYZ"]).should == "123;abc;XYZ\n"
+        end
+      end
+    end
+  end
+end

data/spec/ascii-data-tools/record_type/field_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module AsciiDataTools
+  module RecordType
+    module Field
+      describe Fields do
+        include RecordTypeHelpers
+
+        before do
+          @fields = fields do
+            field "field100"
+            field "field1"
+            field "field10"
+          end
+        end
+        
+        it "should provide the field names" do
+          @fields.names.should == ["field100", "field1", "field10"]
+        end
+        
+        it "should provide the number of content fields" do
+          @fields.number_of_content_fields.should == 3
+        end
+
+        it "should provide the length of the field with the longest name" do
+          @fields.length_of_longest_field_name.should == 8
+        end
+
+        it "should provide an empty constraints description when there are no constraints" do
+          @fields.constraints_description.should be_empty
+        end
+
+        it "should provide a list of comma-delimited field constraints as the constraints description" do
+          @fields.with_name("field100").should_be_constrained_to("ABC")
+          @fields.constraints_description.should == "field100 = ABC"
+
+          @fields.with_name("field10").should_be_constrained_to("DEF")
+          @fields.constraints_description.should == "field100 = ABC, field10 = DEF"          
+        end
+        
+        it "should support searching for specific fields" do
+          found_fields = @fields.fields_with {|field| field.name =~ /field\d{2,}/}
+          found_fields.should have(2).items
+          found_fields.with_name("field1").should be_nil
+        end
+        
+        it "should allow mass normalisation" do
+          @fields.should_be_normalised
+          ["field100", "field1", "field10"].each do |field_name|
+            @fields.with_name(field_name).should be_normalised
+          end
+        end
+        
+        it "should provide names of normalised fields" do
+          @fields.with_name("field1").should_be_normalised
+          @fields.with_name("field10").should_be_normalised
+          @fields.names_of_normalised_fields.should == "field1, field10"
+        end
+        
+        it "should find fields by index" do
+          @fields.with_index(2).name.should == "field1"
+        end
+      end
+      
+      describe Field do
+        it "should have a name" do
+          Field.new("name").name.should == "name"
+        end
+      
+        context "a constrained field" do
+          before do
+            @field = Field.new("name")
+            @field.should_be_constrained_to("abc")
+          end
+          
+          it "should provide a text description of the constraint" do
+            @field.constraint_description.should == "name = abc"
+          end
+          
+          it "should validate input" do
+            @field.should be_a_valid_input("abc")
+          end
+          
+          it "should invalidate input" do
+            @field.should_not be_a_valid_input("def")
+          end
+        end
+      end
+    
+      describe FixedLengthField do
+        it "should have a name" do
+          FixedLengthField.new("name", nil).name.should == "name"
+        end
+      
+        it "should contribute to the regexp string used for type matching" do
+          FixedLengthField.new(nil, 5).extend_regexp_string_for_matching("xxx").should == "xxx(.{5})"
+        end
+      
+        it "should let the constraint contribute to the regexp string used for type matching if it is set" do
+          field = FixedLengthField.new(nil, 5)
+          field.constraint = mock("field constraint", :extend_regexp_string_for_matching => "xxxabc")
+          field.extend_regexp_string_for_matching("xxx").should == "xxxabc"
+        end      
+      end
+      
+      describe ConstantField do
+        it "should be able to store a value" do
+          field = ConstantField.new("XXX")
+          field.value = "abc"
+          field.value.should == "abc"
+        end
+      end
+      
+      describe NoConstraint do
+        it "should always be satisfied" do
+          NoConstraint.new.should be_satisfied_by(Object.new)
+        end
+      end
+    
+      describe FixedLengthConstraint do
+        it "should contribute to a regexp string by limiting the number of characters" do
+          FixedLengthConstraint.new(5).extend_regexp_string_for_matching('xxx').should == "xxx(.{5})"
+        end
+      
+        it "should have an empty string representation" do
+          FixedLengthConstraint.new(5).to_s.should be_empty
+        end
+      end
+    
+      describe OneOfConstraint do
+        it "should contribute to a regexp string that matches the type" do
+          OneOfConstraint.new("ABC", "DEF", "XYZ").extend_regexp_string_for_matching("xxx").should == "xxx(ABC|DEF|XYZ)"
+        end
+      
+        it "should have the appropriate string representation when there is one possible value" do
+          OneOfConstraint.new("ABC").to_s.should == "= ABC"
+        end
+
+        it "should have the appropriate string representation when there is more than one value possible" do
+          OneOfConstraint.new(["ABC", "DEF"]).to_s.should == "one of ABC, DEF"
+        end
+      end
+    
+      describe RegexpConstraint do
+        it "should contribute to a regexp string that matches the type" do
+          RegexpConstraint.new(/A\d{3}C/).extend_regexp_string_for_matching("xxx").should == "xxxA\\d{3}C"
+        end
+      
+        it "should be satisfied when the string passed to it matches its regexp" do
+          RegexpConstraint.new(/ABC/).should be_satisfied_by("xyz.ABC.gz")
+          RegexpConstraint.new(/ABC/).should_not be_satisfied_by("xyz.UVW.gz")
+        end
+      
+        it "should have an appropriate string representation" do
+          RegexpConstraint.new(/ABC/).to_s.should == "=~ /ABC/"
+        end
+      end
+    end
+  end
+end