characterizable 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/characterizable.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'blockenspiel'
 require 'active_support'
 require 'active_support/version'
@@ -18,31 +19,80 @@ module Characterizable
   end
   
   def characteristics
-    @_characteristics ||= ArrayOfBoundCharacteristics.new self
+    @_characteristics ||= Snapshot.new self
   end
   
-  def clear_characteristics
+  def dirty_characteristics!
     @_characteristics = nil
   end
-
-  def known_characteristics
-    characteristics.select do |c|
-      c.known? and not c.trumped?
-    end
-  end
   
-  def unknown_characteristics
-    characteristics.select do |c|
-      c.unknown? and c.requited? and not c.trumped?
+  # hashes that survive as such when you select/reject/slice them
+  class SurvivorHash < Hash
+    attr_reader :survivor_args
+    def initialize(*survivor_args)
+      @survivor_args = survivor_args
+    end
+    def reject(&block)
+      inject(self.class.new(*survivor_args)) do |memo, ary|
+        unless block.call(*ary)
+          memo[ary[0]] = ary[1]
+        end
+        memo
+      end
+    end
+    def select(&block)
+      inject(self.class.new(*survivor_args)) do |memo, ary|
+        if block.call(*ary)
+          memo[ary[0]] = ary[1]
+        end
+        memo
+      end
+    end
+    def slice(*keys)
+      inject(self.class.new(*survivor_args)) do |memo, ary|
+        if keys.include?(ary[0])
+          memo[ary[0]] = ary[1]
+        end
+        memo
+      end
     end
   end
   
-  def visible_known_characteristics
-    known_characteristics.reject { |c| c.hidden? }
-  end
-  
-  def visible_unknown_characteristics
-    unknown_characteristics.reject { |c| c.hidden? }
+  class Snapshot < SurvivorHash
+    def initialize(*survivor_args)
+      super
+      take_snapshot
+    end
+    def snapshotted_obj
+      survivor_args.first
+    end
+    def []=(key, value)
+      snapshotted_obj.dirty_characteristics!
+      super
+    end
+    def take_snapshot
+      snapshotted_obj.characterizable_base.characteristics.each do |k, c|
+        if c.known?(snapshotted_obj) and c.requited?(snapshotted_obj) and not c.trumped?(snapshotted_obj)
+          self[k] = snapshotted_obj.send c.name
+        end
+      end
+    end
+    def known
+      snapshotted_obj.characterizable_base.characteristics.select do |_, c|
+        c.known?(self) and c.requited?(self) and not c.trumped?(self)
+      end
+    end
+    def unknown
+      snapshotted_obj.characterizable_base.characteristics.select do |_, c|
+        c.unknown?(self) and c.requited?(self) and not c.trumped?(self)
+      end
+    end
+    def visible_known
+      known.reject { |_, c| c.hidden? }
+    end
+    def visible_unknown
+      unknown.reject { |_, c| c.hidden? }
+    end
   end
   
   module ClassMethods
@@ -53,51 +103,28 @@ module Characterizable
     delegate :characteristics, :to => :characterizable_base
   end
   
-  # don't want to use a Hash, because that would be annoying to select from
-  class ArrayOfCharacteristics < Array
-    def [](key_or_index)
-      case key_or_index
-      when String, Symbol
-        detect { |c| c.name == key_or_index }
-      else
-        super
-      end
-    end
-  end
-  
-  class ArrayOfBoundCharacteristics < ArrayOfCharacteristics
-    attr_reader :bound_obj
-    def initialize(*args)
-      @bound_obj = args.pop
-      super
-      load_bound_characteristics
-    end
-    def load_bound_characteristics
-      bound_obj.characterizable_base.characteristics.each do |c|
-        b_c = c.dup
-        b_c.bound_obj = bound_obj
-        push b_c
-      end
-    end
-  end
-  
   class Base
     attr_reader :klass
     def initialize(klass)
       @klass = klass
     end
     def characteristics
-      @_characteristics ||= ArrayOfCharacteristics.new
+      @_characteristics ||= SurvivorHash.new
     end
     include Blockenspiel::DSL
     def has(name, options = {}, &block)
-      characteristics.push Characteristic.new(self, name, options, &block)
+      characteristics[name] = Characteristic.new(self, name, options, &block)
+      klass.module_eval(%{
+        def #{name}_with_dirty_characteristics=(new_#{name})
+          dirty_characteristics!
+          self.#{name}_without_dirty_characteristics = new_#{name}
+        end
+        alias_method_chain :#{name}=, :dirty_characteristics
+      }, __FILE__, __LINE__) if klass.instance_methods.include?("#{name}=")
     end
   end
   
   class Characteristic
-    class TreatedBoundAsUnbound < RuntimeError; end
-    class TreatedUnboundAsBound < RuntimeError; end
     attr_reader :base
     attr_reader :name
     attr_reader :trumps
@@ -106,7 +133,7 @@ module Characterizable
     attr_reader :options
     def initialize(base, name, options = {}, &block)
       @base = base
-      @name = name.to_sym
+      @name = name
       @trumps = Array.wrap(options.delete(:trumps))
       @prerequisite = options.delete :prerequisite
       @hidden = options.delete :hidden
@@ -114,29 +141,28 @@ module Characterizable
       Blockenspiel.invoke block, self if block_given?
     end
     delegate :characteristics, :to => :base
-    attr_accessor :bound_obj
-    def effective_obj(obj = nil)
-      raise TreatedBoundAsUnbound, "Can't treat as unbound if bound object is set" if obj and bound_obj
-      raise TreatedUnboundAsBound, "Need an object if unbound" unless obj or bound_obj
-      obj || bound_obj
-    end
-    def value(obj = nil)
-      effective_obj(obj).send name
+    def value(obj)
+      case obj
+      when Hash
+        obj[name]
+      else
+        obj.send name
+      end
     end
-    def unknown?(obj = nil)
+    def unknown?(obj)
       value(obj).nil?
     end
-    def known?(obj = nil)
+    def known?(obj)
       not unknown?(obj)
     end
-    def trumped?(obj = nil)
-      effective_obj(obj).characteristics.any? do |c|
+    def trumped?(obj)
+      characteristics.any? do |_, c|
         c.known?(obj) and c.trumps.include?(name)
       end
     end
-    def requited?(obj = nil)
+    def requited?(obj)
       return true if prerequisite.nil?
-      effective_obj(obj).characteristics[prerequisite].known? obj
+      characteristics[prerequisite].known? obj
     end
     def hidden?
       hidden
@@ -144,15 +170,6 @@ module Characterizable
     include Blockenspiel::DSL
     def reveals(other_name, other_options = {}, &block)
       base.has other_name, other_options.merge(:prerequisite => name), &block
-      base.klass.module_eval %{
-        def #{name}_with_dependent_#{other_name}=(new_#{name})
-          if new_#{name}.nil?
-            self.#{other_name} = nil
-          end
-          self.#{name}_without_dependent_#{other_name} = new_#{name}
-        end
-        alias_method_chain :#{name}=, :dependent_#{other_name}
-      }, __FILE__, __LINE__
     end
   end
 end

data/test/test_characterizable.rb

@@ -53,16 +53,35 @@ class TestCharacterizable < Test::Unit::TestCase
     end
   end
 
+  should "survive as a certain kind of hash" do
+    a = SimpleAutomobile.new
+
+    assert_equal Characterizable::SurvivorHash, SimpleAutomobile.characteristics.class
+    assert_equal Characterizable::SurvivorHash, SimpleAutomobile.characteristics.select { false }.class
+    assert_equal Characterizable::SurvivorHash, SimpleAutomobile.characteristics.slice(:hello).class
+    assert_equal Characterizable::SurvivorHash, SimpleAutomobile.characteristics.merge({:hi => 'there'}).class
+    
+    assert_equal Characterizable::SurvivorHash, a.characteristics.known.class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.known.select { false }.class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.known.slice(:hello).class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.known.merge({:hi => 'there'}).class
+
+    assert_equal Characterizable::Snapshot, a.characteristics.class
+    assert_equal Characterizable::Snapshot, a.characteristics.select { false }.class
+    assert_equal Characterizable::Snapshot, a.characteristics.slice(:hello).class
+    assert_equal Characterizable::Snapshot, a.characteristics.merge({:hi => 'there'}).class
+  end
+  
   should "tell you what characteristics are known" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
-    assert_equal [:make], a.known_characteristics.map(&:name)
+    assert_equal [:make], a.characteristics.known.keys
   end
 
   should "tell you what characteristics are unknown" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
-    assert_equal [:model, :variant], a.unknown_characteristics.map(&:name)
+    assert_equal [:model, :variant], a.characteristics.unknown.keys
   end
 
   should "present a concise set of known characteristics by getting rid of those that have been trumped" do
@@ -70,38 +89,39 @@ class TestCharacterizable < Test::Unit::TestCase
     a.make = 'Ford'
     a.model = 'Taurus'
     a.variant = 'Taurus V6 DOHC'
-    assert_equal [:make, :variant], a.known_characteristics.map(&:name)
+    assert_equal [:make, :variant], a.characteristics.known.keys
   end
 
   should "not mention a characteristic as unknown if, in fact, it has been trumped" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
     a.variant = 'Taurus V6 DOHC'
-    assert_equal [], a.unknown_characteristics.map(&:name)
+    assert_equal [], a.characteristics.unknown.keys
   end
 
   should "not mention a characteristic as unknown if it is waiting on something else to be revealed" do
     a = Automobile.new
-    assert !a.unknown_characteristics.map(&:name).include?(:model_year)
+    assert !a.characteristics.unknown.keys.include?(:model_year)
   end
 
   should "make sure that trumping works even within revealed characteristics" do
     a = Automobile.new
-    assert a.unknown_characteristics.map(&:name).include?(:size_class)
+    assert a.characteristics.unknown.keys.include?(:size_class)
     a.make = 'Ford'
     a.model_year = 1999
     a.model = 'Taurus'
     a.size_class = 'mid-size'
-    assert_equal [:model, :model_year, :make], a.known_characteristics.map(&:name)
-    assert !a.unknown_characteristics.map(&:name).include?(:size_class)
+    assert_equal [:make, :model_year, :model], a.characteristics.known.keys
+    assert !a.characteristics.unknown.keys.include?(:size_class)
   end
 
-  should "enforce prerequisites by using an object's setter" do
+  should "not enforce prerequisites by using an object's setter" do
     a = Automobile.new
     a.make = 'Ford'
     a.model_year = 1999
     a.make = nil
-    assert_equal nil, a.model_year
+    assert_equal 1999, a.model_year
+    assert_equal nil, a.characteristics.known[:model_year]
   end
   
   should "keep user-defined options on a characteristic" do
@@ -114,50 +134,70 @@ class TestCharacterizable < Test::Unit::TestCase
   
   should "know which characteristics are 'visible'" do
     a = Automobile.new
-    assert a.unknown_characteristics.map(&:name).include?(:record_creation_date)
-    assert !a.visible_unknown_characteristics.map(&:name).include?(:record_creation_date)
+    assert a.characteristics.unknown.keys.include?(:record_creation_date)
+    assert !a.characteristics.visible_unknown.keys.include?(:record_creation_date)
     a.record_creation_date = 'yesterday'
-    assert a.known_characteristics.map(&:name).include?(:record_creation_date)
-    assert !a.visible_known_characteristics.map(&:name).include?(:record_creation_date)
+    assert a.characteristics.known.keys.include?(:record_creation_date)
+    assert !a.characteristics.visible_known.keys.include?(:record_creation_date)
   end
-  
+    
   should "be able to access values" do
     a = Automobile.new
     a.make = 'Ford'
-    b = Automobile.new
-    b.make = 'Pontiac'
-    assert_equal 'Ford', Automobile.characteristics[:make].value(a)
-    assert_equal 'Pontiac', Automobile.characteristics[:make].value(b)
+    assert_equal 'Ford', a.characteristics[:make]
   end
   
-  should "give back characteristics with values when accessed from an instance" do
+  should "know what is known on a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
-    assert_equal 'Ford', a.characteristics[:make].value
+    assert_equal [:make], a.characteristics.known.keys
   end
   
-  should "not allow treating [unbound] characteristics like bound ones" do
+  should "know what is unknown on a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
-    assert_raises(Characterizable::Characteristic::TreatedUnboundAsBound) do
-      Automobile.characteristics[:make].value
-    end
+    assert a.characteristics.unknown.keys.include?(:model_year)
   end
   
-  should "not allow treating bound characteristics like unbound ones" do
+  should "not reveal unknown characteristics in snapshots" do
+    a = Automobile.new
+    a.model_year = 1999
+    assert_equal [], a.characteristics.known.keys
+    assert_equal nil, a.characteristics[:model_year]
+  end
+  
+  should "not reveal unknown characteristics in snapshots, even if it was previously revealed" do
     a = Automobile.new
     a.make = 'Ford'
-    b = Automobile.new
-    b.make = 'Pontiac'
-    assert_raises(Characterizable::Characteristic::TreatedBoundAsUnbound) do
-      a.characteristics[:make].value :anything
-    end
+    a.model_year = 1999
+    assert_equal [:make, :model_year], a.characteristics.known.keys
+    a.make = nil
+    assert_equal [], a.characteristics.known.keys
   end
   
-  should "eagely populate bound characteristics" do
+  should "keep snapshots separately" do
+    a = Automobile.new
+    a.make = 'Ford'
+    a.model_year = 1999
+    snapshot = a.characteristics
+    assert_equal [:make, :model_year], snapshot.known.keys
+    a.make = nil
+    assert_equal [], a.characteristics.known.keys
+    assert_equal [:make, :model_year], snapshot.known.keys
+  end
+    
+  should "work when passed around as a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
-    assert_equal ['Ford'], a.known_characteristics.map(&:value)
-    assert_equal [:make], a.known_characteristics.map(&:name)
+    snapshot = a.characteristics
+    assert_equal [:make], snapshot.known.keys
+    assert snapshot.unknown.keys.include?(:model_year)
+    snapshot[:model_year] = 1999
+    assert_equal 1999, snapshot[:model_year]
+    assert_equal [:make, :model_year], snapshot.known.keys
+    assert !snapshot.unknown.keys.include?(:model_year)
+    assert_equal nil, a.model_year
+    assert_equal nil, a.characteristics[:model_year]
+    assert_equal 1999, snapshot[:model_year]
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Andy Rossmeissl