slither-ruby19 0.99.3

data/History.txt

@@ -0,0 +1,16 @@
+  
+== 0.99.2 / 2009-04-28
+
+* Added better support for float formatting
+* Added the money_with_implied_decimal type
+  
+== 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)
+
+== 0.99.0 / 2009-04-14
+
+* Initial Release

data/README.rdoc

@@ -0,0 +1,100 @@
+== 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/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'bones'
+
+task :default => 'spec:run'
+
+PROJ.name = 'slither'
+PROJ.authors = 'Ryan Wood'
+PROJ.email = 'ryan.wood@gmail.com'
+PROJ.url = 'http://github.com/ryanwood/slither'
+PROJ.version = '0.99.3'
+PROJ.exclude = %w(\.git .gitignore ^tasks \.eprj ^pkg)
+PROJ.readme_file = 'README.rdoc'
+
+#PROJ.rubyforge.name = 'codeforpeople'
+
+PROJ.rdoc.exclude << '^data'
+PROJ.notes.exclude = %w(^README\.rdoc$ ^data ^pkg)
+
+# PROJ.svn.path = 'bones'
+# PROJ.spec.opts << '--color'

data/TODO

@@ -0,0 +1,13 @@
+== 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
+
+== 1.x
+
+* Alternate Section Flow (other than linear), i.e. repeatable sections (think batch)

data/lib/slither.rb

@@ -0,0 +1,7 @@
+$: << File.dirname(__FILE__)
+require 'slither/slither'
+require 'slither/definition'
+require 'slither/section'
+require 'slither/column'
+require 'slither/parser'
+require 'slither/generator'

data/lib/slither/column.rb

@@ -0,0 +1,126 @@
+require 'date'
+
+class Slither
+  class ParserError < RuntimeError; end
+  
+  class Column
+    attr_reader :name, :length, :alignment, :type, :padding, :precision, :options
+    
+    def initialize(name, length, options = {})
+      assert_valid_options(options)
+      @name = name
+      @length = length
+      @options = options
+      @alignment = options[:align] || :right
+      @type = options[:type] || :string
+      @padding = options[:padding] || :space
+      @truncate = options[:truncate] || false
+      # Only used with floats, this determines the decimal places
+      @precision = options[:precision] 
+    end
+    
+    def unpacker
+      "A#{@length}"
+    end
+       
+    def parse(value)
+      case @type
+        when :integer
+          value.to_i
+        when :float, :money
+          value.to_f
+        when :money_with_implied_decimal
+          value.to_f / 100
+        when :date
+          if @options[:format]
+            Date.strptime(value, @options[:format])
+          else
+            Date.strptime(value)
+          end
+        else value.strip
+      end
+    rescue
+      raise ParserError, "The value '#{value}' could not be converted to type #{@type}: #{$!}"
+    end
+    
+    def format(value)
+      pad(formatter % to_s(value))
+    rescue
+      puts "Could not format column '#{@name}' as a '#{@type}' with formatter '#{formatter}' and value of '#{value}' (formatted: '#{to_s(value)}'). #{$!}"
+    end
+       
+    private
+    
+      def formatter
+        "%#{aligner}#{sizer}s"
+      end
+          
+      def aligner
+        @alignment == :left ? '-' : ''
+      end
+      
+      def sizer
+        (@type == :float && @precision) ? @precision : @length
+      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 to_s(value)
+        result = case @type
+          when :date            
+            # If it's a DBI::Timestamp object, see if we can convert it to a Time object
+            unless value.respond_to?(:strftime)
+              value = value.to_time if value.respond_to?(:to_time)
+            end
+            if value.respond_to?(:strftime)        
+              if @options[:format]
+                value.strftime(@options[:format])
+              else
+                value.strftime
+              end
+            else
+              value.to_s
+            end
+          when :float
+            @options[:format] ? @options[:format] % value.to_f : value.to_f.to_s
+          when :money
+            "%.2f" % value.to_f
+          when :money_with_implied_decimal
+            "%d" % (value.to_f * 100)
+          else 
+            value.to_s
+        end
+        validate_size 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
+      
+      def validate_size(result)
+        # Handle when length is out of range
+        if result.length > @length
+          if @truncate
+            start = @alignment == :left ? 0 : -@length
+            result = result[start, @length]
+          else
+            raise Slither::FormattedStringExceedsLengthError, 
+              "The formatted value '#{result}' in column '#{@name}' exceeds the allowed length of #{@length} chararacters."
+          end
+        end
+        result
+      end
+  end  
+end

data/lib/slither/definition.rb

@@ -0,0 +1,33 @@
+class Slither  
+  class Definition
+    attr_reader :sections, :templates, :options
+    
+    def initialize(options = {})
+      @sections = []
+      @templates = {}
+      @options = { :align => :right }.merge(options)
+    end
+    
+    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 = Slither::Section.new(name, @options.merge(options))
+      section.definition = self
+      yield(section)
+      @sections << section
+      section
+    end
+    
+    def template(name, options = {}, &block)
+      section = Slither::Section.new(name, @options.merge(options))
+      yield(section)
+      @templates[name] = section
+    end
+    
+    def method_missing(method, *args, &block)
+      section(method, *args, &block)
+    end
+  end  
+end

data/lib/slither/generator.rb

@@ -0,0 +1,26 @@
+class Slither
+  class Generator
+		
+		def initialize(definition)
+			@definition = definition
+		end
+		
+		def generate(data)
+	    @builder = []
+	    @definition.sections.each do |section|
+	      content = data[section.name]
+	      if content
+  	      content = [content] unless content.is_a?(Array)
+  	      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, "Required section '#{section.name}' was empty.") unless section.optional
+	      end
+	    end
+	    @builder.join("\n")
+		end
+		
+	end
+end

data/lib/slither/parser.rb

@@ -0,0 +1,53 @@
+class Slither
+  class Parser
+        
+    def initialize(definition, file)
+      @definition = definition
+      @file = file
+      # This may be used in the future for non-linear or repeating sections
+      @mode = :linear
+    end
+    
+    def parse()
+      @parsed = {}
+      @content = read_file      
+      unless @content.empty?
+        @definition.sections.each do |section|
+          rows = fill_content(section)
+          raise(Slither::RequiredSectionNotFoundError, "Required section '#{section.name}' was not found.") unless rows > 0 || section.optional
+        end
+      end
+      @parsed
+    end
+    
+    private
+    
+      def read_file
+        content = []
+        File.open(@file, 'r') do |f|
+          while (line = f.gets) do
+            content << line
+          end
+        end
+        content
+      end
+      
+      def fill_content(section)
+        matches = 0
+        loop do
+          line = @content.first
+          break unless section.match(line) 
+          add_to_section(section, line)
+          matches += 1
+          @content.shift
+        end
+        matches
+      end
+      
+      def add_to_section(section, line)
+        @parsed[section.name] = [] unless @parsed[section.name]
+        @parsed[section.name] << section.parse(line)
+      end
+    
+  end
+end

data/lib/slither/section.rb

@@ -0,0 +1,76 @@
+class Slither
+  class Section
+    attr_accessor :definition, :optional
+    attr_reader :name, :columns, :options
+    
+    RESERVED_NAMES = [:spacer]
+    
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+      @columns = []
+      @trap = options[:trap]
+      @optional = options[:optional] || false
+    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
+    end
+    
+    def spacer(length)
+      column(:spacer, length)
+    end
+    
+    def trap(&block)
+      @trap = block
+    end
+    
+    def template(name)
+      template = @definition.templates[name]
+      raise ArgumentError, "Template #{name} not found as a known template." unless template
+      @columns = @columns + template.columns
+      # Section options should trump template options
+      @options = template.options.merge(@options)
+    end
+    
+    def format(data)
+      # raise( ColumnMismatchError,
+      #   "The '#{@name}' section has #{@columns.size} column(s) defined, but there are #{data.size} column(s) provided in the data."
+      # ) unless @columns.size == data.size
+      row = ''      
+      @columns.each do |column|
+        row += column.format(data[column.name])
+      end
+      row
+    end
+    
+    def parse(line)
+      line_data = line.unpack(unpacker)
+      row = {}
+      @columns.each_with_index do |c, i|
+        row[c.name] = c.parse(line_data[i]) unless RESERVED_NAMES.include?(c.name)
+      end
+      row
+    end
+    
+    def match(raw_line)
+      raw_line.nil? ? false : @trap.call(raw_line)
+    end
+    
+    def method_missing(method, *args)
+      column(method, *args)
+    end
+  
+    private
+      
+      def unpacker
+        @columns.map { |c| c.unpacker }.join('')
+      end
+
+  end  
+end

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

data/spec/section_spec.rb

@@ -0,0 +1,146 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+    
+describe Slither::Section do
+  before(:each) do
+    @section = Slither::Section.new(:body)
+  end
+  
+  it "should have no columns after creation" do
+    @section.columns.should be_empty
+  end
+  
+  it "should know it's reserved names" do
+    Slither::Section::RESERVED_NAMES.should == [:spacer]
+  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 = 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
+    @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 = Slither::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 raise an error if the data and column definitions aren't the same size" do
+    #   @section.column(:id, 5)
+    #   lambda { @section.format(@data) }.should raise_error(
+    #     Slither::ColumnMismatchError,
+    #     "The 'body' section has 1 column(s) defined, but there are 2 column(s) provided in the data."
+    #   )
+    # end
+  end
+  
+  describe "when parsing a file" do
+    before(:each) do
+      @line = '   45      Ryan      WoodSC '
+      @section = Slither::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
+  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

data/spec/slither_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Slither 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
+      Slither.should_receive(:define).with(@name, @options).and_return(@definition)
+      Slither.define(@name , @options)
+    end
+    
+    it "should pass the definition to the block" do
+      yielded = nil
+      Slither.define(@name) do |y|
+        yielded = y
+      end
+      yielded.should be_a( Slither::Definition )
+    end
+    
+    it "should add to the internal definition count" do
+      Slither.definitions.clear
+      Slither.should have(0).definitions
+      Slither.define(@name , @options) {}
+      Slither.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 { Slither.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({})
+      Slither.should_receive(:definition).with(:test).and_return(definition)
+      Slither::Generator.should_receive(:new).with(definition).and_return(generator)
+      Slither.generate(:test, {})
+    end
+    
+    it "should output a file" do
+  	  file = mock('file')
+  	  text = mock('string')
+  	  file.should_receive(:write).with(text)
+  	  File.should_receive(:open).with('file.txt', 'w').and_yield(file)
+  	  Slither.should_receive(:generate).with(:test, {}).and_return(text)
+      Slither.write('file.txt', :test, {})
+  	end       
+  end
+	
+  describe "when parsing a file" do
+    before(:each) do
+      @file_name = 'file.txt'
+    end
+    
+    it "should check the file exists" do
+      lambda { Slither.parse(@file_name, :test, {}) }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an error if the definition name is not found" do
+      Slither.definitions.clear
+      File.stub!(:exists? => true)
+      lambda { Slither.parse(@file_name, :test, {}) }.should raise_error(ArgumentError)      
+    end
+    
+    it "should create a parser and call parse" do
+      File.stub!(:exists? => true)
+      parser = mock("parser", :null_object => true)
+      definition = mock('definition')     
+      Slither.should_receive(:definition).with(:test).and_return(definition)
+      Slither::Parser.should_receive(:new).with(definition, @file_name).and_return(parser)      
+      Slither.parse(@file_name, :test)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'slither'))
+ 

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: slither-ruby19
+version: !ruby/object:Gem::Version 
+  hash: 405
+  prerelease: false
+  segments: 
+  - 0
+  - 99
+  - 3
+  version: 0.99.3
+platform: ruby
+authors: 
+- Ryan Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-22 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 2
+        - 5
+        - 1
+        version: 2.5.1
+  type: :development
+  version_requirements: *id001
+description: (Temporary fork of slither gem that works with ruby 1.9) A simple, clean DSL for describing, writing, and parsing fixed-width text files.
+email: ryan.wood@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.rdoc
+files: 
+- History.txt
+- README.rdoc
+- Rakefile
+- TODO
+- lib/slither.rb
+- lib/slither/column.rb
+- lib/slither/definition.rb
+- lib/slither/generator.rb
+- lib/slither/parser.rb
+- lib/slither/section.rb
+- lib/slither/slither.rb
+- slither.gemspec
+- spec/column_spec.rb
+- spec/definition_spec.rb
+- spec/generator_spec.rb
+- spec/parser_spec.rb
+- spec/section_spec.rb
+- spec/slither_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/ryanwood/slither
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: !binary |
+  AA==
+
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: (Temporary fork of slither gem that works with ruby 1.9) A simple, clean DSL for describing, writing, and parsing fixed-width text files
+test_files: []
+