pangel-chronic 0.3.0.3 → 0.3.10

data/lib/chronic/separator.rb

@@ -1,91 +1,91 @@
 module Chronic
 
-	class Separator < Tag #:nodoc:
-		def self.scan(tokens)
-			tokens.each_index do |i|
-				if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
-				if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
-				if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
-				if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
-				if t = self.scan_for_on(tokens[i]) then tokens[i].tag(t); next end
-			end
-			tokens
-		end
+  class Separator < Tag #:nodoc:
+    def self.scan(tokens)
+      tokens.each_index do |i|
+        if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_on(tokens[i]) then tokens[i].tag(t); next end
+      end
+      tokens
+    end
+    
+    def self.scan_for_commas(token)
+      scanner = {/^,$/ => :comma}
+      scanner.keys.each do |scanner_item|
+        return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+    
+    def self.scan_for_slash_or_dash(token)
+      scanner = {/^-$/ => :dash,
+                 /^\/$/ => :slash}
+      scanner.keys.each do |scanner_item|
+        return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+    
+    def self.scan_for_at(token)
+      scanner = {/^(at|@)$/ => :at}
+      scanner.keys.each do |scanner_item|
+        return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+    
+    def self.scan_for_in(token)
+      scanner = {/^in$/ => :in}
+      scanner.keys.each do |scanner_item|
+        return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+    
+    def self.scan_for_on(token)
+      scanner = {/^on$/ => :on}
+      scanner.keys.each do |scanner_item|
+        return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+    
+    def to_s
+      'separator'
+    end
+  end
+  
+  class SeparatorComma < Separator #:nodoc:
+    def to_s
+      super << '-comma'
+    end
+  end
+  
+  class SeparatorSlashOrDash < Separator #:nodoc:
+    def to_s
+      super << '-slashordash-' << @type.to_s
+    end
+  end
+  
+  class SeparatorAt < Separator #:nodoc:
+    def to_s
+      super << '-at'
+    end
+  end
+  
+  class SeparatorIn < Separator #:nodoc:
+    def to_s
+      super << '-in'
+    end
+  end
+  
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
 
-		def self.scan_for_commas(token)
-			scanner = {/^,$/ => :comma}
-			scanner.keys.each do |scanner_item|
-				return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
-
-		def self.scan_for_slash_or_dash(token)
-			scanner = {/^-$/ => :dash,
-				/^\/$/ => :slash}
-			scanner.keys.each do |scanner_item|
-				return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
-
-		def self.scan_for_at(token)
-			scanner = {/^(at|@)$/i => :at}
-			scanner.keys.each do |scanner_item|
-				return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
-
-		def self.scan_for_in(token)
-			scanner = {/^in$/i => :in}
-			scanner.keys.each do |scanner_item|
-				return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
-
-		def self.scan_for_on(token)
-			scanner = {/^on$/i => :on}
-			scanner.keys.each do |scanner_item|
-				return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
-
-		def to_s
-			'separator'
-		end
-	end
-
-	class SeparatorComma < Separator #:nodoc:
-		def to_s
-			super << '-comma'
-		end
-	end
-
-	class SeparatorSlashOrDash < Separator #:nodoc:
-		def to_s
-			super << '-slashordash-' << @type.to_s
-		end
-	end
-
-	class SeparatorAt < Separator #:nodoc:
-		def to_s
-			super << '-at'
-		end
-	end
-
-	class SeparatorIn < Separator #:nodoc:
-		def to_s
-			super << '-in'
-		end
-	end
-
-	class SeparatorOn < Separator #:nodoc:
-		def to_s
-			super << '-on'
-		end
-	end
-
-end
+end

data/lib/chronic/time_zone.rb

@@ -1,23 +1,26 @@
 module Chronic
-	class TimeZone < Tag #:nodoc:
-		def self.scan(tokens)
-			tokens.each_index do |i|
-				if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
-			end
-			tokens
-		end
+  class TimeZone < Tag #:nodoc:
+    def self.scan(tokens)
+      tokens.each_index do |i|
+        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+      end
+      tokens
+    end
 
-		def self.scan_for_all(token)
-			scanner = {/[PMCE][DS]T/i => :tz,
-				/(tzminus)?\d{4}/i => :tz}
-			scanner.keys.each do |scanner_item|
-				return self.new(scanner[scanner_item]) if scanner_item =~ token.word
-			end
-			return nil
-		end
+    def self.scan_for_all(token)
+      if RUBY_VERSION =~ /1\.9\./
+        scanner = {/[PMCE][DS]T/i => :tz}
+      else
+        scanner = {/[PMCE][DS]T/i => :tz, /(tzminus)?[01]\d[304][05]/ => :tz}
+      end
+      scanner.keys.each do |scanner_item|
+        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
 
-		def to_s
-			'timezone'
-		end
-	end
-end
+    def to_s
+      'timezone'
+    end
+  end
+end

data/lib/numerizer/numerizer.rb

@@ -2,97 +2,96 @@ 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],
-		['forty', 40],
-		['fourty', 40], # Common misspelling
-		['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],
-	]
-
-	def self.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, '<num>' + dn[1])
-		end
-
-		# ten, twenty, etc.
-
-		TEN_PREFIXES.each do |tp|
-			string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
-		end
-
-		TEN_PREFIXES.each do |tp|
-			string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
-		end
-
-		# hundreds, thousands, millions, etc.
-
-		BIG_PREFIXES.each do |bp|
-			string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
-				andition(string)
-		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.gsub(/<num>/, '')
-	end
-
-	private
-
-	def self.andition(string)
-		sc = StringScanner.new(string)
-		while(sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i))
-			if sc[2] =~ /and/ || sc[1].size > sc[3].size
-				string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
-				sc.reset
-			end
-		end
-	end
-
-end
+  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],
+                  ]
+
+  def self.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, '<num>' + dn[1])
+    end
+    
+    # ten, twenty, etc.
+    
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
+    end
+    
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
+    end
+    
+    # hundreds, thousands, millions, etc.
+    
+    BIG_PREFIXES.each do |bp|
+      string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+      andition(string)
+    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.gsub(/<num>/, '')
+  end
+
+  private
+  
+  def self.andition(string)
+    sc = StringScanner.new(string)
+    while(sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i))
+      if sc[2] =~ /and/ || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
+        sc.reset
+      end
+    end
+  end
+
+end

data/test/suite.rb

@@ -3,7 +3,7 @@ require 'test/unit'
 tests = Dir["#{File.dirname(__FILE__)}/test_*.rb"]
 tests.delete_if { |o| o =~ /test_parsing/ }
 tests.each do |file|
-	require file
+  require file
 end
 
-require File.dirname(__FILE__) + '/test_parsing.rb'
+require File.dirname(__FILE__) + '/test_parsing.rb'

data/test/test_Chronic.rb

@@ -1,50 +1,50 @@
-require File.dirname(__FILE__) + '/../lib/chronic'
+require 'chronic'
 require 'test/unit'
 
 class TestChronic < Test::Unit::TestCase
-
-	def setup
-		# Wed Aug 16 14:00:00 UTC 2006
-		@now = Time.local(2006, 8, 16, 14, 0, 0, 0)
-	end
-
-	def test_post_normalize_am_pm_aliases
-		# affect wanted patterns
-
-		tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
-		tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
-		tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-
-		assert_equal :morning, tokens[1].tags[0].type
-
-		tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-
-		assert_equal :am, tokens[1].tags[0].type
-		assert_equal 2, tokens.size
-
-		# don't affect unwanted patterns
-
-		tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
-		tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
-		tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-
-		assert_equal :morning, tokens[1].tags[0].type
-
-		tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-
-		assert_equal :morning, tokens[1].tags[0].type
-		assert_equal 2, tokens.size
-	end
-
-	def test_guess
-		span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
-		assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-
-		span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
-		assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-
-		span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
-		assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
-	end
-
-end
+  
+  def setup
+    # Wed Aug 16 14:00:00 UTC 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+  
+  def test_post_normalize_am_pm_aliases
+    # affect wanted patterns
+    
+    tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    
+    tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
+    
+    assert_equal :am, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+    
+    # don't affect unwanted patterns
+    
+    tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    
+    tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+  end
+  
+  def test_guess
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
+    
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
+    
+    span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
+    assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
+  end
+  
+end