fuzzy_date 0.8.3 → 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8e21583d0f942c6c5528a5a265e70b0ab2c07c67b25574e37588c8a6f48b8dd
+  data.tar.gz: e188f5303312dd8f097e1755540a0854caaa87cb01ad20c7ebf706bfc4296a55
+SHA512:
+  metadata.gz: 675b22fd8f9693427c47a2dd451b88b2b2cfc005ff1e80463f3c8cf5de7fd72f17d0b75a21a63f27a80f3551b07c333c2a63d639751978db0c4bfafbd52eb4c6
+  data.tar.gz: 0c2ecc1bcb5377e7964f8b6f9948451ad7169386d184eb20da3471c67dec371384a927e91813f90a505e728e7e95232a495fce87b0add127689470247951f281

data/README

@@ -1,57 +1,44 @@
-  Routines to manage the FuzzyDate Class. There is also an extension to the 
+  Routines to manage the FuzzyDate Class. There is also an extension to the
   ActiveRecord::Base class to provide an 'acts_as_fuzzy_date' class method.
-  
-  Historical dates are often incomplete or approximate and this class allows 
+
+  Historical dates are often incomplete or approximate and this class allows
   such dates to be worked with and stored on a database.
-  
+
   construct a new object with FuzzyDate.new( year,month,day,wday,circa)
      year:   optional..is the year number 0 .. big as you like, -ve for BCE
      month:  optional.. is month number 1..12, or nil
      day:    optional.. is day number 1-31 or nil
      wday:   optional.. day of the week - 0=Sunday .. 6=Saturday
-     circa:  true = daye is approx, or nil/false
-     
+     circa:  true = day is approx, or nil/false
+
      note that if you supply the weekday and a year/month/day the system will
      use your weekday as supplied even if this does not actually correspond
      in reality to the date supplied.
-     
+
    construct a new object with FuzzyDate.parse("date_string")
      date_string = eg: "tuesday"
                        "12 nov 1012"
                        "circa 412 bc"
-                       
+
    Use in a database table by storing in an integer field of a format large
    enough to hold the digits of your maximum year + 8. Eg. a BIGNUM field
    stores 19 useful characters allowing the year to go to 99,999,999,999.
    ie 99 billion years.
-   
+
    Use with an ActiveRecord class ..
-   
+
        require 'fuzzy_date'
 
        class HistoricalPerson < ActiveRecord::Base
            acts_as_fuzzy_date : birth_date, death_date
        end
-       
-       
-
-  Copyright (c) Clive Andrews / Reality Bites 2008, 2009, 2010
-
- 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.
+
+
+
+Copyright (c) Clive Andrews / Reality Bites 2008, 2009, 2010, 2020
+
+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/lib/fuzzy_date.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 ################################################################################
 #
-#  Routines to manage the FuzzyDate Class. There is also an extension to the 
+#  Routines to manage the FuzzyDate Class. There is also an extension to the
 #  ActiveRecord::Base class to provide an 'acts_as_fuzzy_date' class method.
 #--
-#  Copyright (c) Clive Andrews / Reality Bites 2008, 2009, 2010
+#  Copyright (c) Clive Andrews / Reality Bites 2008, 2009, 2010, 2020
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -26,105 +28,92 @@
 #
 # version 20100224-1
 # ++
-#  
+#
 ################################################################################
 require 'date'
 
-
 # A fuzzy date is a representation of a date which may well be incomplete
 # or imprecise. You can enter the exact date or for example just the day of
 # the week or the year or a combination thereof. One can also add the Circa
-# prefix to any date. The FuzzyDate object is immutable so if you wish to 
+# prefix to any date. The FuzzyDate object is immutable so if you wish to
 # change a FuzzyDate value it is neccessary to create a new FuzzyDate.
 class FuzzyDate
-  
+
   include Comparable
-  
-  # overload the Date class to modify its parsing routine a little
-  #
-  class FDate < Date # :nodoc:
-    def self._parse_year(str, e) 
-      if str.sub!(/(\d{3,})\b/in, ' ')
-        e.year = $1.to_i
-        true
-      else
-        super(str,e)
-      end
-    end
-  end # FDate
-  
-  # create a new FuzzyDate object. There are no checks here to 
-  # validate if the date is valid or not.. eg there is no check 
+
+  # create a new FuzzyDate object. There are no checks here to
+  # validate if the date is valid or not.. eg there is no check
   # that the day of the week actually corresponds to the actual
   # date if completely specified.
-  def initialize(year=nil,month=nil,day=nil,wday=nil,circa=nil)
-    raise "FuzzyDate: invalid month"   if month && ((month>12) || (month<1))
-    raise "FuzzyDate: invalid day"     if day   && ((day>31)   || (day<1))
-    raise "FuzzyDate: invalid weekday" if wday  && ((wday>6)   || (wday<0))
-    raise "FuzzyDate: year too big !"  if year  && (year.abs > 99999999999 )
-    @year  = year && year.abs
+  def initialize(year = nil, month = nil, day = nil, wday = nil, circa = nil)
+
+    year  = year && Integer(year)
+    month = month && Integer(month)
+    day   = day && Integer(day)
+    wday  = wday && Integer(wday)
+
+    raise ArgumentError, 'invalid month'   if month && ((month > 12) || (month < 1))
+    raise ArgumentError, 'invalid day'     if day   && ((day > 31)   || (day < 1))
+    raise ArgumentError, 'invalid weekday' if wday  && ((wday > 6)   || (wday < 0))
+    raise ArgumentError, 'year too big !'  if year  && (year.abs > 99_999_999_999)
+
+    @year  = year&.abs
     @month = month
     @day   = day
     @wday  = wday
     @circa = circa
-    @bce   = year && (year.to_i < 0)
+    @bce   = year && (year < 0)
   end
-  
+
   # returns an integer representing the day of the week, 0..6
-  # with Sunday=0. returns nil if not known. 
-  def wday 
-    if !@wday && complete? && (@year > 0)
+  # with Sunday=0. returns nil if not known.
+  def wday
+    if !@wday && complete? && !bce?
       to_date.wday
     else
       @wday
     end
   end
-  
+
   # returns the day of the month ( 1..n ). returns nil if not known.
-  def day
-    @day
-  end
-  
+  attr_reader :day
+
   # returns the month number (1..12). returns nil if not known.
-  def month
-    @month
-  end
-  
+  attr_reader :month
+
   # returns the year number (including century)
-  def year
-    @year
-  end
-  
+  attr_reader :year
+
   # is the date approximate ?
   def circa?
-    @circa
+    !!@circa
   end
-  
+
   # is the date before the year zero.
   def bce?
-    @bce
+    !!@bce
   end
-  
+
   #  return an integer representing only the month and day
   def birthday
     month * 100 + day if month && day
   end
-  
+
   # is the date complete
   def complete?
-    year && (month  && month < 13) && (day  && day < 32)
+    !!(year && (month && month < 13) && (day && day < 32))
   end
-  
+
   # is the date completely unknown
   def unknown?
     !@year && !@month && !@day && !@wday
   end
-  
+
   # convert to integer format
   def to_i
     to_db
   end
-  
+
   # convert the fuzzy date into a format which can be stored in a database. The
   # storage format is integer format (BIGINT) with digits having the following positional
   # significance:
@@ -144,127 +133,153 @@ class FuzzyDate
   #   this wierd format has been chosen to allow sorting within the database and to
   #   avoid leading zeros containing information from being stripped from the representation.
   #
-  #   save in a  mysql database in format BIGINT 
+  #   save in a  mysql database in format BIGINT
   #
   def to_db
-    str = ''
-    str= str + (@year > 0 ? @year.to_s : '') if @year
-    str= str + (@month ? "%02d" % @month.to_s : '13')
-    str= str + (@day ? "%02d" % @day.to_s : '32')
-    str= str + (@wday ? (@wday+1).to_s : '8')
-    str= str + (@year  ? '0' : '1')
-    str= str + (@circa  ? '1' : '0')
+    str = String.new
+    str += (@year > 0 ? @year.to_s : '') if @year
+    str += (@month ? '%02d' % @month.to_s : '13')
+    str += (@day ? '%02d' % @day.to_s : '32')
+    str += (@wday ? (@wday + 1).to_s : '8')
+    str += (@year ? '0' : '1')
+    str += (@circa ? '1' : '0')
     i = str.to_i
     i = -i if @bce
     i
   end
-  
+
   # create a new FuzzyDate object from the database formatted
   # integer.
   def self.new_from_db(i)
     return nil unless i
+
     str = i.to_s
     return nil if str == '0'
+
     bce = false
-    raise "Invalid Fuzzy Time String - #{str}" unless str =~/^[+-]?\d{6,}$/
-    str.sub!(/^-/){|m| bce= true;""} 
-    str = ("000000" + str)[-7,7] if str.length < 7
-    circa   =  (str[-1,1] == '1')
-    year    =  (str[-2,1] == '1' ? nil : 0)
-    wday    = str[-3,1].to_i - 1
-    day     = str[-5,2].to_i
-    month   = str[-7,2].to_i
-    wday    = nil if ((wday<0) || (wday>6))
-    day     = nil if ((day==0) || (day>31))
-    month   = nil if ((month==0) || (month > 12))
-    year    = (str[0..-8].to_i > 0 ? str[0..-8].to_i : year )
+    raise "Invalid Fuzzy Time String - #{str}" unless str =~ /^[+-]?\d{6,}$/
+
+    str.sub!(/^-/) { |_m| bce = true; '' }
+    str = ('000000' + str)[-7, 7] if str.length < 7
+    circa = (str[-1, 1] == '1')
+    year = (str[-2, 1] == '1' ? nil : 0)
+    wday = str[-3, 1].to_i - 1
+    day = str[-5, 2].to_i
+    month = str[-7, 2].to_i
+    wday = nil if (wday < 0) || (wday > 6)
+    day = nil if (day == 0) || (day > 31)
+    month = nil if (month == 0) || (month > 12)
+    year = (str[0..-8].to_i > 0 ? str[0..-8].to_i : year)
     year = -year if year && bce
-    new(year,month,day,wday,circa)
+    new(year, month, day, wday, circa)
   end
-  
+
   # convert to a human readable string
   def to_s
     if unknown?
-      str = "unknown"
+      str = 'unknown'
     else
-      str = ""
-      str = "circa "                        if circa?
-      str+= FDate::DAYNAMES[wday]    + " "  if wday 
-      str+= day.to_s + " "                  if day 
-      str+= FDate::MONTHNAMES[month] + " "  if month
-      str+= year.to_s                       if year 
-      str += " bce"                         if bce?
+      str = ''
+      str = 'circa ' if circa?
+      str += Date::DAYNAMES[wday] + ' ' if wday
+      str += day.to_s + ' '                  if day
+      str += Date::MONTHNAMES[month] + ' '  if month
+      str += year.to_s                       if year
+      str += ' bce' if bce?
       str.strip
     end
   end
-  
+
   # if the date is complete then return a regular
   # Date object
   def to_date
-    return nil unless complete?
-    Date.new(@year,@month,@day)
+    Date.new(@year, @month, @day) if complete?
   end
-  
+
   # create a FuzzyDate object from a Date object
-  def self.new_from_date( date)
-    new(date.year,date.month,date.day)
+  def self.new_from_date(date)
+    new(date.year, date.month, date.day)
   end
-  
+
   # create a new date object by parsing a string
-  def self.parse( str )
-    
-    return unless str && str.length > 0
-    
+  def self.parse(str)
+    return unless str # && str.length > 0
+
+    str = str.strip
+
+    return new if str == ''
+
     continue = true
     circa    = false
     bce      = false
     unknown  = false
-    
-    #filter out 'c' or 'circa'
-    str.sub!(/CIRCA/i){|m| circa=true;continue=nil} if continue
-    str.sub!(/^CA /i){|m| circa=true;continue=nil} if continue
-    str.sub!(/^C /i){|m| circa=true;continue=nil} if continue
-    str.sub!(/ABOUT/i){|m| circa=true;continue=nil} if continue
-    str.sub!(/AROUND/i){|m| circa=true;continue=nil} if continue
-    str.sub!(/ROUND/i){|m| circa=true;continue=nil} if continue
-    str.sub!(/APPROX/i){|m| circa=true;continue=nil} if continue
-    str.sub!(/APPROXIMATELY/i){|m| circa=true;continue=nil} if continue
-    
-    #filter out 'bc' 'bce'
+
+    # filter out 'c' or 'circa'
+    str.sub!(/CIRCA/i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/^CA /i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/^C /i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/ABOUT/i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/AROUND/i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/ROUND/i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/APPROX/i) { |_m| circa = true; continue = nil } if continue
+    str.sub!(/APPROXIMATELY/i) { |_m| circa = true; continue = nil } if continue
+
+    # filter out 'bc' 'bce'
     continue = true
-    str.sub!(/BCE/i){|m| bce=true;continue=nil}
-    str.sub!(/BC/i){|m| bce=true;continue=nil} if continue
-    
-    #filter out 'unknown'
+    str.sub!(/BCE/i) { |_m| bce = true; continue = nil }
+    str.sub!(/BC/i) { |_m| bce = true; continue = nil } if continue
+
+    # filter out 'unknown'
     continue = true
-    str.sub!(/UNKNOWN/i){|m| unknown=true;continue=nil}
-    
+    str.sub!(/UNKNOWN/i) { |_m| unknown = true; continue = nil }
+
     # if date is unknown then return an empty FuzzyDate
-    return self.new if unknown
-    
+    return new if unknown
+
     # now try to parse the remaining string with the Date parse
     # method.
-    
-    components= FDate._parse(str,false)
-    year  = components[:year]
+
+    components = case str
+    when /^(\d+)$/ then {:year=>Integer($1)}
+    when /^(\w+)\s+(\d+)$/
+      if Integer($2) > 31
+        Date._parse($1, false).merge( :year=>Integer($2) )
+      else
+        Date._parse(str, false)
+      end
+    else
+      Date._parse(str, false)
+    end
+
+    year = components[:year]
     month = components[:mon]
     day   = components[:mday]
     wday  = components[:wday]
-    
+
     # fudge the results a bit
-    year,day = day,nil if (day && !month && !year) || (!year && (day.to_i > 31))
-    if year && year < 0 
+    if (day && !month && !year) || (!year && (day.to_i > 31))
+      year = day
+      day = nil
+    end
+    if year && year < 0
       year = year.abs
       bce  = true
     end
-    
+
     year = -year if bce
-    self.new(year,month,day,wday,circa)
+    new(year, month, day, wday, circa)
+  end
+
+  def _dump
+    p self
+    self
   end
-  
-  def <=>(other) self.to_db <=> other.to_db end
-  
-end #class FuzzyDate
+
+  def <=>(other)
+    to_db <=> other.to_db
+  end
+
+end # class FuzzyDate
 
 # add an acts_as_fuzzy_date helper to ActiveRecord to define
 # a table field as a FuzzyDate.
@@ -279,14 +294,16 @@ end #class FuzzyDate
 #
 if defined? ActiveRecord::Base
   class ActiveRecord::Base
+
     class << self
+
       def acts_as_fuzzy_date(*args)
         args.each do |name|
-          str =<<-EOF
+          str = <<-EOF
           def #{name}
              FuzzyDate.new_from_db(self['#{name}'])
           end
-    
+
           def #{name}=(s)
              if s.kind_of? String
                  self['#{name}'] = FuzzyDate.parse(s).to_db unless s.strip.empty?
@@ -296,10 +313,12 @@ if defined? ActiveRecord::Base
                  self['#{name}'] = nil
              end
           end
-EOF
+          EOF
           class_eval str
         end
       end
+
     end
+
   end
 end

data/test/test_fuzzy_date.rb

@@ -77,18 +77,18 @@ class TestItem < Test::Unit::TestCase
     assert ( !d1.circa?)
     assert ( !d1.unknown?)
   end
-  
+
   def test_database
-    10000.times do 
+    10000.times do
       d = make_fuzzy_date
-      puts d.to_s
+      #puts d.to_s
       i = d.to_i
       i = i * 1 # reformat ?
       d2 = FuzzyDate.new_from_db( i )
       assert_equal( d.to_i, d2.to_i)
     end
   end
-  
+
   def test_compare
     assert( FuzzyDate.parse("23 april 2000") == FuzzyDate.parse("23 april 2000") )
     assert( FuzzyDate.parse("24 april 2000") > FuzzyDate.parse("23 april 2000") )
@@ -96,7 +96,7 @@ class TestItem < Test::Unit::TestCase
     assert( FuzzyDate.parse("jan 2001") > FuzzyDate.parse("dec 2000") )
     assert( FuzzyDate.parse("sept") > FuzzyDate.parse("july") )
   end
-  
+
   # generate a random fuzzy date
   def make_fuzzy_date
     #    1  2  3  4  5  6  7  8  9  10 11 12
@@ -107,11 +107,11 @@ class TestItem < Test::Unit::TestCase
     day       = rand(tab[month-1]) + 1
     circa     = rand(4) == 0
     bce       = rand(2) == 0
-    do_year   = rand(3) > 0
-    do_month  = rand(3) > 0
-    do_day    = rand(3) > 0
-    do_wday   = rand(3) > 0
-    
+    do_year   = true if rand(3) > 0
+    do_month  = true if rand(3) > 0
+    do_day    = true if rand(3) > 0
+    do_wday   = true if rand(3) > 0
+
     year = - year if bce
     FuzzyDate.new( do_year && year,
                    do_month && month,

metadata

@@ -1,63 +1,48 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: fuzzy_date
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 8
-  - 3
-  version: 0.8.3
+version: !ruby/object:Gem::Version
+  version: 0.9.1
 platform: ruby
-authors: 
+authors:
 - Clive Andrews
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-02-24 00:00:00 +01:00
-default_executable: 
+date: 2010-02-24 00:00:00.000000000 Z
 dependencies: []
-
 description: FuzzyDate is a Ruby class for working with incomplete dates.
 email: pacman@realitybites.eu
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README
 - lib/fuzzy_date.rb
-has_rdoc: true
+- test/test_fuzzy_date.rb
 homepage: http://site.realitybites.eu/content/fuzzy_date
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: fuzzy_date
-rubygems_version: 1.3.6
+rubygems_version: 3.0.4
 signing_key: 
-specification_version: 3
-summary: FuzzyDate is a Ruby class for working with incomplete dates.Can be used in Combination with ActiveRecord.
-test_files: 
+specification_version: 4
+summary: FuzzyDate is a Ruby class for working with incomplete dates.Can be used in
+  Combination with ActiveRecord.
+test_files:
 - test/test_fuzzy_date.rb