gforces-chronik 0.3.0

data/lib/chronik/scalar.rb

@@ -0,0 +1,76 @@
+module Chronik
+
+  class Scalar < Tag #:nodoc:
+    def self.scan(tokens)
+      # for each token
+      tokens.each_index do |i|
+        if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+      end
+      tokens
+    end
+  
+    def self.scan_for_scalars(token, post_token)
+      if token.word =~ /^\d*$/
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
+          return Scalar.new(token.word.to_i)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_days(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarDay.new(toi)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_months(token, post_token)
+      if token.word =~ /^\d\d?$/
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarMonth.new(toi)
+        end
+      end
+      return nil
+    end
+    
+    def self.scan_for_years(token, post_token)
+      if token.word =~ /^([1-9]\d)?\d\d?$/
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
+          return ScalarYear.new(token.word.to_i)
+        end
+      end
+      return nil
+    end
+    
+    def to_s
+      'scalar'
+    end
+  end
+  
+  class ScalarDay < Scalar #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+  
+  class ScalarMonth < Scalar #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+  
+  class ScalarYear < Scalar #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+
+end

data/lib/chronik/separator.rb

@@ -0,0 +1,91 @@
+module Chronik
+
+  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
+
+end

data/lib/chronik/time_zone.rb

@@ -0,0 +1,23 @@
+module Chronik
+  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}/ => :tz}
+      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

data/lib/numerizer/numerizer.rb

@@ -0,0 +1,100 @@
+require 'strscan'
+
+class Numerizer
+
+  DIRECT_NUMS = [
+                  ['jedenaście', '11'],
+                  ['dwanaście', '12'],
+                  ['trzynaście', '13'],
+                  ['czternaście', '14'],
+                  ['piętnaście', '15'],
+                  ['szesnaście', '16'],
+                  ['siedemnaście', '17'],
+                  ['osiemnaście', '18'],
+                  ['dziewiętnaście', '19'],
+                  ['zero', '0'],
+                  ['jeden', '1'],
+                  ['dwa(\W|$)', '2\1'],
+                  ['trzy(\W|$)', '3\1'],
+                  ['cztery', '4'],  
+                  ['pięć(\W|$)', '5\1'], # The weird regex is so that it matches pięć but not pięćdziesiąt
+                  ['sześć(\W|$)', '6\1'],
+                  ['siedem(\W|$)', '7\1'],
+                  ['osiem(\W|$)', '8\1'],
+                  ['dziewięć(\W|$)', '9\1'],
+                  ['dziesięć', '10']
+                ]
+
+  TEN_PREFIXES = [ ['dwadzieścia', 20],
+                    ['trzydzieści', 30],
+                    ['czterdzieści', 40],
+                    ['pięćdziesiąt', 50],
+                    ['sześćdziesiąt', 60],
+                    ['siedemdziesiąt', 70],
+                    ['osiemdziesiąt', 80],
+                    ['dziewięćdziesiąt', 90]
+                  ]
+
+  HUNDRET_PREFIXES = [ ['sto', 100],
+                    ['dwieście', 200],
+                    ['trzysta', 300],
+                    ['czterysta', 400],
+                    ['pięćset', 500],
+                    ['sześćset', 600],
+                    ['siedemset', 700],
+                    ['osiemset', 800],
+                    ['dziewięćset', 900],
+                    ['tysiąc', 1000]
+                  ]
+
+  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.
+    
+    HUNDRET_PREFIXES.each do |hp|
+      string.gsub!(/#{hp[0]}/i) { '<num>' + hp[1].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

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

data/test/test_Chronik.rb

@@ -0,0 +1,50 @@
+require 'chronik'
+require 'test/unit'
+
+class TestChronik < 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 = [Chronik::Token.new("5:00"), Chronik::Token.new("morning")]
+    tokens[0].tag(Chronik::RepeaterTime.new("5:00"))
+    tokens[1].tag(Chronik::RepeaterDayPortion.new(:morning))
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    
+    tokens = Chronik.dealias_and_disambiguate_times(tokens, {})
+    
+    assert_equal :am, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+    
+    # don't affect unwanted patterns
+    
+    tokens = [Chronik::Token.new("friday"), Chronik::Token.new("morning")]
+    tokens[0].tag(Chronik::RepeaterDayName.new(:friday))
+    tokens[1].tag(Chronik::RepeaterDayPortion.new(:morning))
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    
+    tokens = Chronik.dealias_and_disambiguate_times(tokens, {})
+    
+    assert_equal :morning, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+  end
+  
+  def test_guess
+    span = Chronik::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
+    assert_equal Time.local(2006, 8, 16, 12), Chronik.guess(span)
+    
+    span = Chronik::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
+    assert_equal Time.local(2006, 8, 16, 12), Chronik.guess(span)
+    
+    span = Chronik::Span.new(Time.local(2006, 11), Time.local(2006, 12))
+    assert_equal Time.local(2006, 11, 16), Chronik.guess(span)
+  end
+  
+end

data/test/test_Handler.rb

@@ -0,0 +1,110 @@
+require 'chronik'
+require 'test/unit'
+
+class TestHandler < 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_handler_class_1
+    handler = Chronik::Handler.new([:repeater], :handler)
+    
+    tokens = [Chronik::Token.new('friday')]
+    tokens[0].tag(Chronik::RepeaterDayName.new(:friday))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('afternoon')
+    tokens[1].tag(Chronik::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_handler_class_2
+    handler = Chronik::Handler.new([:repeater, :repeater?], :handler)
+    
+    tokens = [Chronik::Token.new('friday')]
+    tokens[0].tag(Chronik::RepeaterDayName.new(:friday))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('afternoon')
+    tokens[1].tag(Chronik::RepeaterDayPortion.new(:afternoon))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('afternoon')
+    tokens[2].tag(Chronik::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_handler_class_3
+    handler = Chronik::Handler.new([:repeater, 'time?'], :handler)
+    
+    tokens = [Chronik::Token.new('friday')]
+    tokens[0].tag(Chronik::RepeaterDayName.new(:friday))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('afternoon')
+    tokens[1].tag(Chronik::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_handler_class_4
+    handler = Chronik::Handler.new([:repeater_month_name, :scalar_day, 'time?'], :handler)
+    
+    tokens = [Chronik::Token.new('may')]
+    tokens[0].tag(Chronik::RepeaterMonthName.new(:may))
+    
+    assert !handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('27')
+    tokens[1].tag(Chronik::ScalarDay.new(27))
+    
+    assert handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_handler_class_5
+    handler = Chronik::Handler.new([:repeater, 'time?'], :handler)
+    
+    tokens = [Chronik::Token.new('friday')]
+    tokens[0].tag(Chronik::RepeaterDayName.new(:friday))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('5:00')
+    tokens[1].tag(Chronik::RepeaterTime.new('5:00'))
+    
+    assert handler.match(tokens, Chronik.definitions)
+    
+    tokens << Chronik::Token.new('pm')
+    tokens[2].tag(Chronik::RepeaterDayPortion.new(:pm))
+    
+    assert handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_handler_class_6
+    handler = Chronik::Handler.new([:scalar, :repeater, :pointer], :handler)
+    
+    tokens = [Chronik::Token.new('3'),
+              Chronik::Token.new('years'),
+              Chronik::Token.new('past')]
+              
+    tokens[0].tag(Chronik::Scalar.new(3))
+    tokens[1].tag(Chronik::RepeaterYear.new(:year))
+    tokens[2].tag(Chronik::Pointer.new(:past))
+    
+    assert handler.match(tokens, Chronik.definitions)
+  end
+  
+  def test_constantize
+    handler = Chronik::Handler.new([], :handler)
+    assert_equal Chronik::RepeaterTime, handler.constantize(:repeater_time)
+  end
+  
+end