cassava 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color -f d

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cassava.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Kurt Stephens
+
+MIT License
+
+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/README.md

@@ -0,0 +1,42 @@
+# Cassava
+
+A command-line CSV tool.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cassava'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cassava
+
+## Usage
+
+    # Concat mulitple CSVs, while merging columns:
+    $ cassava cat first.csv second.csv
+    
+    # Cut columns out of result; '-' is used to pipe results to next command:
+    $ cassava cat first.csv second.csv - cut -c first_name,last_name
+    
+    # Format as ASCII table.
+    $ cassava format first.csv
+    
+    # Select where.
+    $ cassava cat *.csv - where last_name=Smith - format
+    
+    # Sort by a column:
+    $ cassava cat *.csv - sort -by last_name,first_name - format
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+gem 'rspec'
+require 'rspec/core/rake_task'
+
+desc "Default => :test"
+task :default => :test
+
+desc "Run all tests"
+task :test => [ :spec ]
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+

data/bin/cassava

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+$: << File.expand_path("../../lib", __FILE__)
+if ARGV[0] == '-D'
+  ARGV.shift
+  $DEBUG = true
+  require 'rubygems'
+  gem 'ruby-debug'
+  require 'ruby-debug'
+end
+require 'cassava/main'
+exit(Cassava::Main.new(ARGV).run!.exit_code)
+

data/cassava.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cassava/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cassava"
+  gem.version       = Cassava::VERSION
+  gem.authors       = ["Kurt Stephens"]
+  gem.email         = ["ks.github@kurtstephens.com"]
+  gem.description   = %q{A command-line CSV tool.}
+  gem.summary       = %q{A command-line CSV tool.}
+  gem.homepage      = "https://github.com/kstephens/cassava"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'terminal-table', '~> 1.4.5'
+
+  gem.add_development_dependency "rake", "~> 10.0.2"
+  gem.add_development_dependency "rspec", "~> 2.12.0"
+end

data/lib/cassava.rb

@@ -0,0 +1,6 @@
+require "cassava/version"
+
+module Cassava
+end
+
+require 'cassava/document'

data/lib/cassava/document.rb

@@ -0,0 +1,388 @@
+require 'csv'
+
+module Cassava
+  class Document
+    attr_accessor :name, :columns, :column_offset, :offset_column
+    attr_accessor :rows
+    attr_accessor :debug
+
+    def initialize opts = nil
+      @opts = opts
+      @name = opts[:name] or raise ArgumentError, "name not specified"
+      @rows = [ ]
+      @index = { }
+      self.columns = opts[:columns] || [ ]
+      if x = opts[:rows]
+        append_row! x
+      end
+    end
+
+    def columns= x
+      @columns = x
+      update_columns!
+    end
+
+    def update_columns!
+      @ncols = @columns.size
+      @column_offset = { }
+      @offset_column = [ ]
+      i = -1
+      @columns.map! do | c |
+        i += 1
+        c = c.to_s
+        next if c.empty?
+        c = c.to_sym
+        @column_offset[c] = i
+        @offset_column[i] = c
+        c
+      end
+      @column_types = nil
+      @index.keep_if { | c, h | @column_offset[c] }
+      self
+    end
+
+    def add_column! c
+      c = c.to_sym
+      unless i = @column_offset[c]
+        i = @columns.size
+        @columns << c
+        update_columns!
+      end
+      i
+    end
+
+    def to_column_names! a
+      a.map! do | x |
+        case x
+        when Integer
+          c = @columns[x]
+        when String
+          if x == (i = x.to_i).to_s
+            c = @columns[i]
+          else
+            c = x.to_sym
+          end
+        when Symbol
+          c = x
+        else
+          raise TypeError, "#{x.inspect}"
+        end
+        raise TypeError, "#{x.inspect} => #{c.inspect}" unless c
+        c
+      end
+      a
+    end
+
+    def nrows
+      @rows.size
+    end
+
+    def empty_rows!
+      @rows = [ ]
+      @index.clear
+      @column_types = nil
+      self
+    end
+
+    def append_rows! rows
+      return self unless rows
+      if Document === rows
+        rows.columns.each { | c | add_column!(c) }
+        rows = rows.rows
+      end
+      rows.map!{ | r | array_to_row(r) }
+      row_i = @rows.size
+      @rows.concat(rows)
+      rows.each do | r |
+        @ncols = r.size if @ncols < r.size
+        r[:_row_i] = row_i
+        row_i += 1
+      end
+      @index.clear
+      @column_types = nil
+      self
+    end
+
+    def parse!
+      # debugger if $DEBUG
+      csv = nil
+      if RUBY_VERSION =~ /^1\.8/
+        @rows = [ ]
+        csv = CSV.open(name, "rb", @opts[:col_sep]) do | r |
+          @rows << r
+        end
+      else
+        csv_opts = { }
+        csv_opts[:col_sep] = @opts[:col_sep] if @opts[:col_sep]
+        csv = CSV.open(name, "rb", csv_opts)
+        @rows = csv.read
+      end
+
+      @columns = @rows.shift if @columns.empty?
+      update_columns!
+
+      row_i = 0
+      @rows.map! do | r |
+        @ncols = r.size if @ncols < r.size
+        h = { :_row_i => (row_i += 1) }
+        @column_offset.each do | c, i |
+          h[c] = r[i] if c && i
+        end
+        h
+      end
+      # debugger
+      self
+    ensure
+      csv.close if csv
+    end
+
+    def index! c
+      c = @column[c] if Integer === c
+      unless ind = @index[c]
+        ind = { }
+        @rows.each do | r |
+          (ind[r[c]] ||= [ ]) << r
+        end
+        @index[c] = ind
+      end
+      ind
+    end
+
+    def get c, v
+      index!(c)[v]
+    end
+
+    def emit! file
+      out = nil
+      case file
+      when '/dev/stdout', '/dev/fd/0'
+        tmp_file = true
+        out = $stdout
+      when %r{^/dev/}
+        tmp_file = true
+      end
+      if tmp_file
+        tmp_file = "/tmp/cassava-#{$$}.csv"
+        # $stderr.puts "  #{file} => #{tmp_file}"
+        file = tmp_file
+      end
+
+      _emit! file
+
+      if tmp_file
+        out ||= File.open(tmp, "w")
+        # $stderr.puts "  #{tmp_file} => #{out}"
+        out.write(File.read(tmp_file))
+      end
+    ensure
+      File.unlink(tmp_file) if tmp_file
+    end
+
+    def _emit! file
+      CSV.open(file, "wb") do | out |
+        a = @offset_column.map do | c |
+          c && c.to_s
+        end
+        out << a
+        @rows.each do | r |
+          a = @offset_column.map do | i |
+            i && r[i]
+          end
+          out << a
+        end
+      end
+      self
+    end
+    alias :emit! :_emit!
+
+    def array_to_row a, columns = nil
+      if Array === a
+        columns ||= self.columns
+        h = { }
+        columns.each_with_index do | c, i |
+          h[c] = a[i]
+        end
+        a = h
+      end
+      a
+    end
+
+    def row_to_array r
+      unless Array === r
+        r = @offset_column.map do | c |
+          c && r[c]
+        end
+      end
+      r
+    end
+
+    def coerce_to_strings!
+      rows.each do | r |
+        r.each do | k, v |
+          r[k] = v.to_s unless String === v
+        end
+      end
+      self
+    end
+
+    def cast_strings rows
+      rows.each do | r |
+        r.each do | k, v |
+          next if v.nil?
+          old_v = v
+          v = v.to_s
+          if String === v
+            case v
+            when /\A[-+]?\d+\Z/
+              v = v.to_i
+            when /\A([-+]?([0-9]+\.[0-9]+|\.[0-9]+|[0-9]+\.)(e[-+]?\d+)?|[-+]?\d+e[-+]?\d+)\Z/i
+              v = v.to_f
+            end
+            # puts "old_v = #{old_v.inspect} => #{v.inspect}"
+          end
+          r[k] = v
+        end
+      end
+      rows
+    end
+
+    def cast_strings!
+      cast_strings @rows
+      @column_types = nil
+      self
+    end
+
+    def sort! by = nil
+      by ||= @columns
+      cast_strings!
+      # by = by.map { | x | column_offset[x] }
+      ct = { }
+      columns.each_with_index do | c, i |
+        ct[c] = column_types[i]
+      end
+      @rows.sort! do | a, b |
+        r = 0
+        by.each do | c |
+          av = a[c]
+          bv = b[c]
+          case
+          when av.nil? && bv.nil?
+            r = 0
+          when av.nil?
+            r = -1
+          when bv.nil?
+            r = 1
+          else
+            r = (av <=> bv rescue nil) || 0
+          end
+          break if r != 0
+        end
+        r
+      end
+      self
+    end
+
+    require 'pp'
+    def infer_column_types rows = self.rows
+      column_types = [ nil ] * @columns.size
+      ancestors_cache = { }
+      common_ancestor_cache = { }
+      rows.each do | r |
+        raise unless Hash === r
+        @columns.each_with_index do | k, i |
+          v = r[k]
+          next if v.nil?
+          ct = column_types[i]
+          vt = v.class
+          if ct.nil?
+            column_types[i] = vt
+            next
+          end
+          common_ancestor =
+            common_ancestor_cache[[ct, vt]] ||=
+            begin
+              ca =
+                ancestors_cache[ct] ||=
+                ct.ancestors.delete_if{|x| x.class == Module}
+              va =
+                ancestors_cache[vt] ||=
+                vt.ancestors.delete_if{|x| x.class == Module}
+              (ca & va).first || Object
+            end
+          if @debug && k == :float
+            pp [ :k, k, :v, v, :ct, ct, :vt, vt, :ca, ca, :va, va, :common_ancestor, common_ancestor ]
+          end
+          # if Value's class is not a specialization of column class.
+          ct = common_ancestor
+          column_types[i] = ct
+        end
+      end
+      # pp columns.zip(column_types)
+      column_types
+    end
+
+    def column_types
+      unless @column_types
+        @column_types ||= infer_column_types
+      end
+      @column_types
+    end
+
+    def clone_rows rows = self.rows
+      rows.map { | r | r.dup }
+    end
+
+    # Format as ASCII table.
+    def to_text opts = { }
+      gem 'terminal-table'
+      require 'terminal-table'
+
+      table = Terminal::Table.new() do | table |
+        # t.title = self.name
+        s = table.style
+        s.border_x = s.border_y = s.border_i = ''
+        # s.border_i = '|'
+        s.padding_left = 0
+        s.padding_right = 1
+
+        table << self.columns.map{|c| { :value => c.to_s, :alignment => :center }}
+
+        # Convert rows to Arrays and handle nil, etc.
+        self.rows.each do | r |
+          r = self.row_to_array(r)
+          r.map! do | c |
+            c = case c
+                when nil
+                  ''
+                when Integer
+                  thousands(c)
+                else
+                  c
+                end
+            # c = "#{c} |"
+          end
+          table << r
+        end
+
+        # Align numeric columns to the left.
+        column_types = infer_column_types(cast_strings(clone_rows))
+        column_types.each_with_index do | type, ci |
+          if type && type.ancestors.include?(Numeric)
+            # puts "  column #{ci} #{columns[ci]} #{t}"
+            table.align_column(ci, :right)
+          end
+        end
+      end
+
+
+      # Return formatted table.
+      table.to_s
+    end
+
+    def thousands x, sep = '_'
+      x && x.to_s.reverse!.gsub(/(\d{3})/, "\\1#{sep}").reverse!.sub(/^(\D|\A)#{sep}/, '')
+    end
+  end
+end
+
+

data/lib/cassava/main.rb

@@ -0,0 +1,199 @@
+require 'cassava'
+require 'cassava/document'
+
+module Cassava
+  class Main
+    attr_accessor :progname
+    attr_accessor :args, :cmd, :opts, :exit_code
+    attr_accessor :result, :output
+    attr_accessor :by, :columns
+
+    def initialize args = nil
+      @progname = File.basename($0)
+      @args = (args || ARGV).dup
+      @opts = { }
+      @exit_code = 0
+      @output = "/dev/stdout"
+      @debug = true
+      @select_where = { }
+    end
+
+    def run!
+      cmds = [ ]
+      last_arg = nil
+
+      cmd = [ ]
+      args = @args.dup
+      while arg = args.shift
+        if arg == '-'
+          if last_arg
+            cmd << last_arg
+            last_arg = nil
+          end
+          last_arg = '--result'
+          cmds << cmd
+          cmd = [ ]
+        else
+          cmd << arg
+        end
+      end
+      if last_arg
+        cmd << last_arg
+        last_arg = nil
+      end
+      cmds << cmd
+      # pp cmds
+
+      # Run each command:
+      cmds.each do | cmd |
+        @args = cmd.dup
+        next_cmd!
+      end
+
+      result.emit!(@output) if result
+      self
+    rescue ::Exception => exc
+      $stderr.puts "#{progname}: ERROR: #{exc.inspect}"
+      $stderr.puts "  #{exc.backtrace * "\n  "}" if @debug || $DEBUG
+      @exit_code = 1
+      self
+    end
+
+    def next_cmd!
+      @cmd = @args.shift
+      sel = :"_#{cmd}!"
+      raise ArgumentError, "Invalid command: #{cmd.inspect}" unless respond_to?(sel)
+      send(sel)
+    end
+
+    def next_document!
+      doc = nil
+      opts = { }
+      until args.empty?
+        case arg = args.shift
+        when '-cv'
+          k = args.shift.to_sym
+          v = args.shift
+          @select_where[k] = v
+        when /\A([^=]+)=(.*)\Z/
+          k = $1.to_sym
+          v = $2
+          @select_where[k] = v
+        when '--result'
+          doc = @result
+          break
+        when '-c'
+          self.columns = args.shift.split(/\s*,\s*|\s+/)
+        when '-by'
+          self.by = args.shift.split(/\s*,\s*|\s+/)
+        when '-o'
+          self.output = args.shift
+        when '-FS'
+          opts[:col_sep] = args.shift
+        when '-IGNORE'
+          opts[:ignore] = args.shift
+        when '-C'
+          opts[:columns] = args.shift.split(/\s*,\s*|\s+/)
+        else
+          opts[:name] = arg
+          doc = Document.new(opts)
+          doc.parse!
+          break
+        end
+      end
+      doc
+    end
+
+    def self.define_command name, doc, &blk
+      meth = :"_#{name}!"
+      define_method meth, &blk
+      @@commands << { :name => name, :doc => doc }
+    end
+
+    def _cat!
+      self.result = next_document!
+      until args.empty?
+        other = next_document!
+        result.append_rows!(other)
+      end
+    end
+
+    def _where!
+      @select_where = { }
+      self.result = next_document!
+      result.coerce_to_strings!
+      @select_where.each do | col, val |
+        new_result = result.dup
+        new_result.empty_rows!
+        found_rows = result.get(col, val)
+        # puts "  #{col}=#{val} => #{found_rows.size} rows"
+        new_result.append_rows!(found_rows)
+        self.result = new_result
+      end
+    end
+    alias :_select! :_where!
+
+    def _cut!
+      self.columns = nil
+      self.result = next_document!
+      self.columns ||= [ result.columns[0] ]
+      # pp result.columns
+      result.to_column_names! columns
+      new_result = result.dup.empty_rows!
+      new_result.columns = columns & result.columns
+      # pp new_result.columns
+      # pp new_result.column_offset
+      rows = self.result.rows.map do | r |
+        r = r.dup
+        r.keep_if { | c | new_result.column_offset[c] }
+        # pp r
+        r
+      end
+      new_result.append_rows! rows
+      self.result = new_result
+    end
+
+    def _join!
+      self.result = next_document!
+      until args.empty?
+        left_key = args.shift.to_sym
+        right_key = args.shift.to_sym
+        right = next_document!
+        new_result = Document.new
+        result.columns.each do | c |
+          new_result.add_column!(c)
+        end
+        right.columns.each do | c |
+          new_result.add_column!(c)
+        end
+        result.rows.each do | lr |
+          rrows = right.get(right_key, lr[left_key])
+          unless rrows.empty?
+            r = lr.dup
+            rrows.each do | rr |
+              r.merge(rr)
+            end
+            new_result.rows << r
+          end
+        end
+        self.result = new_result
+      end
+    end
+
+    def _sort!
+      self.by = nil
+      self.result = next_document!
+      by = self.by || args
+      by.map! { | c | c.to_sym }
+      result.sort!(by)
+    end
+
+    def _format!
+      rows = result.to_text
+      # $stderr.puts rows
+      rows = rows.split("\n").map { | r | { :_ => r } }
+      # require 'pp'; pp rows
+      self.result = Cassava::Document.new(:name => "#{@result.name}->format", :columns => [ :_ ], :rows => rows)
+    end
+  end
+end

data/lib/cassava/version.rb

@@ -0,0 +1,3 @@
+module Cassava
+  VERSION = "0.0.1"
+end

data/spec/cast_strings_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+class Exception
+  alias :_message :message
+  def message
+    @message ||= _message
+  end
+  def message= msg
+    @message = msg
+  end
+end
+
+describe "Cassava::Document" do
+  attr_accessor :d
+  before do
+    self.d = Cassava::Document.new(:name => 'test', :columns => [ :nil, :string, :fixnum, :float, :integer, :numeric ])
+    rows = <<"END".split("\n").map{|r| r.strip.split(/,\s+/).map{|x| x == 'nil' ? nil : x }}
+       nil, nil, nil, nil, nil, nil
+       nil, string, nil, nil, nil, nil
+       nil, +, nil, nil, nil, nil
+       nil, -, nil, nil, nil, nil
+       nil, 234+, nil, nil, nil, nil
+       nil, 1234ws, nil, nil, nil, nil
+       nil, nil, 1234, nil, nil, nil
+       nil, nil, +1234, nil, nil, nil
+       nil, nil, -1234, nil, nil, nil
+       nil, nil, nil, .2, nil, nil
+       nil, nil, nil, -1.2, nil, nil
+       nil, nil, nil, -2., nil, nil
+       nil, nil, nil, 2e10, nil, nil
+       nil, nil, nil, 1e1, nil, nil
+       nil, nil, nil, 2E-2, nil, nil
+       nil, nil, nil, 3E+3, nil, nil
+       nil, nil, nil, nil, 1234, nil
+       nil, nil, nil, nil, 12341231234523452345345234, nil
+       nil, nil, nil, nil, nil, 1234
+       nil, nil, nil, nil, nil, 123412348102394812934
+       nil, nil, nil, nil, nil, 1234.2342
+END
+    d.append_rows! rows
+    d.cast_strings!
+  end
+
+  def each_row
+    i = 0
+    d.rows.each do | r |
+      begin
+        yield r
+      rescue ::Exception => exc
+        exc.message = "in row #{i} : #{r.inspect} : #{exc.message}"
+        raise exc
+      end
+      i += 1
+    end
+  end
+
+  context "#cast_strings!" do
+    it "should not touch nil columns" do
+      each_row do | r |
+        r[0].should == nil
+      end
+    end
+    it "should not touch string only columns" do
+      each_row do | r |
+        next if r[1].nil?
+        r[1].class.should == String
+      end
+    end
+    it "should coerce integer columns" do
+      each_row do | r |
+        next if r[2].nil?
+        r[2].is_a?(Integer).should == true
+      end
+    end
+    it "should coerce float columns" do
+      each_row do | r |
+        next if r[3].nil?
+        r[3].is_a?(Float).should == true
+      end
+    end
+  end
+
+  context "#infer_types!" do
+    it "should infer nil for all nils" do
+      d.column_types[0].should == nil
+    end
+    it "should infer String for String" do
+      d.column_types[1].should == String
+    end
+    it "should infer Fixum for Fixnum" do
+      d.column_types[2].should == Fixnum
+    end
+    it "should infer Float for all Float" do
+      d.column_types[3].should == Float
+    end
+    it "should infer Integer for Fixnum and Bignum" do
+      d.column_types[4].should == Integer
+    end
+    it "should infer Numeric for Fixnum, Bignum, Float" do
+      d.column_types[5].should == Numeric
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'cassava/main'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: cassava
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kurt Stephens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+description: A command-line CSV tool.
+email:
+- ks.github@kurtstephens.com
+executables:
+- cassava
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cassava
+- cassava.gemspec
+- lib/cassava.rb
+- lib/cassava/document.rb
+- lib/cassava/main.rb
+- lib/cassava/version.rb
+- spec/cast_strings_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kstephens/cassava
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1985077025104642675
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1985077025104642675
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A command-line CSV tool.
+test_files:
+- spec/cast_strings_spec.rb
+- spec/spec_helper.rb