ryanwood-slither 0.99.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.99.0 / 2009-04-14
+
+* Initial Release
+  * Happy Birthday!

data/README.rdoc

@@ -0,0 +1,106 @@
+== 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 do |line|
+        line[0,4] == 'HEAD'
+      end
+      
+      # 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.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
+      footer.template :boundary
+      footer.column :record_count, 10
+    end
+  end
+  
+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.0'
+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,4 @@
+* Validation
+* Alternate Section Flow (other than linear), i.e. repeatable sections (think batch)
+* Better Documentation
+* Limit on section

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 99
+:major: 0

data/lib/slither/column.rb

@@ -0,0 +1,62 @@
+require 'date'
+
+class Slither
+  class Column
+    attr_reader :name, :length, :alignment, :type, :options
+    
+    def initialize(name, length, options = {})
+      assert_valid_options(options)
+      @name = name
+      @length = length
+      @options = options
+      @alignment = options[:align] || :right
+      @type = options[:type] || :string
+    end
+    
+    def formatter
+      "%#{aligner}#{length}s"
+    end
+    
+    def unpacker
+      "A#{@length}"
+    end
+    
+    def to_type(value)
+      case @type
+        when :integer: value.to_i
+        when :float: value.to_f
+        when :date:
+          if @options[:date_format]
+            Date.strptime(value, @options[:date_format])
+          else
+            Date.strptime(value)
+          end
+        else value.strip
+      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
+    end
+    
+    private
+    
+      def aligner
+        @alignment == :left ? '-' : ''
+      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
+      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,29 @@
+class Slither
+  
+  class RequiredSectionEmptyError < StandardError; end
+	
+  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 if content.empty?
+  	      content.each do |row|
+  	        @builder << section.format(row)
+  	      end
+  	    else
+  	      raise Slither::RequiredSectionEmptyError unless section.optional
+	      end
+	    end
+	    @builder.join("\n")
+		end
+		
+	end
+end

data/lib/slither/parser.rb

@@ -0,0 +1,56 @@
+class Slither
+  
+  class RequiredSectionNotFoundError < StandardError; end
+  
+  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 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,66 @@
+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 = {})
+      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)
+      row = ''
+      @columns.each do |column|
+        row += (column.formatter % column.format_string(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.to_type(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
+  
+    private
+      
+      def unpacker
+        @columns.map { |c| c.unpacker }.join('')
+      end
+
+  end  
+end

data/lib/slither/slither.rb

@@ -0,0 +1,42 @@
+class Slither
+  
+  VERSION = '0.99.0'
+  
+  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/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/spec/column_spec.rb

@@ -0,0 +1,107 @@
+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 alignment" do
+      @column.alignment.should == :right
+    end
+   
+     it "should return a proper formatter" do
+      @column.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
+    
+    it "should return a proper formatter" do
+      @column.formatter.should == "%-5s"
+    end
+  end
+
+  it "should return the proper unpack value for a string" do
+    @column.unpacker.should == 'A5'
+  end
+  
+  describe "when typing the value" do
+    it "should default to a string" do
+      @column.to_type('name').should == 'name'
+    end
+    
+    it "should support the :integer type" do
+      @column = Slither::Column.new(@name, @length, :type => :integer)
+      @column.to_type('234').should == 234
+    end
+
+    it "should support the :float type" do
+      @column = Slither::Column.new(@name, @length, :type => :float)
+      @column.to_type('234.45').should == 234.45
+    end
+
+    it "should support the :date type" do
+      @column = Slither::Column.new(@name, @length, :type => :date)
+      dt = @column.to_type('2009-08-22')
+      dt.should be_a(Date)
+      dt.to_s.should == '2009-08-22'
+    end   
+    
+    it "should use the :date_format option with :date type if available" do
+      @column = Slither::Column.new(@name, @length, :type => :date, :date_format => "%m%d%Y")
+      dt = @column.to_type('08222009')
+      dt.should be_a(Date)
+      dt.to_s.should == '2009-08-22'
+    end   
+  end
+  
+  describe "when formatting the value" do
+    it "should default to a string" do
+      @column.format_string('name').should == 'name'
+    end
+    
+    it "should support the :integer type" do
+      @column = Slither::Column.new(@name, @length, :type => :integer)
+      @column.format_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'
+    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'
+    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'
+    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)
+  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,83 @@
+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)
+    end
+    
+    it "raise an error if a section limit is over run"
+  end
+  
+
+  
+  describe "when in linear mode" do
+
+  end
+  
+
+
+end

data/spec/section_spec.rb

@@ -0,0 +1,120 @@
+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
+  
+  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 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
+  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,85 @@
+--- !ruby/object:Gem::Specification 
+name: ryanwood-slither
+version: !ruby/object:Gem::Version 
+  version: 0.99.0
+platform: ruby
+authors: 
+- Ryan Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+    version: 
+description: 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
+- VERSION.yml
+- 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
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: !binary |
+  AA==
+
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple, clean DSL for describing, writing, and parsing fixed-width text files
+test_files: []
+