midnight 0.0.1.pre

data/lib/midnight/repeater.rb

@@ -0,0 +1,153 @@
+class Midnight::Repeater < Chronic::Tag #:nodoc:
+  #
+  def self.scan(tokens)
+    # for each token
+    tokens.each do |token|
+      token = self.scan_for_24h_times(token)
+      token = self.scan_for_numbers(token)
+      token = self.scan_for_month_names(token)
+      token = self.scan_for_day_names(token)
+      token = self.scan_for_special_text(token)
+      token = self.scan_for_units(token)
+    end
+
+    tokens = self.split_time_tokens(tokens)
+    tokens
+  end
+
+  def self.scan_for_numbers(token)
+    num = Float(token.word) rescue nil
+    token.update(:number, nil, num.to_i) if num
+    token
+  end
+
+  def self.scan_for_24h_times(token)
+    if token.word =~ /(2[0-3]|[01]?[0-9]):([0-5]?[0-9])/
+      token.update(:time, nil, nil)
+    end
+    token
+  end
+
+  def self.scan_for_month_names(token)
+    scanner = {
+      /^jan\.?(uary)?$/ => :january,
+      /^feb\.?(ruary)?$/ => :february,
+      /^mar\.?(ch)?$/ => :march,
+      /^apr\.?(il)?$/ => :april,
+      /^may$/ => :may,
+      /^jun\.?e?$/ => :june,
+      /^jul\.?y?$/ => :july,
+      /^aug\.?(ust)?$/ => :august,
+      /^sep\.?(t\.?|tember)?$/ => :september,
+      /^oct\.?(ober)?$/ => :october,
+      /^nov\.?(ember)?$/ => :november,
+    /^dec\.?(ember)?$/ => :december}
+
+    month_sequence = {
+      :january => 1,
+      :february => 2,
+      :march => 3,
+      :april => 4,
+      :may => 5,
+      :june => 6,
+      :july => 7,
+      :august => 8,
+      :september => 9,
+      :october => 10,
+      :november => 11, 
+      :december => 12
+    }
+
+    scanner.each do |scanner_item, month|
+      position_in_sequence = month_sequence[month]
+      token.update(:month_name, scanner[scanner_item], 30, position_in_sequence) if scanner_item =~ token.word
+    end
+    token
+  end
+
+  def self.scan_for_day_names(token)
+    scanner = {
+      /^su[nm](day)?s?$/ => :sunday,
+      /^m[ou]n(day)?s?$/ => :monday,
+      /^t(ue|eu|oo|u|)s(day)?s?$/ => :tuesday,
+      /^tue$/ => :tuesday,
+      /^we(dnes|nds|nns)day?s?$/ => :wednesday,
+      /^wed$/ => :wednesday,
+      /^th(urs|ers)day?s?$/ => :thursday,
+      /^thu$/ => :thursday,
+      /^fr[iy](day)?s?$/ => :friday,
+      /^sat(t?[ue]rday)?s?$/ => :saturday
+    }
+
+    day_sequence = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    scanner.each do |scanner_item, day|
+      position_in_sequence = day_sequence[day]
+      token.update(:weekday, scanner[scanner_item], 7, position_in_sequence) if scanner_item =~ token.word
+    end
+    token
+  end
+
+  def self.scan_for_special_text(token)
+    scanner = {
+      /^other$/ => :other,
+      /^begin(ing|ning)?$/ => :beginning,
+      /^start$/ => :beginning,
+      /^end$/ => :end,
+      /^mid(d)?le$/ => :middle}
+    scanner.keys.each do |scanner_item|
+      token.update(:special, scanner[scanner_item], 7) if scanner_item =~ token.word
+    end
+    token
+  end
+
+  def self.scan_for_units(token)
+    scanner = {
+      /^year(ly)?s?|annually$/ => {:type => :year, :interval => 365, :start => :today},
+      /^month(ly)?s?$/ => {:type => :month, :interval => 30, :start => :today},
+      /^fortnights?$/ => {:type => :fortnight, :interval => 365, :start => :today},
+      /^week(ly)?s?$/ => {:type => :week, :interval => 7, :start => :today},
+      /^weekends?$/ => {:type => :weekend, :interval => 7, :start => :saturday},
+      /^days?$/ => {:type => :day, :interval => 1, :start => :today},
+      /^daily?$/ => {:type => :day, :interval => 1, :start => :today},
+      /^minutes?$/ => {:type => :minute_word, :start => :today},
+      /^hour(ly)?s?$/ => {:type => :hour, :start => :today},
+      /^am|pm$/ => {:type => :meridiem}
+    }
+    scanner.keys.each do |scanner_item|
+      if scanner_item =~ token.word
+        token.update(scanner[scanner_item][:type], scanner[scanner_item][:start], scanner[scanner_item][:interval]) if scanner_item =~ token.word
+      end
+    end
+    token
+  end
+
+  # Split time tokens into constituent hour and minute tokens
+  def self.split_time_tokens(tokens)
+    tokens_output = []
+    tokens.each do |token|
+      if (token.type == :time)
+        time_parts = token.word.split(':')
+        hour_token = Midnight::Token.new(time_parts[0].to_i)
+        minute_token = Midnight::Token.new(time_parts[1].to_i)
+        hour_token.update(:hour)
+        minute_token.update(:minute)
+        tokens_output << hour_token
+        tokens_output << minute_token
+      else
+        tokens_output << token
+      end
+    end
+
+    tokens_output
+  end
+
+end

data/lib/midnight/version.rb

@@ -0,0 +1,3 @@
+module Midnight
+  VERSION = '0.0.1.pre'
+end

data/lib/numerizer/numerizer.rb

@@ -0,0 +1,103 @@
+require 'strscan'
+
+class Numerizer
+
+  DIRECT_NUMS = [
+                  ['eleven', '11'],
+                  ['twelve', '12'],
+                  ['thirteen', '13'],
+                  ['fourteen', '14'],
+                  ['fifteen', '15'],
+                  ['sixteen', '16'],
+                  ['seventeen', '17'],
+                  ['eighteen', '18'],
+                  ['nineteen', '19'],
+                  ['ninteen', '19'], # Common mis-spelling
+                  ['zero', '0'],
+                  ['one', '1'],
+                  ['two', '2'],
+                  ['three', '3'],
+                  ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
+                  ['five', '5'],
+                  ['six(\W|$)', '6\1'],
+                  ['seven(\W|$)', '7\1'],
+                  ['eight(\W|$)', '8\1'],
+                  ['nine(\W|$)', '9\1'],
+                  ['ten', '10'],
+                  ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
+                ]
+
+  TEN_PREFIXES = [ ['twenty', 20],
+                    ['thirty', 30],
+                    ['fourty', 40],
+                    ['fifty', 50],
+                    ['sixty', 60],
+                    ['seventy', 70],
+                    ['eighty', 80],
+                    ['ninety', 90]
+                  ]
+
+  BIG_PREFIXES = [ ['hundred', 100],
+                    ['thousand', 1000],
+                    ['million', 1_000_000],
+                    ['billion', 1_000_000_000],
+                    ['trillion', 1_000_000_000_000],
+                  ]
+
+class << self
+  def numerize(string)
+    string = string.dup
+  
+    # preprocess
+    string.gsub!(/ +|([^\d])-([^d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
+    string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
+
+    # easy/direct replacements
+  
+    DIRECT_NUMS.each do |dn|
+      string.gsub!(/#{dn[0]}/i, dn[1])
+    end
+
+    # ten, twenty, etc.
+
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/(?:#{tp[0]})( *\d(?=[^\d]|$))*/i) { (tp[1] + $1.to_i).to_s }
+    end
+
+    # hundreds, thousands, millions, etc.
+
+    BIG_PREFIXES.each do |bp|
+      string.gsub!(/(\d*) *#{bp[0]}/i) { (bp[1] * $1.to_i).to_s}
+      andition(string)
+      #combine_numbers(string) # Should to be more efficient way to do this
+    end
+
+    # fractional addition
+    # I'm not combining this with the previous block as using float addition complicates the strings
+    # (with extraneous .0's and such )
+    string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
+
+    string
+  end
+
+private
+  def andition(string)
+    sc = StringScanner.new(string)
+    while(sc.scan_until(/(\d+)( | and )(\d+)(?=[^\w]|$)/i))
+      if sc[2] =~ /and/ || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[3].to_i).to_s
+        sc.reset
+      end
+    end
+  end
+
+#  def combine_numbers(string)
+#    sc = StringScanner.new(string)
+#    while(sc.scan_until(/(\d+)(?: | and |-)(\d+)(?=[^\w]|$)/i))
+#      string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[2].to_i).to_s
+#      sc.reset
+#    end
+#  end
+
+end
+end

data/midnight.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'midnight/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "midnight"
+  spec.version       = Midnight::VERSION
+  spec.authors       = ["bluefuton"]
+  spec.email         = ["chris@bluefuton.com"]
+  spec.summary       = %q{Parse natural language date/time into a cron expression}
+  spec.description   = ''
+  spec.homepage      = 'https://github.com/bluefuton/midnight'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", '~> 0'
+  spec.add_dependency 'chronic', '=0.10.2'
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'midnight')
+
+class Test::Unit::TestCase
+end

data/test/test_cron_expression.rb

@@ -0,0 +1,18 @@
+require 'helper'
+require 'time'
+require 'test/unit'
+require './lib/midnight/cron_expression'
+
+class TestParsing < Test::Unit::TestCase
+
+  def setup
+
+  end
+
+  def test_cron_expression
+    cron = Midnight::CronExpression.new
+    cron.minute = 30
+    assert_equal '30 * * * *', cron.to_s
+    assert_equal 30, cron.minute
+  end
+end

data/test/test_parsing.rb

@@ -0,0 +1,68 @@
+require 'helper'
+require 'time'
+require 'test/unit'
+
+class TestParsing < Test::Unit::TestCase
+
+  def test_parse
+    expected_results = {
+      'each day' =>  '0 0 * * *',
+      'every day' =>  '0 0 * * *',
+      'daily' => '0 0 * * *',
+      'every day at 3am' => '0 3 * * *',
+      'daily at 5am' => '0 5 * * *',
+      'every week' => '0 0 * * 0',
+      'weekly' => '0 0 * * 0',
+      'every minute' => '* * * * *',
+      'every 5 minutes' => '*/5 * * * *',
+      'every 30 minutes' => '*/30 * * * *',
+      'every month' => '0 0 1 * *',
+      'monthly' => '0 0 1 * *',
+      'every Monday' => '0 0 * * 1',
+      'every Wednesday' => '0 0 * * 3',
+      'every Friday' => '0 0 * * 5',
+      'this one should not return a result' => nil,
+      'every hour' => '0 * * * *',
+      'every 6 hours' => '0 */6 * * *',
+      'hourly' => '0 * * * *',
+      'every year' => '0 0 1 1 *',
+      'yearly' => '0 0 1 1 *',
+      'annually' => '0 0 1 1 *',
+      'every day at 9am' => '0 9 * * *',
+      'every day at 5pm' => '0 17 * * *',
+      'every day at 5:45pm' => '45 17 * * *',      
+      'every day at 17:00' => '0 17 * * *',
+      'every day at 17:25' => '25 17 * * *',
+      '5:15am every Tuesday' => '15 5 * * 2',
+      '7pm every Thursday' => '0 19 * * 4',
+      'every May' => '0 0 1 5 *',
+      'every December' => '0 0 1 12 *',
+      'midnight' => '0 0 * * *',
+      'midnight on tuesdays' => '0 0 * * 2',
+      'every 5 minutes on Tuesdays' => '*/5 * * * 2',
+      'every other day' => nil, # other is currently unsupported
+      'noon' => '0 12 * * *'
+    }
+
+    expected_results.each do |search,cron_string|
+      assert_equal(cron_string, Midnight.parse(search).to_s, search)
+    end
+  end
+
+  def test_argument_validation
+    assert_raise(Midnight::InvalidArgumentException) do
+      time = Midnight.parse("may 27", :today => 'something odd')
+    end
+
+    assert_raise(Midnight::InvalidArgumentException) do
+      time = Midnight.parse("may 27", :foo => :bar)
+    end
+  end
+
+  private
+  def parse_now(string, options={})
+    out = Midnight.parse(string, {}.merge(options))
+    puts ("Midnight.parse('#{string}')  #=> #{out}")
+    out
+  end
+end

data/todo.txt

@@ -0,0 +1,21 @@
+every 3 days
+every 3 weeks
+every 3 months
+every 3 years
+
+every other day
+every other week
+every other month
+every other year
+every other day starting May 1st
+every other week starting this Sunday
+
+the 10th of the month
+the tenth of the month
+the 3rd Sunday of the month
+out of bounds values e.g. 4:61pm
+midday - 'noon' works, so Chronic could be patched
+every 5 minutes on fridays
+multiple days "every tuesday, wednesday and friday at 5pm"
+multiple hours or minutes
+ranges of minutes

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: midnight
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- bluefuton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+description: ''
+email:
+- chris@bluefuton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- README.textile
+- Rakefile
+- lib/midnight.rb
+- lib/midnight/converter.rb
+- lib/midnight/cron_expression.rb
+- lib/midnight/handler.rb
+- lib/midnight/midnight.rb
+- lib/midnight/repeater.rb
+- lib/midnight/version.rb
+- lib/numerizer/numerizer.rb
+- midnight.gemspec
+- test/helper.rb
+- test/test_cron_expression.rb
+- test/test_parsing.rb
+- todo.txt
+homepage: https://github.com/bluefuton/midnight
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Parse natural language date/time into a cron expression
+test_files:
+- test/helper.rb
+- test/test_cron_expression.rb
+- test/test_parsing.rb
+has_rdoc: