slither 0.99.4 → 0.99.6

metadata

@@ -1,51 +1,29 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: slither
-version: !ruby/object:Gem::Version 
-  hash: 411
-  prerelease: false
-  segments: 
-  - 0
-  - 99
-  - 4
-  version: 0.99.4
+version: !ruby/object:Gem::Version
+  version: 0.99.6
 platform: ruby
-authors: 
+authors:
 - Ryan Wood
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-
-date: 2010-10-07 00:00:00 -04: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: A simple, clean DSL for describing, writing, and parsing fixed-width text files.
-email: ryan.wood@gmail.com
+date: 2024-01-22 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- History.txt
-- README.rdoc
-files: 
-- History.txt
-- README.rdoc
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
 - Rakefile
 - TODO
 - lib/slither.rb
@@ -54,51 +32,31 @@ files:
 - 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/slither/version.rb
+- sig/slither.rbs
+homepage: https://github.com/ryanwood/slither
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  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
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: !binary |
-  AA==
-
-rubygems_version: 1.3.7
-signing_key: 
-specification_version: 2
-summary: A simple, clean DSL for describing, writing, and parsing fixed-width text files
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A simple, clean DSL for describing, writing, and parsing fixed-width text
+  files.
 test_files: []
-

data/History.txt

@@ -1,16 +0,0 @@
-  
-== 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

@@ -1,100 +0,0 @@
-== 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/lib/slither/slither.rb

@@ -1,49 +0,0 @@
-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

@@ -1,224 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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