opal 0.0.1 → 0.1.0

data/opals/foundation/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'foundation'

data/opals/foundation/spec/system/attributes/get_attribute_spec.rb

@@ -0,0 +1,69 @@
+
+class KVCTest
+  
+  def initialize
+    @ivar_key_name = 300
+  end
+  
+  def first_key
+    100
+  end
+  
+  def second_key?
+    200
+  end
+  
+end
+
+describe "Attributes#get_attribute" do
+  
+  it "should call the getter method if one exists" do
+    t = KVCTest.new
+    t.get_attribute('first_key').should == 100
+    t.get_attribute(:first_key).should == 100
+  end
+  
+  it "should call a designated boolean getter method if defined" do
+    t = KVCTest.new
+    t.get_attribute('second_key').should == 200
+    t.get_attribute(:second_key).should == 200
+  end
+  
+  it "should access an instance variable with the key name" do
+    t = KVCTest.new
+    t.get_attribute('ivar_key_name').should == 300
+    t.get_attribute(:ivar_key_name).should == 300
+  end
+  
+  it "should raise an error when the given key name cannot be found" do
+    t = KVCTest.new
+    t.get_attribute('unknown_key').should_raise
+  end
+  
+  it "should always return nil when value_for_key is called on nil" do
+    nil.get_attribute('some_key_name_which_will_not_exist').should == nil
+    nil.get_attribute(:nil_key).should == nil
+  end
+end
+
+describe "Hash KeyValueCoding#value_for_key" do
+  
+  it "should use string keys to access Hash keys and return their value" do
+    hash = { 'first_name' => 100, 'second_name' => 200 }
+    hash.get_attribute('first_name').should == 100
+    hash.get_attribute('second_name').should == 200
+  end
+  
+  it "should return the Hash default for unknown keys" do
+    hash = {}
+    hash.get_attribute('some_unknown_key').should == nil
+  end
+  
+  it "should not treat symbols as string names for accessing keys" do
+    hash = { :first_name => 100, 'second_name' => 200 }
+    hash.get_attribute(:first_name).should == nil
+    hash.get_attribute('second_name').should == 200
+    hash.get_attribute(:second_name).should == 200
+  end
+end
+

data/opals/foundation/spec/system/attributes/get_path_spec.rb

@@ -0,0 +1,44 @@
+class KVCPathTestA
+  attr_accessor :part_b
+end
+
+class KVCPathTestB
+  attr_accessor :part_c
+end
+
+class KVCPathTestC
+  attr_accessor :first_name
+end
+
+
+describe "Attributes#get_path" do
+  
+  it "should call regular value_for_key when no dot-splitter detected" do
+    a = KVCPathTestA.new
+    b = KVCPathTestB.new
+    a.part_b = b
+    a.get_path('part_b').should == b
+  end
+  
+  it "should split the path for paths which are dot seperated" do
+    a = KVCPathTestA.new
+    b = KVCPathTestB.new
+    c = KVCPathTestC.new
+        
+    a.part_b = b
+    b.part_c = c
+    c.first_name = "adam"
+    
+    a.get_path('part_b.part_c').should == c
+    a.get_path('part_b.part_c.first_name').should == "adam"
+  end
+  
+  it "should eventually return nil if nil is encountered anywhere along path" do
+    nil.get_path('a.b.c.d.e').should == nil
+    
+    c = KVCPathTestC.new
+    c.first_name = nil
+    c.get_path('first_name.second_name').should == nil
+    
+  end
+end

data/opals/foundation/spec/system/attributes/set_path_spec.rb

@@ -0,0 +1,24 @@
+
+describe "Attributes#set_path" do
+  
+  it "should call regular set_path when no dot used in path" do
+    a = KVCPathTestA.new
+    b = KVCPathTestB.new
+    a.set_path 'part_b', b
+    a.part_b.should == b
+  end
+  
+  it "should split the path for dot seperated keys, using the last part to set the key" do
+    a = KVCPathTestA.new
+    b = KVCPathTestB.new
+    c = KVCPathTestC.new
+    
+    a.set_path 'part_b', b
+    a.set_path 'part_b.part_c', c
+    a.set_path 'part_b.part_c.first_name', "adam"
+    
+    a.get_path('part_b').should == b
+    a.get_path('part_b.part_c').should == c
+    a.get_path('part_b.part_c.first_name').should == "adam"
+  end
+end

data/opals/foundation/spec/system/attributes/set_spec.rb

@@ -0,0 +1,58 @@
+
+class KVCSettingTest
+  
+  def initialize
+    @ivar_key = 200
+    @ivar_key_array = []
+  end
+  
+  def will_change_attribute(key)
+    @ivar_key_array << :will
+    @ivar_key_array << key
+  end
+  
+  def did_change_attribute(key)
+    @ivar_key_array << :did
+    @ivar_key_array << key
+  end
+  
+  def ivar_key_array
+    @ivar_key_array
+  end
+  
+  def ivar_key
+    @ivar_key
+  end  
+end
+
+class KVCSettingTest2
+  
+  def first_name=(first_name)
+    @first_name = "set_kvc_style_#{first_name}"
+  end
+  
+  def first_name
+    @first_name
+  end
+end
+
+describe "Attributes#set_attribute" do
+  
+  it "should call KVO observer methods when setting an ivar" do
+    a = KVCSettingTest.new
+    a.set_attribute 'ivar_key', 100
+    a.ivar_key_array.should == [:will, 'ivar_key', :did, 'ivar_key']
+    a.ivar_key.should == 100
+  end
+  
+  it "should use the designated setter when available" do
+    a = KVCSettingTest2.new
+    a.set_attribute 'first_name', "adam"
+    a.first_name.should == "set_kvc_style_adam"
+  end
+  
+  it "should raise an error when trying to set an unknown key" do
+    a = KVCSettingTest2.new
+    a.set_attribute 'some_random_key_name', 200
+  end
+end

data/opals/foundation/spec/system/bindings/bindings.rb

@@ -0,0 +1,85 @@
+class BindingsSpecEmail
+  
+  attr_accessor :properties
+  
+  def initialize
+    @properties = {
+      :address  => "test@test.com",
+      :subject  => "Subject",
+      :date     => "Date..",
+      :body     => ""
+    }
+  end
+end
+
+class BindingsSpecMailbox
+  
+  attr_accessor :properties, :emails
+  
+  def initialize
+    @properties = { :title => "New Mailbox " }
+    @emails = []
+  end
+end
+
+class BindingsSpecController
+  
+  def initialize
+    @mailboxes = [1, 2, 3, 4]
+  end
+  
+  attr_accessor :mailboxes
+  
+  def add_email(sender)
+    
+  end
+  
+  def add_mailbox(sender)
+    
+  end
+  
+  def remove_email(sender)
+    
+  end
+  
+  def remove_mailbox(sender)
+    
+  end
+end
+
+describe "Bindings Spec Coded demo" do
+  
+  it "should all be ok" do
+    controller = BindingsSpecController.new
+    # puts "making controller alias"
+    controller_alias = CherryKit::ObjectController.new
+    puts "going to set content"
+    # `console.log(#{controller});`
+    controller_alias.content = controller
+    puts "did set content"
+    # setup mailboxes array controller
+    mailboxes = CherryKit::ArrayController.new
+    mailboxes.bind :content_array, 
+                   :to    => controller_alias,
+                   :path  => 'selection.mailboxes'
+                   
+    mailboxes.object_class = BindingsSpecMailbox
+    
+    puts "mailboxes array controller:"
+    `console.log(#{mailboxes.content_array});`
+    
+    # `console.log(#{controller_alias});`
+    puts "setting mailboxes!"
+    controller.mailboxes = [5, 6, 7, 8]
+    puts "mailboxes array controller after change:"
+    `console.log(#{mailboxes.content_array});`
+    
+    # setup emails array controller
+    # emails = CherryKit::ArrayController.new
+    #    emails.bind :content_array,
+    #                :to   => mailboxes,
+    #                :path => 'selection.emails'
+    #    
+    #    emails.object_class = BindingsSpecEmail
+  end
+end

data/opals/foundation/spec/system/key_value_binding/bind_spec.rb

@@ -0,0 +1,43 @@
+
+class KVBTesterA
+  
+  attr_accessor :first_name
+  
+end
+
+class KVBTesterB
+  
+  attr_reader :my_name
+  
+  def initialize
+    @my_name = "Jon Stewart"
+  end
+  
+end
+
+describe "KeyValueBinding#bind_to" do
+  
+  it "show allow bindings to be exposed" do
+    KVBTesterA.expose_binding :foo_test
+    KVBTesterA.expose_binding :bar_test
+    
+    KVBTesterA.new.respond_to?(:foo_test_binding=).should == true
+    KVBTesterA.new.respond_to?(:bar_test_binding=).should == true
+  end
+  
+  it "should propogate KVC compliant chnages to bound objects" do
+    a = KVBTesterA.new
+    b = KVBTesterB.new
+    
+    a.first_name = "Roger"
+            
+    b.bind :my_name, :to => a, :path => :first_name
+    
+    b.my_name.should == "Roger"
+    
+    a.first_name = "Adam Beynon"
+  
+    b.my_name.should == "Adam Beynon"
+  end
+  
+end

data/opals/foundation/spec/system/observable/dependant_keys_spec.rb

@@ -0,0 +1,74 @@
+
+class DependantKeysTest
+  
+  attr_reader :a, :b, :c
+  
+  keys_affecting :a => [:b, :c]
+  
+  def initialize
+    @a = "a"
+    @b = "b"
+    @c = "c"
+  end
+  
+  def a=(a)
+    @a = a
+  end
+  
+  def a
+    "#{@a}_#{b}_#{c}"
+  end
+  
+  def b=(b)
+    @b = b
+  end
+  
+  def c=(c)
+    @c = c
+  end
+end
+
+describe "KeyValueObserving#keys_affecting" do
+  
+  it "should notify observer when an affecting key is changed" do
+    # puts "==================================================================="
+    obj = DependantKeysTest.new
+    
+    capture_a = nil
+    
+    notification_count = 0
+    
+    notifications = []
+    
+    obj.observe :a do |changes|
+      notifications << :a
+      capture_a = obj.a
+      notification_count = notification_count + 1
+    end
+    
+    obj.observe :b do |changes|
+      notifications << :b
+    end
+    
+    obj.observe :c do |changes|
+      notifications << :c
+    end
+    
+    obj.a = "adam"
+    capture_a.should == "adam_b_c"
+    notification_count.should == 1
+    notifications.should == [:a]
+    
+    notifications = []
+    obj.b = "tom"
+    capture_a.should == "adam_tom_c"
+    notification_count.should == 2
+    notifications.should == [:b, :a]
+    
+    notifications = []
+    obj.c = "ben"
+    capture_a.should == "adam_tom_ben"
+    notification_count.should == 3
+    notifications.should == [:c, :a]
+  end
+end

data/opals/foundation/spec/system/observable/observe_spec.rb

@@ -0,0 +1,292 @@
+class KVOTestSimple
+  
+  attr_reader :first_name
+  
+  attr_accessor :second_name
+    
+  def initialize
+    @some_ivar_we_can_set = nil
+  end
+  
+  def first_name=(first_name)
+    @first_name = "setting_#{first_name}"
+  end
+
+end
+
+
+class KVOMultipartClass
+  attr_accessor :teacher, :students
+end
+
+class KVOMultipartPerson
+  attr_accessor :name, :car
+end
+
+class KVOMultipartCar
+  attr_accessor :model
+end
+
+
+class KVOTestRepeaterA
+  attr_accessor :b
+end
+
+class KVOTestRepeaterB
+  attr_accessor :c
+end
+
+class KVOTestRepeaterC
+  attr_accessor :d
+end
+
+class KVOTestRepeaterD
+  attr_accessor :e
+end
+
+class KVOTestRepeaterE
+  attr_accessor :f
+end
+
+class KVOTestRepeaterF
+  attr_accessor :g
+end
+
+describe "Observable#observe" do
+  
+  it "should allow a simple observer to be added" do
+    a = KVOTestSimple.new
+    
+    old_value = nil
+    new_value = nil
+    did_see_notification = false
+    
+    a.observe :first_name do |changes|
+      did_see_notification = true
+      old_value = changes[:old]
+      new_value = changes[:new]
+    end
+    
+    a.first_name = 'adam'
+    a.first_name.should == 'setting_adam'
+    
+    did_see_notification.should == true
+    
+    old_value.should == nil
+    new_value.should == 'setting_adam'
+  end
+  
+  
+  
+  it "should only observe and post notifications for observed keys" do
+    b = KVOTestSimple.new
+    
+    did_see_notification = false
+    
+    b.observe :first_name do |changes|
+      did_see_notification = true
+    end
+    
+    b.second_name = "adam"
+    b.second_name.should == "adam"
+    did_see_notification.should == false
+    
+  end
+  
+  
+  
+  it "should allow multiple observers for a single key" do
+    c = KVOTestSimple.new
+    d = KVOTestSimple.new
+    
+    first_saw = false
+    second_saw = false
+    
+    c.observe :first_name do |changes|
+      first_saw = true
+    end
+    
+    c.observe :first_name do |changes|
+      second_saw = true
+    end
+    
+    c.first_name = "some_name"
+    c.first_name.should == "setting_some_name"
+    
+    first_saw.should == true
+    second_saw.should == true
+
+  end
+
+  
+  
+  it "should be possible to observe instance variables" do
+    e = KVOTestSimple.new
+    
+    old_value = nil
+    new_value = nil
+    did_see_notification = false
+    
+    e.observe :some_ivar_we_can_set do |changes|
+      did_see_notification = true
+      old_value = changes[:old]
+      new_value = changes[:new]
+    end
+    
+    e.set_attribute :some_ivar_we_can_set, 200
+    
+    did_see_notification.should == true
+    e.get_attribute(:some_ivar_we_can_set).should == 200
+    
+    old_value.should == nil
+    new_value.should == 200
+    
+  end
+  
+  
+  
+  it "should allow observers for multipart keys" do
+    the_class = KVOMultipartClass.new
+    fred = KVOMultipartPerson.new
+    
+    the_class.teacher = fred
+    did_see_observation = false
+    
+    the_class.observe 'teacher.name' do |change|
+      did_see_observation = true
+    end
+    
+    fred.name = "Fred"
+    
+    the_class.get_path('teacher.name').should == "Fred"
+    did_see_observation.should == true
+  end
+  
+  
+  
+  it "should allow a three part key" do
+    cls = KVOMultipartClass.new
+    fred = KVOMultipartPerson.new
+    car = KVOMultipartCar.new
+    
+    did_see_observation = false
+    
+    cls.teacher = fred
+    fred.car = car
+    
+    cls.observe('teacher.car.model') do |info|
+      info[:path].should == "teacher.car.model"
+      did_see_observation = true
+    end
+    
+    car.model = "Jaguar"
+    
+    did_see_observation.should == true
+    cls.teacher.car.model.should == "Jaguar"
+  end
+  
+  
+  
+  it "should allow long observer paths" do
+    a = KVOTestRepeaterA.new
+    a.set_path 'b', KVOTestRepeaterB.new
+    a.set_path 'b.c', KVOTestRepeaterC.new
+    a.set_path 'b.c.d', KVOTestRepeaterD.new
+    a.set_path 'b.c.d.e', KVOTestRepeaterE.new
+    a.set_path 'b.c.d.e.f', KVOTestRepeaterF.new
+    a.set_path 'b.c.d.e.f.g', "Hey G"
+    
+    a.b.c.d.e.f.g.should == "Hey G"
+    did_see_observation = false
+
+    a.observe('b.c.d.e.f.g') do |info|
+      did_see_observation = true
+      
+      info[:path].should == 'b.c'
+      info[:object].class.should == KVOTestRepeaterA
+    end
+    
+    a.b.c = nil
+    did_see_observation.should == true
+    
+  end
+  
+  
+  
+  it "should allow long observer paths, part2" do
+    a = KVOTestRepeaterA.new
+    a.set_path 'b', KVOTestRepeaterB.new
+    a.set_path 'b.c', KVOTestRepeaterC.new
+    a.set_path 'b.c.d', KVOTestRepeaterD.new
+    a.set_path 'b.c.d.e', KVOTestRepeaterE.new
+    a.set_path 'b.c.d.e.f', KVOTestRepeaterF.new
+    a.set_path 'b.c.d.e.f.g', "Hey G"
+    
+    did_see_observation = false
+
+    a.observe('b.c.d.e.f.g') do |info|
+      did_see_observation = true
+      
+      info[:path].should == 'b.c.d'
+      info[:object].class.should == KVOTestRepeaterA
+      info[:new].should == nil
+    end
+    
+    a.b.c.d = nil
+    did_see_observation.should == true
+    
+  end
+  
+  
+  
+  it "should allow long observer paths, part3" do
+    a = KVOTestRepeaterA.new
+    a.set_path 'b', KVOTestRepeaterB.new
+    a.set_path 'b.c', KVOTestRepeaterC.new
+    a.set_path 'b.c.d', KVOTestRepeaterD.new
+    a.set_path 'b.c.d.e', KVOTestRepeaterE.new
+    a.set_path 'b.c.d.e.f', KVOTestRepeaterF.new
+    a.set_path 'b.c.d.e.f.g', "Hey G"
+    
+    did_see_observation = false
+
+    a.observe('b.c.d.e.f.g') do |info|
+      did_see_observation = true
+      
+      info[:path].should == 'b.c.d.e.f.g'
+      info[:object].class.should == KVOTestRepeaterA
+      info[:new].should == 100
+    end
+    
+    a.b.c.d.e.f.g = 100
+    did_see_observation.should == true
+    
+  end
+  
+  
+  
+  it "should allow long observer paths, part3" do
+    a = KVOTestRepeaterA.new
+    a.set_path 'b', KVOTestRepeaterB.new
+    a.set_path 'b.c', KVOTestRepeaterC.new
+    a.set_path 'b.c.d', KVOTestRepeaterD.new
+    a.set_path 'b.c.d.e', KVOTestRepeaterE.new
+    a.set_path 'b.c.d.e.f', KVOTestRepeaterF.new
+    a.set_path 'b.c.d.e.f.g', "Hey G"
+    
+    did_see_observation = false
+
+    a.observe('b.c.d.e.f.g') do |info|
+      did_see_observation = true
+      
+      info[:path].should == 'b'
+      info[:object].class.should == KVOTestRepeaterA
+      info[:new].should == 200
+    end
+    
+    a.b = 200
+    did_see_observation.should == true
+    
+  end
+  
+end