minute 0.1 → 0.2

data/README.md

@@ -1,4 +1,89 @@
 Minute
 ======
 
-Natural Language Date/Time parsing library for Ruby
+Flexible Natural Language Date/Time parsing library for Ruby (1.9.x)
+
+## Feature
+
+* Flexible Natural Language parsing
+* Source code is small, readable and maintainable
+* Can parse short or long sentence when date/time is included
+
+## Approach
+
+[Chronic](http://) has been an amazing gem, but I learned its limitation. It cannot parse long sentence or it will give you `nil` as a resultant value. Chronic's code design is difficult to maintain. 
+
+I was thinking what if I can create a simple Ruby library with the same approach, but more flexible and more features. Thus, Minute was created to address this problem.
+
+Examples:
+
+```ruby
+
+Chronic.parse("I have to meet my friend on December 13 in Dallas, TX")
+#=> nil
+
+Minute.parse("I have to meet my friend on December 13 in Dallas, TX")
+#=> 2012-12-13 00:00:00 -0600
+
+```
+
+
+## Installation
+
+**Gemfile**
+
+	gem 'minute'
+	
+**RubyGem**
+
+	gem install minute
+	
+## Usage
+
+
+```ruby
+
+require 'minute'
+
+Minute.parse("Hi! I am Ruby. I was born on Feb 24 1993. My father taught me to make programmers happy.")
+#=> 1993-02-24 00:00:00 -0600
+
+Minute.parse("Birthday party is tomorrow night!", now: Time.now)
+#=> => 2012-05-01 11:20:48 -0500
+
+```
+
+
+## Speed
+
+Minute is using `String#index?` or Regular Expression to recognize the date or time. `String#index?` is using [Rabin-Karp String Search algorithm](http://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_string_search_algorithm), which it is making the search faster.
+
+	                           user     system      total        real
+	minute                12.750000   0.080000  12.830000 ( 12.833267)
+	chronic               97.860000   0.130000  97.990000 ( 97.983466)
+
+
+## TODO
+
+Minute is still young. Some features are being added soon. 
+
+Planned to add the following:
+
+* This december
+* Last Janurary
+* between 8am and 5pm
+* between Jan and July
+* every weekend
+* this morning
+* tonight
+* and more..
+
+## Contribution
+
+If you discover bugs or want to help or improve it, Pull Requests are welcome. 
+
+Ensure that your Pull request is using a topic branch for patching, improving, refactoring, etc.
+
+## License
+
+Minute is licensed under the MIT License.

data/lib/minute.rb

@@ -1,101 +1,105 @@
+require 'small'
+# Public: Minute is a natural language Date/Time parsing for Ruby Library
+#
+# Examples:
+#
+#   require 'minute'
+#
+#   Minute.parse("Hi I am Ruby I was born on Feb 24, 1993.")
+#
+#   Minute.parse("I came back from May 13, 2025", now: (Time.now + 23.years))
+#
 class Minute
 
   VERSION = "0.1"
 
-  def self.add_unit(name, value)
-    class_eval("def self.#{name}; #{value} end", __FILE__, __LINE__ + 1)
-  end
+  MONTHS = Date::MONTHNAMES.zip(Date::ABBR_MONTHNAMES).flatten.compact.map(&:downcase).freeze
 
-  def self.rule(options = {})
-    rules.merge! options
-  end
+  DATE_WITH_ORDINAL   = /(\d{1,2})(st|nd|rd|th)?\s+(#{MONTHS.join("|")})(\s+\d{4})?/
+  ENGLISH_DATE        = /(#{MONTHS.join("|")}),?\s(\d{1,2})(\s+\d{4})?/
+  DATE                = /(\d{1,4})-?(\d{1,4})-?(\d{1,4})?/
 
-  def self.rules
-    @rules ||= {}
+  # Public: Create a match pattern to capture date/time strings.
+  #
+  # Examples:
+  #
+  #   match "tomorrow", lambda {|time| time + 1.day}
+  #
+  #   match "yesterday" do |time|
+  #     time - 1.day
+  #   end
+  #
+  # Returns Hash of match patterns.
+  def self.match(pattern, block = nil, &blk)
+    patterns.merge!({pattern => (block ? block : blk)})
   end
 
+  # Public: parse the String to capture Date/Time
+  #
+  # Examples:
+  #
+  #   Minute.parse("tomorrow")
+  #
+  # Returns an instance of Time
   def self.parse(text, options = {})
     obj = new(options)
-    obj.parse_string(text)
+    obj.parse_string(text.to_s.downcase.strip)
+  end
+
+  def self.patterns
+    @patterns ||= {}
   end
 
+  attr_reader :now, :current_time
+
   def initialize(options = {})
-    @time         = options[:now] || Time.now
-    @current_time = @time
+    @now          = options[:now] || Time.now
+    @current_time = @now
   end
 
   def parse_string(text)
-    rules.keys.each do |key|
-      if key.is_a?(Regexp) && text =~ key
-        @current_time = rules[key].call(@time, Regexp.last_match)
-      elsif key.is_a?(String) && text.include?(key)
-        @current_time = rules[key].call(@time)
+    patterns.keys.each do |pattern|
+      begin
+        if pattern.is_a?(Regexp) && text =~ pattern
+          @now = patterns[pattern].call(current_time, Regexp.last_match)
+        elsif pattern.is_a?(String) && text.include?(pattern)
+          @now = patterns[pattern].call(current_time)
+        end
+      rescue
+        @now
       end
     end
-    current_time
+    @now
   end
 
-  def rules
-    @rules ||= self.class.rules
+  def patterns
+    @patterns ||= self.class.patterns
   end
 
-  def to_date(time = nil)
-    time ||= @current_time
-    Date.new(time.year, time.month, time.day)
-  end
-
-  def current_time
-    @current_time
+  match 'tomorrow',     lambda {|time| time + 1.day }
+  match 'yesterday',    lambda {|time| time - 1.day }
+  match 'today',        lambda {|time| time }
+
+  match /(last|next|\d+)\s+(year|month|week|day|hour|minute|second)s?(\s+ago)?/ do |time, m|
+    case m[1]
+    when "next" then time + 1.send(m[2].to_sym)
+    when "last" then time - 1.send(m[2].to_sym)
+    when /\d+/
+      if !m[3].nil?
+        time - m[1].to_i.send(m[2].to_sym)
+      else
+        time + m[1].to_i.send(m[2].to_sym)
+      end
+    end
   end
 
-  add_unit 'year',     31536000
-  add_unit 'month',    3600 * 24 * 30
-  add_unit 'week',     3600 * 24 * 7
-  add_unit 'day',      3600 * 24
-  add_unit 'hour',     3600
-  add_unit 'minute',   60
-  add_unit 'second',   1
-
-  rule 'tomorrow'     => lambda {|time| time + day }
-  rule 'yesterday'    => lambda {|time| time - day }
-  rule 'today'        => lambda {|time| time }
-
-  rule 'next year'    => lambda {|time| time + year }
-  rule 'next month'   => lambda {|time| time + month }
-  rule 'next week'    => lambda {|time| time + week }
-  rule 'next day'     => lambda {|time| time + day }
-  rule 'next hour'    => lambda {|time| time + hour }
-  rule 'next minute'  => lambda {|time| time + minute }
-  rule 'next second'  => lambda {|time| time + second }
-
-  rule 'last year'    => lambda {|time| time - year }
-  rule 'last month'   => lambda {|time| time - month }
-  rule 'last week'    => lambda {|time| time - week }
-  rule 'last day'     => lambda {|time| time - day }
-  rule 'last hour'    => lambda {|time| time - hour }
-  rule 'last minute'  => lambda {|time| time - minute }
-  rule 'last second'  => lambda {|time| time - second }
-
-  rule /(\d+) years?/       => lambda {|time, m| time + (m[1].to_i * year) }
-  rule /(\d+) years? ago/   => lambda {|time, m| time - (m[1].to_i * year) }
-  rule /(\d+) months?/      => lambda {|time, m| time + (m[1].to_i * month) }
-  rule /(\d+) months? ago/  => lambda {|time, m| time - (m[1].to_i * month) }
-  rule /(\d+) weeks?/       => lambda {|time, m| time + (m[1].to_i * week) }
-  rule /(\d+) weeks? ago/   => lambda {|time, m| time - (m[1].to_i * week) }
-  rule /(\d+) days?/        => lambda {|time, m| time + (m[1].to_i * day) }
-  rule /(\d+) days? ago/    => lambda {|time, m| time - (m[1].to_i * day) }
-  rule /(\d+) hours?/       => lambda {|time, m| time + (m[1].to_i * hour) }
-  rule /(\d+) hours? ago/   => lambda {|time, m| time - (m[1].to_i * hour) }
-  rule /(\d+) minutes?/     => lambda {|time, m| time + (m[1].to_i * minute) }
-  rule /(\d+) minutes? ago/ => lambda {|time, m| time - (m[1].to_i * minute) }
-  rule /(\d+) seconds?/     => lambda {|time, m| time + (m[1].to_i * second) }
-  rule /(\d+) seconds? ago/ => lambda {|time, m| time - (m[1].to_i * second) }
+  match DATE,               lambda {|time, m| Time.parse(m[1..-1].compact.join("-")) }
+  match ENGLISH_DATE,       lambda {|time, m| Time.parse(m[1..-1].compact.join(" ")) }
+  match DATE_WITH_ORDINAL,  lambda {|time, m| Time.parse(m[1..-1].compact.join(" ")) }
 
   # TODO
   # this december
   # last december
-  # 13 dec 2010
-  # dec 13 2010
   # next jan 13
   # every wed
   # this morning

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minute
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-23 00:00:00.000000000 Z
-dependencies: []
+date: 2012-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: small
+  requirement: &70134369380160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70134369380160
 description: 
 email: bryann83@gmail.com
 executables: []
@@ -39,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Natural Language Date/Time parsing library for Ruby