webget_ruby_spreadsheeting 1.0.4 → 1.0.6

data.tar.gz.sig

@@ -1 +1 @@
-$Nғj�r�a�\qb��)WNwn���~,/B�$�����;���F�����o����?��������X��6�r.��˱$�@.�'�
+�/�f�5���}H��y&k��xuC�t(?ү&ʚ�%mΔ֋�:����M�A�c��!�;V��#Uք�X7!M�wHr�6�-G���A̾��zܮH�Cu�9��<9�xm�8��Q�MƮ���X�|

data/README.rdoc

@@ -6,3 +6,4 @@ Copyright:: Copyright (c) 2006-2010 Joel Parker Henderson
 License:: CreativeCommons License, Non-commercial Share Alike
 License:: LGPL, GNU Lesser General Public License
 
+Fusion key: A0M2R-72E46-K2V7Q-2N3K2

data/lib/webget_ruby_spreadsheeting.rb

@@ -12,128 +12,183 @@ License:: LGPL, GNU Lesser General Public License
 
 module Spreadsheeting
 
- # Parse a string to a date, with some cleanup
- def import_date(s)
-  return nil if s==nil or s.strip==''
-  return Date.parse(s)
- end
-
-
- # There's a typical import use case where a column is
- # a boolean, in a variety of formats like "X" for on,
- # "Y" for yes, "T" for true, etc.
- #
- # @return a boolean
- #
- # We use these rules:
- # - x y yes t true on +  => true
- # - blank n no f false off -  => false
- # - anything else => nil
- #
- # ==Examples
- #   import_flag('Yes') => true
- #   import_flag('No') => false
- #   import_flag('X') => true
- #   import_flag('') => false
- #   import_flag('Hello') => nil
- #   import_flag(nil) => nil
-
- def import_flag(s)
-  s==nil and return nil
-  case s.strip.downcase
-  when 'x','y','yes','t','true','on','+'
-   return true
-  when '','n','no','f','false','off','-'
-   return false
-  else 
-   return nil
+
+  # Convert true/false to "+"/"-"
+  # 
+  # @param [Boolean] flag
+  # @return [String] "+" or "-"
+
+  def export_flag(flag)
+    flag ? '+' : '-'
+  end
+
+
+  # Corresponds to import_flag_or_note
+  #
+  # - flag==true => "+"
+  # - flag==false => "-"
+  # - flag==nil => note
+  #
+  # @return [String] "+" or "-" or freeform string note
+  #
+  # @example
+  #   export_flag_or_note(true,"hello") => "+"
+  #   export_flag_or_note(false,"hello") => "-"
+  #   export_flag_or_note(nil,"hello") => "hello"
+  #
+  # @see #import_flag_or_note
+  # @see #export_flag
+
+  def export_flag_or_note(flag,note=nil)
+    return flag==nil ? note : export_flag(flag)
+  end
+
+
+  # Convert a date to a string format "YYYY/MM/DD"
+  #
+  # @param [Boolean] flag
+  # @return [String] "+" or "-"
+
+  def export_date(date)
+    date.strftime("%Y/%m/%d")
+  end
+
+
+  # Corresponds to import_date_or_note
+  #
+  # - date is non-null => "2007/12/31"
+  # - date is null => note
+  #
+  # @return [String] a date formatted like "2007/12/31" or freeform string note
+  #
+  # @example
+  #   d=Date.parse('1/1/2007')
+  #   export_date_or_note(d,'hello') => '2007-01-01'
+  #   export_date_or_note(nil,'hello') => 'hello'
+  #
+  # @see #import_date_or_note
+
+  def export_date_or_note(date,note=nil)
+    return date==nil ? note : export_date(date)
   end
- end
-
-
- # There's a typical import use case where a column
- # can contain two different data types:
- # - a boolean, in a variety of formats (see _import_flag_)
- # - a note, in plain text
- #
- # We need to separate these two.
- #
- # This method returns two items: a boolean and a note.
- #
- # We use these rules:
- # - x y yes t true on +  => [true, '']
- # - blank n no f false off -  => [false, '']
- # - any other string => [nil, note]
- # - nil => [nil, nil]
- #
- # ==Example
- #   import_flag_or_note('Yes') => [true,'']
- #   import_flag_or_note('No') => [false,'']
- #   import_flag_or_note('X') => [true,'']
- #   import_flag_or_note('') => [false,'']
- #   import_flag_or_note('Hello') => [nil,'Hello']
- #   import_flag_or_note(nil) => [nil,nil]
-
- def import_flag_or_note(s)
-   return [nil, nil] if s==nil
-   flag = import_flag(s)
-   return [flag, flag==nil ? s : '']
- end
-
-
- # There's a common import use case where a column can be of two types:
- # - a date, in a variety of format like "Jan 1, 2008", "1/1/2008", etc.
- # - a note, in plain text
- #
- # This method returns two items: a date (Date class) and a note (String class).
- #
- # ==Example
- #   import_date_or_note('1/1/2007') => [Date(2007,01,01),'']
- #   import_date_or_note('hello') => [nil,'hello']
- 
- def import_date_or_note(s)
-  begin
-   d=import_date(s)
-  rescue
-   d=nil
+
+
+  # Parse a string to a date, with some cleanup.
+  #
+  # @param [String, #to_s, nil] input to parse, e.g. "2007/12/31"
+  # @return [Date] the parsed date
+  #
+  # @see #import_date_or_note
+
+  def import_date(input)
+    return nil if input==nil
+    input_s = input.to_s.strip
+    return nil if input==''
+    return Date.parse(input_s)
+  end
+
+
+  # Parse an imput that may be a date (e.g. "2007/12/31") or a note (e.g. freeform text) into an array.
+  # 
+  # There's a common import use case where a column can be of two types:
+  # - a date, in a variety of format like "Jan 1, 2008", "1/1/2008", etc.
+  # - a note, in plain text
+  #
+  # @param [Boolean, String, #to_s, nil] input typically "Yes", "No", "On", "Off", etc.
+  # @return [Array<Date, String>] the parsed output [date, note]
+  #
+  # @example
+  #   import_date_or_note('1/1/2007') => [Date(2007,01,01),'']
+  #   import_date_or_note('hello') => [nil,'hello']
+  #
+  # @see #export_date_or_note
+  # @see #import_date
+  
+  def import_date_or_note(input)
+    begin
+      d=import_date(input)
+    rescue
+      d=nil
+    end
+    return d ? [d,''] : [nil,input]
+  end
+
+
+  # Parse various input words (e.g. "Yes", "No", "On", "Off") to true or false.
+  #
+  # There's a typical import use case where a column is
+  # a boolean, in a variety of formats like "X" for on,
+  # "Y" for yes, "T" for true, etc.
+  #
+  # We use these rules:
+  # - x y yes t true on +  => true
+  # - blank n no f false off -  => false
+  # - anything else => nil
+  #
+  # @param [Boolean, String, #to_s, nil] input typically "Yes", "No", "On", "Off", etc.
+  # @return [Boolean] the parsed output
+  #
+  # @example
+  #   import_flag("Yes") => true
+  #   import_flag("No") => false
+  #   import_flag("X") => true
+  #   import_flag("") => false
+  #   import_flag("Hello") => nil
+  #   import_flag(true) => true
+  #   import_flag(false) => true
+  #   import_flag(nil) => nil
+  #
+  # @see #import_flag_or_note
+
+  def import_flag(input)
+    return input if (input==true or input==false or input==nil)
+    case input.to_s.strip.downcase
+    when 'x','y','yes','t','true','on','+'
+      return true
+    when '','n','no','f','false','off','-'
+      return false
+    else 
+      return nil
+    end
+  end
+
+
+  # Parse an imput that may be a flag (e.g. true/false) or a note (e.g. freeform text) into an array.
+  #
+  # There's a typical import use case where a column
+  # can contain two different data types:
+  # - a boolean, in a variety of formats (see _import_flag_)
+  # - a note, in plain text
+  #
+  # We need to separate these two.
+  #
+  # We use these rules:
+  # - x y yes t true on +  => [true, '']
+  # - blank n no f false off -  => [false, '']
+  # - any other string => [nil, note]
+  # - nil => [nil, nil]
+  #
+  # @param [Boolean, String, #to_s, nil] input typically "Yes", "No", "On", "Off", etc.
+  # @return [Array<Boolean, String>] the parsed output [flag, note]
+  #
+  # @example
+  #   import_flag_or_note("Yes") => [true,""]
+  #   import_flag_or_note("No") => [false,""]
+  #   import_flag_or_note("X") => [true,""]
+  #   import_flag_or_note("") => [false,""]
+  #   import_flag_or_note("Hello") => [nil,"Hello"]
+  #   import_flag_or_note(true) => [true,""]
+  #   import_flag_or_note(false) => [false,""]
+  #   import_flag_or_note(nil) => [nil,nil]
+  #
+  # @see #export_flag_or_note
+  # @see #import_flag
+
+  def import_flag_or_note(input)
+    return [nil, nil] if (input==nil)
+    flag = import_flag(input)
+    return [flag, flag==nil ? input : '']
   end
-  return d ? [d,''] : [nil,s]
- end
-
-
- # Corresponds to import_flag_or_note
- #
- # ==Return
- # - flag==true => 'X'
- # - flag==false => ''
- # - otherwise return note
- #
- # ==Example
- #   t=true
- #   f=false
- #   export_flag_or_note(t,'hello') => 'X'
- #   export_flag_or_note(f,'hello') => ''
- #   export_flag_or_note(nil,'hello') => 'hello'
-
- def export_flag_or_note(flag,note=nil)
-  return flag==true ? 'X' : flag==false ? '' : note
- end
-
-
- # Corresponds to import_date_or_note
- #
- # ==Return
- # - date exists => date to yyyy-mm-dd format
- # - otherwise return note
- #
- # ==Example
- #   d=Date.parse('1/1/2007')
- #   export_date_or_note(d,'hello') => '2007-01-01'
- #   export_date_or_note(nil,'hello') => 'hello'
-
- def export_date_or_note(date,note=nil)
-  return date ?  date.strftime("%Y-%m-%d") : note
- end
 
 
 end

data/test/webget_ruby_spreadsheeting_test.rb

@@ -6,6 +6,9 @@ class SpreadsheetingTest < Test::Unit::TestCase
 
   include Spreadsheeting
 
+  DATE_STR="2007/12/31"
+  DATE=Date.parse(DATE_STR)
+
   def test_import_flag
     assert_equal(true,    import_flag('X'))
     assert_equal(false,   import_flag(''))
@@ -14,6 +17,8 @@ class SpreadsheetingTest < Test::Unit::TestCase
     assert_equal(true,    import_flag('+'))
     assert_equal(false,   import_flag('-'))
     assert_equal(nil,     import_flag('hello'))
+    assert_equal(true,    import_flag(true))
+    assert_equal(false,   import_flag(false))
     assert_equal(nil,     import_flag(nil))
   end
 
@@ -25,6 +30,8 @@ class SpreadsheetingTest < Test::Unit::TestCase
     assert_equal([true,''],     import_flag_or_note('+'))
     assert_equal([false,''],    import_flag_or_note('-'))
     assert_equal([nil,'hello'], import_flag_or_note('hello'))
+    assert_equal([true,''],     import_flag_or_note(true))
+    assert_equal([false,''],    import_flag_or_note(false))
     assert_equal([nil,nil],     import_flag_or_note(nil))
   end
 
@@ -34,16 +41,24 @@ class SpreadsheetingTest < Test::Unit::TestCase
     assert_equal([nil,'hello'], import_date_or_note('hello'))
   end
 
+  def test_export_flag
+    assert_equal('+',     export_flag(true))
+    assert_equal('-',     export_flag(false))
+  end
+
   def test_export_flag_or_note
-    assert_equal('X',     export_flag_or_note(true,'hello'))
-    assert_equal('',      export_flag_or_note(false,'hello'))
+    assert_equal('+',     export_flag_or_note(true,'hello'))
+    assert_equal('-',     export_flag_or_note(false,'hello'))
     assert_equal('hello', export_flag_or_note(nil,'hello'))
   end
 
+  def test_export_date
+    assert_equal(DATE_STR,export_date(DATE))
+  end
+
   def test_export_date_or_note
-    d=Date.parse('2007/12/31')
-    assert_equal('2007-12-31', export_date_or_note(d,'hello'))
-    assert_equal('hello',      export_date_or_note(nil,'hello'))
+    assert_equal(DATE_STR, export_date_or_note(DATE,'hello'))
+    assert_equal('hello',  export_date_or_note(nil,'hello'))
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: webget_ruby_spreadsheeting
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors: 
 - WebGet
@@ -32,7 +32,7 @@ cert_chain:
   DXnLFY0cVuBnNDMOOFl8vk1qIcZjcTovhzgcixpG6Uk5qmUsKHRLQf4oQJx7TfLK
   -----END CERTIFICATE-----
 
-date: 2010-02-19 00:00:00 -08:00
+date: 2010-03-18 00:00:00 -07:00
 default_executable: 
 dependencies: []