treat 2.0.3 → 2.0.4

data/spec/entities/phrase.rb

@@ -1,27 +1,31 @@
-describe Treat::Entities::Phrase do
+module Treat::Specs::Entities
 
-  describe "Buildable" do
+  describe Treat::Entities::Phrase do
 
-    describe "#build" do
+    describe "Buildable" do
 
-      context "when supplied with a sentence" do
+      describe "#build" do
+
+        context "when supplied with a sentence" do
+
+          it "creates a sentence with the text" do
+            sentence = "This is a sentence."
+            s = Treat::Entities::Phrase.build(sentence)
+            s.type.should eql :sentence
+            s.to_s.should eql sentence
+          end
 
-        it "creates a sentence with the text" do
-          sentence = "This is a sentence."
-          s = Treat::Entities::Phrase.build(sentence)
-          s.type.should eql :sentence
-          s.to_s.should eql sentence
         end
 
-      end
+        context "when supplied with a phrase" do
 
-      context "when supplied with a phrase" do
+          it "creates a phrase with the text" do
+            phrase = "this is a phrase"
+            p = Treat::Entities::Phrase.build(phrase)
+            p.type.should eql :phrase
+            p.to_s.should eql phrase
+          end
 
-        it "creates a phrase with the text" do
-          phrase = "this is a phrase"
-          p = Treat::Entities::Phrase.build(phrase)
-          p.type.should eql :phrase
-          p.to_s.should eql phrase
         end
 
       end
@@ -30,4 +34,4 @@ describe Treat::Entities::Phrase do
 
   end
 
-end
+end

data/spec/entities/token.rb

@@ -1,55 +1,58 @@
 #encoding: utf-8
-describe Treat::Entities::Token do
+module Treat::Specs::Entities
 
-  describe "Buildable" do
+  describe Treat::Entities::Token do
 
-    describe "#build" do
+    describe "Buildable" do
 
-      context "when supplied with a word" do
-        it "creates a word with the text" do
-          t = Treat::Entities::Token.build('word')
-          t.should be_an_instance_of Treat::Entities::Word
-          t.to_s.should eql 'word'
+      describe "#build" do
+
+        context "when supplied with a word" do
+          it "creates a word with the text" do
+            t = Treat::Entities::Token.build('word')
+            t.should be_an_instance_of Treat::Entities::Word
+            t.to_s.should eql 'word'
+          end
         end
-      end
 
-      context "when supplied with a number or a string representing a numerical quantity" do
-        it "creates a number" do
-          t = Treat::Entities::Token.build(2)
-          t2 = Treat::Entities::Token.build(2.2)
-          t3 = Treat::Entities::Token.build('2')
-          t4 = Treat::Entities::Token.build('2.2')
-          t.should be_an_instance_of Treat::Entities::Number
-          t2.should be_an_instance_of Treat::Entities::Number
-          t3.should be_an_instance_of Treat::Entities::Number
-          t4.should be_an_instance_of Treat::Entities::Number
-          t.to_i.should eql 2
-          t2.to_i.should eql 2
-          t3.to_i.should eql 2
-          t4.to_i.should eql 2
-          t.to_f.should eql 2.0
-          t2.to_f.should eql 2.2
-          t3.to_f.should eql 2.0
-          t4.to_f.should eql 2.2
+        context "when supplied with a number or a string representing a numerical quantity" do
+          it "creates a number" do
+            t = Treat::Entities::Token.build(2)
+            t2 = Treat::Entities::Token.build(2.2)
+            t3 = Treat::Entities::Token.build('2')
+            t4 = Treat::Entities::Token.build('2.2')
+            t.should be_an_instance_of Treat::Entities::Number
+            t2.should be_an_instance_of Treat::Entities::Number
+            t3.should be_an_instance_of Treat::Entities::Number
+            t4.should be_an_instance_of Treat::Entities::Number
+            t.to_i.should eql 2
+            t2.to_i.should eql 2
+            t3.to_i.should eql 2
+            t4.to_i.should eql 2
+            t.to_f.should eql 2.0
+            t2.to_f.should eql 2.2
+            t3.to_f.should eql 2.0
+            t4.to_f.should eql 2.2
+          end
         end
-      end
 
-      context "when supplied with a punctuation character" do
-        it "creates a punctuation with the text" do
-          t = Treat::Entities::Token.build('.')
-          t.should be_an_instance_of Treat::Entities::Punctuation
+        context "when supplied with a punctuation character" do
+          it "creates a punctuation with the text" do
+            t = Treat::Entities::Token.build('.')
+            t.should be_an_instance_of Treat::Entities::Punctuation
+          end
         end
-      end
 
-      context "when supplied with a symbol character" do
-        it "creates a symbol with the text" do
-          t = Treat::Entities::Token.build('¨')
-          t.should be_an_instance_of Treat::Entities::Symbol
+        context "when supplied with a symbol character" do
+          it "creates a symbol with the text" do
+            t = Treat::Entities::Token.build('¨')
+            t.should be_an_instance_of Treat::Entities::Symbol
+          end
         end
+
       end
-      
+
     end
 
   end
-
-end
+end

data/spec/entities/word.rb

@@ -1,3 +1,7 @@
-describe Treat::Entities::Word do
+module Treat::Specs::Entities
+
+  describe Treat::Entities::Word do
+
+  end
 
 end

data/spec/entities/zone.rb

@@ -1,43 +1,47 @@
-describe Treat::Entities::Zone do
+module Treat::Specs::Entities
 
-  describe "Buildable" do
+  describe Treat::Entities::Zone do
 
-    describe "#build" do
+    describe "Buildable" do
 
-      context "when called with a section of text" do
+      describe "#build" do
 
-        it "creates a section with the text" do
+        context "when called with a section of text" do
 
-          section = "A title\nFollowed by a fake sentence."
-          s = Treat::Entities::Zone.build(section)
-          s.should be_an_instance_of Treat::Entities::Section
+          it "creates a section with the text" do
+
+            section = "A title\nFollowed by a fake sentence."
+            s = Treat::Entities::Zone.build(section)
+            s.should be_an_instance_of Treat::Entities::Section
+
+          end
 
         end
 
-      end
+        context "when called with a paragraph of text" do
 
-      context "when called with a paragraph of text" do
+          it "creates a paragraph with the text" do
+            paragraph = "Sentence 1. Sentence 2. Sentence 3."
+            p = Treat::Entities::Zone.build(paragraph)
+            p.should be_instance_of Treat::Entities::Paragraph
+          end
 
-        it "creates a paragraph with the text" do
-          paragraph = "Sentence 1. Sentence 2. Sentence 3."
-          p = Treat::Entities::Zone.build(paragraph)
-          p.should be_instance_of Treat::Entities::Paragraph
         end
 
-      end
+        context "when called with a very short text" do
 
-      context "when called with a very short text" do
+          it "creates a title with the text" do
+            title = "A title!"
+            p = Treat::Entities::Zone.build(title)
+            p.should be_instance_of Treat::Entities::Title
+          end
 
-        it "creates a title with the text" do
-          title = "A title!"
-          p = Treat::Entities::Zone.build(title)
-          p.should be_instance_of Treat::Entities::Title
         end
 
       end
 
     end
-    
-  end
 
+  end
+  
 end

data/spec/helper.rb

@@ -7,7 +7,7 @@ module Treat::Specs
   require 'rspec'
   
   # Some configuration options for devel.
-
+=begin
   Treat.databases.mongo.db = 'treat_test'
   Treat.libraries.stanford.model_path =
   '/ruby/stanford-core-nlp-minimal/models/'
@@ -17,6 +17,11 @@ module Treat::Specs
   '/ruby/punkt/models/'
   Treat.libraries.reuters.model_path =
   '/ruby/reuters/models/'
+=end
+  # Mimic the ./lib structure.
+  module Entities; end
+  module Workers; end
+  module Learning; end
 
   ModuleFiles = ['entities/*.rb', 'learning/*.rb']
   
@@ -40,7 +45,7 @@ module Treat::Specs
     end
     
     # Run specs for the core classes.
-    def self.run_core_specs
+    def self.run_library_specs
       files = ModuleFiles.map do |d|
         Dir.glob(Treat.paths.spec + d)
       end

data/spec/learning/data_set.rb

@@ -1,174 +1,178 @@
-describe Treat::Learning::DataSet do
-
-  before do
-    @question = Treat::Learning::Question.new(:is_key_sentence, :sentence, 0, :continuous)
-    @feature = Treat::Learning::Feature.new(:word_count, 0)
-    @problem = Treat::Learning::Problem.new(@question, @feature)
-    @tag = Treat::Learning::Tag.new(:paragraph_length, 0,
-    "->(e) { e.parent_paragraph.word_count }")
-    @paragraph = Treat::Entities::Paragraph.new(
-    "Ranga and I went to the store. Meanwhile, Ryan was sleeping.")
-    @paragraph.do :segment, :tokenize
-    @sentence = @paragraph.sentences[0]
-    @data_set = Treat::Learning::DataSet.new(@problem)
-  end
+module Treat::Specs::Learning
+
+  describe Treat::Learning::DataSet do
+
+    before do
+      @question = Treat::Learning::Question.new(:is_key_sentence, :sentence, 0, :continuous)
+      @feature = Treat::Learning::Feature.new(:word_count, 0)
+      @problem = Treat::Learning::Problem.new(@question, @feature)
+      @tag = Treat::Learning::Tag.new(:paragraph_length, 0,
+      "->(e) { e.parent_paragraph.word_count }")
+      @paragraph = Treat::Entities::Paragraph.new(
+      "Ranga and I went to the store. Meanwhile, Ryan was sleeping.")
+      @paragraph.apply :segment, :tokenize
+      @sentence = @paragraph.sentences[0]
+      @data_set = Treat::Learning::DataSet.new(@problem)
+    end
 
-  describe "#initialize" do
-    context "when supplied with a problem" do
-      it "should initialize an empty data set" do
-        data_set = Treat::Learning::DataSet.new(@problem)
-        data_set.items.should eql []
-        data_set.problem.should eql @problem
+    describe "#initialize" do
+      context "when supplied with a problem" do
+        it "should initialize an empty data set" do
+          data_set = Treat::Learning::DataSet.new(@problem)
+          data_set.items.should eql []
+          data_set.problem.should eql @problem
+        end
       end
-    end
-    context "when supplied with an improper argument" do
-      it "should raise an error" do
-        # The argument to initialize should be a Problem.
-        expect { data_set = Treat::Learning::DataSet.new("foo") }.to raise_error
+      context "when supplied with an improper argument" do
+        it "should raise an error" do
+          # The argument to initialize should be a Problem.
+          expect { data_set = Treat::Learning::DataSet.new("foo") }.to raise_error
+        end
       end
     end
-  end
 
-  describe "#self.build" do
+    describe "#self.build" do
 
-  end
+    end
 
-  describe "#==(other_data_set)" do
-    context "when supplied with an equivalent data set" do
-      it "returns true" do
-        data_set1 = Treat::Learning::DataSet.new(@problem)
-        data_set2 = Treat::Learning::DataSet.new(@problem)
-        data_set1.should == data_set2
-        data_set1 << @sentence
-        data_set2 << @sentence
-        data_set1.should == data_set2
+    describe "#==(other_data_set)" do
+      context "when supplied with an equivalent data set" do
+        it "returns true" do
+          data_set1 = Treat::Learning::DataSet.new(@problem)
+          data_set2 = Treat::Learning::DataSet.new(@problem)
+          data_set1.should == data_set2
+          data_set1 << @sentence
+          data_set2 << @sentence
+          data_set1.should == data_set2
+        end
       end
-    end
 
-    context "when supplied with a non-equivalent data set" do
-      it "returns false" do
-        # Get two slightly different problems.
-        question1 = Treat::Learning::Question.new(
-        :is_key_sentence, :sentence, 0,  :continuous)
-        question2 = Treat::Learning::Question.new(
-        :is_key_word, :sentence, 0, :continuous)
-        problem1 = Treat::Learning::Problem.new(question1, @feature)
-        problem2 = Treat::Learning::Problem.new(question2, @feature)
-        # Then the problems shouldn't be equal anymore.
-        problem1.should_not == problem2
-        # Create data sets with the different problems.
-        data_set1 = Treat::Learning::DataSet.new(problem1)
-        data_set2 = Treat::Learning::DataSet.new(problem2)
-        # Then the data sets shouldn't be equal anymore.
-        data_set1.should_not == data_set2
-        # Create two data sets with the same problems.
-        data_set1 = Treat::Learning::DataSet.new(@problem)
-        data_set2 = Treat::Learning::DataSet.new(@problem)
-        # Then these should be equal.
-        data_set1.should == data_set2
-        # But when different items are added
-        data_set1 << Treat::Entities::Sentence.new(
-        "This sentence is not the same as the other.").tokenize
-        data_set2 << Treat::Entities::Sentence.new(
-        "This sentence is similar to the other.").tokenize
-        # They shouldn't be equal anymore.
-        data_set1.should_not == data_set2
+      context "when supplied with a non-equivalent data set" do
+        it "returns false" do
+          # Get two slightly different problems.
+          question1 = Treat::Learning::Question.new(
+          :is_key_sentence, :sentence, 0,  :continuous)
+          question2 = Treat::Learning::Question.new(
+          :is_key_word, :sentence, 0, :continuous)
+          problem1 = Treat::Learning::Problem.new(question1, @feature)
+          problem2 = Treat::Learning::Problem.new(question2, @feature)
+          # Then the problems shouldn't be equal anymore.
+          problem1.should_not == problem2
+          # Create data sets with the different problems.
+          data_set1 = Treat::Learning::DataSet.new(problem1)
+          data_set2 = Treat::Learning::DataSet.new(problem2)
+          # Then the data sets shouldn't be equal anymore.
+          data_set1.should_not == data_set2
+          # Create two data sets with the same problems.
+          data_set1 = Treat::Learning::DataSet.new(@problem)
+          data_set2 = Treat::Learning::DataSet.new(@problem)
+          # Then these should be equal.
+          data_set1.should == data_set2
+          # But when different items are added
+          data_set1 << Treat::Entities::Sentence.new(
+          "This sentence is not the same as the other.").tokenize
+          data_set2 << Treat::Entities::Sentence.new(
+          "This sentence is similar to the other.").tokenize
+          # They shouldn't be equal anymore.
+          data_set1.should_not == data_set2
+        end
       end
+
     end
 
-  end
+    describe "#merge" do
+      context "when supplied with two data sets refering to the same problem" do
+        it "merges the two together" do
+          # Create two data sets with the same problem.
+          data_set1 = Treat::Learning::DataSet.new(@problem)
+          data_set2 = Treat::Learning::DataSet.new(@problem)
+          # Add a sentence to each data set.
+          data_set1 << Treat::Entities::Sentence.new(
+          "This sentence is not the same as the other.").tokenize
+          data_set2 << Treat::Entities::Sentence.new(
+          "This sentence is similar to the other.").tokenize
+          # Merge the two data sets together.
+          data_set1.merge(data_set2)
+          # Check if the merge has occured properly.
+          data_set1.items.size.should eql 2
+          data_set1.items[1].should eql data_set2.items[0]
+        end
+      end
 
-  describe "#merge" do
-    context "when supplied with two data sets refering to the same problem" do
-      it "merges the two together" do
-        # Create two data sets with the same problem.
-        data_set1 = Treat::Learning::DataSet.new(@problem)
-        data_set2 = Treat::Learning::DataSet.new(@problem)
-        # Add a sentence to each data set.
-        data_set1 << Treat::Entities::Sentence.new(
-        "This sentence is not the same as the other.").tokenize
-        data_set2 << Treat::Entities::Sentence.new(
-        "This sentence is similar to the other.").tokenize
-        # Merge the two data sets together.
-        data_set1.merge(data_set2)
-        # Check if the merge has occured properly.
-        data_set1.items.size.should eql 2
-        data_set1.items[1].should eql data_set2.items[0]
+      context "when supplied with two data sets refering to different problems" do
+        it "raises an error" do
+          # Get two slightly different questions.
+          question1 = Treat::Learning::Question.new(
+          :is_key_sentence, :sentence, 0, :continuous)
+          question2 = Treat::Learning::Question.new(
+          :is_key_word, :sentence, 0, :continuous)
+          # Create two problems with the different questions.
+          problem1 = Treat::Learning::Problem.new(question1, @feature)
+          problem2 = Treat::Learning::Problem.new(question2, @feature)
+          # Create two data sets with the different problems.
+          data_set1 = Treat::Learning::DataSet.new(problem1)
+          data_set2 = Treat::Learning::DataSet.new(problem2)
+          # Add elements to each of the data sets.
+          data_set1 << Treat::Entities::Sentence.new(
+          "This sentence is not the same as the other.").tokenize
+          data_set2 << Treat::Entities::Sentence.new(
+          "This sentence is similar to the other.").tokenize
+          # Try to merge them; but this should fail.
+          expect { data_set1.merge(data_set2) }.to raise_error
+        end
       end
     end
-    
-    context "when supplied with two data sets refering to different problems" do
-      it "raises an error" do
-        # Get two slightly different questions.
-        question1 = Treat::Learning::Question.new(
-        :is_key_sentence, :sentence, 0, :continuous)
-        question2 = Treat::Learning::Question.new(
-        :is_key_word, :sentence, 0, :continuous)
-        # Create two problems with the different questions.
-        problem1 = Treat::Learning::Problem.new(question1, @feature)
-        problem2 = Treat::Learning::Problem.new(question2, @feature)
-        # Create two data sets with the different problems.
-        data_set1 = Treat::Learning::DataSet.new(problem1)
-        data_set2 = Treat::Learning::DataSet.new(problem2)
-        # Add elements to each of the data sets.
-        data_set1 << Treat::Entities::Sentence.new(
-        "This sentence is not the same as the other.").tokenize
-        data_set2 << Treat::Entities::Sentence.new(
-        "This sentence is similar to the other.").tokenize
-        # Try to merge them; but this should fail.
-        expect { data_set1.merge(data_set2) }.to raise_error
+
+    describe "#<<(entity)" do
+      context "when supplied with a proper entity" do
+        it "exports the features and tags and adds them to the data set" do
+          problem = Treat::Learning::Problem.new(@question, @feature, @tag)
+          data_set = Treat::Learning::DataSet.new(problem)
+          data_set << @sentence
+          data_set.items.tap { |e| e[0][:id] = 0 }.
+          should eql [{:tags=>[11], :features=>[7, 0], :id=>0}]
+        end
       end
     end
-  end
 
-  describe "#<<(entity)" do
-    context "when supplied with a proper entity" do
-      it "exports the features and tags and adds them to the data set" do
-        problem = Treat::Learning::Problem.new(@question, @feature, @tag)
-        data_set = Treat::Learning::DataSet.new(problem)
-        data_set << @sentence
-        data_set.items.tap { |e| e[0][:id] = 0 }.
-        should eql [{:tags=>[11], :features=>[7, 0], :id=>0}]
+    describe "#serialize" do
+      context "when asked to use a given adapter" do
+        it "calls the corresponding #to_something method" do
+
+        end
       end
     end
-  end
 
-  describe "#serialize" do
-    context "when asked to use a given adapter" do
-      it "calls the corresponding #to_something method" do
-        
+    describe "#to_marshal, #self.from_marshal" do
+      context "when asked to successively serialize and deserialize data" do
+        it "completes a round trip without losing information" do
+          problem = Treat::Learning::Problem.new(@question, @feature, @tag)
+          data_set = Treat::Learning::DataSet.new(problem)
+          data_set << @sentence
+          data_set.to_marshal(file: 'test.dump')
+          Treat::Learning::DataSet.from_marshal(
+          file: 'test.dump').should == data_set
+          FileUtils.rm('test.dump')
+        end
       end
     end
-  end
 
-  describe "#to_marshal, #self.from_marshal" do
-    context "when asked to successively serialize and deserialize data" do
-      it "completes a round trip without losing information" do
-        problem = Treat::Learning::Problem.new(@question, @feature, @tag)
-        data_set = Treat::Learning::DataSet.new(problem)
-        data_set << @sentence
-        data_set.to_marshal(file: 'test.dump')
-        Treat::Learning::DataSet.from_marshal(
-        file: 'test.dump').should == data_set
-        FileUtils.rm('test.dump')
-      end
+    describe "#to_mongo" do
+
     end
-  end
 
-  describe "#to_mongo" do
-    
-  end
+    describe "#self.unserialize" do
+      context "when asked to use a given adapter" do
+        it "calls the corresponding #to_something method" do
 
-  describe "#self.unserialize" do
-    context "when asked to use a given adapter" do
-      it "calls the corresponding #to_something method" do
-        
+        end
       end
     end
-  end
 
-  describe "#self.from_mongo" do
+    describe "#self.from_mongo" do
+
+    end
 
   end
 
-end
+end