slither 0.99.3

data/lib/slither/slither.rb

@@ -0,0 +1,49 @@
+class Slither
+  
+  VERSION = '0.99.0'
+  
+  class DuplicateColumnNameError < StandardError; end
+  class RequiredSectionNotFoundError < StandardError; end
+  class RequiredSectionEmptyError < StandardError; end
+  class FormattedStringExceedsLengthError < StandardError; end
+  class ColumnMismatchError < StandardError; end
+  
+  
+  def self.define(name, options = {}, &block)
+    definition = Definition.new(options)
+    yield(definition)
+    definitions[name] = definition
+    definition
+  end
+  
+  def self.generate(definition_name, data)
+    definition = definition(definition_name)
+    raise ArgumentError, "Definition name '#{name}' was not found." unless definition
+    generator = Generator.new(definition)
+    generator.generate(data)
+  end
+  
+  def self.write(filename, definition_name, data)
+    File.open(filename, 'w') do |f|
+      f.write generate(definition_name, data)  
+    end
+  end
+  
+  def self.parse(filename, definition_name)
+    raise ArgumentError, "File #{filename} does not exist." unless File.exists?(filename)
+    definition = definition(definition_name)
+    raise ArgumentError, "Definition name '#{definition_name}' was not found." unless definition    
+    parser = Parser.new(definition, filename)
+    parser.parse    
+  end
+  
+  private
+  
+    def self.definitions
+      @@definitions ||= {}
+    end
+    
+    def self.definition(name)
+      definitions[name]
+    end
+end

data/spec/column_spec.rb

@@ -0,0 +1,224 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+    
+describe Slither::Column do
+  before(:each) do
+    @name = :id
+    @length = 5
+    @column = Slither::Column.new(@name, @length)
+  end
+  
+  describe "when being created" do
+    it "should have a name" do
+      @column.name.should == @name
+    end
+    
+    it "should have a length" do
+      @column.length.should == @length
+    end
+    
+    it "should have a default padding" do
+      @column.padding.should == :space
+    end
+    
+    it "should have a default alignment" do
+      @column.alignment.should == :right
+    end
+   
+    it "should return a proper formatter" do
+      @column.send(:formatter).should == "%5s"
+    end
+  end
+
+  describe "when specifying an alignment" do
+    before(:each) do
+      @column = Slither::Column.new(@name, @length, :align => :left)
+    end
+    
+    it "should only accept :right or :left for an alignment" do
+      lambda{ Slither::Column.new(@name, @length, :align => :bogus) }.should raise_error(ArgumentError, "Option :align only accepts :right (default) or :left")
+    end 
+        
+    it "should override the default alignment" do
+      @column.alignment.should == :left
+    end
+  end
+  
+  describe "when specifying padding" do
+    before(:each) do
+      @column = Slither::Column.new(@name, @length, :padding => :zero)
+    end
+    
+    it "should accept only :space or :zero" do
+      lambda{ Slither::Column.new(@name, @length, :padding => :bogus) }.should raise_error(ArgumentError, "Option :padding only accepts :space (default) or :zero")  
+    end
+    
+    it "should override the default padding" do
+      @column.padding.should == :zero
+    end
+  end
+
+  it "should return the proper unpack value for a string" do
+    @column.send(:unpacker).should == 'A5'
+  end
+    
+  describe "when parsing a value from a file" do    
+    it "should default to a string" do
+      @column.parse('    name ').should == 'name'
+      @column.parse('      234').should == '234'
+      @column.parse('000000234').should == '000000234'
+      @column.parse('12.34').should == '12.34'
+    end
+  
+    it "should support the integer type" do
+      @column = Slither::Column.new(:amount, 10, :type=> :integer)
+      @column.parse('234     ').should == 234
+      @column.parse('     234').should == 234
+      @column.parse('00000234').should == 234
+      @column.parse('Ryan    ').should == 0
+      @column.parse('00023.45').should == 23
+    end
+
+    it "should support the float type" do
+      @column = Slither::Column.new(:amount, 10, :type=> :float)
+      @column.parse('  234.45').should == 234.45
+      @column.parse('234.5600').should == 234.56
+      @column.parse('     234').should == 234.0
+      @column.parse('00000234').should == 234.0
+      @column.parse('Ryan    ').should == 0
+      @column.parse('00023.45').should == 23.45
+    end
+    
+    it "should support the money_with_implied_decimal type" do
+      @column = Slither::Column.new(:amount, 10, :type=> :money_with_implied_decimal)
+      @column.parse('   23445').should == 234.45
+    end    
+
+    it "should support the date type" do
+      @column = Slither::Column.new(:date, 10, :type => :date)
+      dt = @column.parse('2009-08-22')
+      dt.should be_a(Date)
+      dt.to_s.should == '2009-08-22'
+    end   
+    
+    it "should use the format option with date type if available" do
+      @column = Slither::Column.new(:date, 10, :type => :date, :format => "%m%d%Y")
+      dt = @column.parse('08222009')
+      dt.should be_a(Date)
+      dt.to_s.should == '2009-08-22'
+    end   
+  end
+  
+  describe "when applying formatting options" do
+    it "should return a proper formatter" do
+      @column = Slither::Column.new(@name, @length, :align => :left)
+      @column.send(:formatter).should == "%-5s"
+    end
+    
+    it "should respect a right alignment" do
+      @column = Slither::Column.new(@name, @length, :align => :right)
+      @column.format(25).should == '   25'
+    end
+    
+    it "should respect a left alignment" do
+      @column = Slither::Column.new(@name, @length, :align => :left)
+      @column.format(25).should == '25   '
+    end
+    
+    it "should respect padding with spaces" do
+      @column = Slither::Column.new(@name, @length, :padding => :space)
+      @column.format(25).should == '   25'
+    end
+    
+    it "should respect padding with zeros with integer types" do
+      @column = Slither::Column.new(@name, @length, :type => :integer, :padding => :zero)
+      @column.format(25).should == '00025'
+    end
+    
+    describe "that is a float type" do
+      it "should respect padding with zeros aligned right" do
+        @column = Slither::Column.new(@name, @length, :type => :float, :padding => :zero, :align => :right)
+        @column.format(4.45).should == '04.45'
+      end
+      
+      it "should respect padding with zeros aligned left" do
+        @column = Slither::Column.new(@name, @length, :type => :float, :padding => :zero, :align => :left)
+        @column.format(4.45).should == '4.450'
+      end
+    end    
+  end
+    
+  describe "when formatting values for a file" do
+    it "should default to a string" do
+      @column = Slither::Column.new(:name, 10)
+      @column.format('Bill').should == '      Bill'
+    end
+    
+    describe "whose size is too long" do
+      it "should raise an error if truncate is false" do
+        @value = "XX" * @length
+        lambda { @column.format(@value) }.should raise_error(
+          Slither::FormattedStringExceedsLengthError,
+          "The formatted value '#{@value}' in column '#{@name}' exceeds the allowed length of #{@length} chararacters."
+        )
+      end
+      
+      it "should truncate from the left if truncate is true and aligned left" do
+        @column = Slither::Column.new(@name, @length, :truncate => true, :align => :left)
+        @column.format("This is too long").should == "This "
+      end
+      
+      it "should truncate from the right if truncate is true and aligned right" do
+        @column = Slither::Column.new(@name, @length, :truncate => true, :align => :right)
+        @column.format("This is too long").should == " long"
+      end
+    end
+    
+    it "should support the integer type" do
+      @column = Slither::Column.new(:amount, 10, :type => :integer)
+      @column.format(234).should        == '       234'
+      @column.format('234').should      == '       234'
+    end
+  
+    it "should support the float type" do
+      @column = Slither::Column.new(:amount, 10, :type => :float)
+      @column.format(234.45).should       == '    234.45'
+      @column.format('234.4500').should   == '    234.45'
+      @column.format('3').should          == '       3.0'
+    end
+    
+    it "should support the float type with a format" do
+      @column = Slither::Column.new(:amount, 10, :type => :float, :format => "%.3f")
+      @column.format(234.45).should       == '   234.450'
+      @column.format('234.4500').should   == '   234.450'
+      @column.format('3').should          == '     3.000'
+    end
+    
+    it "should support the float type with a format, alignment and padding" do
+      @column = Slither::Column.new(:amount, 10, :type => :float, :format => "%.2f", :align => :left, :padding => :zero)
+      @column.format(234.45).should       == '234.450000'
+      @column = Slither::Column.new(:amount, 10, :type => :float, :format => "%.2f", :align => :right, :padding => :zero)
+      @column.format('234.400').should    == '0000234.40'
+      @column = Slither::Column.new(:amount, 10, :type => :float, :format => "%.4f", :align => :left, :padding => :space)
+      @column.format('3').should          == '3.0000    '
+    end
+    
+    it "should support the money_with_implied_decimal type" do
+      @column = Slither::Column.new(:amount, 10, :type=> :money_with_implied_decimal)
+      @column.format(234.450).should   == "     23445"
+      @column.format(12.34).should     == "      1234"
+    end    
+  
+    it "should support the date type" do
+      dt = Date.new(2009, 8, 22)
+      @column = Slither::Column.new(:date, 10, :type => :date)
+      @column.format(dt).should == '2009-08-22'
+    end   
+    
+    it "should support the date type with a :format" do
+      dt = Date.new(2009, 8, 22)
+      @column = Slither::Column.new(:date, 8, :type => :date, :format => "%m%d%Y")
+      @column.format(dt).should == '08222009'
+    end 
+  end
+
+end

data/spec/definition_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Slither::Definition do  
+  before(:each) do
+  end
+  
+  describe "when specifying alignment" do
+    it "should have an alignment option" do
+      d = Slither::Definition.new :align => :right
+      d.options[:align].should == :right
+    end
+    
+    it "should default to being right aligned" do
+      d = Slither::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)
+      Slither::Section.should_receive(:new).with('name', {:align => :left}).and_return(section)
+      d = Slither::Definition.new
+      d.options[:align].should == :right
+      d.section('name', :align => :left) {}
+    end
+  end
+  
+  describe "when creating a section" do
+    before(:each) do
+      @d = Slither::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(Slither::Section)
+      @d.sections.first.should == yielded
+    end
+          
+    it "should magically build a section from an unknown method" do
+      Slither::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(ArgumentError)
+      lambda { @d.section(:header) {} }.should raise_error(ArgumentError, "Reserved or duplicate section name: 'header'")
+    end
+    
+    it "should throw an error if a reserved section name is used" do
+      lambda { @d.section(:spacer) {} }.should raise_error(ArgumentError, "Reserved or duplicate section name: 'spacer'")
+    end
+  end
+  
+  describe "when creating a template" do
+    before(:each) do
+      @d = Slither::Definition.new
+      @section = mock('section', :null_object => true)
+    end
+    
+    it "should create a new section" do
+      Slither::Section.should_receive(:new).with(:row, anything()).and_return(@section)
+      @d.template(:row) {}
+    end
+    
+    it "should yield the new section" do
+      Slither::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/generator_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+    
+describe Slither::Generator do
+  before(:each) do
+    @definition = Slither.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 = Slither::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(Slither::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 
+end

data/spec/parser_spec.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+    
+describe Slither::Parser do
+  before(:each) do
+    @definition = mock('definition', :sections => [])
+    @file = mock("file", :gets => nil)
+    @file_name = 'test.txt'
+    @parser = Slither::Parser.new(@definition, @file_name)
+  end
+  
+  it "should open and yield the source file" do
+    File.should_receive(:open).with(@file_name, 'r').and_yield(@file)
+    @parser.parse
+  end
+  
+  describe "when parsing sections" do
+    before(:each) do
+      @definition = Slither.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
+      File.should_receive(:open).with(@file_name, 'r').and_yield(@file)
+      @parser = Slither::Parser.new(@definition, @file_name)
+    end
+
+    it "should add lines to the proper sections" do
+      @file.should_receive(:gets).exactly(4).times.and_return(
+        'HEAD         1',
+        '      Paul    Hewson',
+        '      Dave     Evans',
+        'FOOT         1',
+        nil
+      )
+      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(:gets).twice.and_return('      Paul    Hewson', nil)
+      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(:gets).twice.and_return('      Ryan      Wood', nil)
+      lambda { @parser.parse }.should raise_error(Slither::RequiredSectionNotFoundError, "Required section 'header' was not found.")
+    end
+    
+    # it "raise an error if a section limit is over run"
+  end
+end