catlogic 0.0.2 → 0.0.3

data/spec/premise_collection_spec.rb

@@ -3,12 +3,22 @@ require 'catlogic'
 
 describe "premise collection object" do
 
-  $collection2 = PremiseCollection.new([Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true),
-               Proposition.new(Quantity.new("universal"), Term.new("People"), Quality.new("affirmative"), Term.new("Mammals"), true)])
+  
+  $collection2 = Catlogic::PremiseCollection.new([Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+               Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true)])
 
-  $collection3 = PremiseCollection.new([Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true),
-                Proposition.new(Quantity.new("universal"), Term.new("People"), Quality.new("affirmative"), Term.new("Mammals"), true),
-                Proposition.new(Quantity.new("universal"), Term.new("Ants"), Quality.new("Negative"), Term.new("Mammals"), true)])
+  $collection3 = Catlogic::PremiseCollection.new([Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Ants"), Catlogic::Quality.new("negative"), Catlogic::Term.new("People"), true)])
+
+  $collection3repeat = Catlogic::PremiseCollection.new([Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true)])
+
+  $collection4 = Catlogic::PremiseCollection.new([Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Dogs"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("People"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Ants"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Cats"), true),
+                Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Zebras"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Whales"), true)])
 
   it "should confirm that there are two or more premises in the collection" do
     result = $collection2.at_least_two?
@@ -20,22 +30,71 @@ describe "premise collection object" do
     result.should == 3
   end
 
-  it 'should reduce collection to unique propositions only and return count of 3' do
-    result = $collection3.unique_set
+  it 'should reduce collection3repeat to unique propositions only and return count of 2' do
+    result = $collection3repeat.unique_set
+    result.count.should == 2
+  end
+
+  it 'should be able to provide actual size of initual set even with a repeat premise' do 
+    result = $collection3repeat.initial_propositions
     result.count.should == 3
   end
+  it 'should be able to provide actual size of unique set when set with a repeat premise is given' do 
+    result = $collection3repeat.unique_propositions
+    result.count.should == 2
+  end
 
-  it 'should reduce non-unique collection to unique propositions only and return count of 2' do
-    collection = PremiseCollection.new([Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true),
-                                          Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true),
-                                          Proposition.new(Quantity.new("universal"), Term.new("Ants"), Quality.new("Negative"), Term.new("Mammals"), true)])
+## testing unique set method
+  it 'should reduce non-unique collection to a new collection with unique propositions only and should have a count of 2' do
+    collection = Catlogic::PremiseCollection.new([Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+                                          Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true),
+                                          Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Ants"), Catlogic::Quality.new("Negative"), Catlogic::Term.new("Mammals"), true)])
     result = collection.unique_set
-    result.count.should == 2
+    result.size.should == 2
 
   end
-
+## Testing factorial on collections2-4; answers calculated based on permutations formula P(n,r) = n! / (n - r)! where n=total set and r=lenght of the subset. 
+## aka "The number of ways of obtaining an ordered subset of r elements from a set of n elements."
   it 'should return a premise pair collection for two propositions whose set count is 2' do
     result = $collection2.premise_pairs
     result.count.should == 2
   end
+
+  it 'should return a premise pair collection for three propositions whose set count is 3' do
+    result = $collection3.premise_pairs
+    result.count.should == 6
+  end
+  it 'should return a premise pair collection for three propositions whose set count is 4' do
+    result = $collection4.premise_pairs
+    result.count.should == 12
+  end
+
+##Testing possible three-term pairs on collections 2-4
+  it 'should return answer of 2 for total number of three term paris in $collection2' do 
+    result = $collection2.three_term_premise_pairs
+    result.count.should == 2
+  end
+  it 'should return answer of 4 for total number of three term paris in $collection3' do 
+    result = $collection3.three_term_premise_pairs
+    result.count.should == 4
+  end
+  it 'should return answer of 0 for total number of three term paris in $collection4' do 
+    result = $collection4.three_term_premise_pairs
+    result.count.should == 0
+  end
+
+  it 'should return valid syllogisms for two premise AA (1) premise pair in $collection 2 (should return an AAA1, AAI1 and an AAI4' do
+    result = $collection2.valid_syllogisms
+    result.count.should == 3
+  end
+
+  it 'should return all valid inferred truths for AA (1) premise pair -- the conclusions for an AAA1, AAI1 and AAI4 syllogisms' do 
+    result = $collection2.inferred_truths_all
+    result.count.should == 3
+  end
+  ## this test isn't very good since collection2 does not generate any repeat inferred truths.
+  it 'should return unique valid inferred truths for AA (1) premise pair' do 
+    result = $collection2.inferred_truths_new
+    result.count.should == 3
+  end
 end

data/spec/premise_pair_spec.rb

@@ -3,9 +3,9 @@ require 'catlogic'
 
 describe "premise pair object" do
 
-  	$major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
-	$minor = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Mortal Things"), true)
-	$pair = PremisePair.new($major, $minor)
+  	$major = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Dogs"), true)
+	$minor = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mortal Things"), true)
+	$pair = Catlogic::PremisePair.new($major, $minor)
 
   it 'can return the major proposition' do
     result = $pair.major
@@ -23,18 +23,18 @@ describe "premise pair object" do
   end
 
   it 'can return false result when this pair has only two distinct terms' do
-  	major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
-	minor = Proposition.new(Quantity.new("universal"), Term.new("Dogs"), Quality.new("affirmative"), Term.new("Mammals"), true)
-	pair = PremisePair.new(major, minor)
+  	major = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Dogs"), true)
+	minor = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Dogs"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Mammals"), true)
+	pair = Catlogic::PremisePair.new(major, minor)
 
   	result = pair.three_term_pair?
   	result.should == false
   end
 
   it 'can return false result when this pair has only four distinct terms' do
-  	major = Proposition.new(Quantity.new("universal"), Term.new("Mammals"), Quality.new("affirmative"), Term.new("Dogs"), true)
-	minor = Proposition.new(Quantity.new("universal"), Term.new("Cats"), Quality.new("affirmative"), Term.new("Wicked"), true)
-	pair = PremisePair.new(major, minor)
+  	major = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Mammals"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Dogs"), true)
+	minor = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Cats"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Wicked"), true)
+	pair = Catlogic::PremisePair.new(major, minor)
 
   	result = pair.three_term_pair?
   	result.should == false
@@ -45,6 +45,11 @@ describe "premise pair object" do
   	result.label.should == "Mammals"
   end
 
+  it 'can retrieve possible conclusions for a premise pair' do 
+    result = $pair.possible_conclusions
+    result.count.should == 4
+  end
+
   
 
 

data/spec/proposition_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 require 'catlogic'
 
 describe 'proposition object' do
-  $propositionAtrue = Proposition.new(Quantity.new("universal"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), true)
-  $propositionIfalse = Proposition.new(Quantity.new("particular"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), false)
-  $propositionItrue = Proposition.new(Quantity.new("particular"), Term.new('dogs'), Quality.new("affirmative"), Term.new('mortal things'), true)
+  $propositionAtrue = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new('dogs'), Catlogic::Quality.new("affirmative"), Catlogic::Term.new('mortal things'), true)
+  $propositionIfalse = Catlogic::Proposition.new(Catlogic::Quantity.new("particular"), Catlogic::Term.new('dogs'), Catlogic::Quality.new("affirmative"), Catlogic::Term.new('mortal things'), false)
+  $propositionItrue = Catlogic::Proposition.new(Catlogic::Quantity.new("particular"), Catlogic::Term.new('dogs'), Catlogic::Quality.new("affirmative"), Catlogic::Term.new('mortal things'), true)
   it 'can return the quantity' do
     result = $propositionAtrue.quantity
     result.label.should == 'universal'
@@ -136,7 +136,7 @@ describe 'proposition object' do
         truthvalue.should == true
   end
   it 'can return the correct position of a designated middle term -- in this case dogs' do
-    middleterm = Term.new('dogs')
+    middleterm = Catlogic::Term.new('dogs')
     position = $propositionAtrue.position_of_term(middleterm)
     position.should == 'subject'
   end
@@ -161,12 +161,12 @@ describe 'proposition object' do
 
   it 'can identify that a given proposition is repeated one time in given array' do 
     premisesArray = [
-      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
-      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
-      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Fun"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Events"), true)
     ]
       
-      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+      proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true)
       
       result = proposition.number_of_occurences(premisesArray)
       result.should == 1
@@ -174,12 +174,12 @@ describe 'proposition object' do
 
   it 'can identify that a given proposition is repeated zero times in given array' do 
     premisesArray = [
-      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
-      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
-      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Fun"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Events"), true)
     ]
       
-      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
+      proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true)
       
       result = proposition.number_of_occurences(premisesArray)
       result.should == 0
@@ -187,12 +187,12 @@ describe 'proposition object' do
   it 'can return answer true when proposition is unique (not included) in a given set' do
 
     premisesArray = [
-      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
-      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
-      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Fun"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Events"), true)
     ]
       
-      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
+      proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true)
 
       result = proposition.unique?(premisesArray)
 
@@ -201,12 +201,12 @@ describe 'proposition object' do
   it 'can return answer false when proposition is not unique (i.e. is included) in a given set' do
 
     premisesArray = [
-      Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true), 
-      Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true),
-      Proposition.new(Quantity.new("universal"), Term.new("Fun"), Quality.new("affirmative"), Term.new("Events"), true)
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true),
+      Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Fun"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Events"), true)
     ]
       
-      proposition = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+      proposition = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true)
 
       result = proposition.unique?(premisesArray)
 
@@ -214,14 +214,14 @@ describe 'proposition object' do
   end
 
   it 'can return answer false for two propositions that are not identical' do
-        prop1 = Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
-        prop2 = Proposition.new(Quantity.new("universal"), Term.new("Free Decisions"), Quality.new("negative"), Term.new("Caused Happenings"), true)
+        prop1 = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true)
+        prop2 = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Free Decisions"), Catlogic::Quality.new("negative"), Catlogic::Term.new("Caused Happenings"), true)
         result = prop1.same_as?(prop2)
         result.should == false
   end
   it 'can return answer true for two propositions that are identical' do
-    prop1 = Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
-    prop2 = Proposition.new(Quantity.new("universal"), Term.new("Events"), Quality.new("affirmative"), Term.new("Caused Happenings"), true)
+    prop1 = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true)
+    prop2 = Catlogic::Proposition.new(Catlogic::Quantity.new("universal"), Catlogic::Term.new("Events"), Catlogic::Quality.new("affirmative"), Catlogic::Term.new("Caused Happenings"), true)
     result = prop1.same_as?(prop2)
     result.should == true
   end

data/spec/proposition_type_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 require 'catlogic'
 
 describe 'proposition_type object' do
-  $typeA = PropositionType.new("A")
-  $typeE = PropositionType.new("E")
-  $typeI = PropositionType.new("I")
-  $typeO = PropositionType.new("O")
+  $typeA = Catlogic::PropositionType.new("A")
+  $typeE = Catlogic::PropositionType.new("E")
+  $typeI = Catlogic::PropositionType.new("I")
+  $typeO = Catlogic::PropositionType.new("O")
 
   it 'can return the correct label for a proposition type A' do
     result = $typeA.label

data/spec/quality_spec.rb

@@ -3,13 +3,13 @@ require 'catlogic'
 
 describe 'quality object' do
   it 'can return quality as string' do
-    quality = Quality.new('affirmative')
+    quality = Catlogic::Quality.new('affirmative')
     result = quality.label
     result.should == 'affirmative'
   end
 
   it 'can return term opposite as string' do
-    quality = Quality.new('affirmative')
+    quality = Catlogic::Quality.new('affirmative')
     opposite = quality.opposite
     result = opposite.label
     result.should == 'negative'

data/spec/quantity_spec.rb

@@ -4,13 +4,13 @@ require 'pry'
 
 describe 'quantity object' do
   it 'can return quantity as string' do
-    quantity = Quantity.new('universal')
+    quantity = Catlogic::Quantity.new('universal')
     result = quantity.label
     result.should == 'universal'
   end
 
   it 'can return term opposite as string' do
-    quantity = Quantity.new('particular')
+    quantity = Catlogic::Quantity.new('particular')
     opposite = quantity.opposite
     result = opposite.label
 

data/spec/syllogism_spec.rb

@@ -3,16 +3,16 @@ require "catlogic"
 
 describe "syllogism object" do 
 
-	$majorproposition = Proposition.new(Quantity.new('universal'), Term.new('mortal things'), Quality.new('affirmative'), Term.new('dogs'), true)
-	$minorproposition = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('mortal things'), true)
-	$conclusionproposition = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('dogs'), true)
-	$syllogism_aaa1 = Syllogism.new($majorproposition, $minorproposition, $conclusionproposition)
-  $syllogism_aaa4 = Syllogism.new($minorproposition, $majorproposition, $conclusionproposition)
+	$majorproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('mortal things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('dogs'), true)
+	$minorproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('mortal things'), true)
+	$conclusionproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('dogs'), true)
+	$syllogism_aaa1 = Catlogic::Syllogism.new($majorproposition, $minorproposition, $conclusionproposition)
+  $syllogism_aaa4 = Catlogic::Syllogism.new($minorproposition, $majorproposition, $conclusionproposition)
 
-  $majorproposition2 = Proposition.new(Quantity.new('universal'), Term.new('dogs'), Quality.new('affirmative'), Term.new('mortal things'), true)
-  $minorproposition2 = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('mortal things'), true)
-  $conclusionproposition2 = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('dogs'), true)
-  $syllogism_aaa2 = Syllogism.new($majorproposition2, $minorproposition2, $conclusionproposition2)
+  $majorproposition2 = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('dogs'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('mortal things'), true)
+  $minorproposition2 = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('mortal things'), true)
+  $conclusionproposition2 = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('dogs'), true)
+  $syllogism_aaa2 = Catlogic::Syllogism.new($majorproposition2, $minorproposition2, $conclusionproposition2)
 
 	it 'can retrieve the middle term' do
 		
@@ -21,10 +21,10 @@ describe "syllogism object" do
 	end
 
   it 'can return error if not trying to get middle on non three-term syllogism' do
-    majorproposition = Proposition.new(Quantity.new('universal'), Term.new('mortal things'), Quality.new('affirmative'), Term.new('living things'), true)
-    minorproposition = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('mortal things'), true)
-    conclusionproposition = Proposition.new(Quantity.new('universal'), Term.new('living things'), Quality.new('affirmative'), Term.new('dogs'), true)
-    syllogism_test = Syllogism.new(majorproposition, minorproposition, conclusionproposition)
+    majorproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('mortal things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('living things'), true)
+    minorproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('mortal things'), true)
+    conclusionproposition = Catlogic::Proposition.new(Catlogic::Quantity.new('universal'), Catlogic::Term.new('living things'), Catlogic::Quality.new('affirmative'), Catlogic::Term.new('dogs'), true)
+    syllogism_test = Catlogic::Syllogism.new(majorproposition, minorproposition, conclusionproposition)
 
     middleterm = syllogism_test.middle
     middleterm.should == 'Error: this is not a three term syllogism'

data/spec/term_spec.rb

@@ -4,28 +4,28 @@ require 'pry'
 
 describe 'term object' do
   it 'can return term as string' do
-    term = Term.new('dogs')
+    term = Catlogic::Term.new('dogs')
     result = term.label
     result.should == 'dogs'
   end
 
   it 'can return term opposite as string' do
-    term = Term.new('dogs')
+    term = Catlogic::Term.new('dogs')
     opposite = term.opposite
     result = opposite.label
     result.should == 'non-dogs'
   end
 
   it 'can return correct distribution for subject term' do
-    term = Term.new('dogs')
-    quantity = Quantity.new('universal')
+    term = Catlogic::Term.new('dogs')
+    quantity = Catlogic::Quantity.new('universal')
     result = term.distribution_subject(quantity)
     result.label.should == 'distributed'
   end
 
   it 'can return correct distribution for predicate term' do
-    term = Term.new('dogs')
-    quality = Quality.new('affirmative')
+    term = Catlogic::Term.new('dogs')
+    quality = Catlogic::Quality.new('affirmative')
     result = term.distribution_predicate(quality)
     result.label.should == 'undistributed'
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: catlogic
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jeffrey C. Witt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-02 00:00:00.000000000 Z
+date: 2015-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,7 @@ files:
 - lib/catlogic/distribution.rb
 - lib/catlogic/figure.rb
 - lib/catlogic/form.rb
+- lib/catlogic/integer.rb
 - lib/catlogic/mood.rb
 - lib/catlogic/premise_collection.rb
 - lib/catlogic/premise_pair.rb
@@ -93,6 +94,7 @@ files:
 - lib/catlogic/proposition_type.rb
 - lib/catlogic/quality.rb
 - lib/catlogic/quantity.rb
+- lib/catlogic/string.rb
 - lib/catlogic/syllogism.rb
 - lib/catlogic/term.rb
 - lib/catlogic/version.rb