tickle 0.0.3 → 0.0.4

data/README.rdoc

@@ -43,42 +43,52 @@ Tickle HEAVILY uses chronic for parsing both the event and the start date.
   require 'rubygems'
   require 'tickle'
   
-  .Time.now
-  2010-04-22 17:11:52 -0400
-
-  Tickle.parse('each day')  #=> 2010-04-23 17:24:24 -0400
-  Tickle.parse('every day')  #=> 2010-04-23 17:24:24 -0400
-  Tickle.parse('every week')  #=> 2010-04-29 17:24:24 -0400
-  Tickle.parse('every Month')  #=> 2010-05-22 17:24:24 -0400
-  Tickle.parse('every year')  #=> 2011-04-22 17:24:24 -0400
-  Tickle.parse('daily')  #=> 2010-04-23 17:24:24 -0400
-  Tickle.parse('weekly')  #=> 2010-04-29 17:24:24 -0400
-  Tickle.parse('monthly')  #=> 2010-05-22 17:24:24 -0400
-  Tickle.parse('yearly')  #=> 2011-04-22 17:24:24 -0400
-  Tickle.parse('every 3 days')  #=> 2010-04-25 17:24:24 -0400
-  Tickle.parse('every 3 weeks')  #=> 2010-05-13 17:24:24 -0400
-  Tickle.parse('every 3 months')  #=> 2010-07-21 17:24:24 -0400
-  Tickle.parse('every 3 years')  #=> 2013-04-21 17:24:24 -0400
-  Tickle.parse('every other day')  #=> 2010-04-24 17:24:24 -0400
-  Tickle.parse('every other week')  #=> 2010-05-06 17:24:24 -0400
-  Tickle.parse('every other month')  #=> 2010-06-22 17:24:24 -0400
-  Tickle.parse('every other year')  #=> 2012-04-22 17:24:24 -0400
+  Time.now
+  2010-04-24 12:05:51 -0400
+
+  Tickle.parse('each day')  #=> 2010-04-24 12:05:51 -0400
+  Tickle.parse('every day')  #=> 2010-04-24 12:05:51 -0400
+  Tickle.parse('every week')  #=> 2010-05-01 12:05:51 -0400
+  Tickle.parse('every Month')  #=> 2010-05-24 12:05:51 -0400
+  Tickle.parse('every year')  #=> 2011-04-24 12:05:51 -0400
+  Tickle.parse('daily')  #=> 2010-04-24 12:05:51 -0400
+  Tickle.parse('weekly')  #=> 2010-05-01 12:05:51 -0400
+  Tickle.parse('monthly')  #=> 2010-05-24 12:05:51 -0400
+  Tickle.parse('yearly')  #=> 2011-04-24 12:05:51 -0400
+  Tickle.parse('every 3 days')  #=> 2010-04-27 12:05:51 -0400
+  Tickle.parse('every 3 weeks')  #=> 2010-05-15 12:05:51 -0400
+  Tickle.parse('every 3 months')  #=> 2010-07-23 12:05:51 -0400
+  Tickle.parse('every 3 years')  #=> 2013-04-23 12:05:51 -0400
+  Tickle.parse('every other day')  #=> 2010-04-26 12:05:51 -0400
+  Tickle.parse('every other week')  #=> 2010-05-08 12:05:51 -0400
+  Tickle.parse('every other month')  #=> 2010-06-24 12:05:51 -0400
+  Tickle.parse('every other year')  #=> 2012-04-24 12:05:51 -0400
   Tickle.parse('every other day starting May 1st')  #=> 2010-05-01 12:00:00 -0400
   Tickle.parse('every other week starting this Sunday')  #=> 2010-04-25 12:00:00 -0400
   Tickle.parse('every Monday')  #=> 2010-04-26 12:00:00 -0400
   Tickle.parse('every Wednesday')  #=> 2010-04-28 12:00:00 -0400
-  Tickle.parse('every Friday')  #=> 2010-04-23 12:00:00 -0400
+  Tickle.parse('every Friday')  #=> 2010-04-30 12:00:00 -0400
   Tickle.parse('every May')  #=> 2010-05-01 12:00:00 -0400
   Tickle.parse('every june')  #=> 2010-06-01 12:00:00 -0400
   Tickle.parse('beginning of the week')  #=> 2010-04-25 12:00:00 -0400
   Tickle.parse('middle of the week')  #=> 2010-04-28 12:00:00 -0400
-  Tickle.parse('end of the week')  #=> 2010-04-24 12:00:00 -0400
+  Tickle.parse('end of the week')  #=> 2010-05-01 12:00:00 -0400
   Tickle.parse('beginning of the month')  #=> 2010-05-01 12:00:00 -0400
   Tickle.parse('middle of the month')  #=> 2010-05-15 12:00:00 -0400
   Tickle.parse('end of the month')  #=> 2010-04-30 00:00:00 -0400
   Tickle.parse('beginning of the year')  #=> 2011-01-01 12:00:00 -0500
   Tickle.parse('middle of the year')  #=> 2010-06-15 00:00:00 -0400
   Tickle.parse('end of the year')  #=> 2010-12-31 00:00:00 -0500
+  Tickle.parse('the 3rd of May')  #=> 2010-05-03 12:00:00 -0400
+  Tickle.parse('the 3rd of February')  #=> 2011-02-03 12:00:00 -0500
+  Tickle.parse('the 10th of the month')  #=> 2010-05-10 12:00:00 -0400
+  Tickle.parse('the tenth of the month')  #=> 2010-05-10 12:00:00 -0400
+  Tickle.parse('the first of the month')  #=> 2010-05-01 12:00:00 -0400
+  Tickle.parse('the thirtieth')  #=> 2010-04-30 12:00:00 -0400
+  Tickle.parse('the fifth')  #=> 2010-05-05 12:00:00 -0400
+  Tickle.parse('the 3rd Sunday of May')  #=> 2010-05-16 12:00:00 -0400
+  Tickle.parse('the 3rd Sunday of the month')  #=> 2010-05-16 12:00:00 -0400
+
 
 
 -- USING IN APP

data/SCENARIOS.rdoc

@@ -10,3 +10,6 @@ every November 15th => month found with number.  interval = 365, start_date = Ch
 every day => word 'day' found without a number.  interval = 1.  start_day = today
 every week => word 'week' found without a number.  interval = 7.  start_day = today
 every month => word 'month' found without a number.  interval = 30.  start_day = today
+
+
+

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/git-flow-version

@@ -0,0 +1 @@
+GITFLOW_VERSION=0.0.4

data/lib/tickle.rb

@@ -18,24 +18,41 @@ require 'tickle/repeater'
 
 module Tickle
   VERSION = "0.0.3"
-  
+
   def self.debug; false; end
-  
+
   def self.dwrite(msg)
     puts msg if Tickle.debug
   end
+
+  def self.is_date(str)
+    begin
+      Date.parse(str.to_s)
+      return true
+    rescue Exception => e
+      return false
+    end
+  end
 end
 
-class Date 
-   def days_in_month 
-     d,m,y = mday,month,year 
-     d += 1 while Date.valid_civil?(y,m,d) 
-     d - 1 
-   end 
+class Date
+  def days_in_month
+    d,m,y = mday,month,year
+    d += 1 while Date.valid_civil?(y,m,d)
+    d - 1
+  end
+end
+
+class String
+  def is_ordinal?
+    scanner = %w{first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventieth eighteenth nineteenth twenty thirty thirtieth}
+    regex = /\b(\d*)(st|nd|rd|th)\b/
+    !(self =~ regex).nil? || scanner.include?(self.downcase)
+  end
 end
 
 class Array
   def same?(y)
     self.sort == y.sort
   end
-end
+end

data/lib/tickle/handler.rb

@@ -4,23 +4,24 @@ module Tickle
     def guess()
       interval = guess_unit_types
       interval ||= guess_weekday
-      interval ||= guess_weekday
       interval ||= guess_month_names
       interval ||= guess_number_and_unit
+      interval ||= guess_ordinal
+      interval ||= guess_ordinal_and_unit
       interval ||= guess_special
 
       # defines the next occurrence of this tickle if not set in a guess routine
       @next ||= @start + (interval * 60 * 60 * 24) if interval
-      
+
       # check to see if the start date is > NOW and, if so, set the next occurrence = start
       @next = @start if @start.to_time > Time.now
-      
+
       # return the next occurrence
       return @next.to_time if interval
     end
 
     def guess_unit_types
-      interval = 1 if token_types.same?([:day])
+      interval = 0 if token_types.same?([:day])
       interval = 7 if token_types.same?([:week])
       interval = 30 if token_types.same?([:month])
       interval = 365 if token_types.same?([:year])
@@ -51,6 +52,20 @@ module Tickle
       interval
     end
 
+    def guess_ordinal
+      if token_types.same?([:ordinal]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).start} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
+      interval
+    end
+
+    def guess_ordinal_and_unit
+      parse_text = ''
+      if token_types.same?([:ordinal, :month_name]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} day in #{token_of_type(:month_name).start.to_s}"); end
+      if token_types.same?([:ordinal, :month]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).start} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
+      if token_types.same?([:ordinal, :weekday, :month_name]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} #{token_of_type(:weekday).start.to_s} in #{token_of_type(:month_name).start.to_s}"); end
+      if token_types.same?([:ordinal, :weekday, :month]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} #{token_of_type(:weekday).start.to_s} in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
+      interval
+    end
+
     def guess_special
       interval = guess_special_other
       interval ||= guess_special_beginning
@@ -81,16 +96,16 @@ module Tickle
       if token_types.same?([:special, :year]) && token_of_type(:special).start == :end then interval = 365;  @start = Date.new(Date.today.year, 12, 31); end
       interval
     end
-    
+
     def guess_special_middle
       if token_types.same?([:special, :week]) && token_of_type(:special).start == :middle then interval = 7;  @start = Chronic.parse('Wednesday'); end
       if token_types.same?([:special, :month]) && token_of_type(:special).start == :middle then
         interval = 30;
-        @start = (Date.today.day >= 15 ? Chronic.parse('15th day of next month') : Date.new(Date.today.year, Date.today.month, 15))
+        @start = (Date.today.day > 15 ? Chronic.parse('15th day of next month') : Date.new(Date.today.year, Date.today.month, 15))
       end
       if token_types.same?([:special, :year]) && token_of_type(:special).start == :middle then
         interval = 365;
-        @start = (Date.today.day >= 15 && Date.today.month >= 6 ? Date.new(Date.today.year+1, 6, 15) : Date.new(Date.today.year, 6, 15))
+        @start = (Date.today.day > 15 && Date.today.month > 6 ? Date.new(Date.today.year+1, 6, 15) : Date.new(Date.today.year, 6, 15))
       end
       interval
     end
@@ -99,5 +114,13 @@ module Tickle
       @tokens.detect {|token| token.type == type}
     end
 
+
+    private
+
+    def get_next_month(ordinal)
+      ord_to_int = ordinal.gsub(/\b(\d*)(st|nd|rd|th)\b/,'\1').to_i
+      month = (ord_to_int < Date.today.day ? Date.today.month + 1 : Date.today.month)
+    end
+
   end
 end

data/lib/tickle/repeater.rb

@@ -4,10 +4,12 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     # for each token
     tokens.each do |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)
+      token = self.scan_for_ordinal_names(token)
+      token = self.scan_for_ordinals(token)
+      token = self.scan_for_month_names(token) unless token.type
+      token = self.scan_for_day_names(token) unless token.type
+      token = self.scan_for_special_text(token) unless token.type
+      token = self.scan_for_units(token) unless token.type
     end
     tokens
   end
@@ -18,6 +20,42 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     token
   end
 
+  def self.scan_for_ordinal_names(token)
+    scanner = {/first/ => '1st',
+    /second/ => '2nd',
+    /third/ => '3rd',
+    /fourth/ => '4th',
+    /fifth/ => '5th',
+    /sixth/ => '6th',
+    /seventh/ => '7th',
+    /eighth/ => '8th',
+    /ninth/ => '9th',
+    /tenth/ => '10th',
+    /eleventh/ => '11th',
+    /twelfth/ => '12th',
+    /thirteenth/ => '13th',
+    /fourteenth/ => '14th',
+    /fifteenth/ => '15th',
+    /sixteenth/ => '16th',
+    /seventeenth/ => '17th',
+    /eighteenth/ => '18th',
+    /nineteenth/ => '19th',
+    /twenty/ => '20th',
+    /thirty/ => '30th',
+    /thirtieth/ => '30th',
+    }
+    scanner.keys.each do |scanner_item|
+      token.update(:ordinal, scanner[scanner_item], 365) if scanner_item =~ token.original
+    end
+    token
+  end
+  
+  def self.scan_for_ordinals(token)
+    regex = /\b(\d*)(st|nd|rd|th)\b/
+    token.update(:ordinal, token.original, 365) if !(token.original =~ regex).nil?
+    token
+  end
+
   def self.scan_for_month_names(token)
     scanner = {/^jan\.?(uary)?$/ => :january,
       /^feb\.?(ruary)?$/ => :february,
@@ -59,7 +97,7 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
       /^begin(ing|ning)?$/ => :beginning,
       /^start$/ => :beginning,
       /^end$/ => :end,
-      /^mid(d)?le$/ => :middle}
+    /^mid(d)?le$/ => :middle}
     scanner.keys.each do |scanner_item|
       token.update(:special, scanner[scanner_item], 7) if scanner_item =~ token.word
     end
@@ -72,7 +110,7 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
       /^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},
+      /^days?$/ => {:type => :day, :interval => 1, :start => :today},
     /^daily?$/ => {:type => :day, :interval => 1, :start => :today}}
     scanner.keys.each do |scanner_item|
       if scanner_item =~ token.word

data/lib/tickle/tickle.rb

@@ -8,43 +8,39 @@ module Tickle
 
       # ensure the specified options are valid
       specified_options.keys.each do |key|
-        default_options.keys.include?(key) || raise(InvalidArgumentException, "#{key} is not a valid option key.")
+        raise(InvalidArgumentException, "#{key} is not a valid option key.") unless default_options.keys.include?(key)
       end
-      Chronic.parse(specified_options[:start]) || raise(InvalidArgumentException, ':start specified is not a valid datetime.') if specified_options[:start]
-
-      # remove every is specified
-      text = text.gsub(/^every\s\b/, '')
-
-      # put the text into a normal format to ease scanning using Chronic
-      text = pre_normalize(text)
-      text = Chronic.pre_normalize(text)
-      text = numericize_ordinals(text)
+      raise(InvalidArgumentException, ':start specified is not a valid datetime.') unless  (is_date(specified_options[:start]) || Chronic.parse(specified_options[:start])) if specified_options[:start]
 
       # check to see if this event starts some other time and reset now
       event, starting = text.split('starting')
       @start = (Chronic.parse(starting) || options[:start])
       @next = nil
 
+      # put the text into a normal format to ease scanning using Chronic
+      event = pre_tokenize(event)
+
       # split into tokens
       @tokens = base_tokenize(event)
 
+      # process each original word for implied word
+      post_tokenize
+
       # scan the tokens with each token scanner
       @tokens = Repeater.scan(@tokens)
 
       # remove all tokens without a type
       @tokens.reject! {|token| token.type.nil? }
 
-      # dwrite @tokens.inspect
-
       return guess
     end
 
     # Normalize natural string removing prefix language
-    def pre_normalize(text)
+    def pre_tokenize(text)
       normalized_text = text.gsub(/^every\s\b/, '')
       normalized_text = text.gsub(/^each\s\b/, '')
       normalized_text = text.gsub(/^on the\s\b/, '')
-      normalized_text
+      normalized_text.downcase
     end
 
     # Split the text on spaces and convert each word into
@@ -53,11 +49,45 @@ module Tickle
       text.split(' ').map { |word| Token.new(word) }
     end
 
+    # normalizes each token
+    def post_tokenize
+      @tokens.each do |token|
+        token.word = normalize(token.original)
+      end
+    end
+    
+    # Clean up the specified input text by stripping unwanted characters,
+    # converting idioms to their canonical form, converting number words
+    # to numbers (three => 3), and converting ordinal words to numeric
+    # ordinals (third => 3rd)
+    def normalize(text) #:nodoc:
+      normalized_text = text.to_s.downcase
+      normalized_text = Numerizer.numerize(normalized_text)
+      normalized_text.gsub!(/['"\.]/, '')
+      normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
+      normalized_text.gsub!(/\btoday\b/, 'this day')
+      normalized_text.gsub!(/\btomm?orr?ow\b/, 'next day')
+      normalized_text.gsub!(/\byesterday\b/, 'last day')
+      normalized_text.gsub!(/\bnoon\b/, '12:00')
+      normalized_text.gsub!(/\bmidnight\b/, '24:00')
+      normalized_text.gsub!(/\bbefore now\b/, 'past')
+      normalized_text.gsub!(/\bnow\b/, 'this second')
+      normalized_text.gsub!(/\b(ago|before)\b/, 'past')
+      normalized_text.gsub!(/\bthis past\b/, 'last')
+      normalized_text.gsub!(/\bthis last\b/, 'last')
+      normalized_text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
+      normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
+      normalized_text.gsub!(/\btonight\b/, 'this night')
+      normalized_text.gsub!(/(?=\w)([ap]m|oclock)\b/, ' \1')
+      normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
+      normalized_text = numericize_ordinals(normalized_text)
+    end
+
     # Convert ordinal words to numeric ordinals (third => 3rd)
     def numericize_ordinals(text) #:nodoc:
       text = text.gsub(/\b(\d*)(st|nd|rd|th)\b/, '\1')
     end
-
+    
     # Returns an array of types for all tokens
     def token_types
       @tokens.map(&:type)
@@ -65,11 +95,11 @@ module Tickle
   end
 
   class Token #:nodoc:
-    attr_accessor :word, :type, :interval, :start
+    attr_accessor :original, :word, :type, :interval, :start
 
-    def initialize(word)
-      @word = word
-      @type = @interval = @start = nil
+    def initialize(original)
+      @original = original
+      @word = @type = @interval = @start = nil
     end
 
     def update(type, start=nil, interval=nil)

data/test/git-flow-version

@@ -0,0 +1 @@
+GITFLOW_VERSION=0.1.0

data/test/test_parsing.rb

@@ -11,49 +11,62 @@ class TestParsing < Test::Unit::TestCase
   def test_parse_best_guess
     puts "Time.now"
     p Time.now
-    
-    parse_now('each day')
-
-    parse_now('every day')
-    parse_now('every week')
-    parse_now('every Month')
-    parse_now('every year')
-
-    parse_now('daily')
-    parse_now('weekly')
-    parse_now('monthly')
-    parse_now('yearly')
-
-    parse_now('every 3 days')
-    parse_now('every 3 weeks')
-    parse_now('every 3 months')
-    parse_now('every 3 years')
-
-    parse_now('every other day')
-    parse_now('every other week')
-    parse_now('every other month')
-    parse_now('every other year')
-    parse_now('every other day starting May 1st')
-    parse_now('every other week starting this Sunday')
 
-    parse_now('every Monday')
-    parse_now('every Wednesday')
-    parse_now('every Friday')
-
-    parse_now('every May')
-    parse_now('every june')
-
-    parse_now('beginning of the week')
-    parse_now('middle of the week')
-    parse_now('end of the week')
-
-    parse_now('beginning of the month')
-    parse_now('middle of the month')
-    parse_now('end of the month')
-
-    parse_now('beginning of the year')
-    parse_now('middle of the year')
-    parse_now('end of the year')
+    parse_now('each day')
+      
+      parse_now('every day')
+      parse_now('every week')
+      parse_now('every Month')
+      parse_now('every year')
+      
+      parse_now('daily')
+      parse_now('weekly')
+      parse_now('monthly')
+      parse_now('yearly')
+      
+      parse_now('every 3 days')
+      parse_now('every 3 weeks')
+      parse_now('every 3 months')
+      parse_now('every 3 years')
+      
+      parse_now('every other day')
+      parse_now('every other week')
+      parse_now('every other month')
+      parse_now('every other year')
+      parse_now('every other day starting May 1st')
+      parse_now('every other week starting this Sunday')
+      
+      parse_now('every Monday')
+      parse_now('every Wednesday')
+      parse_now('every Friday')
+      
+      parse_now('every May')
+      parse_now('every june')
+      
+      parse_now('beginning of the week')
+      parse_now('middle of the week')
+      parse_now('end of the week')
+      
+      parse_now('beginning of the month')
+      parse_now('middle of the month')
+      parse_now('end of the month')
+      
+      parse_now('beginning of the year')
+      parse_now('middle of the year')
+      parse_now('end of the year')
+
+      parse_now('the 3rd of May')
+      parse_now('the 3rd of February', {:start => Date.new(2010, 03, 01).to_time})
+      
+      parse_now('the 10th of the month')
+      parse_now('the tenth of the month')
+      
+      parse_now('the first of the month')
+      parse_now('the thirtieth')
+      parse_now('the fifth', {:start => Date.new(2010, 03, 15)})
+
+    parse_now('the 3rd Sunday of May')
+    parse_now('the 3rd Sunday of the month')
   end
 
   def test_argument_validation

data/tickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tickle}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Lippiner"]
-  s.date = %q{2010-04-22}
+  s.date = %q{2010-04-24}
   s.description = %q{Tickle is a date/time helper gem to help parse natural language into a recurring pattern.  Tickle is designed to be a compliment of Chronic and can interpret things such as "every 2 days, every Sunday, Sundays, Weekly, etc.}
   s.email = %q{jlippiner@noctivity.com}
   s.extra_rdoc_files = [
@@ -25,11 +25,13 @@ Gem::Specification.new do |s|
      "Rakefile",
      "SCENARIOS.rdoc",
      "VERSION",
+     "git-flow-version",
      "lib/numerizer/numerizer.rb",
      "lib/tickle.rb",
      "lib/tickle/handler.rb",
      "lib/tickle/repeater.rb",
      "lib/tickle/tickle.rb",
+     "test/git-flow-version",
      "test/helper.rb",
      "test/test_parsing.rb",
      "tickle.gemspec"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Joshua Lippiner
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-22 00:00:00 -04:00
+date: 2010-04-24 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,11 +63,13 @@ files:
 - Rakefile
 - SCENARIOS.rdoc
 - VERSION
+- git-flow-version
 - lib/numerizer/numerizer.rb
 - lib/tickle.rb
 - lib/tickle/handler.rb
 - lib/tickle/repeater.rb
 - lib/tickle/tickle.rb
+- test/git-flow-version
 - test/helper.rb
 - test/test_parsing.rb
 - tickle.gemspec