csv_pirate 2.0.1

data/CHANGELOG

@@ -0,0 +1,7 @@
+Version 2.0.1 2009-10-01
+- Fixed Readme formatting
+
+Version 2.0.0 2009-09-30
+- Added a new API a la attachment_fu
+- Fixed bug: now works when specifying grub with no spyglasses
+- Fixed rails/init.rb for use as gem with rails

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Peter H. Boling
+
+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.rdoc

@@ -0,0 +1,189 @@
+== CsvPirate v2.0.1 (20091001)
+
+Easily create CSVs of any data that can be derived from your models.
+
+CsvPirate is the easy way to create a CSV of essentially anything in Rails, in full pirate regalia.
+It works better if you are wearing a tricorne!
+
+CsvPirate only works for commissions of swag OR grub!
+
+Initialize method (a.k.a new()) takes a hash of params:
+
+  swag:         the ARrr collection of swag to work on (optional)
+  grub:         the ARrr class that the spyglasses will be used on (optional)
+  spyglasses:   named scopes in your model that will refine the rows in the CSV according to conditions of the spyglass,
+                  and order them according to the order of the spyglass (only used with grub, not swag)
+  booty:        booty on your model that you want printed in the CSV
+  chart:        name of directory where you want to hide your loot
+  waggoner:     name of document where you will give detailed descriptions of the loot
+  chronometer:  keeps track of when you hunt for treasure
+  gibbet:       filename spacer after the date, and before the iterative counter/timestamp.  MuST contain a '.'
+  swab:         can be :counter, :timestamp, or :none
+    :counter    - default, each successive run will create a new file using a counter
+    :timestamp  - each successive run will create a new file using a HHMMSS time stamp
+    :none       - no iterative file naming convention, just use waggoner and aft
+  mop:          can be :clean or :dirty (:overwrite or :append) (only has an effect if :swab is :none) since overwriting is irrelevant for a new file
+    :clear      - do not use :counter or :timestamp, and instead overwrite the file
+    :dirty      - do not use :counter, or :timestamp, or :overwrite.  Just keep adding on.
+
+The create method has the same parameters, and actually creates the CSV.
+
+Avast! Here be pirates! To brush up on pirate coding naming conventions:
+
+  http://www.privateerdragons.com/pirate_dictionary.html
+
+Perhaps the next version will have CSV importing abilities...
+
+== On The Web
+
+Source:
+  http://github.com/pboling/csv_pirate
+
+Release Announcement:
+  http://galtzo.blogspot.com/2009/03/csv-pirate.html
+
+
+== Installation
+
+Gem Using Git building from source:
+
+  mkdir -p ~/src
+  cd ~/src
+  git clone git://github.com/pboling/csv_pirate.git
+  cd csv_pirate
+  gem build csv_pirate.gemspec
+  sudo gem install csv_pirate-2.0.1.gem # (Or whatever version gets built)
+
+Then cd to your rails app to optionally freeze the gem into your app:
+
+  rake gems:freeze GEM=csv_pirate
+
+Installing Gem from Github's Gem Server:
+
+  sudo gem install pboling-csv_pirate -s http://gems.github.com
+
+Plugin using Git:
+
+  ruby script/plugin install git://github.com/pboling/csv_pirate.git
+
+
+== Example & Usage
+
+Assuming a Make (as in manufacturers of automobiles) model like this:
+
+  # == Schema Information
+  #
+  # Table name: makes
+  #
+  #  id      :integer(4)      not null, primary key
+  #  name    :string(255)
+  #  factory :string(255)
+  #  sales   :integer(4)
+  #
+
+  class Make < ActiveRecord::Base
+    has_many :vehicle_models
+    named_scope :factory_in_germany, :conditions => ["factory = ?", "Germany"]
+
+    has_csv_pirate_ship :spyglasses => [:factory_in_germany],
+                        :booty => [:id, :name]
+  end
+
+To create a csv of the names and ids of makes with factories in germany:
+
+  Make.walk_the_plank  # Get it? HA! If you can't believe I wrote this whole thing JUST to be able to make jokes like that... check ma sources :)
+
+The name of the csv that comes out will be (by defualt located in log directory):
+
+  Make.20090930.export.13.csv
+
+Where Make is the class, 20090930 is today's date, .export is the gibbet, and 13 is the iterative file counter, meaning I've run this export 13 times today.
+
+All of those filename parts are customizable to a degree.
+
+You can also customize the CSV, for example if you want to add a column to the csv:
+
+  Make.walk_the_plank({:booty => [:id, :name, :sales]})
+  Make.walk_the_plank({:booty => [:id, :name, :sales], :spyglasses => [:all], :swab => :timestamp})
+  Make.walk_the_plank({:booty => [:id, :name, :sales], :spyglasses => [:all], :swab => :none, :mop => :dirty})
+
+If you have a method in the Make class like this:
+
+  def to_slug
+    "#{self.name}_#{self.id}"
+  end
+
+getting it in the CSV is easy peasy:
+
+  Make.walk_the_plank({:booty => [:id, :name, :to_slug]})
+
+Add whatever methods you want to the :booty array.  Write new methods, and add them!  Make lots of glorious CSVs full of data to impress the pointy ones in the office.
+
+You can also use the raw CsvPirate class itself directly wherever you want.  These are the available options to methods:
+new, create, or walk_the_plank
+
+  # CsvPirate only works for commissions of swag OR grub!
+  # :swag         the ARrr collection of swag to work on (optional)
+  # :grub         the ARrr class that the spyglasses will be used on (optional)
+  # :spyglasses   named scopes in your model that will refine the rows in the CSV according to conditions of the spyglasses,
+  #                 and order them according to the order of the spyglasses (optional)
+  # :booty        booty (columns/methods) on your model that you want printed in the CSV, also used to create the figurehead (CSV header)
+  # :chart        name of directory where you want to hide your loot
+  # :wagonner     name of document where you will give detailed descriptions of the loot
+  # :aft          filename extention ('.csv')
+  # :chronometer  keeps track of when you hunt for treasure
+  # :gibbet       filename spacer after the date, and before the iterative counter/timestamp.  MuST contain a '.'
+  # :swab         can be :counter, :timestamp, or :none
+  #   :counter - default, each successive run will create a new file using a counter
+  #   :timestamp - each successive run will create a new file using a HHMMSS time stamp
+  #   :none - no iterative file naming convention, just use waggoner and aft
+  # :mop          can be :clean or :dirty (:overwrite or :append) (only has an effect if :swab is :none) since overwriting is irrelevant for a new file
+  #   :clear - do not use :counter or :timestamp, and instead overwrite the file
+  #   :dirty - do not use :counter, or :timestamp, or :overwrite.  Just keep adding on.
+
+The following two sets of code are identical:
+
+  csv_pirate = CsvPirate.new({
+    :grub => User,
+    :spyglasses => [:active,:logged_in],
+    :waggoner => 'active_users_logged_in',
+    :booty => ["id","number","login","created_at"],
+    :chart => 'log/csv/'
+  })
+  csv_pirate.hoist_mainstay() # creates CSV file and writes out the rows
+
+  CsvPirate.create({
+    :grub => User,
+    :spyglasses => [:active,:logged_in],
+    :waggoner => 'active_users_logged_in',
+    :booty => ["id","number","login","created_at"],
+    :chart => 'log/csv/'
+  })# creates CSV file and writes out the rows
+
+Another example using swag instead of grub:
+
+  users = User.logged_out.inactive
+  csv_pirate = CsvPirate.new({
+    :swag => users,
+    :waggoner => 'inactive_users_not_logged_in',
+    :booty => ["id","number","login","created_at"],
+    :chart => 'log/csv/'
+  })
+  csv_pirate.hoist_mainstay()
+
+Then if you want to get your hands on the loot immediately:
+
+  csv_pirate.weigh_anchor()
+
+For those who can't help but copy/paste into console and then edit:
+
+  csv_pirate = CsvPirate.new({:grub => User,:spyglasses => [:active,:logged_in],:waggoner => 'active_users_logged_in',:booty => ["id","number","login","created_at"],:chart => 'log/csv/'})
+
+OR
+
+  csv_pirate = CsvPirate.new({:swag => users,:waggoner => 'inactive_users_not_logged_in',:booty => ["id","number","login","created_at"],:chart => 'log/csv/'})
+
+
+----------------------------------------------------------------------------------
+  Author: Peter Boling, peter.boling at gmail dot com
+  Copyright (c) 2009 Peter H. Boling of 9thBit LLC, released under the MIT license.  See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "csv_pirate"
+    gemspec.summary = "Easily create CSVs of any data that can be derived from your models (using pirates!)."
+    gemspec.description = %q{CsvPirate is the easy way to create a CSV of essentially anything in Rails, in full pirate regalia.
+It works better if you are wearing a tricorne!}
+    gemspec.email = "peter.boling@gmail.com"
+    gemspec.homepage = "http://github.com/pboling/csv_pirate"
+    gemspec.authors = ["Peter Boling"]
+    gemspec.files = ["README.rdoc",
+             "csv_pirate.gemspec",
+             "init.rb",
+             "rails/init.rb",
+             "install.rb",
+             "about.yml",
+             "lib/csv_pirate.rb",
+             "lib/ninth_bit/pirate_ship.rb",
+             "Rakefile",
+             "LICENSE",
+             "CHANGELOG",
+             "VERSION.yml"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'csv_pirate'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 2
+:minor: 0
+:patch: 1

data/about.yml

@@ -0,0 +1,7 @@
+author:
+  name: Peter H. Boling
+  homepage: http://www.peterboling.com
+summary: How does a Pirate create CSVs?  With the waggoner, charts, spyglasses, chronometers, swag, and grub.
+version: 2.0.1
+rails_version: 1.0+
+license: MIT

data/csv_pirate.gemspec

@@ -0,0 +1,53 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{csv_pirate}
+  s.version = "2.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Peter Boling"]
+  s.date = %q{2009-10-01}
+  s.description = %q{CsvPirate is the easy way to create a CSV of essentially anything in Rails, in full pirate regalia.
+It works better if you are wearing a tricorne!}
+  s.email = %q{peter.boling@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "about.yml",
+     "csv_pirate.gemspec",
+     "init.rb",
+     "install.rb",
+     "lib/csv_pirate.rb",
+     "lib/ninth_bit/pirate_ship.rb",
+     "rails/init.rb"
+  ]
+  s.homepage = %q{http://github.com/pboling/csv_pirate}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Easily create CSVs of any data that can be derived from your models (using pirates!).}
+  s.test_files = [
+    "spec/csv_pirate_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1,9 @@
+require 'csv_pirate'
+require 'ninth_bit/pirate_ship'
+
+# If you are using this on a vanilla Ruby class (no rails or active record) then extend your class like this:
+#  MyClass.send(:extend, NinthBit::PirateShip::ActMethods) if defined?(MyClass)
+# Alternatively you can do this inside your class definition:
+#   class MyClass
+#     extend NinthBit::PirateShip::ActMethods
+#   end

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))

data/lib/csv_pirate.rb

@@ -0,0 +1,392 @@
+# CsvPirate
+#Copyright ©2009 Peter H. Boling of 9thBit LLC, released under the MIT license
+#Gem / Plugin for Rails / Active Record: Easily make CSVs of anything that can be derived from your models
+#Language: Ruby (written by a pirate)
+#License:  MIT License
+#Labels:   Ruby, Rails, Gem, Plugin
+#Version:  1.0
+#Project owners:
+#    peter.boling (The Cap'n)
+require 'fastercsv'
+
+class CsvPirate
+
+  BOOKIE = [:counter, :timestamp, :none]
+  MOP_HEADS = [:clean, :dirty]
+
+  attr_accessor :waggoner         #filename
+  attr_accessor :chart            #directory, default is ('log/')
+  attr_accessor :aft              #extension, default is ('.csv')
+  attr_accessor :gibbet           #part of the filename after waggoner and date, before swabbie and aft
+  attr_accessor :chronometer
+
+  # Must provide swag or grub (not both)
+  attr_accessor :swag             # ARrr array of objects
+  attr_accessor :grub             # ARrr class
+  # spyglasses is only used with grub, not swag
+  attr_accessor :spyglasses       # named_scopes
+  
+  # These are the booty of the CSV
+  # Should be methods/columns on the swag
+  # also used to create the figurehead (CSV header)
+  attr_accessor :booty            # methods / columns
+
+  attr_accessor :bury_treasure    # should we store the csv data in an array for later inspection, or just write the CSV?
+                                  # default is true
+  # The array that gets built as we write the CSV... could be useful?
+  attr_accessor :buried_treasure  # info array
+  
+  attr_accessor :rhumb_lines      # the file object to write the CSV lines to
+  
+  attr_accessor :astrolabe        # when true then read only CsvPirate instance for loading of CSVs
+
+  attr_accessor :swab             # default is :counter
+  attr_accessor :mop              # default is :clean (only has an effect if :swab is :none) since overwriting is irrelevant for a new file
+  attr_accessor :swabbie          # value of the counter / timestamp
+
+  cattr_accessor :parlay          # verbosity on a scale of 0 - 3 (0=:none, 1=:error, 2=:info, 3=:debug, 0 being no screen output, 1 is default
+
+  # CsvPirate only works for commissions of swag OR grub!
+  # :swag         the ARrr collection of swag to work on (optional)
+  # :grub         the ARrr class that the spyglasses will be used on (optional)
+  # :spyglasses   named scopes in your model that will refine the rows in the CSV according to conditions of the spyglasses,
+  #                 and order them according to the order of the spyglasses (optional)
+  # :booty        booty (columns/methods) on your model that you want printed in the CSV, also used to create the figurehead (CSV header)
+  # :chart        name of directory where you want to hide your loot
+  # :wagonner     name of document where you will give detailed descriptions of the loot
+  # :aft          filename extention ('.csv')
+  # :chronometer  keeps track of when you hunt for treasure
+  # :gibbet       filename spacer after the date, and before the iterative counter/timestamp.  MuST contain a '.'
+  # :swab         can be :counter, :timestamp, or :none
+  #   :counter - default, each successive run will create a new file using a counter
+  #   :timestamp - each successive run will create a new file using a HHMMSS time stamp
+  #   :none - no iterative file naming convention, just use waggoner and aft
+  # :mop          can be :clean or :dirty (:overwrite or :append) (only has an effect if :swab is :none) since overwriting is irrelevant for a new file
+  #   :clear - do not use :counter or :timestamp, and instead overwrite the file
+  #   :dirty - do not use :counter, or :timestamp, or :overwrite.  Just keep adding on.
+  # See README for examples
+  
+  def initialize(*args)
+
+    @swag = args.first[:swag]
+    @grub = args.first[:grub]
+
+    # if they provide both
+    raise ArgumentError, "must provide either specify :swag or :grub" if !args.first[:swag].blank? && !args.first[:grub].blank?
+    # if they provide neither
+    raise ArgumentError, "must provide either specify :swag or :grub, not both" if args.first[:swag].blank? && args.first[:grub].blank?
+
+    @swab = args.first[:swab] || :counter
+    raise ArgumentError, ":swab is #{args.first[:swab].inspect}, but must be one of #{CsvPirate::BOOKIE.inspect}" unless CsvPirate::BOOKIE.include?(args.first[:swab])
+
+    @mop = args.first[:mop] || :clean
+    raise ArgumentError, ":mop is #{args.first[:mop].inspect}, but must be one of #{CsvPirate::MOP_HEADS.inspect}" unless CsvPirate::MOP_HEADS.include?(args.first[:mop])
+
+    @gibbet = args.first[:gibbet] || '.export'
+    raise ArgumentError, ":gibbet is #{args.first[:gibbet].inspect}, and does not contain a '.' character, which is required for iterative filenames" if args.first[:gibbet].nil? || !args.first[:gibbet].include?('.')
+
+    @waggoner = args.first[:waggoner] || "#{self.grub}"
+    raise ArgumentError, ":waggoner is #{args.first[:waggoner].inspect}, and must be a string at least one character long" if args.first[:waggoner].nil? || args.first[:waggoner].length < 1
+
+    @booty = args.first[:booty] || []
+    raise ArgumentError, ":booty is #{args.first[:booty].inspect}, and must be an array of methods to call on a class for CSV data" if args.first[:booty].nil? || args.first[:booty].empty?
+
+    @chart = args.first[:chart] || 'log/'
+    @aft = args.first[:aft] || '.csv'
+    @chronometer = args.first[:chronometer] || Date.today
+
+    @spyglasses = (args.first[:spyglasses] || [:all]) if self.grub
+
+
+    @astrolabe = args.first[:astrolabe] || false
+
+    @bury_treasure = args.first[:astrolabe] || true
+    @buried_treasure = []
+
+    # Initialize doesn't write anything to a CSV, 
+    #   but does create the traverse_board and opens the waggoner for reading / writing
+    Dir.mkdir(self.traverse_board) if !self.astrolabe && Dir.glob(self.traverse_board).empty?
+
+    # Once the traverse_board (dir) exists, then check if the rhumb_lines (file) already exists, and set our rhumb_lines counter
+    @swabbie = self.insult_swabbie
+    # Then open the rhumb_lines
+    self.rhumb_lines = File.open(File.expand_path(self.poop_deck),self.astrolabe ? "r" : "a")
+  end
+
+  def self.create(*args)
+    csv_pirate = CsvPirate.new({
+      :chart => args.first[:chart],
+      :aft => args.first[:aft],
+      :gibbet => args.first[:gibbet],
+      :chronometer => args.first[:chronometer],
+      :waggoner => args.first[:waggoner],
+      :swag => args.first[:swag],
+      :swab => args.first[:swab],
+      :mop => args.first[:mop],
+      :grub => args.first[:grub],
+      :spyglasses => args.first[:spyglasses],
+      :booty => args.first[:booty],
+      :astrolabe => args.first[:astrolabe],
+      :bury_treasure => args.first[:bury_treasure]
+    })
+    csv_pirate.hoist_mainstay()
+    csv_pirate
+  end
+
+  ########################################
+  ########### INSTANCE METHODS ###########
+  ########################################
+
+  # This is the hardest working method.  Get your shovels!
+  def dig_for_treasure(&block)
+    return false unless block_given?
+  
+    if !grub.nil?
+      self.swag = grub
+      spyglasses.each {|x| self.swag = self.swag.send(x) }
+    end
+  
+    treasure_chest = self.swag.map do |spoils| 
+      self.prize(spoils)
+    end
+  
+    treasure_chest.each do |loot|
+      yield loot
+    end
+  end
+  
+  def prize(spoils)
+    gold_doubloons = []
+    self.booty.each do |plunder|
+      gold_doubloons << spoils.send(plunder.to_sym)
+    end
+    gold_doubloons
+  end
+  
+  def scrivener(msg)
+    self.rhumb_lines.puts msg
+  end
+  
+  # Sail through your db looking for buried treasure! 
+  # - restricted to loot that can be seen through spyglasses (if provided)!
+  def hoist_mainstay
+
+    self.swab_poop_deck
+
+    self.figurehead
+  
+    self.bury_treasure ? self.buried_treasure = self.dead_mans_chest : self.dead_mans_chest
+
+    self.rhumb_lines.close
+
+    self.jolly_roger if CsvPirate.parlay > 1
+
+    # returns the array that was created before exporting it to CSV
+    return self.bury_treasure ? self.buried_treasure : true
+  end
+
+  def dead_mans_chest
+    self.dig_for_treasure do |treasure|
+      self.scrivener(treasure.map {|x| "#{x}"}.to_csv) # |x| marks the spot!
+    end
+  end
+
+  def jolly_roger
+    if self.buried_treasure.is_a?(Array)
+      puts "Found #{self.buried_treasure.length} deniers buried here: '#{self.poop_deck}'" if CsvPirate.parlay > 1
+      puts "You must weigh_anchor to review your plunder!" if CsvPirate.parlay > 1
+    else
+      puts "Failed to locate treasure" if CsvPirate.parlay > 1
+    end
+  end
+
+  # write the header of the CSV (column/method names)
+  def figurehead
+    self.scrivener(self.booty.to_csv)
+  end
+  
+  def traverse_board
+    "#{RAILS_ROOT}/#{self.chart}"
+  end
+  
+  def sand_glass
+    "#{self.chronometer.respond_to?(:strftime) ? '.' + self.chronometer.strftime("%Y%m%d") : ''}"
+  end
+  
+  #complete file path
+  def poop_deck
+    "#{self.analemma}#{self.swabbie}#{self.aft}"
+  end
+
+  def analemma
+    "#{self.traverse_board}#{self.waggoner}#{self.sand_glass}#{self.gibbet}"
+  end
+
+  def lantern
+    "#{self.analemma}.*"
+  end
+
+  def filibuster(flotsam)
+    base = File.basename(flotsam, self.aft)
+    index = base.rindex('.')
+    tail = index.nil? ? nil : base[index+1,base.length]
+    # Ensure numbers
+    counter = tail.nil? ? 0 : tail[/\d*/].to_i
+  end
+
+  def boatswain
+    return self.swabbie unless self.swabbie.nil?
+    counter = 0
+    bowspirit = Dir.glob(self.lantern)
+    highval = 0
+    bowspirit.each do |flotsam|
+      counter = self.filibuster(flotsam)
+      highval = ((highval <=> counter) == 1) ? highval : counter
+      counter = 0
+    end
+    self.swabbie = ".#{highval + 1}"
+  end
+
+  def coxswain
+    return self.swabbie unless self.swabbie.nil?
+    self.swabbie = ".#{Time.now.strftime("%I%M%S")}"
+  end
+
+  # Swabs the poop_deck if the mop is clean. (!)
+  def swab_poop_deck
+    self.rhumb_lines.truncate(0) if self.swab == :none && self.mop == :clean && File.size(self.poop_deck) > 0
+  end
+
+  # Sets the swabby file counter
+  def insult_swabbie
+    return case self.swab
+      when :counter
+        self.boatswain
+      when :timestamp
+        self.coxswain
+      else
+        self.swabbie = ""
+    end
+  end
+
+  # Must be done on order to rummage through the loot found by the pirate ship
+  def weigh_anchor
+    CsvPirate.rinse(self.poop_deck)
+  end
+
+  # Sink your own ship! Or run a block of code on each row of the current CSV
+  def scuttle(&block)
+    return false unless block_given?
+    CsvPirate.broadside(self.poop_deck) do |careen|
+      yield careen
+    end
+  end
+
+  ########################################
+  ############ CLASS METHODS #############
+  ########################################
+
+  # Used to read any loot found by any pirate
+  def self.rinse(quarterdeck)
+    File.open(File.expand_path(quarterdeck), "r") do |bucket_line|
+      bucket_line.each_line do |bucket|
+        puts bucket
+      end
+    end
+  end
+
+  # Sink other ships! Or run a block of code on each row of a CSV
+  def self.broadside(galley, &block)
+    return false unless block_given?
+    count = 1 if report_kills
+    FasterCSV.foreach(galley, {:headers => :first_row, :return_headers => false}) do |gun|
+      puts "Galleys sunk: #{count+=1}" if CsvPirate.parlay > 1
+      yield gun
+    end
+  end
+
+  # During a mutiny things are a little different!
+  # Essentially you are using an existing CSV to drive queries to create a second CSV cased on the first
+  # The capn hash is:
+  #   :grub       => is the class on which to make booty [method] calls
+  #   :swag       => column index in CSV (0th, 1st, 2nd, etc. column?)
+  #                  (swag OR spyglasses can be specified, but code defers to swag if provided)
+  #   :spyglasses => is the column to load ("find_by_#{booty}") the ARrr object for each row on the first CSV
+  #                  (swag OR spyglasses can be specified, but code defers to swag if provided)
+  #   :waggoner   => where the capn's loot was stashed (filename)
+  #   :chart      => directory where capn's waggoner is located
+  #   :astrolabe  => true (file is opened at top of file in read only mode when true)
+  # The first_mate hash is:
+  #   :grub       => is the class on which to make booty [method] calls, or 
+  #                    is a method (as a string) we call to get from the object loaded by capn,
+  #                    to the object on which we'll make the first_mate booty [method] calls, or nil, if same object
+  #   :swag       => is the method to call on first CSV row's object to find second CSV row's object (if grub is a class)
+  #   :spyglasses => is the column to load ("find_by_#{booty}") the ARrr object for each row on the second CSV (if grub is a class)
+  #   :booty      => is the methods to call on the ARrr object for each row on the second CSV
+  #   :waggoner   => where to stash the first mate's loot (filename)
+  #   :chart      => directory where first mate's waggoner is located
+  #   :astrolabe  => false (false is the default for astrolabe, so we could leave it off the first_mate)
+  #
+  # Example:
+#   capn      = {:grub => User,:spyglasses => [:inactive],:booty => ['id','login','status'],:waggoner => 'orig',:chart => 'log/csv/',:astrolabe => false}
+#   make_orig = CsvPirate.new(capn)
+#   make_orig.hoist_mainstay
+#   make_orig.weigh_anchor
+#
+#   first_mate = {:grub => 'account',:booty => ["id","number","name","created_at"],:waggoner => 'fake',:chart => 'log/csv/'}
+#  OR
+#   # for same class, we re-use the object loaded from first CSV and make the booty [method] calls on it
+#   first_mate = {:grub => User,:booty => ["id","login","visits_count"],:waggoner => 'fake',:chart => 'log/csv/'}
+#  OR
+#   first_mate = {:grub => Account,:spyglasses => 'id',:swag=>'user_id',:booty => ["id","name","number"],:waggoner => 'fake',:chart => 'log/csv/'}
+#  AND
+#   capn       = {:grub => User,:spyglasses => 'login',:swag => 1,:waggoner => 'orig',:chart => 'log/csv/',:astrolabe => true}
+#   after_mutiny = CsvPirate.mutiny(capn, first_mate)
+#
+  def self.mutiny(capn, first_mate)
+    carrack = CsvPirate.new(capn)
+    cutthroat = CsvPirate.new(first_mate)
+    
+    cutthroat.figurehead
+
+    carrack.scuttle do |cutlass|
+      puts "CUTLASS: #{cutlass.inspect}" if CsvPirate.parlay > 2
+      puts "CARRACK.SWAG: #{carrack.swag.inspect}" if CsvPirate.parlay > 2
+      backstaff = cutlass[carrack.swag] || cutlass["#{carrack.spyglasses}"]
+      puts "BACKSTAFF: #{backstaff}" if CsvPirate.parlay > 2
+      puts "CARRACK.SPYGLASSES: #{carrack.spyglasses.inspect}" if CsvPirate.parlay > 2
+      gully = carrack.grub.send("find_by_#{carrack.spyglasses}".to_sym, backstaff)
+      puts "GULLY: #{gully.inspect}" if CsvPirate.parlay > 2
+      if gully
+        flotsam = cutthroat.grub.is_a?(String) ? 
+          gully.send(cutthroat.grub.to_sym) : 
+          cutthroat.grub.is_a?(Symbol) ? 
+            gully.send(cutthroat.grub) : 
+            cutthroat.grub.class == carrack.grub.class ?
+              gully :
+              cutthroat.grub.class == Class ? 
+                cutthroat.grub.send("find_by_#{cutthroat.swag}", gully.send(cutthroat.spyglasses)) : 
+                nil
+        puts "FLOTSAM: #{flotsam.inspect}" if CsvPirate.parlay > 2
+        if flotsam
+          plunder = cutthroat.prize(flotsam)
+          cutthroat.buried_treasure << plunder
+          cutthroat.scrivener(plunder.map {|bulkhead| "#{bulkhead}"}.join(','))
+        else
+          puts "Unable to locate: #{cutthroat.grub} related to #{carrack.grub}.#{carrack.spyglasses} '#{gully.send(carrack.spyglasses)}'" if CsvPirate.parlay > 1
+        end
+      else
+        puts "Unable to locate: #{carrack.grub}.#{carrack.spyglasses} '#{gully.send(carrack.spyglasses)}'" if CsvPirate.parlay > 1
+      end
+    end
+    
+    carrack.rhumb_lines.close
+    cutthroat.rhumb_lines.close
+
+    cutthroat.jolly_roger
+
+    # returns the array that is created before exporting it to CSV
+    return cutthroat
+  end
+
+end

data/lib/ninth_bit/pirate_ship.rb

@@ -0,0 +1,69 @@
+module NinthBit
+  module PirateShip
+
+    module ActMethods
+      #coding tyle is adopted from attachment_fu
+      def has_csv_pirate_ship(options = {})
+        if options.blank?
+          raise ArgumentError, "must provide required options"
+        end
+        options[:chart]         ||= 'log/'
+        options[:aft]           ||= '.csv'
+        options[:gibbet]        ||= '.export'
+        #Needs to be defined at runtime, doesn't make sense here
+        #options[:chronometer]   ||= Date.today
+        options[:waggoner]      ||= "#{self}"
+        options[:swag]          ||= nil
+        options[:swab]          ||= :counter
+        options[:mop]           ||= :clean
+        options[:grub]          ||= self if options[:swag].nil?
+        options[:spyglasses]    ||= [:all]
+        options[:booty]         ||= self.column_names
+        options[:bury_treasure] ||= true
+        options[:parlay]        ||= 1
+
+        # if they provide both
+        raise ArgumentError, "must provide either specify :swag or :grub" if !options[:swag].blank? && !options[:grub].blank?
+        # if they provide neither
+        raise ArgumentError, "must provide either specify :swag or :grub, not both" if options[:swag].blank? && options[:grub].blank?
+        raise ArgumentError, ":swab is #{options[:swab].inspect}, but must be one of #{CsvPirate::BOOKIE.inspect}" unless CsvPirate::BOOKIE.include?(options[:swab])
+        raise ArgumentError, ":mop is #{options[:mop].inspect}, but must be one of #{CsvPirate::MOP_HEADS.inspect}" unless CsvPirate::MOP_HEADS.include?(options[:mop])
+        raise ArgumentError, ":gibbet is #{options[:gibbet].inspect}, and does not contain a '.' character, which is required for iterative filenames" if options[:gibbet].nil? || !options[:gibbet].include?('.')
+        raise ArgumentError, ":waggoner is #{options[:waggoner].inspect}, and must be a string at least one character long" if options[:waggoner].nil? || options[:waggoner].length < 1
+        raise ArgumentError, ":booty is #{options[:booty].inspect}, and must be an array of methods to call on a class for CSV data" if options[:booty].nil? || options[:booty].empty?
+
+        extend ClassMethods unless (class << self; included_modules; end).include?(ClassMethods)
+
+        self.piratey_options = options
+
+      end
+    end
+
+    module ClassMethods
+
+      def self.extended(base)
+        base.class_inheritable_accessor :piratey_options
+      end
+
+      def walk_the_plank(args = {})
+        CsvPirate.parlay = args[:parlay] || self.piratey_options[:parlay]
+        CsvPirate.create({
+          :chart => args[:chart] || self.piratey_options[:chart],
+          :aft => args[:aft] || self.piratey_options[:aft],
+          :gibbet => args[:gibbet] || self.piratey_options[:gibbet],
+          :chronometer => args[:chronometer] || Date.today,
+          :waggoner => args[:waggoner] || self.piratey_options[:waggoner] || "#{self}",
+          :swag => args[:swag] || self.piratey_options[:swag],
+          :swab => args[:swab] || self.piratey_options[:swab],
+          :mop => args[:mop] || self.piratey_options[:mop],
+          :grub => args[:grub] || self.piratey_options[:grub],
+          :spyglasses => args[:spyglasses] || self.piratey_options[:spyglasses],
+          :booty => args[:booty] || self.piratey_options[:booty],
+          :bury_treasure => args[:bury_treasure] || self.piratey_options[:bury_treasure]
+        })
+      end
+
+    end
+
+  end
+end

data/rails/init.rb

@@ -0,0 +1,11 @@
+require 'csv_pirate'
+require 'ninth_bit/pirate_ship'
+
+# If you are using this on a vanilla Ruby class (no rails or active record) then extend your class like this:
+#  MyClass.send(:extend, NinthBit::PirateShip::ActMethods) if defined?(MyClass)
+# Alternatively you can do this inside your class definition:
+#   class MyClass
+#     extend NinthBit::PirateShip::ActMethods
+#   end
+# If you are using ActiveRecord then it is done for you :)
+ActiveRecord::Base.send(:extend, NinthBit::PirateShip::ActMethods) if defined?(ActiveRecord)

data/spec/csv_pirate_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "CsvPirate" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'csv_pirate'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: csv_pirate
+version: !ruby/object:Gem::Version 
+  version: 2.0.1
+platform: ruby
+authors: 
+- Peter Boling
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-01 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |-
+  CsvPirate is the easy way to create a CSV of essentially anything in Rails, in full pirate regalia.
+  It works better if you are wearing a tricorne!
+email: peter.boling@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- about.yml
+- csv_pirate.gemspec
+- init.rb
+- install.rb
+- lib/csv_pirate.rb
+- lib/ninth_bit/pirate_ship.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/pboling/csv_pirate
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Easily create CSVs of any data that can be derived from your models (using pirates!).
+test_files: 
+- spec/csv_pirate_spec.rb
+- spec/spec_helper.rb