greeb 0.1.0.rc7 → 0.1.0.rc8

data/README.md

@@ -1,8 +1,8 @@
 Greeb
 =====
 
-Greeb is a simple yet awesome text tokenizer that is based on regular
-expressions.
+Greeb is a simple yet awesome and Unicode-aware text segmentator
+that is based on regular expressions.
 
 ## Installation
 
@@ -25,7 +25,7 @@ Or install it yourself as:
 Greeb can help you to solve simple text processing problems:
 
 ```ruby
-pp Greeb::Tokenizer.new('Hello!').tokens
+pp Greeb::Tokenizer.tokenize('Hello!')
 =begin
 [#<struct Greeb::Entity from=0, to=5, type=:letter>,
  #<struct Greeb::Entity from=5, to=6, type=:punct>]
@@ -41,7 +41,7 @@ Hello! I am 18! My favourite number is 133.7...
 What about you?
 EOF
 
-pp Greeb::Tokenizer.new(text).tokens
+pp Greeb::Tokenizer.tokenize(text)
 =begin
 [#<struct Greeb::Entity from=0, to=5, type=:letter>,
  #<struct Greeb::Entity from=5, to=6, type=:punct>,
@@ -79,8 +79,8 @@ such as sentence detection tasks:
 
 ```ruby
 text = 'Hello! How are you?'
-tokenizer = Greeb::Tokenizer.new(text)
-pp Greeb::Segmentator.new(tokenizer).sentences
+tokens = Greeb::Tokenizer.tokenize(text)
+pp Greeb::Segmentator.new(tokens).sentences
 =begin
 [#<struct Greeb::Entity from=0, to=6, type=:sentence>,
  #<struct Greeb::Entity from=7, to=19, type=:sentence>]
@@ -92,9 +92,9 @@ segmentator:
 
 ```ruby
 text = 'Hello! How are you?'
-tokenizer = Greeb::Tokenizer.new(text)
-sentences = Greeb::Segmentator.new(tokenizer).sentences
-pp segmentator.extract(*sentences)
+tokens = Greeb::Tokenizer.tokenize(text)
+sentences = Greeb::Segmentator.new(tokens).sentences
+pp segmentator.extract(sentences)
 =begin
 {#<struct Greeb::Entity from=0, to=6, type=:sentence>=>
   [#<struct Greeb::Entity from=0, to=5, type=:letter>,
@@ -127,9 +127,6 @@ punctuation), and `:break`.
 4. Push to the branch (`git push origin my-new-feature`);
 5. Create new Pull Request.
 
-I highly recommend you to use git flow to make development process much
-systematic and awesome.
-
 ## Build Status [<img src="https://secure.travis-ci.org/eveel/greeb.png"/>](http://travis-ci.org/eveel/greeb)
 
 ## Dependency Status [<img src="https://gemnasium.com/eveel/greeb.png?travis"/>](https://gemnasium.com/eveel/greeb)

data/lib/greeb.rb

@@ -22,6 +22,24 @@ class Greeb::Entity < Struct.new(:from, :to, :type)
   end
 end
 
+# This runtime error appears when {Greeb::Tokenizer} or
+# {Greeb::Segmentator} tries to recognize unknown character.
+#
+class Greeb::UnknownEntity < RuntimeError
+  attr_reader :text, :pos
+
+  # @private
+  def initialize(text, pos)
+    @text, @pos = text, pos
+  end
+
+  # Generate the real error message.
+  #
+  def to_s
+    'Could not recognize character "%s" @ %d' % [text[pos], pos]
+  end
+end
+
 require 'greeb/strscan'
 require 'greeb/tokenizer'
 require 'greeb/segmentator'

data/lib/greeb/segmentator.rb

@@ -13,15 +13,10 @@ class Greeb::Segmentator
 
   # Create a new instance of {Greeb::Segmentator}.
   #
-  # @param tokenizer_or_tokens [Greeb::Tokenizer,Set] an instance of
-  #   {Greeb::Tokenizer} or set of its results.
-  #
-  def initialize tokenizer_or_tokens
-    @tokens = if tokenizer_or_tokens.is_a? Greeb::Tokenizer
-      tokenizer_or_tokens.tokens
-    else
-      tokenizer_or_tokens
-    end
+  # @param tokens [Array<Greeb::Entity>] tokens from [Greeb::Tokenizer].
+  #
+  def initialize tokens
+    @tokens = tokens
   end
 
   # Sentences memoization method.
@@ -49,7 +44,7 @@ class Greeb::Segmentator
   # @return [Hash<Greeb::Entity, Array<Greeb::Entity>>] a hash with
   #   sentences as keys and tokens arrays as values.
   #
-  def extract *sentences
+  def extract sentences
     Hash[
       sentences.map do |s|
         [s, tokens.select { |t| t.from >= s.from and t.to <= s.to }]
@@ -64,7 +59,7 @@ class Greeb::Segmentator
   # @return [Hash<Greeb::Entity, Array<Greeb::Entity>>] a hash with
   #   sentences as keys and subsentences arrays as values.
   #
-  def subextract *sentences
+  def subextract sentences
     Hash[
       sentences.map do |s|
         [s, subsentences.select { |ss| ss.from >= s.from and ss.to <= s.to }]
@@ -73,90 +68,90 @@ class Greeb::Segmentator
   end
 
   protected
-    # Implementation of the sentence detection method. This method
-    # changes the `@sentences` ivar.
-    #
-    # @return [nil] nothing.
-    #
-    def detect_sentences!
-      @sentences = []
-
-      rest = tokens.inject(new_sentence) do |sentence, token|
-        if !sentence.from and SENTENCE_DOESNT_START.include?(token.type)
-          next sentence
-        end
-
-        sentence.from = token.from unless sentence.from
-
-        next sentence if sentence.to and sentence.to > token.to
-
-        if :punct == token.type
-          sentence.to = tokens.
-            select { |t| t.from >= token.from }.
-            inject(token) { |r, t| break r if t.type != token.type; t }.
-            to
-
-          @sentences << sentence
-          sentence = new_sentence
-        elsif :separ != token.type
-          sentence.to = token.to
-        end
-
-        sentence
+  # Implementation of the sentence detection method. This method
+  # changes the `@sentences` ivar.
+  #
+  # @return [nil] nothing.
+  #
+  def detect_sentences!
+    @sentences = []
+
+    rest = tokens.inject(new_sentence) do |sentence, token|
+      if !sentence.from and SENTENCE_DOESNT_START.include?(token.type)
+        next sentence
+      end
+
+      sentence.from = token.from unless sentence.from
+
+      next sentence if sentence.to and sentence.to > token.to
+
+      if :punct == token.type
+        sentence.to = tokens.
+          select { |t| t.from >= token.from }.
+          inject(token) { |r, t| break r if t.type != token.type; t }.
+          to
+
+        @sentences << sentence
+        sentence = new_sentence
+      elsif :separ != token.type
+        sentence.to = token.to
       end
 
-      nil.tap { @sentences << rest if rest.from and rest.to }
+      sentence
     end
 
-    # Implementation of the subsentence detection method. This method
-    # changes the `@subsentences` ivar.
-    #
-    # @return [nil] nothing.
-    #
-    def detect_subsentences!
-      @subsentences = SortedSet.new
+    nil.tap { @sentences << rest if rest.from and rest.to }
+  end
 
-      rest = tokens.inject(new_subsentence) do |subsentence, token|
-        if !subsentence.from and SENTENCE_DOESNT_START.include?(token.type)
-          next subsentence
-        end
+  # Implementation of the subsentence detection method. This method
+  # changes the `@subsentences` ivar.
+  #
+  # @return [nil] nothing.
+  #
+  def detect_subsentences!
+    @subsentences = SortedSet.new
 
-        subsentence.from = token.from unless subsentence.from
+    rest = tokens.inject(new_subsentence) do |subsentence, token|
+      if !subsentence.from and SENTENCE_DOESNT_START.include?(token.type)
+        next subsentence
+      end
 
-        next subsentence if subsentence.to and subsentence.to > token.to
+      subsentence.from = token.from unless subsentence.from
 
-        if [:punct, :spunct].include? token.type
-          subsentence.to = tokens.
-            select { |t| t.from >= token.from }.
-            inject(token) { |r, t| break r if t.type != token.type; t }.
-            to
+      next subsentence if subsentence.to and subsentence.to > token.to
 
-          @subsentences << subsentence
-          subsentence = new_subsentence
-        elsif :separ != token.type
-          subsentence.to = token.to
-        end
+      if [:punct, :spunct].include? token.type
+        subsentence.to = tokens.
+          select { |t| t.from >= token.from }.
+          inject(token) { |r, t| break r if t.type != token.type; t }.
+          to
 
-        subsentence
+        @subsentences << subsentence
+        subsentence = new_subsentence
+      elsif :separ != token.type
+        subsentence.to = token.to
       end
 
-      nil.tap { @subsentences << rest if rest.from and rest.to }
+      subsentence
     end
 
+    nil.tap { @subsentences << rest if rest.from and rest.to }
+  end
+
   private
-    # Create a new instance of {Greeb::Entity} with `:sentence` type.
-    #
-    # @return [Greeb::Entity] a new entity instance.
-    #
-    def new_sentence
-      Greeb::Entity.new(nil, nil, :sentence)
-    end
+  # Create a new instance of {Greeb::Entity} with `:sentence` type.
+  #
+  # @return [Greeb::Entity] a new entity instance.
+  #
+  def new_sentence
+    Greeb::Entity.new(nil, nil, :sentence)
+  end
 
-    # Create a new instance of {Greeb::Entity} with `:subsentence` type.
-    #
-    # @return [Greeb::Entity] a new entity instance.
-    #
-    def new_subsentence
-      Greeb::Entity.new(nil, nil, :subsentence)
-    end
+  # Create a new instance of {Greeb::Entity} with `:subsentence` type.
+  #
+  # @return [Greeb::Entity] a new entity instance.
+  #
+  def new_subsentence
+    Greeb::Entity.new(nil, nil, :subsentence)
+  end
 end

data/lib/greeb/tokenizer.rb

@@ -5,24 +5,9 @@
 # Unicode character categories been obtained from
 # <http://www.fileformat.info/info/unicode/category/index.htm>.
 #
-class Greeb::Tokenizer
-  # This runtime error appears when {Greeb::Tokenizer} tries to recognize
-  # unknown character.
-  #
-  class UnknownEntity < RuntimeError
-    attr_reader :text, :pos
-
-    # @private
-    def initialize(text, pos)
-      @text, @pos = text, pos
-    end
-
-    # Generate the real error message.
-    #
-    def to_s
-      'Could not recognize character "%s" @ %d' % [text[pos], pos]
-    end
-  end
+module Greeb::Tokenizer
+  # http://www.youtube.com/watch?v=eF1lU-CrQfc
+  extend self
 
   # English and Russian letters.
   #
@@ -56,83 +41,67 @@ class Greeb::Tokenizer
   #
   RESIDUALS = /[\p{C}\p{M}\p{Sk}]+/u
 
-  attr_reader :text, :scanner
-  protected :scanner
-
-  # Create a new instance of {Greeb::Tokenizer}.
+  # Perform the tokenization process.
   #
-  # @param text [String] text to be tokenized.
+  # @return [Array<Greeb::Entity>] a set of tokens.
   #
-  def initialize(text)
-    @text = text
+  def tokenize text
+    scanner = Greeb::StringScanner.new(text)
+    tokens = []
+    while !scanner.eos?
+      parse! scanner, tokens, LETTERS, :letter or
+      parse! scanner, tokens, FLOATS, :float or
+      parse! scanner, tokens, INTEGERS, :integer or
+      split_parse! scanner, tokens, SENTENCE_PUNCTUATIONS, :spunct or
+      split_parse! scanner, tokens, PUNCTUATIONS, :punct or
+      split_parse! scanner, tokens, SEPARATORS, :separ or
+      split_parse! scanner, tokens, BREAKS, :break or
+      parse! scanner, tokens, RESIDUALS, :residual or
+      raise Greeb::UnknownEntity.new(text, scanner.char_pos)
+    end
+    tokens
+  ensure
+    scanner.terminate
   end
 
-  # Tokens memoization method.
+  private
+  # Try to parse one small piece of text that is covered by pattern
+  # of necessary type.
   #
-  # @return [Array<Greeb::Entity>] a set of tokens.
+  # @param scanner [Greeb::StringScanner] string scanner.
+  # @param tokens [Array<Greeb::Entity>] result array.
+  # @param pattern [Regexp] a regular expression to extract the token.
+  # @param type [Symbol] a symbol that represents the necessary token
+  #   type.
   #
-  def tokens
-    tokenize! unless @tokens
-    @tokens
+  # @return [Array<Greeb::Entity>] the modified set of extracted tokens.
+  #
+  def parse! scanner, tokens, pattern, type
+    return false unless token = scanner.scan(pattern)
+    position = scanner.char_pos
+    tokens << Greeb::Entity.new(position - token.length,
+                                position,
+                                type)
   end
 
-  protected
-    # Perform the tokenization process. This method modifies
-    # `@scanner` and `@tokens` instance variables.
-    #
-    # @return [nil] nothing unless exception is raised.
-    #
-    def tokenize!
-      @scanner = Greeb::StringScanner.new(text)
-      @tokens = []
-      while !scanner.eos?
-        parse! LETTERS, :letter or
-        parse! FLOATS, :float or
-        parse! INTEGERS, :integer or
-        split_parse! SENTENCE_PUNCTUATIONS, :spunct or
-        split_parse! PUNCTUATIONS, :punct or
-        split_parse! SEPARATORS, :separ or
-        split_parse! BREAKS, :break or
-        parse! RESIDUALS, :residual or
-        raise UnknownEntity.new(text, scanner.char_pos)
-      end
-    ensure
-      scanner.terminate
-    end
-
-    # Try to parse one small piece of text that is covered by pattern
-    # of necessary type.
-    #
-    # @param pattern [Regexp] a regular expression to extract the token.
-    # @param type [Symbol] a symbol that represents the necessary token
-    #   type.
-    #
-    # @return [Array<Greeb::Entity>] the modified set of extracted tokens.
-    #
-    def parse! pattern, type
-      return false unless token = scanner.scan(pattern)
-      position = scanner.char_pos
-      @tokens << Greeb::Entity.new(position - token.length,
-                                   position,
-                                   type)
-    end
-
-    # Try to parse one small piece of text that is covered by pattern
-    # of necessary type. This method performs grouping of the same
-    # characters.
-    #
-    # @param pattern [Regexp] a regular expression to extract the token.
-    # @param type [Symbol] a symbol that represents the necessary token
-    #   type.
-    #
-    # @return [Array<Greeb::Entity>] the modified set of extracted tokens.
-    #
-    def split_parse! pattern, type
-      return false unless token = scanner.scan(pattern)
-      position = scanner.char_pos - token.length
-      token.scan(/((.|\n)\2*)/).map(&:first).inject(position) do |before, s|
-        @tokens << Greeb::Entity.new(before, before + s.length, type)
-        before + s.length
-      end
+  # Try to parse one small piece of text that is covered by pattern
+  # of necessary type. This method performs grouping of the same
+  # characters.
+  #
+  # @param scanner [Greeb::StringScanner] string scanner.
+  # @param tokens [Array<Greeb::Entity>] result array.
+  # @param pattern [Regexp] a regular expression to extract the token.
+  # @param type [Symbol] a symbol that represents the necessary token
+  #   type.
+  #
+  # @return [Array<Greeb::Entity>] the modified set of extracted tokens.
+  #
+  def split_parse! scanner, tokens, pattern, type
+    return false unless token = scanner.scan(pattern)
+    position = scanner.char_pos - token.length
+    token.scan(/((.|\n)\2*)/).map(&:first).inject(position) do |before, s|
+      tokens << Greeb::Entity.new(before, before + s.length, type)
+      before + s.length
     end
+  end
 end

data/lib/greeb/version.rb

@@ -5,5 +5,5 @@
 module Greeb
   # Version of Greeb.
   #
-  VERSION = '0.1.0.rc7'
+  VERSION = '0.1.0.rc8'
 end

data/spec/segmentator_spec.rb

@@ -5,16 +5,11 @@ require File.expand_path('../spec_helper', __FILE__)
 module Greeb
   describe Segmentator do
     describe 'initialization' do
-      before { @tokenizer = Tokenizer.new('Vodka') }
+      let(:tokens) { Tokenizer.tokenize('Vodka') }
 
-      subject { Segmentator.new(@tokenizer) }
+      subject { Segmentator.new(tokens) }
 
-      it 'can be initialized either with Tokenizer' do
-        subject.tokens.must_be_kind_of Array
-      end
-
-      it 'can be initialized either with a set of tokens' do
-        subject = Segmentator.new(@tokenizer.tokens)
+      it 'is initialized either with set of tokens' do
         subject.tokens.must_be_kind_of Array
       end
 
@@ -24,75 +19,64 @@ module Greeb
     end
 
     describe 'a simple sentence' do
-      before { @tokenizer = Tokenizer.new('Hello, I am JC Denton.') }
+      let(:tokens) { Tokenizer.tokenize('Hello, I am JC Denton.') }
 
-      subject { Segmentator.new(@tokenizer).sentences }
+      subject { Segmentator.new(tokens).sentences }
 
       it 'should be segmented' do
-        subject.must_equal(
-          [Entity.new(0, 22, :sentence)]
-        )
+        subject.must_equal([Entity.new(0, 22, :sentence)])
       end
     end
 
     describe 'a simple sentence without punctuation' do
-      before { @tokenizer = Tokenizer.new('Hello, I am JC Denton') }
+      let(:tokens) { Tokenizer.tokenize('Hello, I am JC Denton') }
 
-      subject { Segmentator.new(@tokenizer).sentences }
+      subject { Segmentator.new(tokens).sentences }
 
       it 'should be segmented' do
-        subject.must_equal(
-          [Entity.new(0, 21, :sentence)]
-        )
+        subject.must_equal([Entity.new(0, 21, :sentence)])
       end
     end
 
     describe 'a simple sentence with trailing whitespaces' do
-      before { @tokenizer = Tokenizer.new('      Hello, I am JC Denton  ') }
+      let(:tokens) { Tokenizer.tokenize('      Hello, I am JC Denton  ') }
 
-      subject { Segmentator.new(@tokenizer).sentences }
+      subject { Segmentator.new(tokens).sentences }
 
       it 'should be segmented' do
-        subject.must_equal(
-          [Entity.new(6, 27, :sentence)]
-        )
+        subject.must_equal([Entity.new(6, 27, :sentence)])
       end
     end
 
     describe 'two simple sentences' do
-      before { @tokenizer = Tokenizer.new('Hello! I am JC Denton.') }
+      let(:tokens) { Tokenizer.tokenize('Hello! I am JC Denton.') }
 
-      subject { Segmentator.new(@tokenizer).sentences }
+      subject { Segmentator.new(tokens).sentences }
 
       it 'should be segmented' do
-        subject.must_equal(
-          [Entity.new(0, 6,  :sentence),
-           Entity.new(7, 22, :sentence)]
-        )
+        subject.must_equal([Entity.new(0, 6,  :sentence),
+                            Entity.new(7, 22, :sentence)])
       end
     end
 
     describe 'one wrong character and one simple sentence' do
-      before { @tokenizer = Tokenizer.new('! I am JC Denton.') }
+      let(:tokens) { Tokenizer.tokenize('! I am JC Denton.') }
 
-      subject { Segmentator.new(@tokenizer).sentences }
+      subject { Segmentator.new(tokens).sentences }
 
       it 'should be segmented' do
-        subject.must_equal(
-          [Entity.new(2, 17, :sentence)]
-        )
+        subject.must_equal([Entity.new(2, 17, :sentence)])
       end
     end
 
-    describe 'token extractor' do
-      before { @tokenizer = Tokenizer.new('Hello! I am JC Denton.') }
+    describe 'sentence extractor' do
+      let(:tokens) { Tokenizer.tokenize('Hello! I am JC Denton.') }
+      let(:segmentator) { Segmentator.new(tokens) }
 
-      subject { Segmentator.new(@tokenizer) }
-
-      let(:sentences) { subject.sentences }
+      subject { segmentator.extract(segmentator.sentences) }
 
       it 'should be extracted' do
-        subject.extract(*sentences).must_equal({
+        subject.must_equal(
           Entity.new(0,  6, :sentence) => [
             Entity.new(0, 5, :letter),
             Entity.new(5, 6, :punct)
@@ -107,24 +91,23 @@ module Greeb
             Entity.new(15, 21, :letter),
             Entity.new(21, 22, :punct)
           ]
-        })
+        )
       end
     end
 
     describe 'subsentence extractor' do
-      before { @tokenizer = Tokenizer.new('Hello, I am JC Denton.') }
-
-      subject { Segmentator.new(@tokenizer) }
+      let(:tokens) { Tokenizer.tokenize('Hello, I am JC Denton.') }
+      let(:segmentator) { Segmentator.new(tokens) }
 
-      let(:sentences) { subject.sentences }
+      subject { segmentator.subextract(segmentator.sentences) }
 
       it 'should extract subsentences' do
-        subject.subextract(*sentences).must_equal({
+        subject.must_equal(
           Entity.new(0,  22, :sentence) => [
             Entity.new(0, 6, :subsentence),
             Entity.new(7, 22, :subsentence)
           ]
-        })
+        )
       end
     end
   end

data/spec/tokenizer_spec.rb

@@ -4,59 +4,35 @@ require File.expand_path('../spec_helper', __FILE__)
 
 module Greeb
   describe Tokenizer do
-    describe 'initialization' do
-      subject { Tokenizer.new('vodka') }
-
-      it 'should be initialized with a text' do
-        subject.text.must_equal 'vodka'
-      end
-
-      it 'should has the @text ivar' do
-        subject.instance_variable_get(:@text).must_equal 'vodka'
-      end
-
-      it 'should not has @tokens ivar' do
-        subject.instance_variable_get(:@tokens).must_be_nil
-      end
-    end
-
     describe 'after tokenization' do
-      subject { Tokenizer.new('vodka').tap(&:tokens) }
-
-      it 'should has the @tokens ivar' do
-        subject.instance_variable_get(:@tokens).wont_be_nil
-      end
-
-      it 'should has the @scanner ivar' do
-        subject.instance_variable_get(:@scanner).wont_be_nil
-      end
+      subject { Tokenizer.tokenize('vodka') }
 
       it 'should has the tokens set' do
-        subject.tokens.must_be_kind_of Array
+        subject.must_be_kind_of Array
       end
     end
 
     describe 'tokenization facilities' do
       it 'can handle words' do
-        Tokenizer.new('hello').tokens.must_equal(
+        Tokenizer.tokenize('hello').must_equal(
           [Entity.new(0, 5, :letter)]
         )
       end
 
       it 'can handle floats' do
-        Tokenizer.new('14.88').tokens.must_equal(
+        Tokenizer.tokenize('14.88').must_equal(
           [Entity.new(0, 5, :float)]
         )
       end
 
       it 'can handle integers' do
-        Tokenizer.new('1337').tokens.must_equal(
+        Tokenizer.tokenize('1337').must_equal(
           [Entity.new(0, 4, :integer)]
         )
       end
 
       it 'can handle words and integers' do
-        Tokenizer.new('Hello, I am 18').tokens.must_equal(
+        Tokenizer.tokenize('Hello, I am 18').must_equal(
           [Entity.new(0,  5,  :letter),
            Entity.new(5,  6,  :spunct),
            Entity.new(6,  7,  :separ),
@@ -69,7 +45,7 @@ module Greeb
       end
 
       it 'can handle multi-line paragraphs' do
-        Tokenizer.new("Brateeshka..!\n\nPrines!").tokens.must_equal(
+        Tokenizer.tokenize("Brateeshka..!\n\nPrines!").must_equal(
           [Entity.new(0,  10, :letter),
            Entity.new(10, 12, :punct),
            Entity.new(12, 13, :punct),
@@ -80,7 +56,7 @@ module Greeb
       end
 
       it 'can handle separated integers' do
-        Tokenizer.new('228/359').tokens.must_equal(
+        Tokenizer.tokenize('228/359').must_equal(
           [Entity.new(0, 3, :integer),
            Entity.new(3, 4, :separ),
            Entity.new(4, 7, :integer)]
@@ -88,7 +64,7 @@ module Greeb
       end
 
       it 'can deal with Russian language' do
-        Tokenizer.new('Братишка, я тебе покушать принёс!').tokens.must_equal(
+        Tokenizer.tokenize('Братишка, я тебе покушать принёс!').must_equal(
           [Entity.new(0,  8,  :letter),
            Entity.new(8,  9,  :spunct),
            Entity.new(9,  10, :separ),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: greeb
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc7
+  version: 0.1.0.rc8
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-14 00:00:00.000000000 Z
+date: 2012-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +109,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      hash: 2716089438708653231
+      hash: -482579338117024513
       version: '0'
       segments:
       - 0