gotime-slither 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3d2ee3717c7e3ed3187c30b6f5913f15ca2d382
+  data.tar.gz: c941cd80a505c801172bf0377343b27064df2eb0
+SHA512:
+  metadata.gz: 2ab17161a128a546574ea4f1cd2b5be6f39363005c7578a0eb758a381e0d2afa1a8eba1c0bf421d233e456dd9396cf43429fd7434bb52a4d8accffde40e4894e
+  data.tar.gz: 3b9c5d9746c2cb86b943efdcbeb0871f93de2b7509cbb5e86d04f1ca253acd3299dc277618e8d84c57d1f312dfc4657e1a5788aee0d79337200bb0238e87a292

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,109 @@
+== 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
+* Helpful error messages for invalid data
+
+== SYNOPSIS:
+
+  # Create a Slither::Defintion to describe a file format
+  Slither.define :simple, :by_bytes => false 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, binary, money, and money_with_implied_decimal.
+
+Use :by_bytes => true (default) to allow newlines within rows and specify length in bytes.
+Use :by_bytes => false to support sections of different lengths and length specification
+in number of characters.
+
+Binary types will be returned as an array of 8-bit unsigned byte values
+
+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(output_filename, :simple, test_data)
+
+or parse files already in that format into a nested hash:
+
+   parsed_data = Slither.parse(input_filename, :simple)
+   parsed_data = Slither.parseIo(io_object, :simple)
+
+
+== 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,14 @@
+== 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)
+* Equivalent of parse by bytes, but with chars.  Use "io.gets nil, num_chars_per_line"

data/lib/gotime-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,146 @@
+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
+      case @type
+        when :binary
+          "C#{@length}"
+        else
+          "A#{@length}"
+      end
+    end
+
+    def parse_length
+      case @type
+        when :binary
+          @length
+        else
+          1
+      end
+    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 :binary
+          value
+        when :date
+          if @options[:format]
+            Date.strptime(value, @options[:format])
+          else
+            Date.strptime(value)
+          end
+        else value.strip
+      end
+    rescue
+      raise ParserError, "Error parsing column ''#{name}'. 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 inspect
+        "#<#{self.class} #{instance_variables.map{|iv| "#{iv}=>#{instance_variable_get(iv)}"}.join(', ')}>"
+      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,35 @@
+class Slither  
+  class Definition
+    attr_reader :sections, :templates, :options
+    
+    def initialize(options = {})
+      @sections = []
+      @templates = {}
+      @options = { :align => :right, :by_bytes => true, :validate_length => true,
+        :error_handler => nil, force_character_offset: false, :newline_style => :unix,
+        :terminal_newline => false }.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,37 @@
+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
+	    newline_style = newline_lookup(@definition.options[:newline_style])
+
+	    output_string = @builder.join(newline_style)
+	    output_string << newline_style if @definition.options[:terminal_newline]
+	    
+	    output_string
+		end
+		
+		private
+		
+		def newline_lookup(option)
+		  option == :dos ? "\r\n" : "\n"
+	  end
+		
+	end
+end

data/lib/slither/parser.rb

@@ -0,0 +1,109 @@
+class Slither
+  class Parser
+        
+    def initialize(definition, file_io)
+      @definition = definition
+      @file = file_io
+      # This may be used in the future for non-linear or repeating sections
+      @mode = :linear
+    end
+    
+    def parse(error_handler=nil)
+      parsed = {}
+
+      @file.each_line do |line|
+        line.chomp! if line
+        next if line.empty?
+        @definition.sections.each do |section|
+          if section.match(line)
+            validate_length(line, section, error_handler) if @definition.options[:validate_length]
+            parsed = fill_content(line, section, parsed)
+          end
+        end
+      end
+
+      @definition.sections.each do |section|
+        raise(Slither::RequiredSectionNotFoundError, "Required section '#{section.name}' was not found.") unless parsed[section.name] || section.optional
+      end
+      parsed
+    end
+    
+    def parse_by_bytes
+      parsed = {}
+      
+      all_section_lengths = @definition.sections.map{|sec| sec.length }
+      byte_length = all_section_lengths.max
+      all_section_lengths.each { |bytes| raise(Slither::SectionsNotSameLengthError,
+          "All sections must have the same number of bytes for parse by bytes") if bytes != byte_length }
+      
+      while record = @file.read(byte_length)
+        
+        unless remove_newlines! && byte_length == record.length
+          parsed_line = parse_for_error_message(record)
+          raise(Slither::LineWrongSizeError, "Line wrong size: No newline at #{byte_length} bytes. #{parsed_line}") 
+        end
+    
+        record.force_encoding @file.external_encoding
+        
+        @definition.sections.each do |section|
+          if section.match(record)
+            parsed = fill_content(record, section, parsed)
+          end
+        end
+      end
+      
+      @definition.sections.each do |section|
+        raise(Slither::RequiredSectionNotFoundError, "Required section '#{section.name}' was not found.") unless parsed[section.name] || section.optional
+      end
+      parsed
+    end
+    
+    private
+    
+      def fill_content(line, section, parsed)
+        parsed[section.name] ||= []
+        parsed[section.name] << section.parse(line)
+        parsed
+      end
+      
+      def validate_length(line, section, error_handler)
+        if line.length != section.length
+          if error_handler
+            error_handler.call(line)
+          else
+            parsed_line = parse_for_error_message(line)
+            raise Slither::LineWrongSizeError, "Line wrong size: (#{line.length} when it should be #{section.length}. #{parsed_line})" 
+          end
+        end
+      end
+      
+      def remove_newlines!
+        return true if @file.eof?
+        b = @file.getbyte
+        if b == 10 || b == 13 && @file.getbyte == 10
+          return true
+        else
+          @file.ungetbyte b
+          return false
+        end
+      end
+      
+      def newline?(char_code)
+        # \n or LF -> 10
+        # \r or CR -> 13
+        [10, 13].any?{|code| char_code == code}
+      end
+      
+      def parse_for_error_message(line)
+        parsed = ''
+        line.force_encoding @file.external_encoding
+        @definition.sections.each do |section|
+          if section.match(line)
+            parsed = section.parse_when_problem(line)
+          end
+        end
+        parsed
+      end
+      
+  end
+end