ryanwood-slither 0.99.0 → 0.99.1

data/History.txt

@@ -1,4 +1,10 @@
 == 0.99.0 / 2009-04-14
 
 * Initial Release
-  * Happy Birthday!
+  
+== 0.99.1 / 2009-04-22
+
+* Make the missing method build a column  i.e. body.record_type 1
+* Prevent duplicate column names
+* Better error messages
+* Implement custom padding (spaces (default), zero)

data/README.rdoc

@@ -24,31 +24,23 @@ A simple, clean DSL for describing, writing, and parsing fixed-width text files.
     end 
    
     # Create a header section
-    d.header, :align => :left do |header|
-      
+    d.header, :align => :left do |header|      
       # The trap tells Slither which lines should fall into this section
-      header.trap do |line|
-        line[0,4] == 'HEAD'
-      end
-      
+      header.trap { |line| line[0,4] == 'HEAD' }
       # Use the boundary template for the columns
       header.template :boundary
     end
   
     d.body do |body|
-      body.trap do |line|
-        line[0,4] =~ /[^(HEAD|FOOT)]/
-      end
+      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, :, :limit => 1 do |footer|
-      footer.trap do |line|
-        line[0,4] == 'FOOT'
-      end
+    d.footer do |footer|
+      footer.trap { |line| line[0,4] == 'FOOT' }
       footer.template :boundary
       footer.column :record_count, 10
     end

data/TODO

@@ -1,4 +1,13 @@
-* Validation
-* Alternate Section Flow (other than linear), i.e. repeatable sections (think batch)
+== 0.99.2
+
+* Add :limit option on sections
+* Add :validation option for columns
+* Add a validate_file() method to parse a file and run all validation tests (implies validation implemented)
+
+== 1.0.0
+
 * Better Documentation
-* Limit on section
+
+== 1.x
+
+* Alternate Section Flow (other than linear), i.e. repeatable sections (think batch)

data/lib/slither/column.rb

@@ -2,7 +2,7 @@ require 'date'
 
 class Slither
   class Column
-    attr_reader :name, :length, :alignment, :type, :options
+    attr_reader :name, :length, :alignment, :type, :padding, :precision, :options
     
     def initialize(name, length, options = {})
       assert_valid_options(options)
@@ -11,16 +11,15 @@ class Slither
       @options = options
       @alignment = options[:align] || :right
       @type = options[:type] || :string
-    end
-    
-    def formatter
-      "%#{aligner}#{length}s"
+      @padding = options[:padding] || :space
+      # Only used with floats, this determines the decimal places
+      @precision = options[:precision] 
     end
     
     def unpacker
       "A#{@length}"
     end
-    
+       
     def to_type(value)
       case @type
         when :integer: value.to_i
@@ -35,28 +34,65 @@ class Slither
       end
     end
     
-    def format_string(value)
-      case @type
-        when :date:
-          if @options[:date_format]
-            value.strftime(@options[:date_format])
-          else
-            value.strftime
-          end
-        else value.to_s
-      end
+    def format(value)
+      pad(formatter % format_as_string(value))
     end
-    
+       
     private
     
+      def formatter
+        "%#{aligner}#{sizer}#{typer}"
+      end
+          
       def aligner
         @alignment == :left ? '-' : ''
       end
       
+      def sizer
+        (@type == :float && @precision) ? @precision : @length
+      end
+      
+      def typer
+        case @type
+          when :integer: 'd'
+          when :float: 's'
+          else 's'
+        end
+      end
+      
+      # Manually apply padding. sprintf only allows padding on numeric fields.
+      def pad(value)
+      	return value unless @padding == :zero
+      	matcher = @alignment == :right ? /^ +/ : / +$/
+      	space = value.match(matcher)
+      	return value unless space
+      	value.gsub(space[0], '0' * space[0].size)
+      end
+      
+      def format_as_string(value)
+        result = case @type
+          when :date:
+            if @options[:date_format]
+              value.strftime(@options[:date_format])
+            else
+              value.strftime
+            end
+          else value.to_s
+        end
+        raise( 
+          Slither::FormattedStringExceedsLengthError, 
+          "The formatted value '#{result}' exceeds #{@length} chararacters, the allowable length of the '#{@name}' column."
+        ) if result.length > @length
+        result
+      end
+
       def assert_valid_options(options)
         unless options[:align].nil? || [:left, :right].include?(options[:align])
           raise ArgumentError, "Option :align only accepts :right (default) or :left"
         end
+        unless options[:padding].nil? || [:space, :zero].include?(options[:padding])
+          raise ArgumentError, "Option :padding only accepts :space (default) or :zero"
+        end
       end    
   end  
 end

data/lib/slither/definition.rb

@@ -10,8 +10,8 @@ class Slither
     
     def section(name, options = {}, &block)
       raise( ArgumentError, "Reserved or duplicate section name: '#{name}'") if  
-      	Section::RESERVED_NAMES.include?( name ) || 
-      	(@sections.size > 0 && @sections.map{ |s| s.name }.include?( name ))
+      Section::RESERVED_NAMES.include?( name ) || 
+      (@sections.size > 0 && @sections.map{ |s| s.name }.include?( name ))
     
       section = Slither::Section.new(name, @options.merge(options))
       section.definition = self
@@ -27,7 +27,7 @@ class Slither
     end
     
     def method_missing(method, *args, &block)
-    	section(method, *args, &block)
+      section(method, *args, &block)
     end
   end  
 end

data/lib/slither/generator.rb

@@ -1,7 +1,4 @@
 class Slither
-  
-  class RequiredSectionEmptyError < StandardError; end
-	
   class Generator
 		
 		def initialize(definition)
@@ -14,12 +11,12 @@ class Slither
 	      content = data[section.name]
 	      if content
   	      content = [content] unless content.is_a?(Array)
-  	      raise Slither::RequiredSectionEmptyError if content.empty?
+  	      raise(Slither::RequiredSectionEmptyError, "Required section '#{section.name}' was empty.") if content.empty?
   	      content.each do |row|
   	        @builder << section.format(row)
   	      end
   	    else
-  	      raise Slither::RequiredSectionEmptyError unless section.optional
+  	      raise(Slither::RequiredSectionEmptyError, "Required section '#{section.name}' was empty.") unless section.optional
 	      end
 	    end
 	    @builder.join("\n")

data/lib/slither/parser.rb

@@ -1,7 +1,4 @@
 class Slither
-  
-  class RequiredSectionNotFoundError < StandardError; end
-  
   class Parser
         
     def initialize(definition, file)
@@ -17,7 +14,7 @@ class Slither
       unless @content.empty?
         @definition.sections.each do |section|
           rows = fill_content(section)
-          raise Slither::RequiredSectionNotFoundError unless rows > 0 || section.optional
+          raise(Slither::RequiredSectionNotFoundError, "Required section '#{section.name}' was not found.") unless rows > 0 || section.optional
         end
       end
       @parsed

data/lib/slither/section.rb

@@ -14,6 +14,9 @@ class Slither
     end
     
     def column(name, length, options = {})
+      raise(Slither::DuplicateColumnNameError, "You have already defined a column named '#{name}'.") if @columns.map do |c|
+        RESERVED_NAMES.include?(c.name) ? nil : c.name
+      end.flatten.include?(name)
       col = Column.new(name, length, @options.merge(options))
       @columns << col
       col
@@ -38,7 +41,7 @@ class Slither
     def format(data)
       row = ''
       @columns.each do |column|
-        row += (column.formatter % column.format_string(data[column.name]))
+        row += column.format(data[column.name])
       end
       row
     end
@@ -55,6 +58,10 @@ class Slither
     def match(raw_line)
       raw_line.nil? ? false : @trap.call(raw_line)
     end
+    
+    def method_missing(method, *args)
+      column(method, *args)
+    end
   
     private
       

data/lib/slither/slither.rb

@@ -2,6 +2,12 @@ class Slither
   
   VERSION = '0.99.0'
   
+  class DuplicateColumnNameError < StandardError; end
+  class RequiredSectionNotFoundError < StandardError; end
+  class RequiredSectionEmptyError < StandardError; end
+  class FormattedStringExceedsLengthError < StandardError; end
+  
+  
   def self.define(name, options = {}, &block)
     definition = Definition.new(options)
     yield(definition)

data/spec/column_spec.rb

@@ -16,12 +16,16 @@ describe Slither::Column 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.formatter.should == "%5s"
+    it "should return a proper formatter" do
+      @column.send(:formatter).should == "%5s"
     end
   end
 
@@ -37,14 +41,24 @@ describe Slither::Column do
     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 return a proper formatter" do
-      @column.formatter.should == "%-5s"
+    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.unpacker.should == 'A5'
+    @column.send(:unpacker).should == 'A5'
   end
   
   describe "when typing the value" do
@@ -77,31 +91,77 @@ describe Slither::Column do
     end   
   end
   
-  describe "when formatting the value" do
+  describe "when getting the column's the value as a string" do
     it "should default to a string" do
-      @column.format_string('name').should == 'name'
+      @column.send(:format_as_string, 'name').should == 'name'
+    end
+    
+    it "should raise an error if the value is longer than the length" do
+      lambda { @column.send(:format_as_string, 'This string is too long') }.should raise_error(
+        Slither::FormattedStringExceedsLengthError, 
+        "The formatted value 'This string is too long' exceeds #{@length} chararacters, the allowable length of the '#{@name}' column."
+      )
     end
     
     it "should support the :integer type" do
       @column = Slither::Column.new(@name, @length, :type => :integer)
-      @column.format_string(234).should == '234'
+      @column.send(:format_as_string, 234).should == '234'
     end
 
     it "should support the :float type" do
-      @column = Slither::Column.new(@name, @length, :type => :float)
-      @column.format_string(234.45).should == '234.45'
+      @column = Slither::Column.new(:amount, 6, :type => :float)
+      @column.send(:format_as_string, 234.45).should == '234.45'
     end
 
     it "should support the :date type" do
       dt = Date.new(2009, 8, 22)
-      @column = Slither::Column.new(@name, @length, :type => :date)
-      @column.format_string(dt).should == '2009-08-22'
+      @column = Slither::Column.new(:date, 10, :type => :date)
+      @column.send(:format_as_string, dt).should == '2009-08-22'
     end   
     
     it "should use the :date_format option with :date type if available" do
       dt = Date.new(2009, 8, 22)
-      @column = Slither::Column.new(@name, @length, :type => :date, :date_format => "%m%d%Y")
-      @column.format_string(dt).should == '08222009'
+      @column = Slither::Column.new(:date, 8, :type => :date, :date_format => "%m%d%Y")
+      @column.send(:format_as_string, dt).should == '08222009'
     end 
   end
+  
+  describe "when formatting a column" 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
 end

data/spec/generator_spec.rb

@@ -32,7 +32,7 @@ describe Slither::Generator do
   
   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)
+    lambda {  @generator.generate(@data) }.should raise_error(Slither::RequiredSectionEmptyError, "Required section 'header' was empty.")
   end
   
   it "should generate a string" do

data/spec/parser_spec.rb

@@ -66,7 +66,7 @@ describe Slither::Parser do
       
     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)
+      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"

data/spec/section_spec.rb

@@ -13,28 +13,46 @@ describe Slither::Section do
     Slither::Section::RESERVED_NAMES.should == [:spacer]
   end
   
-  it "should build an ordered column list" do
-    @section.should have(0).columns
+  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
+      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
+      @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 "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 = Slither::Section.new('name', :align => :left)
-    section.options[:align].should == :left
+    it "can should override the alignment of the definition" do
+      section = Slither::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" do
+      @section.column :id, 10
+      lambda { @section.column(:id, 30) }.should raise_error(Slither::DuplicateColumnNameError, "You have already defined a column named 'id'.")
+    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(Slither::DuplicateColumnNameError)
+    end    
   end
   
   it "should accept and store the trap as a block" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ryanwood-slither
 version: !ruby/object:Gem::Version 
-  version: 0.99.0
+  version: 0.99.1
 platform: ruby
 authors: 
 - Ryan Wood