todo_time_patterns 0.0.0

data/lib/todo_time_patterns.rb

@@ -0,0 +1,36 @@
+require_relative 'todo_time_patterns/parser'
+require_relative 'todo_time_patterns/time_patterns_finder'
+
+class TodoTimePatterns
+  def self.parse(input)
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    time_patterns_finder = TimePatterns::TimePatternsFinder.new
+    tokens_with_time_patterns = time_patterns_finder.find_and_update tokens
+
+    result = generate_result(tokens_with_time_patterns, input)
+
+    result
+  end
+
+  def self.generate_result(tokens, input)
+    time_token = tokens.find {|token| token.to_s == "{ending_form}"}
+
+    unless time_token.nil?
+      time_token = tokens.find {|token| token.to_s == "{ending_form}"}
+      to_remove = input.slice(time_token.start_index, time_token.end_index - time_token.start_index + 1)
+
+      {
+        hours: time_token.hours,
+        minutes: time_token.minutes,
+        interval: time_token.interval,
+        result_string: input.sub(to_remove, "").sub("  ", " ").strip
+      }
+    else
+      nil
+    end
+  end
+
+  private_class_method :generate_result
+end

data/lib/todo_time_patterns/helper_modules.rb

@@ -0,0 +1,7 @@
+module TimePatterns
+  module TokensStringRepresentation
+    def to_s
+      self.each_with_object("") { |token, result| result << token.to_s }  
+    end
+  end  
+end

data/lib/todo_time_patterns/parser.rb

@@ -0,0 +1,47 @@
+require_relative 'parser_helpers'
+require_relative 'tokens'
+require_relative 'helper_modules'
+
+module TimePatterns
+  class Parser
+    def initialize
+      @parser_checks = {
+        letter?: WordToken,
+        number?: NumberToken,
+        symbol?: SymbToken,
+        unknown?: UnknownToken
+      }
+    end
+
+    def parse(input)
+
+      i = 0
+      buffer = ""
+      tokens = []
+
+      while input[i]
+        break if input[i] == nil
+
+        while input[i] == " "
+          i += 1
+        end
+
+        @parser_checks.each do |check_method, check_class|
+          token_start_index = i
+          while input[i] != nil and input[i] != " " and input[i].send check_method
+            buffer << input[i]
+            i += 1
+          end
+
+          unless buffer.empty?
+            tokens << (check_class.new buffer, token_start_index)
+            buffer = ""
+          end
+        end
+      end
+
+      tokens.extend(TokensStringRepresentation)
+      tokens
+    end
+  end
+end

data/lib/todo_time_patterns/parser_helpers.rb

@@ -0,0 +1,17 @@
+class String
+  def letter?
+    ('a'..'z').include?(self) or ('A'..'Z').include?(self)
+  end
+
+  def number?
+    true if Integer(self) rescue false
+  end
+
+  def symbol?
+    [':', '#'].include?(self)
+  end
+
+  def unknown?
+    not letter? and not number?
+  end
+end

data/lib/todo_time_patterns/time_patterns.rb

@@ -0,0 +1,148 @@
+require_relative 'helper_modules'
+
+module TimePatterns
+  class TimePattern
+    def initialize(pattern_array, token_class)
+      @pattern = pattern_array.join
+      @number_of_pattern_tokens = pattern_array.length
+      @token_class = token_class
+    end
+
+    def find_and_update(tokens)
+      return tokens unless tokens.to_s.include? @pattern
+
+      tokens_clone = tokens.clone
+      tokens.each_cons(@number_of_pattern_tokens) do |tokens_set|
+        break unless tokens_set.length == @number_of_pattern_tokens
+
+        tokens_set.extend(TokensStringRepresentation)
+
+        if tokens_set.to_s == @pattern
+          next unless valid? tokens_set
+
+          time_token = @token_class.new tokens_set
+          substitute_tokens tokens_set, time_token, tokens_clone
+        end
+      end
+
+      tokens_clone
+    end
+
+    private
+    def substitute_tokens(old, new, tokens)
+      index = tokens.index old[0]
+      tokens.delete_if {|token| old.include? token}
+      tokens.insert index, new
+    end
+  end
+
+  class TimeWithModifierPattern < TimePattern
+    def initialize
+      super(%w[{number} {word}], TimeToken)
+    end
+
+    def valid?(tokens_pair)
+      hour, modifier = tokens_pair.map { |token| token.value }
+      (0..12).include?(hour) and ["am", "pm"].include?(modifier) and not
+        (hour == 0 and modifier == "pm")
+    end
+  end
+
+  class ClassicTimePattern < TimePattern
+    def initialize
+      super(%w[{number} {symbol} {number}], TimeToken)
+    end
+
+    def valid?(tokens_triplet)
+      hour, colon, minutes = tokens_triplet.map { |token| token.value }
+      (0..23).include?(hour) and (0..59).include?(minutes) and colon == ":"
+    end
+  end
+
+  class ClassicTimeWithModifierPattern < TimePattern
+    def initialize
+      super(%w[{number} {symbol} {number} {word}], TimeToken)
+    end
+
+    def valid?(tokens_quadruple)
+      hour, colon, minutes, modifier = tokens_quadruple.map { |token| token.value }
+      (0..12).include?(hour) and (0..59).include?(minutes) and colon == ":" and ["am", "pm"].include?(modifier)
+    end
+  end
+
+  class ComplexIntervalPattern < TimePattern
+    def initialize
+      super(%w[{number} {word} {number} {word}], IntervalToken)
+    end
+
+    def valid?(tokens_quadruple)
+      tokens = tokens_quadruple.each_slice(2).to_a
+      interval_pair_valid?(tokens[0], true) and interval_pair_valid?(tokens[1], false)
+    end
+
+    private
+    def interval_pair_valid?(tokens_pair, for_hours)
+      modifier = tokens_pair[1].value
+
+      if for_hours and %w[h hour hours].include? modifier
+        hours = tokens_pair[0].value
+        (0..23).include? hours
+      elsif not for_hours and %w[m min mins minutes].include? modifier
+        minutes = tokens_pair[0].value
+        (0..59).include? minutes
+      else
+        false
+      end
+    end
+  end
+
+  class SimpleIntervalPattern < TimePattern
+    def initialize
+      super(%w[{number} {word}], IntervalToken)
+    end
+
+    def valid?(tokens_pair)
+      modifier = tokens_pair[1].value
+
+      if %w[h hour hours].include? modifier
+        hours = tokens_pair[0].value
+        (0..23).include? hours
+      elsif %w[m min mins minutes].include? modifier
+        minutes = tokens_pair[0].value
+        (0..59).include? minutes
+      else
+        false    
+      end
+    end
+  end
+
+  class TimeEndingPattern < TimePattern
+    def initialize
+      super(%w[{word} {time}], TimeEndingToken)
+    end
+
+    def valid?(tokens_pair)
+      tokens_pair.first.value == "at"
+    end
+  end
+
+  class IntervalEndingPattern < TimePattern
+    def initialize
+      super(%w[{word} {time} {word} {interval}], IntervalEndingToken)
+    end
+
+    def valid?(tokens_quadruple)
+      tokens_quadruple[0].value == "at" and tokens_quadruple[2].value == "for"
+    end
+  end
+
+  class IntervalTimeEndingPattern < TimePattern
+    def initialize
+      super(%w[{word} {time} {word} {time}], IntervalTimeEndingToken)
+    end
+
+    def valid?(tokens_quadruple)
+      tokens_quadruple[0].value == "from" and tokens_quadruple[2].value == "to"
+    end
+  end
+end

data/lib/todo_time_patterns/time_patterns_finder.rb

@@ -0,0 +1,39 @@
+require_relative 'helper_modules'
+require_relative 'tokens'
+require_relative 'time_patterns'
+
+module TimePatterns
+  class TimePatternsFinder
+    def find_and_update(tokens)
+      tokens_with_time = find_and_update_time tokens
+      tokens_with_intervals = find_and_update_intervals tokens_with_time
+      result = find_and_update_ending_forms tokens_with_intervals
+
+      result
+    end
+
+    private
+    def find_and_update_time(tokens)
+      patterns = [ClassicTimeWithModifierPattern.new, ClassicTimePattern.new, 
+        TimeWithModifierPattern.new]
+      patterns.each { |pattern| tokens = pattern.find_and_update tokens }
+
+      tokens
+    end
+
+    def find_and_update_intervals(tokens)
+      patterns = [ComplexIntervalPattern.new, SimpleIntervalPattern.new]
+      patterns.each { |pattern| tokens = pattern.find_and_update tokens }
+
+      tokens
+    end
+
+    def find_and_update_ending_forms(tokens)
+      patterns = [IntervalEndingPattern.new, IntervalTimeEndingPattern.new, 
+        TimeEndingPattern.new]
+      patterns.each { |pattern| tokens = pattern.find_and_update tokens }
+
+      tokens
+    end
+  end
+end

data/lib/todo_time_patterns/tokens.rb

@@ -0,0 +1,266 @@
+require_relative 'helper_modules'
+
+module TimePatterns
+  class WordToken
+    attr_reader :value
+    attr_reader :start_index
+
+    def initialize(value, start_index)
+      @value = value
+      @start_index = start_index
+    end
+
+    def to_s
+      "{word}"
+    end
+  end
+
+  class NumberToken
+    attr_reader :value
+    attr_reader :start_index
+
+    def initialize(value, start_index)
+      @value = Integer(value)
+      @start_index = start_index
+    end
+
+    def to_s
+      "{number}"
+    end
+  end
+
+  class SymbToken
+    attr_reader :value
+    attr_reader :start_index
+    
+    def initialize(value, start_index)
+      @value = value
+      @start_index = start_index
+    end
+
+    def to_s
+      "{symbol}"
+    end
+  end
+
+  class UnknownToken
+    attr_reader :value
+    attr_reader :start_index
+
+    def initialize(value, start_index)
+      @value = value
+      @start_index = start_index
+    end
+
+    def to_s
+      "{unknown}"
+    end
+  end
+
+  class TimeToken
+    attr_reader :start_index
+    attr_reader :end_index
+
+    attr_reader :hours
+    attr_reader :minutes
+
+    def initialize(values)
+      @values = values
+      @values.extend(TokensStringRepresentation)
+
+      set_start_and_end_indexes values
+      set_hours_and_minutes values
+    end
+
+    def to_s
+      "{time}"
+    end
+
+    private
+    def set_start_and_end_indexes(values)
+      @start_index = values.first.start_index
+      @end_index = values.last.start_index + values.last.value.to_s.length - 1
+    end
+
+    def set_hours_and_minutes(values)
+      pattern = values.join
+
+      case pattern
+      when "{number}{word}" then set_time_values(values[0].value, 0, values[1].value)
+      when "{number}{symbol}{number}" then set_time_values(values[0].value, values[2].value)
+      when "{number}{symbol}{number}{word}" then set_time_values(values[0].value, values[2].value, values[3].value)
+      end
+    end
+
+    def set_time_values(hours, minutes, modifier = "am")
+      #3pm
+      #17:00
+      #13:00pm
+
+      if modifier == "am"
+        if hours == 12
+          @hours = 0
+        else
+          @hours = hours
+        end
+      elsif modifier == "pm"
+        if hours == 12
+          @hours = 12
+        else
+          @hours = hours + 12
+        end
+      end
+
+      @minutes = minutes
+    end
+  end
+
+  class IntervalToken
+    attr_reader :start_index
+    attr_reader :end_index
+    attr_reader :minutes
+
+    def initialize(values)
+      @values = values
+      @values.extend(TokensStringRepresentation)
+
+      set_start_and_end_indexes values
+      set_minutes values
+    end
+
+    def to_s
+      "{interval}"
+    end
+
+    private
+    def set_start_and_end_indexes(values)
+      @start_index = values.first.start_index
+      @end_index = values.last.start_index + values.last.value.to_s.length - 1
+    end
+
+    def set_minutes(values)
+      #1h 30mins
+      #20mins
+      #1 hour
+
+      pattern = values.join
+
+      @minutes = 0
+      if pattern == "{number}{word}"
+        if %w[h hour hours].include? values[1].value
+          @minutes = values[0].value * 60
+        else
+          @minutes = values[0].value
+        end
+      elsif pattern == "{number}{word}{number}{word}"
+        hours = values[0].value
+        @minutes = values[2].value + hours * 60
+      end
+    end
+  end
+
+  class TimeEndingToken
+    attr_reader :start_index
+    attr_reader :end_index
+    attr_reader :hours
+    attr_reader :minutes
+    attr_reader :interval
+
+    def initialize(values)
+      @interval = 0
+      @values = values
+      @values.extend(TokensStringRepresentation)
+
+      set_start_and_end_indexes values
+      set_minutes values
+    end
+
+    def to_s
+      "{ending_form}"
+    end
+    
+    private
+    def set_start_and_end_indexes(values)
+      @start_index = values.first.start_index
+      @end_index = values.last.end_index
+    end
+
+    def set_minutes(values)
+      time = values[1]
+      @minutes = time.minutes
+      @hours = time.hours
+    end
+  end
+
+  class IntervalEndingToken
+    attr_reader :start_index
+    attr_reader :end_index
+    attr_reader :minutes
+    attr_reader :hours
+    attr_reader :interval
+
+    def initialize(values)
+      @values = values
+      @values.extend(TokensStringRepresentation)
+
+      set_start_and_end_indexes values
+      set_time_and_interval values
+    end
+
+    def set_start_and_end_indexes(values)
+      @start_index = values.first.start_index
+      @end_index = values.last.end_index
+    end
+
+    def set_time_and_interval(values)
+      time = values[1]
+      @minutes = time.minutes
+      @hours = time.hours
+
+      @interval = values[3].minutes
+    end
+
+    def to_s
+      "{ending_form}"
+    end
+  end
+
+  class IntervalTimeEndingToken
+    attr_reader :start_index
+    attr_reader :end_index
+    attr_reader :minutes
+    attr_reader :hours
+    attr_reader :interval
+
+    def initialize(values)
+      @values = values
+      @values.extend(TokensStringRepresentation)
+
+      set_start_and_end_indexes values
+      set_time_and_interval values
+    end
+
+    def set_start_and_end_indexes(values)
+      @start_index = values.first.start_index
+      @end_index = values.last.end_index
+    end
+
+    def set_time_and_interval(values)
+      first_time = values[1]
+      second_time = values[3]
+
+      first_time_minutes = first_time.hours * 60 + first_time.minutes
+      second_time_minutes = second_time.hours * 60 + second_time.minutes
+
+      raise "Second time in interval is less than the first one" if first_time_minutes > second_time_minutes
+
+      @hours = first_time.hours
+      @minutes = first_time.minutes
+      @interval = second_time_minutes - first_time_minutes
+    end
+
+    def to_s
+      "{ending_form}"
+    end
+  end
+end

data/tests/console_test.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/todo_time_patterns'
+
+pattern = ARGV[0]
+result = TodoTimePatterns.parse pattern
+puts result

data/tests/parser_tests.rb

@@ -0,0 +1,18 @@
+require 'minitest/autorun'
+
+require_relative '../lib/todo_time_patterns/parser'
+
+class ParserTests < MiniTest::Unit::TestCase
+  def test_parse_input_into_tokens
+    input = "Buy bread at 17:00"
+    expected_tokens = "{word}{word}{word}{number}{symbol}{number}"
+
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    indexes = tokens.map { |t| t.start_index }
+
+    assert_equal(expected_tokens, tokens.to_s)
+    assert_equal([0, 4, 10, 13, 15, 16], indexes)
+  end
+end

data/tests/time_patterns_finder_tests.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+
+require_relative '../lib/todo_time_patterns/parser'
+require_relative '../lib/todo_time_patterns/time_patterns_finder'
+
+class TimePatternsFinderTests < MiniTest::Unit::TestCase
+  def setup
+    @parser = TimePatterns::Parser.new
+    @patterns_finder = TimePatterns::TimePatternsFinder.new
+  end
+
+  def test_simple_form
+    input = "Meet Sergii at 4pm"
+
+    tokens = @parser.parse input
+    result = @patterns_finder.find_and_update tokens
+
+    assert_equal("{word}{word}{ending_form}", result.to_s)
+  end
+
+  def test_interval
+    input = "Meet Sergii at 4pm for 2 hours 30mins"
+
+    tokens = @parser.parse input
+    result = @patterns_finder.find_and_update tokens
+
+    assert_equal("{word}{word}{ending_form}", result.to_s)
+    assert_equal(150, result.last.interval)
+  end
+
+  def test_interval_with_time
+    input = "Meet Sergii from 4pm to 18:23"
+
+    tokens = @parser.parse input
+    result = @patterns_finder.find_and_update tokens
+
+    assert_equal("{word}{word}{ending_form}", result.to_s)
+  end
+end

data/tests/time_patterns_tests.rb

@@ -0,0 +1,200 @@
+require 'minitest/autorun'
+
+require_relative '../lib/todo_time_patterns/parser'
+require_relative '../lib/todo_time_patterns/time_patterns'
+
+class TimePatternsTests < MiniTest::Unit::TestCase
+  def setup
+    @modifiers = %w[am pm]
+    @hour_postfixes = %w[h hour hours]
+    @minute_postfixes = %w[m min mins minutes]
+    @parser = TimePatterns::Parser.new
+  end
+
+  def test_time_with_modifier_pattern
+    @modifiers.each do |modifier|
+      input = "Buy bread at 12#{modifier}"
+      tokens = @parser.parse input
+
+      pattern = TimePatterns::TimeWithModifierPattern.new
+      result = pattern.find_and_update tokens
+
+      assert_equal("{word}{word}{word}{time}", result.to_s)
+    end
+  end
+
+  def test_time_with_modifier_pattern_and_invalid_entry
+    @modifiers.each do |modifier|
+      input = "Buy bread at 17 #{modifier}"
+
+      tokens = @parser.parse input
+
+      pattern = TimePatterns::TimeWithModifierPattern.new
+      result = pattern.find_and_update tokens
+
+      assert_equal("{word}{word}{word}{number}{word}", result.to_s)
+    end
+  end
+
+  def test_classic_time_pattern
+    input = "Buy bread at 17:00"
+
+    tokens = @parser.parse input
+
+    pattern = TimePatterns::ClassicTimePattern.new
+    result = pattern.find_and_update tokens
+
+    assert_equal("{word}{word}{word}{time}", result.to_s)
+  end
+
+  def test_classic_time_pattern_and_invalid_entry
+    input = "Buy bread at 25:00"
+
+    tokens = @parser.parse input
+
+    pattern = TimePatterns::ClassicTimePattern.new
+    result = pattern.find_and_update tokens
+
+    assert_equal("{word}{word}{word}{number}{symbol}{number}", result.to_s)
+  end
+
+  def test_classic_time_with_modifier_pattern
+    @modifiers.each do |modifier|
+      input = "Buy bread at 7:10#{modifier}"
+
+      tokens = @parser.parse input
+
+      pattern = TimePatterns::ClassicTimeWithModifierPattern.new
+      result = pattern.find_and_update tokens
+
+      assert_equal("{word}{word}{word}{time}", result.to_s)  
+    end
+  end
+
+  def test_classic_time_with_modifier_pattern_and_invalid_entry
+    @modifiers.each do |modifier|
+      input = "Buy bread at 17:39 #{modifier}"
+
+      tokens = @parser.parse input
+
+      pattern = TimePatterns::ClassicTimeWithModifierPattern.new
+      result = pattern.find_and_update tokens
+
+      assert_equal("{word}{word}{word}{number}{symbol}{number}{word}", result.to_s)
+    end
+  end
+
+  def test_simple_interval_pattern
+    @modifiers.each do |modifier|
+      @minute_postfixes.each do |minutes|
+        input = "Meeting at 1#{modifier} for 30#{minutes}"
+
+        tokens = @parser.parse input
+
+        pattern = TimePatterns::SimpleIntervalPattern.new
+        result = pattern.find_and_update tokens
+
+        assert_equal("{word}{word}{number}{word}{word}{interval}", result.to_s)
+      end
+    end
+  end
+
+  def test_simple_interval_values
+    input = "Meeting with Pixel at 1pm for 1 hour"
+
+    tokens = @parser.parse input
+
+    pattern = TimePatterns::SimpleIntervalPattern.new
+    result = pattern.find_and_update tokens
+
+    assert_equal(60, result.last.minutes)
+  end
+
+  def test_simple_interval_pattern_invalid_entry
+    input = "Meeting at 1pm for 30hours"
+
+    tokens = @parser.parse input
+
+    pattern = TimePatterns::SimpleIntervalPattern.new
+    result = pattern.find_and_update tokens
+
+    assert_equal("{word}{word}{number}{word}{word}{number}{word}", result.to_s)
+  end
+
+  def test_complex_interval_pattern
+    @hour_postfixes.each do |hours|
+      @minute_postfixes.each do |minutes|
+        input = "Breakfast for 1#{hours} 23#{minutes}"
+
+        tokens = @parser.parse input
+
+        pattern = TimePatterns::ComplexIntervalPattern.new
+        result = pattern.find_and_update tokens
+
+        assert_equal("{word}{word}{interval}", result.to_s)
+      end
+    end
+  end
+
+  def test_complex_interval_pattern_invalid_entry
+    input = "Breakfast for 1m 23m"
+
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    pattern = TimePatterns::ComplexIntervalPattern.new
+    result = pattern.find_and_update tokens    
+
+    assert_equal("{word}{word}{number}{word}{number}{word}", result.to_s)
+  end
+
+  def test_simple_time_ending
+    input = "Breakfast at 17:00"
+
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    pattern = TimePatterns::ClassicTimePattern.new
+    result = pattern.find_and_update tokens
+
+    ending_pattern = TimePatterns::TimeEndingPattern.new
+    ending_result = ending_pattern.find_and_update result
+
+    assert_equal("{word}{ending_form}", ending_result.to_s)
+  end
+
+  def test_interval_ending
+    input = "Breakfast at 4pm for 1h 30mins"
+
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    pattern = TimePatterns::TimeWithModifierPattern.new
+    result = pattern.find_and_update tokens
+    interval_pattern = TimePatterns::ComplexIntervalPattern.new
+    result = interval_pattern.find_and_update result
+
+    ending_pattern = TimePatterns::IntervalEndingPattern.new
+    ending_result = ending_pattern.find_and_update result
+
+    assert_equal("{word}{ending_form}", ending_result.to_s)
+  end
+
+  def test_interval_with_time_ending
+    input = "Breakfast from 4:00 to 9:43pm"
+
+    parser = TimePatterns::Parser.new
+    tokens = parser.parse input
+
+    pattern = TimePatterns::ClassicTimeWithModifierPattern.new
+    result = pattern.find_and_update tokens
+
+    pattern = TimePatterns::ClassicTimePattern.new
+    result = pattern.find_and_update result
+
+    ending_pattern = TimePatterns::IntervalTimeEndingPattern.new
+    ending_result = ending_pattern.find_and_update result
+
+    assert_equal("{word}{ending_form}", ending_result.to_s)
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: todo_time_patterns
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ivan Bokii
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-22 00:00:00.000000000 Z
+dependencies: []
+description: ! "    Todo time patterns is a small library that helps you to parse
+  different\n    time patterns in strings like:\n      - meet bob at 4pm\n      -
+  meeting at 13:34\n      - watch Adventure Times at 3:34pm\n      - Go shopping at
+  2pm for 2h\n      - Pay your tech. debt at 2pm for 35mins to Mafia\n      - Sleep
+  well from 1am to 8:00\n\n      etc.\n"
+email: bokiyis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/todo_time_patterns/helper_modules.rb
+- lib/todo_time_patterns/parser.rb
+- lib/todo_time_patterns/parser_helpers.rb
+- lib/todo_time_patterns/time_patterns.rb
+- lib/todo_time_patterns/time_patterns_finder.rb
+- lib/todo_time_patterns/tokens.rb
+- lib/todo_time_patterns.rb
+- tests/console_test.rb
+- tests/parser_tests.rb
+- tests/time_patterns_finder_tests.rb
+- tests/time_patterns_tests.rb
+homepage: https://github.com/spkenny/todo_time_patterns
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Library that helps you to parse date patterns in strings like 'meet Bob at
+  5:45pm'
+test_files: []