nickel 0.0.6 → 0.1.0

data/lib/nickel/ztime.rb

@@ -1,15 +1,15 @@
-# Ruby Nickel Library 
-# Copyright (c) 2008-2011 Lou Zell, lzell11@gmail.com, http://hazelmade.com
-# MIT License [http://www.opensource.org/licenses/mit-license.php]
+require 'time'
 
 module Nickel
-  
+
   class ZTime
-    # @firm will be used to indicate user provided am/pm
+    include Comparable
+
+    # \@firm will be used to indicate user provided am/pm
     attr_accessor :firm
 
-    # @time is always stored on 24 hour clock, but we could initialize a Time object with ZTime.new("1020", :pm)
-    # we will convert this to 24 hour clock and set @firm = true
+    # \@time is always stored on 24 hour clock, but we could initialize a Time object with ZTime.new("1020", :pm)
+    # we will convert this to 24 hour clock and set \@firm = true
     def initialize(hhmmss = nil, am_pm = nil)
       t = hhmmss ? hhmmss : ::Time.new.strftime("%H%M%S")
       t.gsub!(/:/,'') # remove any hyphens, so a user can initialize with something like "2008-10-23"
@@ -20,7 +20,7 @@ module Nickel
     def time
       @time
     end
-    
+
     def time=(hhmmss)
       @time = lazy(hhmmss)
       @firm = false
@@ -30,44 +30,68 @@ module Nickel
     def hour_str
       @time[0..1]
     end
-    
+
+    # @deprecated Please use {#min_str} instead
     def minute_str
+      warn "[DEPRECATION] `minute_str` is deprecated.  Please use `min_str` instead."
+      min_str
+    end
+
+    def min_str
       @time[2..3]
     end
-    
+
+    # @deprecated Please use {#sec_str} instead
     def second_str
+      warn "[DEPRECATION] `second_str` is deprecated.  Please use `sec_str` instead."
+      sec_str
+    end
+
+    def sec_str
       @time[4..5]
     end
-    
+
     def hour
       hour_str.to_i
     end
-    
+
+    # @deprecated Please use {#min} instead
     def minute
-      minute_str.to_i
+      warn "[DEPRECATION] `minute` is deprecated.  Please use `min` instead."
+      min
     end
-    
+
+    def min
+      min_str.to_i
+    end
+
+    # @deprecated Please use {#sec} instead
     def second
-      second_str.to_i
+      warn "[DEPRECATION] `second` is deprecated.  Please use `sec` instead."
+      sec
+    end
+
+    def sec
+      sec_str.to_i
     end
 
-    # add_ methods return new ZTime object
-    # add_ methods take an optional block, the block will be passed the number of days that have passed; 
+    # add\_ methods return new ZTime object
+    # add\_ methods take an optional block, the block will be passed the number of days that have passed;
     # i.e. adding 48 hours will pass a 2 to the block, this is handy for something like this:
     # time.add_hours(15) {|x| date.add_days(x)}
     def add_minutes(number, &block)
       # new minute is going to be (current minute + number) % 60
       # number of hours to add is (current minute + number) / 60
-      hours_to_add = (self.minute + number) / 60
+      hours_to_add = (self.min + number) / 60
       # note add_hours returns a new time object
       if block_given?
         o = self.add_hours(hours_to_add, &block)
       else
         o = self.add_hours(hours_to_add)
       end
-      o.change_minute_to((o.minute + number) % 60)  # modifies self
+      o.change_minute_to((o.min + number) % 60)  # modifies self
     end
-    
+
     def add_hours(number, &block)
       o = self.dup
       if block_given?
@@ -79,73 +103,73 @@ module Nickel
 
     # NOTE: change_ methods modify self.
     def change_hour_to(h)
-      self.time = h.to_s2 + minute_str + second_str
+      self.time = ZTime.format_time(h, min_str, sec_str)
       self
     end
-    
+
     def change_minute_to(m)
-      self.time = hour_str + m.to_s2 + second_str
+      self.time = ZTime.format_time(hour_str, m, sec_str)
       self
     end
-    
+
     def change_second_to(s)
-      self.time = hour_str + minute_str + s.to_s2
+      self.time = ZTime.format_time(hour_str, min_str, s)
       self
     end
 
     def readable
       @time[0..1] + ":" + @time[2..3] + ":" + @time[4..5]
     end
-    
+
     def readable_12hr
-      hour_on_12hr_clock.to_s2 + ":" + @time[2..3] + " #{am_pm}"
+      hour_on_12hr_clock + ":" + @time[2..3] + " #{am_pm}"
     end
-    
+
     def hour_on_12hr_clock
-      h = hour % 12 
+      h = hour % 12
       h += 12 if h == 0
       h
     end
-    
+
     def is_am?
       hour < 12   # 0 through 11 on 24hr clock
     end
-    
+
     def am_pm
       is_am? ? "am" : "pm"
     end
-    
 
-    def <(t2)
-      (self.hour < t2.hour) || (self.hour == t2.hour && (self.minute < t2.minute || (self.minute == t2.minute && self.second < t2.second)))
-    end
-    
-    def <=(t2)
-      (self.hour < t2.hour) || (self.hour == t2.hour && (self.minute < t2.minute || (self.minute == t2.minute && self.second <= t2.second)))
-    end
-    
-    def >(t2)
-      (self.hour > t2.hour) || (self.hour == t2.hour && (self.minute > t2.minute || (self.minute == t2.minute && self.second > t2.second)))
-    end
-    
-    def >=(t2)
-      (self.hour > t2.hour) || (self.hour == t2.hour && (self.minute > t2.minute || (self.minute == t2.minute && self.second >= t2.second)))
+
+    def before(t2)
+      (t2.respond_to? :hour) && (hour < t2.hour) ||
+        (t2.respond_to? :min) && (hour == t2.hour && (min < t2.min ||
+          (t2.respond_to? :sec) && (min == t2.min && sec < t2.sec)))
     end
-    
-    def ==(t2)
-      self.hour == t2.hour && self.minute == t2.minute && self.second == t2.second
+
+    def after(t2)
+      (t2.respond_to? :hour) && (hour > t2.hour) ||
+        (t2.respond_to? :min) && (hour == t2.hour && (min > t2.min ||
+          (t2.respond_to? :sec) && (min == t2.min && sec > t2.sec)))
     end
-    
+
     def <=>(t2)
-      if self < t2
+      if before(t2)
         -1
-      elsif self > t2
+      elsif after(t2)
         1
       else
         0
       end
     end
-    
+
+    def to_s
+      time
+    end
+
+    def to_time
+      Time.parse("#{hour}:#{min}:#{sec}")
+    end
+
     class << self
 
       # send an array of ZTime objects, this will make a guess at whether they should be am/pm if the user did not specify
@@ -154,7 +178,7 @@ module Nickel
         # find firm time indices
         firm_time_indices = []
         time_array.each_with_index {|t,i| firm_time_indices << i if t.firm}
-        
+
         if firm_time_indices.empty?
           # pure guess
           # DO WE REALLY WANT TO DO THIS?
@@ -170,7 +194,7 @@ module Nickel
           (min_boundary...max_boundary).to_a.reverse.each do |i|      # this says, iterate backwards starting from max_boundary, but not including it, until the min boundary
             time_array[i].modify_such_that_is_before(time_array[i+1])
           end
-          
+
           firm_time_indices.each_index do |j|
             # now handle all times after first firm time until the next firm time
             min_boundary = firm_time_indices[j]
@@ -186,10 +210,66 @@ module Nickel
         # note 12am is 00
         h % 12
       end
-      
+
       def pm_to_24hr(h)
         h == 12 ? 12 : h + 12
       end
+
+      def format_hour(h)
+        h.to_s.rjust(2, '0')
+      end
+
+      def format_minute(m)
+        m.to_s.rjust(2, '0')
+      end
+
+      def format_second(s)
+        s.to_s.rjust(2, '0')
+      end
+
+      # formats the hours, minutes and seconds into the format expected by the ZTime constructor
+      def format_time(hours, minutes=0, seconds=0)
+        format_hour(hours) + format_minute(minutes) + format_second(seconds)
+      end
+
+      # Interpret Time is an important one, set some goals:
+      #     match all of the following
+      #     a.) 5,   12,   530,    1230,     2000
+      #     b.) 5pm, 12pm, 530am,  1230am,
+      #     c.)            5:30,   12:30,    20:00
+      #     d.)            5:3,    12:3,     20:3    ...  that's not needed but we supported it in version 1, this would be 5:30 and 12:30
+      #     e.)            5:30am, 12:30am
+      #     20:00am, 20:00pm ... ZTime will flag these as invalid, so it is ok if we match them here
+      def interpret(str)
+        a_b   = /^(\d{1,4})(am|pm)?$/                     # handles cases (a) and (b)
+        c_d_e = /^(\d{1,2}):(\d{1,2})(am|pm)?$/           # handles cases (c), (d), and (e)
+        if mdata = str.match(a_b)
+          am_pm = mdata[2]
+          # this may look a bit confusing, but all we are doing is interpreting
+          # what the user meant based on the number of digits they provided
+          if mdata[1].length <= 2
+            # e.g. "11" means 11:00
+            hstr = mdata[1]
+            mstr = "0"
+          elsif mdata[1].length == 3
+            # e.g. "530" means 5:30
+            hstr = mdata[1][0..0]
+            mstr = mdata[1][1..2]
+          elsif mdata[1].length == 4
+            # e.g. "1215" means 12:15
+            hstr = mdata[1][0..1]
+            mstr = mdata[1][2..3]
+          end
+        elsif mdata = str.match(c_d_e)
+          am_pm = mdata[3]
+          hstr = mdata[1]
+          mstr = mdata[2]
+        else
+          return nil
+        end
+        # in this case we do not care if time fails validation, if it does, it just means we haven't found a valid time, return nil
+        begin ZTime.new(ZTime.format_time(hstr, mstr), am_pm) rescue return nil end
+      end
     end
 
     # this can very easily be cleaned up
@@ -198,7 +278,7 @@ module Nickel
       raise "ZTime#modify_such_that_is_before says: time2 does not have @firm set" if !time2.firm
       # self cannot have @firm set, so all hours will be between 1 and 12
       # time2 is an end time, self could be its current setting, or off by 12 hours
-      
+
       # self to time2 --> self to time2
       # 12   to 2am   --> 1200 to 0200
       # 12   to 12am  --> 1200 to 0000
@@ -211,7 +291,7 @@ module Nickel
           self.hour == 12 ? change_hour_to(0) : change_hour_to(self.hour + 12)
         end
       elsif self < time2
-        if time2.hour >= 12 && ZTime.new((time2.hour - 12).to_s2 + time2.minute_str + time2.second_str) > self
+        if time2.hour >= 12 && ZTime.new(ZTime.format_time(time2.hour - 12, time2.min_str, time2.sec_str)) > self
           # 4 to 5pm  or 0400 to 1700
           change_hour_to(self.hour + 12)
         else
@@ -225,7 +305,7 @@ module Nickel
       self.firm = true
       self
     end
-    
+
     def modify_such_that_is_after(time1)
       raise "ZTime#modify_such_that_is_after says: trying to modify time that has @firm set" if @firm
       raise "ZTime#modify_such_that_is_after says: time1 does not have @firm set" if !time1.firm
@@ -237,14 +317,14 @@ module Nickel
       # 930am  to 5 --->  0930 to 0500
       # 930pm  to 5 --->  2130 to 0500
       if self < time1
-        unless time1.hour >= 12 && ZTime.new((time1.hour - 12).to_s2 + time1.minute_str + time1.second_str) >= self
+        unless time1.hour >= 12 && ZTime.new(ZTime.format_time(time1.hour - 12, time1.min_str, time1.sec_str)) >= self
           self.hour == 12 ? change_hour_to(0) : change_hour_to(self.hour + 12)
         end
       elsif self > time1
         # # time1 to self --> time1 to self
         # # 10am  to 11   --> 1000  to 1100
-        # # 
-        # if time1.hour >= 12 && ZTime.new((time1.hour - 12).to_s2 + time1.minute_str + time1.second_str) > self
+        # #
+        # if time1.hour >= 12 && ZTime.new(ZTime.format_time(time1.hour - 12, time1.min_str, time1.sec_str)) > self
         #   change_hour_to(self.hour + 12)
         # else
         #   # do nothing
@@ -269,9 +349,9 @@ module Nickel
         self.hour == 12 ? change_hour_to(0) : change_hour_to(self.hour + 12)
       end
     end
-    
+
     private
-    
+
     def adjust_for(am_pm)
       # how does validation work?  Well, we already know that @time is valid, and once we modify we call time= which will
       # perform validation on the new time.  That won't catch something like this though:  ZTime.new("2215", :am)
@@ -287,27 +367,27 @@ module Nickel
       end
       @firm = true
     end
-    
+
     def validate
       raise "ZTime#validate says: invalid time" unless valid
     end
-    
+
     def valid
       @time.length == 6 && @time !~ /\D/ && valid_hour && valid_minute && valid_second
     end
-    
+
     def valid_hour
       hour >= 0 and hour < 24
     end
-    
+
     def valid_minute
-      minute >= 0 and minute < 60
+      min >= 0 and min < 60
     end
-    
+
     def valid_second
-      second >= 0 and second < 60
+      sec >= 0 and sec < 60
     end
-    
+
     def lazy(s)
       # someone isn't following directions, but we will let it slide
       s.length == 1 && s = "0#{s}0000"        # only provided h

data/nickel.gemspec

@@ -1,40 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nickel/version'
+
 Gem::Specification.new do |s|
-  s.name     = "nickel"
-  s.version  = "0.0.6"
-  s.summary  = "Natural language date, time, and message parsing."
-  s.email    = "lzell11@gmail.com"
-  s.homepage = "http://github.com/lzell/nickel"
-	s.description = "Extracts date, time, and message information from naturally worded text."
-  s.has_rdoc = true
-  s.authors  = ["Lou Zell"]
-  s.files    = 
-    [
-        "History.txt",
-        "License.txt",
-        "README.rdoc", 
-        "Rakefile",
-        "nickel.gemspec",
-        "lib/nickel.rb",
-        "lib/nickel/construct.rb",
-        "lib/nickel/construct_finder.rb",
-        "lib/nickel/construct_interpreter.rb",
-        "lib/nickel/instance_from_hash.rb",
-        "lib/nickel/nlp.rb",
-        "lib/nickel/occurrence.rb",
-        "lib/nickel/query.rb",
-        "lib/nickel/query_constants.rb",
-        "lib/nickel/zdate.rb",
-        "lib/nickel/ztime.rb",
-        "lib/nickel/ruby_ext/calling_method.rb",
-        "lib/nickel/ruby_ext/to_s2.rb",
-        "test/compare.rb",
-        "test/nlp_test.rb",
-        "test/nlp_tests_helper.rb",
-        "test/zdate_test.rb",
-        "test/ztime_test.rb",
-        "spec/nickel_spec.rb"
-    ]
-  s.require_paths = ["lib"]
-  s.rdoc_options = ["--main", "README.rdoc", "--title", "Nickel"]
-  s.extra_rdoc_files = ["README.rdoc"]
+  s.name               = "nickel"
+  s.version            = Nickel::VERSION
+  s.summary            = "Natural language date, time, and message parsing."
+  s.homepage           = "http://github.com/iainbeeston/nickel"
+  s.description        = "Extracts date, time, and message information from naturally worded text."
+  s.has_rdoc           = true
+  s.license            = "MIT"
+  s.authors            = ["Lou Zell", "Iain Beeston"]
+
+  s.files              = `git ls-files`.split($/)
+  s.test_files         = s.files.grep(%r{^(test|spec)/})
+  s.require_paths      = ["lib"]
+
+  if RUBY_ENGINE == 'rbx'
+    s.add_dependency 'rubysl-date'
+    s.add_dependency 'rubysl-time'
+    s.add_development_dependency 'rubysl-rake'
+    s.add_development_dependency 'rubysl-bundler'
+  end
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "3.0.0.beta2"
+  s.add_development_dependency "coveralls"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "kramdown"
 end