factis 0.0.6 → 0.0.7

data/README.md

@@ -49,8 +49,25 @@ That being the case, I'm going to use terminology from that side of the
 experience. Here's everything that World gets when you use Factis.
 
 ```ruby
-# Let's memorize that my brother, Joe, just loves pie.
+# Let's memorize that my brother, Joe, just loves cake.
+memorize_fact("What does Joe love?", "Joe loves cake.")
+  => "Joe loves cake."
+
+# Wait, I had that wrong. Joe loves pie.
+
 memorize_fact("What does Joe love?", "Joe loves pie.")
+  => Cannot memorize a fact more than once: 'What does Joe love?' (RuntimeError)
+
+# Why does that happen?
+# Er, because we're trying to track state safely, and overwriting states
+# all willy-nilly is kinda unsafe.
+# So, how do I overwrite a known fact?
+# If you want to unsafely track state, you should probably just use global
+# variables. Shooting from the hip never did anybody wrong, after all. Or, you
+# can use indifferently_memorize_fact, which is a bad thing to do.
+
+indifferently_memorize_fact("What does Joe love?", "Joe loves pie.")
+  => "Joe loves pie."
 
 # Hey Factis, what does Joe love?
 recall_fact("What does Joe love?")
@@ -58,6 +75,7 @@ recall_fact("What does Joe love?")
 
 # That's not very interesting. Let's forget about it.
 forget_fact("What does Joe love?")
+  => "Joe loves pie."
 
 # Wait, what does Joe love again?
 recall_fact("What does Joe love?")
@@ -79,6 +97,7 @@ end
 
 # The content can be pretty much anything.
 memorize_fact(:some_foo, Foo.new)
+  => #<Foo:0x007ffd84394728>
 
 # What's a foo?
 recall_fact(:some_foo)

data/lib/factis.rb

@@ -14,6 +14,10 @@ module Factis
     Factis::Memory.memorize(fact, content)
   end
 
+  def indifferently_memorize_fact(fact, content)
+    Factis::Memory.memorize(fact, content, :overwrite => true)
+  end
+
   def recall_fact(fact)
     Factis::Memory.recall(fact)
   end

data/lib/factis/memory.rb

@@ -10,8 +10,13 @@ module Factis
       @facts
     end
 
-    def self.memorize(fact, content)
+    def self.memorize(fact, content, options = {})
       init_memory! if @facts.nil?
+      if known_fact?(fact)
+        unless options[:overwrite] == true
+          raise %{Cannot memorize a fact more than once: '#{fact}'}
+        end
+      end
       @facts[fact] = content
     end
 

data/lib/factis/version.rb

@@ -1,3 +1,3 @@
 module Factis
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/spec/factis/memory_spec.rb

@@ -7,6 +7,10 @@ describe Factis::Memory do
   let(:fact) {"Joe"}
   let(:content) {"Likes pie"}
 
+  before(:each) do
+    Factis::Memory.reset!
+  end
+
   describe '.all_facts' do
     it 'is a Hash' do
       memory.all_facts.should be_a(Hash)
@@ -14,11 +18,28 @@ describe Factis::Memory do
   end
 
   describe %{.memorize} do
+    let(:new_content) {'Something else'}
     it %{records a fact when given a name and some content} do
       memory.memorize(fact, content)
       memory.all_facts.keys.include?(fact).should be_true
       memory.all_facts[fact].should == content
     end
+
+    it %{returns the content of the fact} do
+      memory.memorize(fact, content).should == content
+    end
+
+    it %{raises an error when given a known fact} do
+      memory.memorize(fact, content)
+      lambda {memory.memorize(fact, new_content)}.should raise_error
+    end
+
+    it %{allows a fact to be explicitly over-written} do
+      memory.memorize(fact, content)
+      lambda {memory.memorize(fact, new_content, overwrite: true)}.should_not raise_error
+      memory.recall(fact).should == new_content
+
+    end
   end
 
   describe %{.known_fact?} do
@@ -40,13 +61,15 @@ describe Factis::Memory do
       memory.memorize(fact, content)
     end
 
-    
-
     it %{removes a known fact from memory} do
       memory.forget(fact)
       memory.known_fact?(fact).should be_false
     end
 
+    it %{returns the content of the fact} do
+      memory.forget(fact).should == content
+    end
+
     it %{raises an error when given an unknown fact} do
       lambda {memory.forget("unknown fact")}.should raise_error
     end

data/spec/factis_spec.rb

@@ -7,6 +7,10 @@ describe Factis do
     let(:fact) {"Joe"}
     let(:content) {"likes pie"}
 
+    before(:each) do
+      Factis::Memory.reset!
+    end
+
     describe %{#clear_all_facts!} do
       it %{resets the Factis memory core} do
         Factis::Memory.should_receive(:reset!)
@@ -15,10 +19,13 @@ describe Factis do
     end
 
     describe %{#all_facts} do
-      it %{returns the contents of the Factis memory core} do
+      it %{returns the entire fact hash} do
         facts = {fact => content}
         Factis::Memory.should_receive(:all_facts).and_return(facts)
-        factis.all_facts.should == facts
+        factis.all_facts.tap do |all_facts|
+          all_facts.should be_a(Hash)
+          all_facts.should == facts
+        end
       end
     end
 
@@ -27,12 +34,30 @@ describe Factis do
         Factis::Memory.should_receive(:memorize).with(fact, content).and_call_original
         factis.memorize_fact(fact, content)
       end
+
+      it %{returns the content of the provided fact} do
+        factis.memorize_fact(fact, content).should == content
+      end
+
+      it %{raises an error if the fact is already known} do
+        factis.memorize_fact(fact, content)
+        lambda {factis.memorize_fact(fact, 'Something else')}.should raise_error
+      end
+    end
+
+    describe %{#indifferently_memorize_fact} do
+      it %{stores the provided fact, even if it's already known} do
+        new_content = 'Something else'
+        factis.memorize_fact(fact, content)
+        lambda {factis.indifferently_memorize_fact(fact, new_content)}.should_not raise_error
+        factis.recall_fact(fact).should == new_content
+      end
     end
 
     describe %{#recall_fact} do
       before(:each) {factis.memorize_fact(fact, content)}
 
-      it %{recalls the provided fact if known} do
+      it %{returns the fact content if known} do
         Factis::Memory.should_receive(:recall).with(fact).and_call_original
         factis.recall_fact(fact).should == content
       end
@@ -51,6 +76,10 @@ describe Factis do
         factis.all_facts.keys.include?(fact).should_not be_true
       end
 
+      it %{returns the content of the fact} do
+        factis.forget_fact(fact).should == content
+      end
+
       it %{raises an error if the fact is not known} do
         lambda {factis.forget_fact(:unknown)}.should raise_error
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factis
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-04 00:00:00.000000000 Z
+date: 2013-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec