slither 0.99.4 → 0.99.5

data/README.rdoc

@@ -1,100 +0,0 @@
-== slither
-    by Ryan Wood
-    http://ryanwood.com
-
-== DESCRIPTION:
-
-A simple, clean DSL for describing, writing, and parsing fixed-width text files.
-
-== FEATURES:
-
-* Easy DSL syntax
-* Can parse and format fixed width files
-* Templated sections for reuse
-
-== SYNOPSIS:
-
-  # Create a Slither::Defintion to describe a file format
-  Slither.define :simple do |d|
-  
-    # This is a template section that can be reused in other sections
-    d.template :boundary do |t|
-      t.column :record_type, 4  
-      t.column :company_id, 12      
-    end 
-   
-    # Create a header section
-    d.header, :align => :left do |header|      
-      # The trap tells Slither which lines should fall into this section
-      header.trap { |line| line[0,4] == 'HEAD' }
-      # Use the boundary template for the columns
-      header.template :boundary
-    end
-  
-    d.body do |body|
-      body.trap { |line| line[0,4] =~ /[^(HEAD|FOOT)]/ }
-      body.column :id, 10, :type => :integer
-      body.column :name, 10, :align => :left
-      body.spacer 3
-      body.column :state, 2
-    end
-        
-    d.footer do |footer|
-      footer.trap { |line| line[0,4] == 'FOOT' }
-      footer.template :boundary
-      footer.column :record_count, 10
-    end
-  end
-  
-Supported types are: string, integer, date, float, money, and money_with_implied_decimal.
-  
-Then either feed it a nested struct with data values to create the file in the defined format:
-
-  test_data = {
-    :body => [
-      { :id => 12, :name => "Ryan", :state => 'SC' },
-      { :id => 23, :name => "Joe", :state => 'VA' },
-      { :id => 42, :name => "Tommy", :state => 'FL' },
-    ], 
-    :header => { :record_type => 'HEAD', :company_id => 'ABC'  }, 
-    :footer => { :record_type => 'FOOT', :company_id => 'ABC'  }
-  }
-  
-  # Generates the file as a string
-  puts Slither.generate(:simple, test_data)
-  
-  # Writes the file
-  Slither.write('outfile.txt', :simple, test_data)
-
-or parse files already in that format into a nested hash:
-
-  parsed_data = Slither.parse('infile.txt', :test).inspect
-
-== INSTALL:
-
-sudo gem install slither
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2008
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/slither/slither.rb

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

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

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

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

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