gotime-slither 1.0.2

data/spec/generator_spec.rb

@@ -0,0 +1,48 @@
+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 with default newline options" do
+    expected = "HEAD         1\n      Paul    Hewson\n      Dave     Evans\nFOOT         1"
+    @generator.generate(@data).should == expected
+  end 
+  
+  it "should generate a string with the specified newline options" do
+    @definition.options.merge!({:newline_style => :dos, :terminal_newline => true})
+    expected = "HEAD         1\r\n      Paul    Hewson\r\n      Dave     Evans\r\nFOOT         1\r\n"
+    @generator.generate(@data).should == expected
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,297 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+    
+describe Slither::Parser do
+  
+  describe "when parsing sections" do
+    before(:each) do
+      @definition = Slither.define :test, :by_bytes => false 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' &&  line[0,4] != '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
+      
+      @io = StringIO.new 
+      @parser = Slither::Parser.new(@definition, @io)
+    end
+
+    it "should add lines to the proper sections" do
+      @io.string = "HEAD         1\n      Paul    Hewson\n      Dave     Evans\nFOOT         1"
+
+      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
+      @io.string = '      Paul    Hewson'
+
+      expected = { :body => [ {:first => "Paul", :last => "Hewson" } ] }
+      @parser.parse.should == expected      
+    end
+      
+    it "should raise an error if a required section is not found" do
+      @io.string = '      Ryan      Wood'
+
+      lambda { @parser.parse }.should raise_error(Slither::RequiredSectionNotFoundError, "Required section 'header' was not found.")
+    end
+    
+    it "should raise an error if the line is too long" do
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @io.string = 'abc'*20
+      
+      lambda { @parser.parse }.should raise_error(Slither::LineWrongSizeError)
+    end
+    
+    it "should raise an error if the line is too short" do
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @io.string = 'abc'
+
+      lambda { @parser.parse }.should raise_error(Slither::LineWrongSizeError)
+    end
+    
+    it "shouldn't raise an error if validate is turned off and too short" do
+      @definition.options[:validate_length] = false
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @io.string = "abcdefghijk\nabc"
+      
+      expected = { :body => [ {:first => "abcdefghij", :last => "k" },
+        {:first => "abc", :last => "" } ] }
+      @parser.parse.should == expected
+    end
+    
+    it "shouldn't raise an error if validate is turned off and too long" do
+      @definition.options[:validate_length] = false
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @io.string = 'abcdefghijklmnopqrstuvwxyz'
+      
+      expected = { :body => [ {:first => "abcdefghij", :last => "klmnopqrst" } ] }
+      @parser.parse.should == expected
+    end
+    
+    it 'should handle utf characters with force_character_offset = true' do
+      @definition.sections[0].optional = true
+      @definition.sections[2].optional = true
+      @definition.options[:force_character_offset] = true
+      utf_str1 = "12\xE5\x9B\xBD4567890".force_encoding('utf-8')
+      utf_str2 = "ab\xE5\x9B\xBDdefghij".force_encoding('utf-8')
+      @io.string = (utf_str1 + utf_str2)
+      
+      (utf_str1 + utf_str2).size.should eq(20)
+
+      expected = {
+        :body => [ {:first => utf_str1, :last => utf_str2} ]
+      }
+      
+      Slither.parseIo(@io, :test).should eq(expected)
+    end
+    
+  end
+  
+  describe "when parsing by bytes" do
+    before(:each) do
+      @definition = Slither.define :test do |d|
+        d.body do |b|
+          b.trap { true }
+          b.column :first, 5
+          b.column :last, 5
+        end   
+      end
+      
+      @io = StringIO.new 
+      @parser = Slither::Parser.new(@definition, @io)
+    end
+    
+    it 'should raise error for data with line length too long' do
+      @io.string = "abcdefghijklmnop"
+
+      lambda { @parser.parse_by_bytes }.should raise_error(Slither::LineWrongSizeError)
+    end
+    
+    it 'should raise error for data with line length too short' do
+      @io.string = "abc"
+
+      lambda { @parser.parse_by_bytes }.should raise_error(Slither::LineWrongSizeError)
+    end
+    
+    it 'should raise error for data with empty lines' do
+      @io.string = "abcdefghij\r\n\n\n\n"  # 10 then 3
+
+      lambda { @parser.parse_by_bytes }.should raise_error(Slither::LineWrongSizeError)
+    end
+    
+    it 'should handle utf characters' do
+      utf_str1 = "\xE5\x9B\xBD45"
+      utf_str2 = "ab\xE5\x9B\xBD"
+      @io.string = (utf_str1 + utf_str2)
+
+      expected = {
+        :body => [ {:first => utf_str1, :last => utf_str2} ]
+      }
+      
+      Slither.parseIo(@io, :test).should eq(expected)
+    end
+    
+    it 'should handle mid-line newline chars' do
+      str1 = "12\n45"
+      str2 = "a\n\r\nb"
+      @io.string = (str1 + str2 + "\n" + str1 + str2)
+
+      expected = {
+        :body => [ {:first => str1, :last => str2}, {:first => str1, :last => str2} ]
+      }
+      
+      Slither.parseIo(@io, :test).should eq(expected)
+    end
+    
+    it 'should throw exception if section lengths are different' do
+      definition = Slither.define :test, :by_bytes => true do |d|
+        d.body do |b|
+          b.column :one, 5
+        end
+        d.foot do |f|
+          f.column :only, 2
+        end   
+      end
+      
+      parser = Slither::Parser.new(definition, @io)
+      
+      lambda { parser.parse_by_bytes }.should raise_error(Slither::SectionsNotSameLengthError)
+    end
+  end
+
+  describe 'when parsing binary data' do
+    before(:each) do
+      @definition = Slither.define :test do |d|
+        d.body do |b|
+          b.trap { true }
+          b.column :first, 3
+          b.column :dat, 2, type: :binary
+          b.column :last, 3
+        end
+      end
+
+      @io = StringIO.new
+      @parser = Slither::Parser.new(@definition, @io)
+    end
+
+    it 'should work basic case' do
+      @io.string = "abc\x00\x18end\n"
+
+      expected = {
+          :body => [ {:first => 'abc', :dat => [0x00, 0x18], :last => 'end'} ]
+      }
+
+      Slither.parseIo(@io, :test).should eq(expected)
+    end
+
+    it 'should handle spaces' do
+      @io.string = "abc \x18end\n"
+
+      expected = {
+          :body => [ {:first => 'abc', :dat => [0x20, 0x18], :last => 'end'} ]
+      }
+
+      Slither.parseIo(@io, :test).should eq(expected)
+    end
+  end
+
+  describe 'when calling the helper method' do
+    
+    it 'remove_newlines returns true for file starting in newlines or EOF' do
+      @io = StringIO.new 
+      @parser = Slither::Parser.new(@definition, @io)
+      
+      @parser.send(:remove_newlines!).should eq(true)
+      
+      @io.string = "\nXYZ"
+      @parser.send(:remove_newlines!).should eq(true)
+      @io.string = "\r\n"
+      @parser.send(:remove_newlines!).should eq(true)
+      @io.string = "\n\n\n\nXYZ\n"
+      @parser.send(:remove_newlines!).should eq(true)
+      @io.string = ""
+      @parser.send(:remove_newlines!).should eq(true)
+      
+    end
+    
+    it 'remove_newlines returns false for any other first characters' do
+      @io = StringIO.new 
+      @parser = Slither::Parser.new(@definition, @io)
+      
+      @io.string = "XYZ\nxyz"
+      @parser.send(:remove_newlines!).should eq(false)
+      @io.string = " \nxyz"
+      @parser.send(:remove_newlines!).should eq(false)
+      @io.string = "!YZxyz\n"
+      @parser.send(:remove_newlines!).should eq(false)
+      
+    end
+    
+    it 'remove_newlines leaves first non-newline char in place' do
+      @io = StringIO.new 
+      @parser = Slither::Parser.new(@definition, @io)
+      
+      @io.string = "\nXYZ"
+      @parser.send(:remove_newlines!).should eq(true)
+      @io.getc.should eq("X")
+      @parser.send(:remove_newlines!).should eq(false)
+    end
+    
+    it 'newline? it is true for \n or \r and false otherwise' do
+      @parser = Slither::Parser.new(nil,nil)
+      
+      [["\n",true],["\r",true],["n",false]].each do |el|
+        @parser.send(:newline?,el[0].ord).should eq(el[1])
+      end
+      @parser.send(:newline?,nil).should eq(false)
+      @parser.send(:newline?,"").should eq(false)
+    end
+  end
+  
+  describe "when using error handler" do
+    
+    it "calls the error_handler lambda" do
+      error_handler = lambda {|line| raise "error handler exception for #{line}"}
+      
+      @definition = Slither.define :test, error_handler: error_handler do |d|
+        d.body do |b|
+          b.trap { true }
+          b.column :first, 5
+          b.column :last, 5
+        end   
+      end
+      
+      @io = StringIO.new 'abc'
+      @parser = Slither::Parser.new(@definition, @io)
+      
+      lambda { @parser.parse(error_handler) }.should raise_error(RuntimeError, "error handler exception for abc")
+    end
+    
+  end
+
+end

data/spec/section_spec.rb

@@ -0,0 +1,156 @@
+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
+      @template.should_receive(:length).and_return(0)
+      @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.should_receive(:length).and_return(0)
+       @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)
+      definition = Slither::Definition.new()
+      @section.definition = definition
+      @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
+
+    it "should retain encoding of source" do
+      @column_content.each { |k,v| @section.column(k, v) }
+      parsed = @section.parse(@line)
+      parsed[:id].encoding.should eq(@line.encoding)
+    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