csv_pirate 2.1.2 → 2.4.4

data/CHANGELOG

@@ -1,3 +1,19 @@
+Version 2.4.1 2009-10-01
+- Fixed critical typo
+
+Version 2.4.0 2009-10-01
+- Added blindfold to pirate_ship
+- Added say_your_last_words to pirate_ship which is hash for send_data
+
+Version 2.3.0 2009-10-01
+- No longer requires rails at all
+- hoise_mainstay now returns the exported text
+- Better documentation in Readme and source
+
+Version 2.2.0 2009-10-01
+- Use FasterCSV for all backend work
+- Added shrouds for creating tsv and psv files
+
 Version 2.1.0 2009-10-01
 - Added handling of nested methods!
 

data/README.rdoc

@@ -1,4 +1,4 @@
-== CsvPirate v2.0.1 (20091001)
+== CsvPirate
 
 Easily create CSVs of any data that can be derived from your models.
 
@@ -9,22 +9,26 @@ 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.
+  # 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')
+  # :shrouds      CSV column separator, default is ','. For tsv, tab-delimited, "\t"
+  # :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.
+  # There are others too, check the source for a complete picture!
 
 The create method has the same parameters, and actually creates the CSV.
 
@@ -89,7 +93,7 @@ Assuming a Make (as in manufacturers of automobiles) model like this:
                         :booty => [:id, :name]
   end
 
-To create a csv of the names and ids of makes with factories in germany:
+To create a csv of the names and ids of makes with factories in germany and return the text of the export:
 
   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 :)
 
@@ -104,9 +108,24 @@ 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]})
+
+Youw want a timestamp file counter instead of the integer default:
+
   Make.walk_the_plank({:booty => [:id, :name, :sales], :spyglasses => [:all], :swab => :timestamp})
+
+If you want to append each export to the end of the same file (on a per day basis):
+
   Make.walk_the_plank({:booty => [:id, :name, :sales], :spyglasses => [:all], :swab => :none, :mop => :dirty})
 
+If you want to restrict the csv to a particular set of named scopes:
+
+  Make.walk_the_plank({:booty => [:id, :name, :sales], :spyglasses => [:with_abs, :with_esc, :with_heated_seats]})
+
+If you want to create a tsv (tab-delimited) or psv (pipe-delimited) instead of a csv:
+
+  Make.walk_the_plank({:booty => [:id, :name, :sales], :shrouds => '\t'})
+  Make.walk_the_plank({:booty => [:id, :name, :sales], :shrouds => '|'})
+
 If you have a method in the Make class like this:
 
   def to_slug
@@ -117,29 +136,14 @@ 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.
+If you want to traverse Active Record Associations, or call a method on the return value of another method (unlimited nesting):
 
-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
+  Make.walk_the_plank({:booty => [:id, :name, :to_slug, {:to_slug => :hash}]})  #will call .hash on the result of make.to_slug
+  Make.walk_the_plank({:booty => [:id, :name, :to_slug, {:to_slug => {:hash => :abs}}]})  #returns make.to_slug.hash.abs
 
-  # 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.
+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.
 
 The following two sets of code are identical:
 
@@ -183,6 +187,35 @@ OR
 
   csv_pirate = CsvPirate.new({:swag => users,:waggoner => 'inactive_users_not_logged_in',:booty => ["id","number","login","created_at"],:chart => 'log/csv/'})
 
+
+== Downloading the CSV
+
+You have the same Make class as above, and you have a MakeController:
+
+  class MakeController < ApplicationController
+
+    def download_csv
+      send_data Make.say_your_last_words  # "utf-8" is default, and uses options from has_csv_pirate_ship
+    end
+
+    # OR you can customize it just like walk_the_plank
+
+    def download_csv
+      send_data Make.say_your_last_words("iso-8859-1", {:booty => [:id, :name]})
+    end
+
+  end
+
+Too easy?  I wrote this for two reasons... pirate jokes and to make my life easier.  If you need more flexibility then:
+
+  def download_csv
+    csv_pirate = Make.blindfold
+    send_data csv_pirate.maroon,
+      :type => 'text/csv; charset=iso-8859-1; header=present',
+      :disposition => "attachment; filename=#{csv_pirate.nocturnal}"
+  end
+
+
 == Advanced Example with Nested Methods
 
 You have a VehicleModel class and the same Make class as up above:

data/VERSION.yml

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

data/csv_pirate.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{csv_pirate}
-  s.version = "2.1.2"
+  s.version = "2.4.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Peter Boling"]

data/lib/csv_pirate.rb

@@ -32,7 +32,7 @@ class CsvPirate
   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
+                                  # default is false
   # The array that gets built as we write the CSV... could be useful?
   attr_accessor :buried_treasure  # info array
   
@@ -40,41 +40,48 @@ class CsvPirate
   
   attr_accessor :astrolabe        # when true then read only CsvPirate instance for loading of CSVs
 
+  attr_accessor :shrouds          # CSV column separator
+
   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
+  attr_accessor :maroon           # text of csv
+  attr_accessor :nocturnal        # basename of the filepath (i.e. filename)
 
   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
+  # :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')
+  # :shrouds        CSV column separator, default is ','. For tsv, tab-delimited, "\t"
+  # :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
+  # :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.
+  # :bury_treasure  should we store the csv data as it is collected in an array in Ruby form for later use (true), or just write the CSV (false)?
   # See README for examples
   
   def initialize(*args)
+    raise ArgumentError, "must provide required options" if args.blank?
 
     @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?
+    raise ArgumentError, "must provide either :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?
+    raise ArgumentError, "must provide either :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])
@@ -96,19 +103,25 @@ class CsvPirate
     @chronometer = args.first[:chronometer] || Date.today
 
     @spyglasses = (args.first[:spyglasses] || [:all]) if self.grub
-
+    @shrouds = args.first[:shrouds] || ','  # for tsv, tab-delimited, "\t"
 
     @astrolabe = args.first[:astrolabe] || false
 
-    @bury_treasure = args.first[:astrolabe] || true
+    @bury_treasure = args.first[:astrolabe] || false
     @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?
 
+    # This will contain the text of the csv from this particular execution
+    @maroon = ""
+
     # 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
+
+    @nocturnal = File.basename(self.poop_deck)
+
     # Then open the rhumb_lines
     self.rhumb_lines = File.open(File.expand_path(self.poop_deck),self.astrolabe ? "r" : "a")
   end
@@ -122,6 +135,7 @@ class CsvPirate
       :waggoner => args.first[:waggoner],
       :swag => args.first[:swag],
       :swab => args.first[:swab],
+      :shrouds => args.first[:shrouds],
       :mop => args.first[:mop],
       :grub => args.first[:grub],
       :spyglasses => args.first[:spyglasses],
@@ -178,40 +192,49 @@ class CsvPirate
 
     self.swab_poop_deck
 
-    self.figurehead
-  
-    self.bury_treasure ? self.buried_treasure = self.dead_mans_chest : 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
+    # returns the text of this CSV export
+    return self.maroon
   end
 
   def dead_mans_chest
-    self.dig_for_treasure do |treasure|
-      self.scrivener(treasure.map {|x| "#{x}"}.to_csv) # |x| marks the spot!
+    self.maroon = FasterCSV.generate(:col_sep => self.shrouds) do |csv|
+      self.sounding(csv)
     end
+    self.scrivener(self.maroon)
+    self.maroon
   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
+    if self.bury_treasure
+      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
   end
 
-  # write the header of the CSV (column/method names)
-  def figurehead
-    self.scrivener(self.booty.to_csv)
+  def sounding(csv)
+    # create the header of the CSV (column/method names)
+    csv << self.booty
+    # create the data for the csv
+    self.dig_for_treasure do |treasure|
+      moidore = treasure.map {|x| "#{x}"}
+      csv << moidore # |x| marks the spot!
+      self.buried_treasure << moidore if self.bury_treasure
+    end
   end
-  
+
   def traverse_board
-    "#{RAILS_ROOT}/#{self.chart}"
+    #If we have rails environment then we use rails root, otherwise self.chart stands on its own as a relative path
+    "#{defined?(Rails) ? Rails.root + '/' : defined?(RAILS_ROOT) ? RAILS_ROOT + '/' : ''}#{self.chart}"
   end
   
   def sand_glass
@@ -223,14 +246,38 @@ class CsvPirate
     "#{self.analemma}#{self.swabbie}#{self.aft}"
   end
 
+  def merchantman
+    "#{self.waggoner}#{self.sand_glass}#{self.gibbet}"
+  end
+
   def analemma
-    "#{self.traverse_board}#{self.waggoner}#{self.sand_glass}#{self.gibbet}"
+    "#{self.traverse_board}#{self.merchantman}"
+  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
+
+  # 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
+
+  protected
+
   def lantern
     "#{self.analemma}.*"
   end
-
+  
   def filibuster(flotsam)
     base = File.basename(flotsam, self.aft)
     index = base.rindex('.')
@@ -238,7 +285,7 @@ class CsvPirate
     # Ensure numbers
     counter = tail.nil? ? 0 : tail[/\d*/].to_i
   end
-
+  
   def boatswain
     return self.swabbie unless self.swabbie.nil?
     counter = 0
@@ -249,17 +296,12 @@ class CsvPirate
       highval = ((highval <=> counter) == 1) ? highval : counter
       counter = 0
     end
-    self.swabbie = ".#{highval + 1}"
+    ".#{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
+    ".#{Time.now.strftime("%I%M%S")}"
   end
 
   # Sets the swabby file counter
@@ -270,22 +312,11 @@ class CsvPirate
       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
+  public
 
   ########################################
   ############ CLASS METHODS #############

data/lib/ninth_bit/pirate_ship.rb

@@ -4,9 +4,8 @@ module NinthBit
     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
+        raise ArgumentError, "must provide required options" if options.blank?
+
         options[:chart]         ||= 'log/'
         options[:aft]           ||= '.csv'
         options[:gibbet]        ||= '.export'
@@ -16,6 +15,7 @@ module NinthBit
         options[:swag]          ||= nil
         options[:swab]          ||= :counter
         options[:mop]           ||= :clean
+        options[:shrouds]       ||= ','
         options[:grub]          ||= self if options[:swag].nil?
         options[:spyglasses]    ||= [:all]
         options[:booty]         ||= self.column_names
@@ -23,9 +23,9 @@ module NinthBit
         options[:parlay]        ||= 1
 
         # if they provide both
-        raise ArgumentError, "must provide either specify :swag or :grub" if !options[:swag].blank? && !options[:grub].blank?
+        raise ArgumentError, "must provide either :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, "must provide either :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?('.')
@@ -45,10 +45,41 @@ module NinthBit
         base.class_inheritable_accessor :piratey_options
       end
 
+      # intended for use with send_data for downloading the text of the csv:
+      # send_data Make.say_your_last_words
+      def say_your_last_words(charset = 'utf-8', args = {})
+        csv_pirate = self.blindfold(args)
+        return [ csv_pirate.maroon,
+          {:type => "text/csv; charset=#{charset}; header=present"},
+          {:disposition => "attachment; filename=#{csv_pirate.nocturnal}"} ]
+      end
+      
+      #returns the text of the csv export (not the file - this is important if you are appending)
+      # warning if using from console: if you are exporting a large csv this will all print in your console.
+      # intended for use with send_data for downloading the text of the csv:
+      # send_data Make.walk_the_plank,
+      #          :type => 'text/csv; charset=iso-8859-1; header=present',
+      #          :disposition => "attachment; filename=Data.csv"
       def walk_the_plank(args = {})
+        csv_pirate = CsvPirate.new(self.piratey_args(args))
+        csv_pirate.hoist_mainstay()
+      end
+
+      #returns the csv_pirate object so you have access to everything
+      # If using in a download action it might look like this:
+      # csv_pirate = Make.blindfold
+      # send_data csv_pirate.maroon,
+      #          :type => 'text/csv; charset=iso-8859-1; header=present',
+      #          :disposition => "attachment; filename=#{csv_pirate.nocturnal}"
+      def blindfold(args = {})
         CsvPirate.parlay = args[:parlay] || self.piratey_options[:parlay]
-        CsvPirate.create({
-          :chart => args[:chart] || self.piratey_options[:chart],
+        CsvPirate.create(self.piratey_args(args))
+      end
+
+      protected
+
+      def piratey_args(args = {})
+        { :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,
@@ -56,11 +87,11 @@ module NinthBit
           :swag => args[:swag] || self.piratey_options[:swag],
           :swab => args[:swab] || self.piratey_options[:swab],
           :mop => args[:mop] || self.piratey_options[:mop],
+          :shrouds => args[:swab] || self.piratey_options[:shrouds],
           :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]
-        })
+          :bury_treasure => args[:bury_treasure] || self.piratey_options[:bury_treasure] }
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: csv_pirate
 version: !ruby/object:Gem::Version 
-  version: 2.1.2
+  version: 2.4.4
 platform: ruby
 authors: 
 - Peter Boling