characterizable 0.0.2 → 0.0.3

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/characterizable.rb

@@ -22,11 +22,12 @@ module Characterizable
     @_characteristics ||= Snapshot.new self
   end
   
-  def dirty_characteristics!
+  def expire_snapshot!
     @_characteristics = nil
   end
   
   # hashes that survive as such when you select/reject/slice them
+  # they also keep arguments passed to them
   class SurvivorHash < Hash
     attr_reader :survivor_args
     def initialize(*survivor_args)
@@ -63,35 +64,25 @@ module Characterizable
       super
       take_snapshot
     end
-    def snapshotted_obj
+    def target
       survivor_args.first
     end
     def []=(key, value)
-      snapshotted_obj.dirty_characteristics!
+      target.expire_snapshot!
       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
+      target.characterizable_base.characteristics.each do |_, c|
+        if c.relevant?(target)
+          self[c.name] = c.value(target)
         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? }
+    def relevant
+      target.characterizable_base.characteristics.select { |_, c| c.relevant?(self) }
     end
-    def visible_unknown
-      unknown.reject { |_, c| c.hidden? }
+    def irrelevant
+      target.characterizable_base.characteristics.select { |_, c| c.irrelevant?(self) }
     end
   end
   
@@ -115,57 +106,55 @@ module Characterizable
     def has(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}
+        def #{name}_with_expire_snapshot=(new_#{name})
+          expire_snapshot!
+          self.#{name}_without_expire_snapshot = new_#{name}
         end
-        alias_method_chain :#{name}=, :dirty_characteristics
+        alias_method_chain :#{name}=, :expire_snapshot
       }, __FILE__, __LINE__) if klass.instance_methods.include?("#{name}=")
     end
   end
-  
   class Characteristic
     attr_reader :base
     attr_reader :name
     attr_reader :trumps
     attr_reader :prerequisite
-    attr_reader :hidden
     attr_reader :options
     def initialize(base, name, options = {}, &block)
       @base = base
       @name = name
-      @trumps = Array.wrap(options.delete(:trumps))
-      @prerequisite = options.delete :prerequisite
-      @hidden = options.delete :hidden
+      @trumps = Array.wrap options.delete(:trumps)
+      @prerequisite = options.delete(:prerequisite)
       @options = options
       Blockenspiel.invoke block, self if block_given?
     end
+    def trumped_by
+      @_trumped_by ||= characteristics.select { |_, c| c.trumps.include? name }
+    end
     delegate :characteristics, :to => :base
-    def value(obj)
-      case obj
+    def value(target)
+      case target
       when Hash
-        obj[name]
+        target[name]
       else
-        obj.send name
+        target.send name if target.respond_to?(name)
       end
     end
-    def unknown?(obj)
-      value(obj).nil?
+    def irrelevant?(target)
+      value(target).nil? and revealed? target and untrumped? target
     end
-    def known?(obj)
-      not unknown?(obj)
+    def relevant?(target)
+      !value(target).nil? and revealed? target and untrumped? target
     end
-    def trumped?(obj)
-      characteristics.any? do |_, c|
-        c.known?(obj) and c.trumps.include?(name)
+    def untrumped?(target)
+      return true if trumped_by.empty?
+      trumped_by.none? do |_, c|
+        c.relevant? target
       end
     end
-    def requited?(obj)
+    def revealed?(target)
       return true if prerequisite.nil?
-      characteristics[prerequisite].known? obj
-    end
-    def hidden?
-      hidden
+      characteristics[prerequisite].relevant? target
     end
     include Blockenspiel::DSL
     def reveals(other_name, other_options = {}, &block)

data/test/helper.rb

@@ -2,10 +2,14 @@ require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'ruby-debug'
+require 'set'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'characterizable'
 
 class Test::Unit::TestCase
+  def assert_same_contents(a, b)
+    assert_equal Set.new(a), Set.new(b)
+  end
 end

data/test/test_characterizable.rb

@@ -1,6 +1,11 @@
 require 'helper'
 
-# TODO
+class Characterizable::Characteristic
+  def hidden?
+    !!options[:hidden]
+  end
+end
+
 class Automobile
   attr_accessor :make, :model_year, :model, :variant, :size_class, :hybridity, :daily_distance_estimate
   attr_accessor :record_creation_date
@@ -20,6 +25,7 @@ class Automobile
     # has :urbanity, :measures => :percentage
     has :hybridity
     has :daily_distance_estimate, :trumps => [:weekly_distance_estimate, :annual_distance_estimate, :daily_duration], :measures => :length #, :weekly_fuel_cost, :annual_fuel_cost]
+    has :daily_distance_oracle_estimate, :trumps => :daily_distance_estimate
     # has :daily_duration, :trumps => [:annual_distance_estimate, :weekly_distance_estimate, :daily_distance_estimate], :measures => :time #, :weekly_fuel_cost, :annual_fuel_cost]
     # has :weekly_distance_estimate, :trumps => [:annual_distance_estimate, :daily_distance_estimate, :daily_duration], :measures => :length #, :weekly_fuel_cost, :annual_fuel_cost]
     # has :annual_distance_estimate, :trumps => [:weekly_distance_estimate, :daily_distance_estimate, :daily_duration], :measures => :length #, :weekly_fuel_cost, :annual_fuel_cost]
@@ -61,10 +67,10 @@ class TestCharacterizable < Test::Unit::TestCase
     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::SurvivorHash, a.characteristics.relevant.class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.relevant.select { false }.class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.relevant.slice(:hello).class
+    assert_equal Characterizable::SurvivorHash, a.characteristics.relevant.merge({:hi => 'there'}).class
 
     assert_equal Characterizable::Snapshot, a.characteristics.class
     assert_equal Characterizable::Snapshot, a.characteristics.select { false }.class
@@ -72,47 +78,47 @@ class TestCharacterizable < Test::Unit::TestCase
     assert_equal Characterizable::Snapshot, a.characteristics.merge({:hi => 'there'}).class
   end
   
-  should "tell you what characteristics are known" do
+  should "tell you what characteristics are relevant" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
-    assert_equal [:make], a.characteristics.known.keys
+    assert_same_contents [:make], a.characteristics.relevant.keys
   end
 
-  should "tell you what characteristics are unknown" do
+  should "tell you what characteristics are irrelevant" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
-    assert_equal [:model, :variant], a.characteristics.unknown.keys
+    assert_same_contents [:model, :variant], a.characteristics.irrelevant.keys
   end
 
-  should "present a concise set of known characteristics by getting rid of those that have been trumped" do
+  should "present a concise set of relevant characteristics by getting rid of those that have been trumped" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
     a.model = 'Taurus'
     a.variant = 'Taurus V6 DOHC'
-    assert_equal [:make, :variant], a.characteristics.known.keys
+    assert_same_contents [:make, :variant], a.characteristics.relevant.keys
   end
 
-  should "not mention a characteristic as unknown if, in fact, it has been trumped" do
+  should "not mention a characteristic as irrelevant if, in fact, it has been trumped" do
     a = SimpleAutomobile.new
     a.make = 'Ford'
     a.variant = 'Taurus V6 DOHC'
-    assert_equal [], a.characteristics.unknown.keys
+    assert_same_contents [], a.characteristics.irrelevant.keys
   end
 
-  should "not mention a characteristic as unknown if it is waiting on something else to be revealed" do
+  should "not mention a characteristic as irrelevant if it is waiting on something else to be revealed" do
     a = Automobile.new
-    assert !a.characteristics.unknown.keys.include?(:model_year)
+    assert !a.characteristics.irrelevant.keys.include?(:model_year)
   end
 
   should "make sure that trumping works even within revealed characteristics" do
     a = Automobile.new
-    assert a.characteristics.unknown.keys.include?(:size_class)
+    assert a.characteristics.irrelevant.keys.include?(:size_class)
     a.make = 'Ford'
     a.model_year = 1999
     a.model = 'Taurus'
     a.size_class = 'mid-size'
-    assert_equal [:make, :model_year, :model], a.characteristics.known.keys
-    assert !a.characteristics.unknown.keys.include?(:size_class)
+    assert_same_contents [:make, :model_year, :model], a.characteristics.relevant.keys
+    assert !a.characteristics.irrelevant.keys.include?(:size_class)
   end
 
   should "not enforce prerequisites by using an object's setter" do
@@ -121,7 +127,7 @@ class TestCharacterizable < Test::Unit::TestCase
     a.model_year = 1999
     a.make = nil
     assert_equal 1999, a.model_year
-    assert_equal nil, a.characteristics.known[:model_year]
+    assert_equal nil, a.characteristics.relevant[:model_year]
   end
   
   should "keep user-defined options on a characteristic" do
@@ -132,13 +138,9 @@ class TestCharacterizable < Test::Unit::TestCase
     assert !Automobile.characteristics[:daily_distance_estimate].options.has_key?(:trumps)
   end
   
-  should "know which characteristics are 'visible'" do
-    a = Automobile.new
-    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.characteristics.known.keys.include?(:record_creation_date)
-    assert !a.characteristics.visible_known.keys.include?(:record_creation_date)
+  should "allow the user to add custom functionality to characteristics" do
+    assert Automobile.characteristics[:record_creation_date].hidden?
+    assert !Automobile.characteristics[:daily_distance_estimate].hidden?
   end
     
   should "be able to access values" do
@@ -147,32 +149,32 @@ class TestCharacterizable < Test::Unit::TestCase
     assert_equal 'Ford', a.characteristics[:make]
   end
   
-  should "know what is known on a snapshot" do
+  should "know what is relevant on a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
-    assert_equal [:make], a.characteristics.known.keys
+    assert_same_contents [:make], a.characteristics.relevant.keys
   end
   
-  should "know what is unknown on a snapshot" do
+  should "know what is irrelevant on a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
-    assert a.characteristics.unknown.keys.include?(:model_year)
+    assert a.characteristics.irrelevant.keys.include?(:model_year)
   end
   
-  should "not reveal unknown characteristics in snapshots" do
+  should "not reveal irrelevant characteristics in snapshots" do
     a = Automobile.new
     a.model_year = 1999
-    assert_equal [], a.characteristics.known.keys
+    assert_same_contents [], a.characteristics.relevant.keys
     assert_equal nil, a.characteristics[:model_year]
   end
   
-  should "not reveal unknown characteristics in snapshots, even if it was previously revealed" do
+  should "not reveal irrelevant characteristics in snapshots, even if it was previously revealed" do
     a = Automobile.new
     a.make = 'Ford'
     a.model_year = 1999
-    assert_equal [:make, :model_year], a.characteristics.known.keys
+    assert_same_contents [:make, :model_year], a.characteristics.relevant.keys
     a.make = nil
-    assert_equal [], a.characteristics.known.keys
+    assert_same_contents [], a.characteristics.relevant.keys
   end
   
   should "keep snapshots separately" do
@@ -180,24 +182,81 @@ class TestCharacterizable < Test::Unit::TestCase
     a.make = 'Ford'
     a.model_year = 1999
     snapshot = a.characteristics
-    assert_equal [:make, :model_year], snapshot.known.keys
+    assert_same_contents [:make, :model_year], snapshot.relevant.keys
     a.make = nil
-    assert_equal [], a.characteristics.known.keys
-    assert_equal [:make, :model_year], snapshot.known.keys
+    assert_same_contents [], a.characteristics.relevant.keys
+    assert_same_contents [:make, :model_year], snapshot.relevant.keys
   end
     
   should "work when passed around as a snapshot" do
     a = Automobile.new
     a.make = 'Ford'
     snapshot = a.characteristics
-    assert_equal [:make], snapshot.known.keys
-    assert snapshot.unknown.keys.include?(:model_year)
+    assert_same_contents [:make], snapshot.relevant.keys
+    assert snapshot.irrelevant.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_same_contents [:make, :model_year], snapshot.relevant.keys
+    assert !snapshot.irrelevant.keys.include?(:model_year)
     assert_equal nil, a.model_year
     assert_equal nil, a.characteristics[:model_year]
     assert_equal 1999, snapshot[:model_year]
   end
+  
+  should "appreciate that sometimes characteristics just magically appear" do
+    a = Automobile.new
+    a.daily_distance_estimate = 15
+    snapshot = a.characteristics
+    snapshot[:daily_distance_oracle_estimate] = 20
+    assert_same_contents [:daily_distance_oracle_estimate], snapshot.relevant.keys
+    assert_same_contents [:daily_distance_estimate], a.characteristics.relevant.keys
+  end
+
+  # has :make do |make|
+  #   make.reveals :model_year do |model_year|
+  #     model_year.reveals :model, :trumps => :size_class do |model|
+  #       model.reveals :variant, :trumps => :hybridity
+  should "handle revelations on multiple levels" do
+    a = Automobile.new
+    a.make = 'Ford'
+    a.model_year = 1999
+    a.model = 'Taurus'
+    a.variant = 'Taurus 1999'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.make = nil
+    assert_same_contents [], a.characteristics.relevant.keys
+    a.make = 'Ford'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.model_year = nil
+    assert_same_contents [:make], a.characteristics.relevant.keys
+    a.model_year = 1999
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.model = nil
+    assert_same_contents [:make, :model_year], a.characteristics.relevant.keys
+    a.model = 'Taurus'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.variant = nil
+    assert_same_contents [:make, :model_year, :model], a.characteristics.relevant.keys
+  end
+  
+  should "handle trumping on multiple levels" do
+    a = Automobile.new
+    a.size_class = 'small' # can be trumped by model
+    a.hybridity = 'no' # can be trumped by variant
+    a.make = 'Ford'
+    a.model_year = 1999
+    a.model = 'Taurus'
+    a.variant = 'Taurus 1999'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.variant = nil
+    assert_same_contents [:make, :model_year, :model, :hybridity], a.characteristics.relevant.keys
+    a.variant = 'Taurus 1999'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.model = nil # which reveals size class, but also hybridity!
+    assert_same_contents [:make, :model_year, :size_class, :hybridity], a.characteristics.relevant.keys
+    a.model = 'Taurus'
+    assert_same_contents [:make, :model_year, :model, :variant], a.characteristics.relevant.keys
+    a.make = nil
+    assert_same_contents [:size_class, :hybridity], a.characteristics.relevant.keys
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Andy Rossmeissl
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-11 00:00:00 -04:00
+date: 2010-05-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency