treat 1.1.2 → 1.2.0

data/spec/core.rb

@@ -1,32 +1,441 @@
-require_relative '../lib/treat'
+require_relative 'helper'
+
+describe Treat::Core::Question do
+
+  describe "#initialize" do
+    context "when supplied with acceptable parameters" do
+      it "should give access to the parameters" do
+        question = Treat::Core::Question.new(
+        :is_keyword, :word, :continuous, 0, [0, 1])
+        question.name.should eql :is_keyword
+        question.target.should eql :word
+        question.type.should eql :continuous
+        question.default.should eql 0
+        question.labels.should eql [0, 1]
+      end
+    end
+    context "when supplied with wrong parameters" do
+      it "should raise an exception" do
+        # Name should be a symbol
+        expect { Treat::Core::Question.new(
+        nil, :sentence) }.to raise_error
+        # Target should be an actual entity type
+        expect { Treat::Core::Question.new(
+        :name, :foo) }.to raise_error
+        # Distribution type should be continuous or discrete
+        expect { Treat::Core::Question.new(
+        :name, :sentence, :nonsense) }.to raise_error
+      end
+    end
+  end
+
+  describe "#==(question)" do
+    context "when supplied with an equal question" do
+      it "should return true" do
+        Treat::Core::Question.new(
+        :is_keyword, :word).
+        should == Treat::Core::Question.new(
+        :is_keyword, :word)
+        Treat::Core::Question.new(
+        :is_keyword, :word, :continuous).
+        should == Treat::Core::Question.new(
+        :is_keyword, :word, :continuous)
+        Treat::Core::Question.new(
+        :is_keyword, :word, :continuous, [0, 1]).
+        should == Treat::Core::Question.new(
+        :is_keyword, :word, :continuous, [0, 1])
+      end
+    end
+    context "when supplied with a different question" do
+      it "should return false" do
+        Treat::Core::Question.new(
+        :is_keyword, :word).
+        should_not == Treat::Core::Question.new(
+        :is_keyword, :sentence)
+        Treat::Core::Question.new(
+        :is_keyword, :word, :continuous).
+        should_not == Treat::Core::Question.new(
+        :is_keyword, :word, :discrete)
+        Treat::Core::Question.new(
+        :is_keyword, :word, :continuous, [0, 1]).
+        should_not == Treat::Core::Question.new(
+        :is_keyword, :word, :continuous, [1, 0])
+      end
+    end
+  end
+
+end
+
+describe Treat::Core::Export do
+
+  describe "#initialize" do
+    context "when supplied with acceptable parameters" do
+      it "should give access to the parameters" do
+        export = Treat::Core::Export.new(:name, 0, "->(e) { e }")
+        export.name.should eql :name
+        export.default.should eql 0
+        export.proc_string.should eql "->(e) { e }"
+        export.proc.should be_instance_of Proc
+        export.proc.call('x').should eql 'x'
+      end
+    end
+    context "when supplied with wrong parameters" do
+      it "should raise an exception" do
+        # First argument should be a symbol representing the name of the export.
+        expect { Treat::Core::Export.new(nil) }.to raise_error
+        # Third argument, if supplied, should be a string that
+        # evaluates to a proc (NOT a proc/lambda).
+        expect { Treat::Core::Export.new(:name, 0, lambda { x } ) }.to raise_error
+        # Third argument should be proper ruby syntax.
+        expect { Treat::Core::Export.new(:name, 0, "->(e) { ") }.to raise_error
+        # Third argument should evaluate to a proc.
+        expect { Treat::Core::Export.new(:name, 0, "2") }.to raise_error
+      end
+    end
+  end
+
+  describe "#==(question)" do
+    context "when supplied with an equal question" do
+      it "should return true" do
+        Treat::Core::Export.new(:name).
+        should == Treat::Core::Export.new(:name)
+        Treat::Core::Export.new(:name, 0).
+        should == Treat::Core::Export.new(:name, 0)
+        Treat::Core::Export.new(:name, 0, "->(e) { }").
+        should == Treat::Core::Export.new(:name, 0, "->(e) { }")
+      end
+    end
+    context "when supplied with a different question" do
+      it "should return false" do
+        Treat::Core::Export.new(:name).
+        should_not == Treat::Core::Export.new(:name2)
+        Treat::Core::Export.new(:name, 0).
+        should_not == Treat::Core::Export.new(:name, 1)
+        Treat::Core::Export.new(:name, 0, "->(e) { }").
+        should_not == Treat::Core::Export.new(:name, 0, "->(e) { x }")
+      end
+    end
+  end
+
+end
 
 describe Treat::Core::DataSet do
-=begin
 
+  before do
+    @question = Treat::Core::Question.new(:is_key_sentence, :sentence, :continuous, 0, [0, 1])
+    @feature = Treat::Core::Feature.new(:word_count, 0)
+    @problem = Treat::Core::Problem.new(@question, @feature)
+    @tag = Treat::Core::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::Core::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::Core::DataSet.new(@problem)
+          data_set.items.should eql []
+          data_set.problem.should eql @problem
+        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::Core::DataSet.new("foo") }.to raise_error
+        end
+      end
+    end
+
+    describe "#self.build" do
+
+    end
+
+    describe "#==(other_data_set)" do
+      context "when supplied with an equivalent data set" do
+        it "returns true" do
+          data_set1 = Treat::Core::DataSet.new(@problem)
+          data_set2 = Treat::Core::DataSet.new(@problem)
+          data_set1.should == data_set2
+          data_set1 << @sentence
+          data_set2 << @sentence
+          data_set1.should == data_set2
+        end
+      end
+
+      context "when supplied with a non-equivalent data set" do
+        it "returns false" do
+          # Get two slightly different problems.
+          question1 = Treat::Core::Question.new(
+          :is_key_sentence, :sentence, :continuous, 0, [0, 1])
+          question2 = Treat::Core::Question.new(
+          :is_key_word, :sentence, :continuous, 0, [1, 1])
+          problem1 = Treat::Core::Problem.new(question1, @feature)
+          problem2 = Treat::Core::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::Core::DataSet.new(problem1)
+          data_set2 = Treat::Core::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::Core::DataSet.new(@problem)
+          data_set2 = Treat::Core::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
+
+    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::Core::DataSet.new(@problem)
+          data_set2 = Treat::Core::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
+      
+      context "when supplied with two data sets refering to different problems" do
+        it "raises an error" do
+          # Get two slightly different questions.
+          question1 = Treat::Core::Question.new(
+          :is_key_sentence, :sentence, :continuous, 0, [0, 1])
+          question2 = Treat::Core::Question.new(
+          :is_key_word, :sentence, :continuous, 0, [1, 1])
+          # Create two problems with the different questions.
+          problem1 = Treat::Core::Problem.new(question1, @feature)
+          problem2 = Treat::Core::Problem.new(question2, @feature)
+          # Create two data sets with the different problems.
+          data_set1 = Treat::Core::DataSet.new(problem1)
+          data_set2 = Treat::Core::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
+
+    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::Core::Problem.new(@question, @feature, @tag)
+          data_set = Treat::Core::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
+
+    describe "#serialize" do
+      context "when asked to use a given adapter" do
+        it "calls the corresponding #to_something method" do
+          
+        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::Core::Problem.new(@question, @feature, @tag)
+          data_set = Treat::Core::DataSet.new(problem)
+          data_set << @sentence
+          data_set.to_marshal(file: 'test.dump')
+          Treat::Core::DataSet.from_marshal(
+          file: 'test.dump').should == data_set
+          FileUtils.rm('test.dump')
+        end
+      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
+          
+        end
+      end
+    end
+
+    describe "#self.from_mongo" do
+
+    end
+
+  end
+
+  describe Treat::Core::Problem do
+
+    before do
+      @question = Treat::Core::Question.new(:is_key_sentence,
+      :sentence, :continuous, 0, [0, 1])
+      @feature = Treat::Core::Feature.new(:word_count, 0)
+      @tag = Treat::Core::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]
+        @hash = {"question"=>{"name"=>:is_key_sentence, "target"=>:sentence,
+        "type"=>:continuous, "default"=>0, "labels"=>[0, 1]}, "features"=>[
+        {"proc_string"=>nil, "default"=>0, "name"=>:word_count, "proc"=>nil}],
+        "tags"=>[{"proc_string"=>"->(e) { e.parent_paragraph.word_count }",
+        "default"=>0, "name"=>:paragraph_length, "proc"=>nil}], "id"=>0}
+      end
 
-p = Problem(
-  Question(:is_key_sentence, :sentence, false),
-  Feature(:word_count, 0)
-)
+      describe "#initialize" do
+        context "when supplied with proper arguments" do
+          it "initializes the problem and gives access to parameters" do
+            problem = Treat::Core::Problem.new(@question, @feature, @tag)
+            problem.question.should eql @question
+            problem.features.should eql [@feature]
+            problem.tags.should eql [@tag]
+            problem.feature_labels.should eql [@feature.name]
+            problem.tag_labels.should eql [@tag.name]
+            # ID ???      FIXME
+          end
+        end
+        context "when supplied with unacceptable arguments" do
+          it "raises an error" do
+            # First argument should be instance of Question.
+            expect { Treat::Core::Problem.new('foo') }.to raise_error
+            # Arguments >= 2 should be instances of Export.
+            expect { Treat::Core::Problem.new(@question, 'foo') }.to raise_error
+            # Should have at least one Feature in the arguments.
+            expect { Treat::Core::Problem.new(@question, @tag) }.to raise_error
+          end
+        end
+      end
 
-p2 = Problem(
-  Question(:is_key_sentence, :sentence, false),
-  Feature(:word_count, 0)
-)
+      describe "#==(problem)" do
+        context "when supplied with an equal problem" do
+          it "should return true" do
+            Treat::Core::Problem.new(@question, @feature).
+            should == Treat::Core::Problem.new(@question, @feature)
+            Treat::Core::Problem.new(@question, @feature, @tag).
+            should == Treat::Core::Problem.new(@question, @feature, @tag)
+          end
+        end
+        context "when supplied with a different question" do
+          it "should return false" do
+            question = Treat::Core::Question.new(:is_key_sentence, :sentence)
+            feature = Treat::Core::Feature.new(:word_count, 999)
+            tag = Treat::Core::Tag.new(:paragraph_length, 999)
+            Treat::Core::Problem.new(@question, @feature).
+            should_not == Treat::Core::Problem.new(question, @feature)
+            Treat::Core::Problem.new(@question, @feature).
+            should_not == Treat::Core::Problem.new(@question, feature)
+            Treat::Core::Problem.new(@question, @feature, @tag).
+            should_not == Treat::Core::Problem.new(@question, @feature, tag)
+          end
+        end
+      end
 
-ds = DataSet(p)
+      describe "#export_tags(entity)" do
+        context "when called on a problem that has tags" do
+          context "and called with an entity of the proper type" do
+            it "returns an array of the tags" do
+              problem = Treat::Core::Problem.new(@question, @feature, @tag)
+              problem.export_tags(@sentence).should eql [11]
+            end
+          end
+        end
+        context "when called on a problem that doesn't have tags" do
+          it "raises an error" do
+            problem = Treat::Core::Problem.new(@question, @feature)
+            expect { problem.export_tags(@sentence) }.to raise_error
+          end
+        end
+      end
 
-text = Paragraph("Welcome to the zoo! This is a text.")
-text2 = Paragraph("Welcome here my friend. This is well, a text.")
+      describe "#export_features(entity, include_answer = true)" do
 
-text.do :segment, :tokenize
-text2.do :segment, :tokenize
+        context "when called with an entity of the proper type" do
+          context "and include_answer is set to true" do
+            context "and the answer is already set on the entity" do
+              it "returns an array of the exported features, with the answer" do
+                problem = Treat::Core::Problem.new(@question, @feature)
+                @sentence.set :is_key_sentence, 1
+                problem.export_features(@sentence).should eql [7, 1]
+              end
+            end
+            context "and the answer is not already set on the entity" do
+              it "returns an array of the exported features, with the question's default answer" do
+                problem = Treat::Core::Problem.new(@question, @feature)
+                problem.export_features(@sentence).should eql [7, @question.default]
+              end
+            end
+          end
+          context "and include_answer is set to false" do
+            it "returns an array of the exported features, without the answer" do
+              problem = Treat::Core::Problem.new(@question, @feature)
+              problem.export_features(@sentence, false).should eql [7]
+            end
+          end
+        end
+        context "when supplied with an entity that is not of the proper type" do
+          it "raises an error" do
+            problem = Treat::Core::Problem.new(@question, @feature)
+            word = Treat::Entities::Word.new('test')
+            expect { problem.export_features(word) }.to raise_error
+          end
+        end
+      end
 
-ds1 = text.export(p)
-ds2 = text2.export(p2)
+      describe "#to_hash" do
+        context "when called on a problem" do
+          it "returns a hash describing the problem" do
+            Treat::Core::Problem.new(@question, @feature, @tag).
+            to_hash.tap { |e| e['id'] = 0 }.should eql @hash
+          end
+        end
+      end
 
-ds1.merge(ds2)
+      describe "#self.from_hash" do
+        context "when called with a hash describing a problem" do
+          it "returns a problem based on the hash" do
+            problem = Treat::Core::Problem.from_hash(@hash)
+            problem.question.name.should eql :is_key_sentence
+            problem.question.target.should eql :sentence
+            problem.question.type.should eql :continuous
+            problem.question.default.should eql 0
+            problem.question.labels.should eql [0, 1]
+            problem.features[0].proc_string.should eql nil
+            problem.features[0].default.should eql 0
+            problem.features[0].name.should eql :word_count
+            problem.features[0].proc.should eql nil
+          end
+        end
+      end
 
-puts ds1.inspect
-=end
-end
+    end

data/spec/document.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Document do
 

data/spec/entity.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Entity do
 
@@ -119,13 +119,7 @@ describe Treat::Entities::Entity do
       it "returns a data set with the exported features" do
         ds = @sentence.export(problem)
         ds.problem.should eql problem
-        ds.problem.labels.should eql [:tag]
-        ds.entities.should eql @sentence.words.map { |w| w.id }
-        ds.items.should eql [
-          ["DT", false], ["JJ", false],
-          ["NN", false], ["VBZ", false],
-          ["VBG", false]
-        ]
+        # MORE TESTS HERE - FIXME
       end
     end
 

data/spec/helper.rb

@@ -0,0 +1,34 @@
+require 'simplecov'
+
+SimpleCov.start do
+
+  add_filter '/spec/'
+  add_filter '/config/'
+
+  add_group 'Core', 'treat/core'
+  add_group 'Entities', 'treat/entities'
+  add_group 'Helpers', 'treat/helpers'
+  add_group 'Loaders', 'treat/loaders'
+  add_group 'Workers', 'treat/workers'
+  add_group 'Config', 'config.rb'
+  add_group 'Proxies', 'proxies.rb'
+  add_group 'Treat', 'treat.rb'
+
+end
+
+require_relative '../lib/treat'
+=begin
+Treat.core.language.detect = true
+Treat.core.verbosity.debug = true
+Treat.paths.files = './files/'
+Treat.databases.mongo.db = 'gistify'
+Treat.databases.default.adapter = :mongo
+Treat.libraries.stanford.model_path = 
+'/ruby/stanford/stanford-core-nlp-all/'
+Treat.libraries.stanford.jar_path =
+'/ruby/stanford/stanford-core-nlp-all/'
+Treat.libraries.punkt.model_path = 
+'/ruby/punkt/'
+Treat.libraries.reuters.model_path =
+'/ruby/reuters/'
+=end

data/spec/phrase.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Phrase do
 

data/spec/sandbox.rb

@@ -1,13 +1,36 @@
-require_relative '../lib/treat'
+require_relative 'helper'
+=begin
+problem = Problem(
+  Question(:is_key_sentence, :sentence, :discrete, 0, [0, 1]),
+  Feature(:word_count, 0),
+  Tag(:number_count, 0)
+)
 
-Treat.databases.mongo.db = 'testingyetagain'
+problem.id = 70316753228720
+
+test = Paragraph("Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.")
 
-d = Document('http://www.cbc.ca/news/world/story/2012/07/21/syria-aleppo-clashes.html')
+test.do :segment, :tokenize, :tag, :category
 
-d2 = Document('http://www.cbc.ca/news/canada/british-columbia/story/2012/07/19/bc-monty-robinson-sentencing.html')
+test.sentences[0].set :is_key_sentence, 1
+test.sentences[1].set :is_key_sentence, 1
+test.sentences[2].set :is_key_sentence, 0
 
-c = Collection('testing')
-c << d
-c << d2
+ds = test.export(problem)
 
-c.serialize :mongo
+test.each_sentence do |s|
+  puts s.classify :linear, training: ds
+end
+=end
+=begin
+Treat.databases.mongo.db = 'testing_ds'
+ds1 = Treat::Core::DataSet.unserialize :marshal, file: 'test.dump'
+ds1.serialize :mongo
+puts ds1.problem.id
+ds = Treat::Core::DataSet.unserialize :mongo, {problem: ds1.problem.id}
+puts ds.inspect
+
+Treat.databases.mongo.db = 'testingyetagain'
+ds = DataSet(:dump, './all.dump')
+ds.to_mongo({db: 'test_ds', collection: 'data'})
+=end

data/spec/token.rb

@@ -1,5 +1,5 @@
 #encoding: utf-8
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Token do
 

data/spec/treat.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat do
 

data/spec/word.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Word do
 

data/spec/zone.rb

@@ -1,4 +1,4 @@
-require_relative '../lib/treat'
+require_relative 'helper'
 
 describe Treat::Entities::Zone do
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: treat
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
+date: 2012-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schiphol
@@ -122,6 +122,8 @@ files:
 - lib/treat/config/languages/russian.rb
 - lib/treat/config/languages/spanish.rb
 - lib/treat/config/languages/swedish.rb
+- lib/treat/config/libraries/punkt.rb
+- lib/treat/config/libraries/reuters.rb
 - lib/treat/config/libraries/stanford.rb
 - lib/treat/config/linguistics/categories.rb
 - lib/treat/config/linguistics/punctuation.rb
@@ -139,8 +141,7 @@ files:
 - lib/treat/config/workers/retrievers.rb
 - lib/treat/config.rb
 - lib/treat/core/data_set.rb
-- lib/treat/core/feature.rb
-- lib/treat/core/node.rb
+- lib/treat/core/export.rb
 - lib/treat/core/problem.rb
 - lib/treat/core/question.rb
 - lib/treat/core.rb
@@ -168,6 +169,7 @@ files:
 - lib/treat/helpers/didyoumean.rb
 - lib/treat/helpers/escaping.rb
 - lib/treat/helpers/formatting.rb
+- lib/treat/helpers/objtohash.rb
 - lib/treat/helpers/platform.rb
 - lib/treat/helpers/reflection.rb
 - lib/treat/helpers/temporary.rb
@@ -219,7 +221,9 @@ files:
 - lib/treat/workers/inflectors/stemmers/porter_c.rb
 - lib/treat/workers/inflectors/stemmers/uea.rb
 - lib/treat/workers/learners/classifiers/id3.rb
+- lib/treat/workers/learners/classifiers/linear.rb
 - lib/treat/workers/learners/classifiers/mlp.rb
+- lib/treat/workers/learners/classifiers/svm.rb
 - lib/treat/workers/lexicalizers/categorizers/from_tag.rb
 - lib/treat/workers/lexicalizers/sensers/wordnet/synset.rb
 - lib/treat/workers/lexicalizers/sensers/wordnet.rb
@@ -247,7 +251,7 @@ files:
 - spec/core.rb
 - spec/document.rb
 - spec/entity.rb
-- spec/node.rb
+- spec/helper.rb
 - spec/phrase.rb
 - spec/samples/mathematicians/archimedes.abw
 - spec/samples/mathematicians/euler.html
@@ -260,10 +264,7 @@ files:
 - spec/word.rb
 - spec/zone.rb
 - tmp/MANIFEST
-- files/3_2_release_notes.html
-- files/bc-monty-robinson-sentencing.html
 - files/MANIFEST
-- files/syria-aleppo-clashes.html
 - README.md
 - LICENSE
 homepage: https://github.com/louismullie/treat