solutious-rudy 0.7.3 → 0.7.4

data/lib/escape.rb

@@ -1,305 +0,0 @@
-# escape.rb - escape/unescape library for several formats
-#
-# Copyright (C) 2006,2007 Tanaka Akira  <akr@fsij.org>
-# 
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# 
-#  1. Redistributions of source code must retain the above copyright notice, this
-#     list of conditions and the following disclaimer.
-#  2. Redistributions in binary form must reproduce the above copyright notice,
-#     this list of conditions and the following disclaimer in the documentation
-#     and/or other materials provided with the distribution.
-#  3. The name of the author may not be used to endorse or promote products
-#     derived from this software without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
-# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
-# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Escape module provides several escape functions.
-# * URI
-# * HTML
-# * shell command
-module Escape #:nodoc:all
-  module_function
-
-  class StringWrapper
-    class << self
-      alias new_no_dup new
-      def new(str)
-        new_no_dup(str.dup)
-      end
-    end
-
-    def initialize(str)
-      @str = str
-    end
-
-    def to_s
-      @str.dup
-    end
-
-    def inspect
-      "\#<#{self.class}: #{@str}>"
-    end
-
-    def ==(other)
-      other.class == self.class && @str == other.instance_variable_get(:@str)
-    end
-    alias eql? ==
-
-    def hash
-      @str.hash
-    end
-  end
-
-  class ShellEscaped < StringWrapper
-  end
-
-  # Escape.shell_command composes
-  # a sequence of words to
-  # a single shell command line.
-  # All shell meta characters are quoted and
-  # the words are concatenated with interleaving space.
-  # It returns an instance of ShellEscaped.
-  #
-  #  Escape.shell_command(["ls", "/"]) #=> #<Escape::ShellEscaped: ls />
-  #  Escape.shell_command(["echo", "*"]) #=> #<Escape::ShellEscaped: echo '*'>
-  #
-  # Note that system(*command) and
-  # system(Escape.shell_command(command)) is roughly same.
-  # There are two exception as follows.
-  # * The first is that the later may invokes /bin/sh.
-  # * The second is an interpretation of an array with only one element: 
-  #   the element is parsed by the shell with the former but
-  #   it is recognized as single word with the later.
-  #   For example, system(*["echo foo"]) invokes echo command with an argument "foo".
-  #   But system(Escape.shell_command(["echo foo"])) invokes "echo foo" command without arguments (and it probably fails).
-  def shell_command(*command)
-    command = [command].flatten.compact # Delano
-    s = command.map {|word| shell_single_word(word) }.join(' ')
-    ShellEscaped.new_no_dup(s)
-  end
-
-  # Escape.shell_single_word quotes shell meta characters.
-  # It returns an instance of ShellEscaped.
-  #
-  # The result string is always single shell word, even if
-  # the argument is "".
-  # Escape.shell_single_word("") returns #<Escape::ShellEscaped: ''>.
-  #
-  #  Escape.shell_single_word("") #=> #<Escape::ShellEscaped: ''>
-  #  Escape.shell_single_word("foo") #=> #<Escape::ShellEscaped: foo>
-  #  Escape.shell_single_word("*") #=> #<Escape::ShellEscaped: '*'>
-  def shell_single_word(str)
-    return unless str
-    str &&= str.to_s # Delano fix
-    if str.empty?
-      ShellEscaped.new_no_dup("''")
-    elsif %r{\A[0-9A-Za-z+,./:=@_-]+\z} =~ str
-      ShellEscaped.new(str)
-    else
-      result = ''
-      str.scan(/('+)|[^']+/) {
-        if $1
-          result << %q{\'} * $1.length
-        else
-          result << "'#{$&}'"
-        end
-      }
-      ShellEscaped.new_no_dup(result)
-    end
-  end
-
-  class PercentEncoded < StringWrapper
-  end
-
-  # Escape.uri_segment escapes URI segment using percent-encoding.
-  # It returns an instance of PercentEncoded.
-  #
-  #  Escape.uri_segment("a/b") #=> #<Escape::PercentEncoded: a%2Fb>
-  #
-  # The segment is "/"-splitted element after authority before query in URI, as follows.
-  #
-  #   scheme://authority/segment1/segment2/.../segmentN?query#fragment
-  #
-  # See RFC 3986 for details of URI.
-  def uri_segment(str)
-    # pchar - pct-encoded = unreserved / sub-delims / ":" / "@"
-    # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-    # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-    s = str.gsub(%r{[^A-Za-z0-9\-._~!$&'()*+,;=:@]}n) {
-      '%' + $&.unpack("H2")[0].upcase
-    }
-    PercentEncoded.new_no_dup(s)
-  end
-
-  # Escape.uri_path escapes URI path using percent-encoding.
-  # The given path should be a sequence of (non-escaped) segments separated by "/".
-  # The segments cannot contains "/".
-  # It returns an instance of PercentEncoded.
-  #
-  #  Escape.uri_path("a/b/c") #=> #<Escape::PercentEncoded: a/b/c>
-  #  Escape.uri_path("a?b/c?d/e?f") #=> #<Escape::PercentEncoded: a%3Fb/c%3Fd/e%3Ff>
-  #
-  # The path is the part after authority before query in URI, as follows.
-  #
-  #   scheme://authority/path#fragment
-  #
-  # See RFC 3986 for details of URI.
-  #
-  # Note that this function is not appropriate to convert OS path to URI.
-  def uri_path(str)
-    s = str.gsub(%r{[^/]+}n) { uri_segment($&) }
-    PercentEncoded.new_no_dup(s)
-  end
-
-  
-  def html_form_fast(pairs, sep='&')
-    s = pairs.map {|k, v|
-      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
-      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
-      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
-      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
-      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
-      k = k.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
-        '%' + $&.unpack("H2")[0].upcase
-      }
-      v = v.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
-        '%' + $&.unpack("H2")[0].upcase
-      }
-      "#{k}=#{v}"
-    }.join(sep)
-    PercentEncoded.new_no_dup(s)
-  end
-  
-
-  # Escape.html_form composes HTML form key-value pairs as a x-www-form-urlencoded encoded string.
-  # It returns an instance of PercentEncoded.
-  #
-  # Escape.html_form takes an array of pair of strings or
-  # an hash from string to string.
-  #
-  #  Escape.html_form([["a","b"], ["c","d"]]) #=> #<Escape::PercentEncoded: a=b&c=d>
-  #  Escape.html_form({"a"=>"b", "c"=>"d"}) #=> #<Escape::PercentEncoded: a=b&c=d>
-  #
-  # In the array form, it is possible to use same key more than once.
-  # (It is required for a HTML form which contains
-  # checkboxes and select element with multiple attribute.)
-  #
-  #  Escape.html_form([["k","1"], ["k","2"]]) #=> #<Escape::PercentEncoded: k=1&k=2>
-  #
-  # If the strings contains characters which must be escaped in x-www-form-urlencoded,
-  # they are escaped using %-encoding.
-  #
-  #  Escape.html_form([["k=","&;="]]) #=> #<Escape::PercentEncoded: k%3D=%26%3B%3D>
-  #
-  # The separator can be specified by the optional second argument.
-  #
-  #  Escape.html_form([["a","b"], ["c","d"]], ";") #=> #<Escape::PercentEncoded: a=b;c=d>
-  #
-  # See HTML 4.01 for details.
-  def html_form(pairs, sep='&')
-    r = ''
-    first = true
-    pairs.each {|k, v|
-      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
-      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
-      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
-      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
-      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
-      r << sep if !first
-      first = false
-      k.each_byte {|byte|
-        ch = byte.chr
-        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
-          r << "%" << ch.unpack("H2")[0].upcase
-        else
-          r << ch
-        end
-      }
-      r << '='
-      v.each_byte {|byte|
-        ch = byte.chr
-        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
-          r << "%" << ch.unpack("H2")[0].upcase
-        else
-          r << ch
-        end
-      }
-    }
-    PercentEncoded.new_no_dup(r)
-  end
-
-  class HTMLEscaped < StringWrapper
-  end
-
-  
-  HTML_TEXT_ESCAPE_HASH = {
-    '&' => '&amp;',
-    '<' => '&lt;',
-    '>' => '&gt;',
-  }
-  
-
-  # Escape.html_text escapes a string appropriate for HTML text using character references.
-  # It returns an instance of HTMLEscaped.
-  #
-  # It escapes 3 characters:
-  # * '&' to '&amp;'
-  # * '<' to '&lt;'
-  # * '>' to '&gt;'
-  #
-  #  Escape.html_text("abc") #=> #<Escape::HTMLEscaped: abc>
-  #  Escape.html_text("a & b < c > d") #=> #<Escape::HTMLEscaped: a &amp; b &lt; c &gt; d>
-  #
-  # This function is not appropriate for escaping HTML element attribute
-  # because quotes are not escaped.
-  def html_text(str)
-    s = str.gsub(/[&<>]/) {|ch| HTML_TEXT_ESCAPE_HASH[ch] }
-    HTMLEscaped.new_no_dup(s)
-  end
-
-  
-  HTML_ATTR_ESCAPE_HASH = {
-    '&' => '&amp;',
-    '<' => '&lt;',
-    '>' => '&gt;',
-    '"' => '&quot;',
-  }
-  
-
-  class HTMLAttrValue < StringWrapper
-  end
-
-  # Escape.html_attr_value encodes a string as a double-quoted HTML attribute using character references.
-  # It returns an instance of HTMLAttrValue.
-  #
-  #  Escape.html_attr_value("abc") #=> #<Escape::HTMLAttrValue: "abc">
-  #  Escape.html_attr_value("a&b") #=> #<Escape::HTMLAttrValue: "a&amp;b">
-  #  Escape.html_attr_value("ab&<>\"c") #=> #<Escape::HTMLAttrValue: "ab&amp;&lt;&gt;&quot;c">
-  #  Escape.html_attr_value("a'c") #=> #<Escape::HTMLAttrValue: "a'c">
-  #
-  # It escapes 4 characters:
-  # * '&' to '&amp;'
-  # * '<' to '&lt;'
-  # * '>' to '&gt;'
-  # * '"' to '&quot;'
-  #
-  def html_attr_value(str)
-    s = '"' + str.gsub(/[&<>"]/) {|ch| HTML_ATTR_ESCAPE_HASH[ch] } + '"'
-    HTMLAttrValue.new_no_dup(s)
-  end
-end

data/lib/rudy/backup.rb

@@ -1,135 +0,0 @@
-
-require 'date'
-
-module Rudy
-  module MetaData
-    class Backup < Storable
-      include Rudy::AWS
-      
-      field :rtype
-      field :awsid
-      
-      field :region
-      field :zone
-      field :environment
-      field :role
-      field :position
-      field :path
-      
-      field :date
-      field :time
-      field :second
-      
-      field :unixtime => Integer
-      
-      field :size
-      field :volume
-      
-      def initialize
-        @zone = DEFAULT_ZONE
-        @region = DEFAULT_REGION
-        @position = "01"
-        @rtype = Backup.rtype
-        time_stamp # initialize time to right now
-      end
-      
-      def self.rtype
-        'back'
-      end
-      
-      
-      def name
-        time = Time.at(@unixtime)
-        Backup.generate_name(@zone, @environment, @role, @position, @path, time)
-      end
-      
-      def valid?
-        #puts(@zone, @environment, @role, @position, @path, @date, @time, @second)
-        (@zone && @environment && @role && @position && @path && @date && @time && @second)
-      end
-      
-      def time_stamp
-        #return [@date, @time] if @date && @time
-        now = Time.now.utc
-        datetime = Backup.format_timestamp(now).split(Rudy::DELIM)
-        @unixtime = now.to_i
-        @date, @time, @second = datetime
-      end
-      
-      def nice_time
-        return "" unless @date && @time
-        t = @date.scan(/(\d\d\d\d)(\d\d)(\d\d)/).join('-')
-        t << " " << @time.scan(/(\d\d)(\d\d)/).join(':')
-        t
-      end
-      
-      def to_query(more=[], remove=[])
-        criteria = [:rtype, :zone, :environment, :role, :position, :path, :date, :time, :second, *more]
-        criteria -= [*remove].flatten
-        query = "select * from #{Rudy::DOMAIN} where unixtime > '0' "
-        criteria.each do |n|
-          query << "and #{n} = '#{self.send(n.to_sym)}'"
-        end
-        query << " order by unixtime desc"
-      end
-      
-      def to_s
-        str = ""
-        field_names.each do |key|
-          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
-        end
-        str
-       end
-      
-      def disk
-        Disk.generate_name(@zone, @environment, @role, @position, @path)
-      end
-      
-      # 20090224-1813-36
-      def Backup.format_timestamp(dat)
-        mon, day, hour, min, sec = [dat.mon, dat.day, dat.hour, dat.min, dat.sec].collect { |v| v.to_s.rjust(2, "0") }
-        [dat.year, mon, day, Rudy::DELIM, hour, min, Rudy::DELIM, sec].join
-      end
-      
-      # Times are converted to UTC
-      # back-us-east-1b-stage-app-01-rilli-app-20090224-1813-36
-      def Backup.generate_name(zon, env, rol, pos, pat, dat, sep=File::SEPARATOR)
-        raise "The date you provided is not a Time object" unless dat.is_a?(Time)
-        pos = pos.to_s.rjust 2, '0'
-        dirs = pat.split sep if pat
-        dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
-        timestamp = Backup.format_timestamp(dat.utc)
-        [rtype, zon, env, rol, pos, dirs, timestamp].flatten.join(Rudy::DELIM)
-      end
-      
-      
-      
-      
-      def to_select
-        
-      end
-      
-      def save
-        @@sdb.store(Rudy::DOMAIN, name, self.to_hash, :replace) # Always returns nil
-        true
-      end
-      
-      def destroy
-        @@sdb.destroy(Rudy::DOMAIN, name)
-        true
-      end
-      
-      def refresh
-        h = @@sdb.get(Rudy::DOMAIN, name) || {}
-        from_hash(h)
-      end
-      
-      def Backup.get(dname)
-        h = @@sdb.get(Rudy::DOMAIN, dname) || {}
-        from_hash(h)
-      end
-      
-    end
-  end
-end
-

data/lib/storable.rb

@@ -1,292 +0,0 @@
-#--
-# TODO: Handle nested hashes and arrays. 
-# TODO: to_xml, see: http://codeforpeople.com/lib/ruby/xx/xx-2.0.0/README
-# TODO: Rename to Stuffany
-#++
-
-require 'yaml'
-require 'fileutils'
-
-
-# Storable makes data available in multiple formats and can
-# re-create objects from files. Fields are defined using the 
-# Storable.field method which tells Storable the order and 
-# name.
-class Storable
-  unless defined?(SUPPORTED_FORMATS) # We can assume all are defined
-    VERSION = 5
-    NICE_TIME_FORMAT  = "%Y-%m-%d@%H:%M:%S".freeze 
-    SUPPORTED_FORMATS = [:tsv, :csv, :yaml, :json, :s, :string].freeze 
-  end
-  
-  # This value will be used as a default unless provided on-the-fly.
-  # See SUPPORTED_FORMATS for available values.
-  attr_reader :format
-  
-  # See SUPPORTED_FORMATS for available values
-  def format=(v)
-    v &&= v.to_sym
-    raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
-    @format = v
-  end
-  
-  def postprocess
-  end
-  
-  # TODO: from_args([HASH or ordered params])
-  
-  # Accepts field definitions in the one of the follow formats:
-  #
-  #     field :product
-  #     field :product => Integer
-  #
-  # The order they're defined determines the order the will be output. The fields
-  # data is available by the standard accessors, class.product and class.product= etc...
-  # The value of the field will be cast to the type (if provided) when read from a file. 
-  # The value is not touched when the type is not provided. 
-  def self.field(args={})
-    # TODO: Examine casting from: http://codeforpeople.com/lib/ruby/fattr/fattr-1.0.3/
-    args = {args => nil} unless args.is_a? Hash
-
-    args.each_pair do |m,t|
-      
-      [[:@@field_names, m], [:@@field_types, t]].each do |tuple|
-        class_variable_set(tuple[0], []) unless class_variable_defined?(tuple[0])
-        class_variable_set(tuple[0], class_variable_get(tuple[0]) << tuple[1])
-      end
-      
-      next if method_defined?(m)
-      
-      define_method(m) do instance_variable_get("@#{m}") end
-      define_method("#{m}=") do |val| 
-        instance_variable_set("@#{m}",val)
-      end
-    end
-  end
-  
-  # Returns an array of field names defined by self.field
-  def self.field_names
-    class_variable_get(:@@field_names)
-  end
-  # Returns an array of field names defined by self.field
-  def field_names
-    self.class.send(:class_variable_get, :@@field_names)
-  end
-  # Returns an array of field types defined by self.field. Fields that did 
-  # not receive a type are set to nil. 
-  def self.field_types
-    class_variable_get(:@@field_types)
-  end
-  # Returns an array of field types defined by self.field. Fields that did 
-  # not receive a type are set to nil.
-  def field_types
-    self.class.send(:class_variable_get, :@@field_types)
-  end
-
-  # Dump the object data to the given format. 
-  def dump(format=nil, with_titles=false)
-    format &&= format.to_sym
-    format ||= 's' # as in, to_s
-    raise "Format not defined (#{format})" unless SUPPORTED_FORMATS.member?(format)
-    send("to_#{format}", with_titles) 
-  end
-  
-  def to_string(*args)
-    to_s(*args)
-  end
-  
-  # Create a new instance of the object using data from file. 
-  def self.from_file(file_path, format='yaml')
-    raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
-    raise "#{self} doesn't support from_#{format}" unless self.respond_to?("from_#{format}")
-    format = format || File.extname(file_path).tr('.', '')
-    me = send("from_#{format}", read_file_to_array(file_path))
-    me.format = format
-    me
-  end
-  # Write the object data to the given file. 
-  def to_file(file_path=nil, with_titles=true)
-    raise "Cannot store to nil path" if file_path.nil?
-    format = File.extname(file_path).tr('.', '')
-    format &&= format.to_sym
-    format ||= @format
-    Storable.write_file(file_path, dump(format, with_titles))
-  end
-
-  # Create a new instance of the object from a hash.
-  def self.from_hash(from={})
-    return nil if !from || from.empty?
-    me = self.new
-        
-    fnames = field_names
-    fnames.each_with_index do |key,index|
-      
-      stored_value = from[key] || from[key.to_s] # support for symbol keys and string keys
-      
-      # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
-      
-      if field_types[index] == Array
-        ((value ||= []) << stored_value).flatten 
-      elsif field_types[index] == Hash
-        
-        value = stored_value
-      else
-        
-        # SimpleDB stores attribute shit as lists of values
-        value = stored_value.first if stored_value.is_a?(Array) && stored_value.size == 1
-
-        if field_types[index] == Time
-          value = Time.parse(value)
-        elsif field_types[index] == DateTime
-          value = DateTime.parse(value)
-        elsif field_types[index] == TrueClass
-          value = (value.to_s == "true")
-        elsif field_types[index] == Float
-          value = value.to_f
-        elsif field_types[index] == Integer
-          value = value.to_i
-        elsif field_types[index].kind_of?(Storable) && stored_value.is_a?(Hash)
-          value = field_types[index].from_hash(stored_value)
-        else
-          value = (stored_value.is_a?(Array) && stored_value.size == 1) ? stored_value.first : stored_value
-        end
-      end
-      
-      me.send("#{key}=", value) if self.method_defined?("#{key}=")  
-    end
-    
-    me.postprocess
-    
-    me
-  end
-  # Return the object data as a hash
-  # +with_titles+ is ignored. 
-  def to_hash(with_titles=true)
-    tmp = {}
-    field_names.each do |fname|
-      tmp[fname] = self.send(fname)
-    end
-    tmp
-  end
-  
-  # Create a new instance of the object from YAML. 
-  # +from+ a YAML string split into an array by line. 
-  def self.from_yaml(from=[])
-    # from is an array of strings
-    from_str = from.join('')
-    hash = YAML::load(from_str)
-    hash = from_hash(hash) if hash.is_a? Hash 
-    hash
-  end
-  def to_yaml(with_titles=true)
-    to_hash.to_yaml
-  end
-  
-  # Create a new instance of the object from a JSON string. 
-  # +from+ a JSON string split into an array by line.
-  def self.from_json(from=[])
-    require 'json'
-    # from is an array of strings
-    from_str = from.join('')
-    tmp = JSON::load(from_str)
-    hash_sym = tmp.keys.inject({}) do |hash, key|
-       hash[key.to_sym] = tmp[key]
-       hash
-    end
-    hash_sym = from_hash(hash_sym) if hash_sym.is_a? Hash  
-    hash_sym
-  end
-  def to_json(with_titles=true)
-    require 'json'
-    to_hash.to_json
-  end
-  
-  # Return the object data as a delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  # +delim+ is the field delimiter.
-  def to_delimited(with_titles=false, delim=',')
-    values = []
-    field_names.each do |fname|
-      values << self.send(fname.to_s)   # TODO: escape values
-    end
-    output = values.join(delim)
-    output = field_names.join(delim) << $/ << output if with_titles
-    output
-  end
-  # Return the object data as a tab delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  def to_tsv(with_titles=false)
-    to_delimited(with_titles, "\t")
-  end
-  # Return the object data as a comma delimited string. 
-  # +with_titles+ specifiy whether to include field names (default: false)
-  def to_csv(with_titles=false)
-    to_delimited(with_titles, ',')
-  end
-  # Create a new instance from tab-delimited data.  
-  # +from+ a JSON string split into an array by line.
-  def self.from_tsv(from=[])
-    self.from_delimited(from, "\t")
-  end
-  # Create a new instance of the object from comma-delimited data.
-  # +from+ a JSON string split into an array by line.
-  def self.from_csv(from=[])
-    self.from_delimited(from, ',')
-  end
-  
-  # Create a new instance of the object from a delimited string.
-  # +from+ a JSON string split into an array by line.
-  # +delim+ is the field delimiter.
-  def self.from_delimited(from=[],delim=',')
-    return if from.empty?
-    # We grab an instance of the class so we can 
-    hash = {}
-    
-    fnames = values = []
-    if (from.size > 1 && !from[1].empty?)
-      fnames = from[0].chomp.split(delim)
-      values = from[1].chomp.split(delim)
-    else
-      fnames = self.field_names
-      values = from[0].chomp.split(delim)
-    end
-    
-    fnames.each_with_index do |key,index|
-      next unless values[index]
-      hash[key.to_sym] = values[index]
-    end
-    hash = from_hash(hash) if hash.is_a? Hash 
-    hash
-  end
-
-  def self.read_file_to_array(path)
-    contents = []
-    return contents unless File.exists?(path)
-    
-    open(path, 'r') do |l|
-      contents = l.readlines
-    end
-
-    contents
-  end
-  
-  def self.write_file(path, content, flush=true)
-    write_or_append_file('w', path, content, flush)
-  end
-  
-  def self.append_file(path, content, flush=true)
-    write_or_append_file('a', path, content, flush)
-  end
-  
-  def self.write_or_append_file(write_or_append, path, content = '', flush = true)
-    #STDERR.puts "Writing to #{ path }..." 
-    create_dir(File.dirname(path))
-    
-    open(path, write_or_append) do |f| 
-      f.puts content
-      f.flush if flush;
-    end
-    File.chmod(0600, path)
-  end
-end
-