gotime-slither 1.0.2

data/lib/slither/section.rb

@@ -0,0 +1,109 @@
+class Slither
+  class Section
+    attr_accessor :definition, :optional
+    attr_reader :name, :columns, :options, :length
+    
+    RESERVED_NAMES = [:spacer]
+    
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+      @columns = []
+      @trap = options[:trap]
+      @optional = options[:optional] || false
+      @length = 0
+    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
+      @length += length
+      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 += template.columns
+      @length += template.length
+      # 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 = divide( line, @columns.map(&:length) )
+      row = {}
+      i = 0
+      @columns.each do |c|
+        unless RESERVED_NAMES.include?(c.name)
+          row[c.name] = (c.parse_length == 1 ?
+              c.parse(line_data[i]) : c.parse(line_data[i, c.parse_length]))
+        end
+        i += c.parse_length
+      end
+      row
+    end
+    
+    def parse_when_problem(line)
+      line_data = divide( line, @columns.map(&:length) )
+      row = ''
+      @columns.each_with_index do |c, i|
+        row << "\n'#{c.name}':'#{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
+
+      def divide(string, sections)
+        result = []
+        str = string.dup
+        unless @definition.options[:force_character_offset]
+          result = str.unpack(unpacker)
+          result.each do |s|
+            s.force_encoding(string.encoding) if s.respond_to? :force_encoding
+          end
+        else
+          sections.each do |s|
+            result << str.slice!(0..(s-1))
+          end
+        end
+        result
+      end
+
+  end  
+end

data/lib/slither/slither.rb

@@ -0,0 +1,57 @@
+class Slither
+  
+  VERSION = '0.99.5'
+  
+  class DuplicateColumnNameError < StandardError; end
+  class RequiredSectionNotFoundError < StandardError; end
+  class RequiredSectionEmptyError < StandardError; end
+  class FormattedStringExceedsLengthError < StandardError; end
+  class ColumnMismatchError < StandardError; end
+  class LineWrongSizeError < StandardError; end
+  class SectionsNotSameLengthError < 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)
+
+    file_io = File.open(filename, 'r')
+    parseIo(file_io, definition_name)
+  end
+
+  def self.parseIo(io, definition_name)
+    definition = definition(definition_name)
+    raise ArgumentError, "Definition name '#{definition_name}' was not found." unless definition
+    parser = Parser.new(definition, io)
+    definition.options[:by_bytes] ? parser.parse_by_bytes : parser.parse(definition.options[:error_handler])
+  end
+  
+  private
+  
+    def self.definitions
+      @@definitions ||= {}
+    end
+    
+    def self.definition(name)
+      definitions[name]
+    end
+end

data/spec/column_spec.rb

@@ -0,0 +1,229 @@
+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 accept a binary byte type" do
+      @column = Slither::Column.new(:dat, 1, :type=> :binary)
+      @column.parse(0x18).should == 0x18
+    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,86 @@
+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
+      d = Slither::Definition.new
+      d.options[:align].should == :right
+      d.section('name', :align => :left) {}
+      section = nil
+      d.sections.each { |sec| section = sec if sec.name == 'name' }
+      section.options[:align].should eq(:left)
+    end
+  end
+  
+  describe "when creating a section" do
+    before(:each) do
+      @d = Slither::Definition.new
+      @section = mock('section').as_null_object
+    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').as_null_object
+    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