fixed_width 0.2.0

data/spec/definition_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedWidth::Definition do
+  before(:each) do
+  end
+
+  describe "when specifying alignment" do
+    it "should have an alignment option" do
+      d = FixedWidth::Definition.new :align => :right
+      d.options[:align].should == :right
+    end
+
+    it "should default to being right aligned" do
+      d = FixedWidth::Definition.new
+      d.options[:align].should == :right
+    end
+
+    it "should override the default if :align is passed to the section" do
+      section = mock('section', :null_object => true)
+      FixedWidth::Section.should_receive(:new).with('name', {:align => :left}).and_return(section)
+      d = FixedWidth::Definition.new
+      d.options[:align].should == :right
+      d.section('name', :align => :left) {}
+    end
+  end
+
+  describe "when creating a section" do
+    before(:each) do
+      @d = FixedWidth::Definition.new
+      @section = mock('section', :null_object => true)
+    end
+
+    it "should create and yield a new section object" do
+      yielded = nil
+      @d.section :header do |section|
+        yielded = section
+      end
+      yielded.should be_a(FixedWidth::Section)
+      @d.sections.first.should == yielded
+    end
+
+    it "should magically build a section from an unknown method" do
+      FixedWidth::Section.should_receive(:new).with(:header, anything()).and_return(@section)
+      @d.header {}
+    end
+
+    it "should not create duplicate section names" do
+      lambda { @d.section(:header) {} }.should_not raise_error(FixedWidth::DuplicateSectionNameError)
+      lambda { @d.section(:header) {} }.should raise_error(FixedWidth::DuplicateSectionNameError, "Duplicate section name: 'header'")
+    end
+  end
+
+  describe "when creating a template" do
+    before(:each) do
+      @d = FixedWidth::Definition.new
+      @section = mock('section', :null_object => true)
+    end
+
+    it "should create a new section" do
+      FixedWidth::Section.should_receive(:new).with(:row, anything()).and_return(@section)
+      @d.template(:row) {}
+    end
+
+    it "should yield the new section" do
+      FixedWidth::Section.should_receive(:new).with(:row, anything()).and_return(@section)
+      yielded = nil
+      @d.template :row do |section|
+        yielded = section
+      end
+      yielded.should == @section
+    end
+
+    it "add a section to the templates collection" do
+      @d.should have(0).templates
+      @d.template :row do |t|
+        t.column :id, 3
+      end
+      @d.should have(1).templates
+    end
+  end
+end

data/spec/fixed_width_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedWidth do
+
+  before(:each) do
+    @name = :doc
+    @options = { :align => :left }
+  end
+
+  describe "when defining a format" do
+    before(:each) do
+      @definition = mock('definition')
+    end
+
+    it "should create a new definition using the specified name and options" do
+      FixedWidth.should_receive(:define).with(@name, @options).and_return(@definition)
+      FixedWidth.define(@name , @options)
+    end
+
+    it "should pass the definition to the block" do
+      yielded = nil
+      FixedWidth.define(@name) do |y|
+        yielded = y
+      end
+      yielded.should be_a( FixedWidth::Definition )
+    end
+
+    it "should add to the internal definition count" do
+      FixedWidth.definitions.clear
+      FixedWidth.should have(0).definitions
+      FixedWidth.define(@name , @options) {}
+      FixedWidth.should have(1).definitions
+    end
+  end
+
+  describe "when creating file from data" do 
+    it "should raise an error if the definition name is not found" do
+      lambda { FixedWidth.generate(:not_there, {}) }.should raise_error(ArgumentError)
+    end
+
+    it "should output a string" do
+      definition = mock('definition')
+      generator = mock('generator')
+      generator.should_receive(:generate).with({})
+      FixedWidth.should_receive(:definition).with(:test).and_return(definition)
+      FixedWidth::Generator.should_receive(:new).with(definition).and_return(generator)
+      FixedWidth.generate(:test, {})
+    end
+
+    it "should output a file" do
+      file = mock('file')
+      text = mock('string')
+      file.should_receive(:write).with(text)
+      FixedWidth.should_receive(:generate).with(:test, {}).and_return(text)
+      FixedWidth.write(file, :test, {})
+    end
+  end
+
+  describe "when parsing a file" do
+    before(:each) do
+      @file = mock('file')
+    end
+
+    it "should check the file exists" do
+      lambda { FixedWidth.parse(@file, :test, {}) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if the definition name is not found" do
+      FixedWidth.definitions.clear
+      lambda { FixedWidth.parse(@file, :test, {}) }.should raise_error(ArgumentError)
+    end
+
+    it "should create a parser and call parse" do
+      parser = mock("parser", :null_object => true)
+      definition = mock('definition')
+      FixedWidth.should_receive(:definition).with(:test).and_return(definition)
+      FixedWidth::Parser.should_receive(:new).with(definition, @file).and_return(parser)
+      FixedWidth.parse(@file, :test)
+    end
+  end
+end

data/spec/generator_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedWidth::Generator do
+  before(:each) do
+    @definition = FixedWidth.define :test do |d|
+      d.header do |h|
+        h.trap { |line| line[0,4] == 'HEAD' }
+        h.column :type, 4
+        h.column :file_id, 10
+      end
+      d.body do |b|
+        b.trap { |line| line[0,4] =~ /[^(HEAD|FOOT)]/ }
+        b.column :first, 10
+        b.column :last, 10
+      end
+      d.footer do |f|
+        f.trap { |line| line[0,4] == 'FOOT' }
+        f.column :type, 4
+        f.column :file_id, 10
+      end
+    end
+    @data = {
+      :header => [ {:type => "HEAD", :file_id => "1" } ],
+      :body => [ 
+        {:first => "Paul", :last => "Hewson" },
+        {:first => "Dave", :last => "Evans" }
+      ],
+      :footer => [ {:type => "FOOT", :file_id => "1" }]
+    }
+    @generator = FixedWidth::Generator.new(@definition)
+  end
+
+  it "should raise an error if there is no data for a required section" do
+    @data.delete :header
+    lambda {  @generator.generate(@data) }.should raise_error(FixedWidth::RequiredSectionEmptyError, "Required section 'header' was empty.")
+  end
+
+  it "should generate a string" do
+    expected = "HEAD         1\n      Paul    Hewson\n      Dave     Evans\nFOOT         1"
+    @generator.generate(@data).should == expected
+  end
+  
+  it "should handle lazy data declaration (no array around single record for a section)" do
+    expected = "HEAD         1\n      Paul    Hewson\n      Dave     Evans\nFOOT         1"
+    @data[:header] = @data[:header].first
+    @generator.generate(@data).should == expected
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedWidth::Parser do
+  before(:each) do
+    @definition = mock('definition', :sections => [])
+    @file = mock("file")
+    @parser = FixedWidth::Parser.new(@definition, @file)
+  end
+
+  it "should read in a source file" do
+    @file.should_receive(:readlines).and_return(["\n"])
+    @parser.parse
+  end
+
+  describe "when parsing sections" do
+    before(:each) do
+      @definition = FixedWidth.define :test do |d|
+        d.header do |h|
+          h.trap { |line| line[0,4] == 'HEAD' }
+          h.column :type, 4
+          h.column :file_id, 10
+        end
+        d.body do |b|
+          b.trap { |line| line[0,4] =~ /[^(HEAD|FOOT)]/ }
+          b.column :first, 10
+          b.column :last, 10
+        end
+        d.footer do |f|
+          f.trap { |line| line[0,4] == 'FOOT' }
+          f.column :type, 4
+          f.column :file_id, 10
+        end
+      end
+      @parser = FixedWidth::Parser.new(@definition, @file)
+    end
+
+    it "should add lines to the proper sections" do
+      @file.should_receive(:readlines).and_return([
+        "HEAD         1\n",
+        "      Paul    Hewson\n",
+        "      Dave     Evans\n",
+        "FOOT         1\n"
+      ])
+      expected = {
+        :header => [ {:type => "HEAD", :file_id => "1" } ],
+        :body => [ 
+          {:first => "Paul", :last => "Hewson" },
+          {:first => "Dave", :last => "Evans" }
+        ],
+        :footer => [ {:type => "FOOT", :file_id => "1" } ]
+      }
+      result = @parser.parse
+      result.should == expected
+    end
+
+    it "should treat singular sections properly" do
+      @definition = FixedWidth.define :test do |d|
+        d.header(:singular => true) do |h|
+          h.trap { |line| line[0,4] == 'HEAD' }
+          h.column :type, 4
+          h.column :file_id, 10
+        end
+        d.body do |b|
+          b.trap { |line| line[0,4] =~ /[^(HEAD|FOOT)]/ }
+          b.column :first, 10
+          b.column :last, 10
+        end
+        d.footer(:singular => true) do |f|
+          f.trap { |line| line[0,4] == 'FOOT' }
+          f.column :type, 4
+          f.column :file_id, 10
+        end
+      end
+      @parser = FixedWidth::Parser.new(@definition, @file)
+      @file.should_receive(:readlines).and_return([
+        "HEAD         1\n",
+        "      Paul    Hewson\n",
+        "      Dave     Evans\n",
+        "FOOT         1\n"
+      ])
+      expected = {
+        :header => {:type => "HEAD", :file_id => "1" },
+        :body => [
+          {:first => "Paul", :last => "Hewson" },
+          {:first => "Dave", :last => "Evans" }
+        ],
+        :footer => {:type => "FOOT", :file_id => "1" }
+      }
+      result = @parser.parse
+      result.should == expected
+    end
+
+    it "should allow optional sections to be skipped" do
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @file.should_receive(:readlines).and_return([
+        "      Paul    Hewson\n"
+      ])
+      expected = { :body => [ {:first => "Paul", :last => "Hewson" } ] }
+      @parser.parse.should == expected
+    end
+
+    it "should raise an error if a required section is not found" do
+      @file.should_receive(:readlines).and_return([
+        "      Ryan      Wood\n"
+      ])
+      lambda { @parser.parse }.should raise_error(FixedWidth::RequiredSectionNotFoundError, "Required section 'header' was not found.")
+    end
+  end
+end

data/spec/section_spec.rb

@@ -0,0 +1,176 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedWidth::Section do
+  before(:each) do
+    @section = FixedWidth::Section.new(:body)
+  end
+
+  it "should have no columns after creation" do
+    @section.columns.should be_empty
+  end
+
+  describe "when adding columns" do
+    it "should build an ordered column list" do
+      @section.should have(0).columns
+
+      col1 = @section.column :id, 10
+      col2 = @section.column :name, 30
+      col3 = @section.column :state, 2
+
+      @section.should have(3).columns
+      @section.columns[0].should be(col1)
+      @section.columns[1].should be(col2)
+      @section.columns[2].should be(col3)
+    end
+
+    it "should create spacer columns" do
+      @section.should have(0).columns
+      @section.spacer(5)
+      @section.should have(1).columns
+    end
+
+    it "can should override the alignment of the definition" do
+      section = FixedWidth::Section.new('name', :align => :left)
+      section.options[:align].should == :left
+    end
+
+    it "should use a missing method to create a column" do
+      @section.should have(0).columns
+      @section.first_name 5
+      @section.should have(1).columns
+    end
+
+    it "should prevent duplicate column names without any groupings" do
+      @section.column :id, 10
+      lambda { @section.column(:id, 30) }.should raise_error(FixedWidth::DuplicateColumnNameError, /column named 'id'/)
+    end
+
+    it "should prevent column names that already exist as groups" do
+      @section.column :foo, 11, :group => :id
+      lambda { @section.column(:id, 30) }.should raise_error(FixedWidth::DuplicateGroupNameError, /group named 'id'/)
+    end
+
+    it "should prevent group names that already exist as columns" do
+      @section.column :foo, 11
+      lambda { @section.column(:id, 30, :group => :foo) }.should raise_error(FixedWidth::DuplicateGroupNameError, /column named 'foo'/)
+    end
+
+    it "should prevent duplicate column names within groups" do
+      @section.column :id, 10, :group => :foo
+      lambda { @section.column(:id, 30, :group => :foo) }.should raise_error(FixedWidth::DuplicateColumnNameError, /column named 'id' in the ':foo' group/)
+    end
+
+    it "should allow duplicate column names in different groups" do
+      @section.column :id, 10, :group => :foo
+      lambda { @section.column(:id, 30, :group => :bar) }.should_not raise_error(FixedWidth::DuplicateColumnNameError)
+    end
+
+    it "should allow duplicate column names that are reserved (i.e. spacer)" do
+      @section.spacer 10
+      lambda { @section.spacer 10 }.should_not raise_error(FixedWidth::DuplicateColumnNameError)
+    end
+  end
+
+  it "should accept and store the trap as a block" do
+    @section.trap { |v| v == 4 }
+    trap = @section.instance_variable_get(:@trap)
+    trap.should be_a(Proc)
+    trap.call(4).should == true
+  end
+
+  describe "when adding a template" do
+    before(:each) do
+      @template = mock('templated section', :columns => [1,2,3], :options => {})
+      @definition = mock("definition", :templates => { :test => @template } )
+      @section.definition = @definition
+    end
+
+    it "should ensure the template exists" do
+      @definition.stub! :templates => {}
+      lambda { @section.template(:none) }.should raise_error(ArgumentError)
+    end
+
+    it "should add the template columns to the current column list" do
+      @section.template :test
+      @section.should have(3).columns
+    end
+
+    it "should merge the template option" do
+       @section = FixedWidth::Section.new(:body, :align => :left)
+       @section.definition = @definition
+       @template.stub! :options => {:align => :right}
+       @section.template :test
+       @section.options.should == {:align => :left}
+    end
+  end
+
+  describe "when formatting a row" do
+    before(:each) do
+      @data = { :id => 3, :name => "Ryan" }
+    end
+
+    it "should default to string data aligned right" do
+      @section.column(:id, 5)
+      @section.column(:name, 10)
+      @section.format( @data ).should == "    3      Ryan"
+    end
+
+    it "should left align if asked" do
+      @section.column(:id, 5)
+      @section.column(:name, 10, :align => :left)
+      @section.format(@data).should == "    3Ryan      "
+    end
+
+    it "should read from groups" do
+      @data = { :id => 3, :foo => { :name => "Ryan" } }
+      @section.column(:id, 5)
+      @section.column(:name, 10, :align => :left, :group => :foo)
+      @section.format(@data).should == "    3Ryan      "
+    end
+  end
+
+  describe "when parsing a file" do
+    before(:each) do
+      @line = '   45      Ryan      WoodSC '
+      @section = FixedWidth::Section.new(:body)
+      @column_content = { :id => 5, :first => 10, :last => 10, :state => 2 }
+    end
+
+    it "should return a key for key column" do
+      @column_content.each { |k,v| @section.column(k, v) }
+      parsed = @section.parse(@line)
+      @column_content.each_key { |name| parsed.should have_key(name) }
+    end
+
+    it "should not return a key for reserved names" do
+      @column_content.each { |k,v| @section.column(k, v) }
+      @section.spacer 5
+      @section.should have(5).columns
+      parsed = @section.parse(@line)
+      parsed.should have(4).keys
+    end
+    
+    it "should break columns into groups" do
+      @section.column(:id, 5)
+      @section.column(:first, 10, :group => :name)
+      @section.column(:last, 10, :group => :name)
+      @section.column(:state, 2, :group => :address)
+      @section.spacer 5
+      @section.should have(5).columns
+      parsed = @section.parse(@line)
+      parsed.should have(3).keys
+      parsed[:id].should == '45'
+      parsed[:name][:first].should == 'Ryan'
+      parsed[:name][:last].should == 'Wood'
+      parsed[:address][:state].should == 'SC'
+    end
+  end
+
+  it "should try to match a line using the trap" do
+    @section.trap do |line|
+      line == 'hello'
+    end
+    @section.match('hello').should be_true
+    @section.match('goodbye').should be_false
+  end
+end