rapid-core 0.1

data/spec/rapid/setting/definer_spec.rb

@@ -0,0 +1,318 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Setting::Definer do
+  
+  before do
+    Object.class_eval do
+      class MyClass
+        include Rapid::Settings
+      end
+    end
+    
+    @definer = Rapid::Setting::Definer.new MyClass
+  end
+  
+  after do
+    Object.send(:remove_const, :MyClass) rescue nil
+  end
+  
+  describe "boolean" do
+    
+    it "should define a setting" do
+      @definer.boolean 'my_boolean'
+      
+      @instance = MyClass.new
+      @instance.my_boolean.should == nil
+      @instance.my_boolean?.should == false
+      
+      @instance.my_boolean = true
+      @instance.my_boolean.should == true
+      @instance.my_boolean?.should == true
+      
+      @instance.my_boolean = false
+      @instance.my_boolean.should == false
+      @instance.my_boolean?.should == false
+      
+      @instance.my_boolean = nil
+      @instance.my_boolean.should == nil
+      @instance.my_boolean?.should == false
+    end
+    
+    it "should define a setting with a default of true" do
+      @definer.boolean 'my_boolean', :default => true
+      
+      @instance = MyClass.new
+      @instance.my_boolean.should == true
+      @instance.my_boolean?.should == true
+      
+      @instance.my_boolean = false
+      @instance.my_boolean.should == false
+      @instance.my_boolean?.should == false
+      
+      @instance.my_boolean = nil
+      @instance.my_boolean.should == nil
+      @instance.my_boolean?.should == false
+    end
+    
+    it "should define a setting with a default of false" do
+      @definer.boolean 'my_boolean', :default => false
+      
+      @instance = MyClass.new
+      @instance.my_boolean.should == false
+      @instance.my_boolean?.should == false
+      
+      @instance.my_boolean = true
+      @instance.my_boolean.should == true
+      @instance.my_boolean?.should == true
+      
+      @instance.my_boolean = nil
+      @instance.my_boolean.should == nil
+      @instance.my_boolean?.should == false
+    end
+    
+    it "should defined within an existing namespace" do
+      @definer.namespace 'foo'
+      @definer.boolean 'foo.bar', :default => false
+      
+      @instance = MyClass.new
+      @instance.foo.bar.should == false
+      @instance.foo.bar?.should == false
+    end
+    
+  end
+  
+  describe "string" do
+    
+    it "should define a setting" do
+      @definer.string 'my_string'
+      
+      @instance = MyClass.new
+      @instance.my_string.should == nil
+      @instance.my_string?.should == false
+      
+      @instance.my_string = "foo"
+      @instance.my_string.should == "foo"
+      @instance.my_string?.should == true
+    end
+    
+    it "should define a setting with a default" do
+      @definer.string 'my_string', :default => "foo"
+      
+      @instance = MyClass.new
+      @instance.my_string.should == "foo"
+      
+      @instance.my_string = "bar"
+      @instance.my_string.should == "bar"
+    end
+    
+    it "should know the namespace is empty even when there is a default child value" do
+      @definer.namespace 'foo'
+      @definer.string    'foo.name', :default => 'Dan'
+      
+      @instance = MyClass.new
+      @instance.foo = false
+      @instance.foo?.should == false
+    end
+    
+  end
+  
+  describe "integer" do
+    
+    it "should define a setting" do
+      @definer.integer 'my_integer'
+      
+      @instance = MyClass.new
+      @instance.my_integer.should == nil
+      @instance.my_integer?.should == false
+      @instance.my_integer = 1
+      @instance.my_integer.should == 1
+      @instance.my_integer?.should == true
+    end
+    
+    it "should define a setting with a default" do
+      @definer.integer 'my_integer', :default => 1
+      
+      @instance = MyClass.new
+      @instance.my_integer.should == 1
+      @instance.my_integer = 2
+      @instance.my_integer.should == 2
+    end
+    
+  end
+  
+  describe "namespace" do
+    
+    it "should define a setting" do
+      @definer.namespace 'my_namespace'
+      
+      @instance = MyClass.new
+      @instance.my_namespace.should_not be_nil
+    end
+    
+    it "should define a setting with default true" do
+      @definer.namespace 'my_namespace', :default => true
+      
+      @instance = MyClass.new
+      @instance.my_namespace?.should be_true
+      @instance.my_namespace = nil
+      @instance.my_namespace?.should be_false
+    end
+    
+    it "should define a setting with default false" do
+      @definer.namespace 'my_namespace', :default => false
+      
+      @instance = MyClass.new
+      @instance.my_namespace?.should be_false
+      @instance.my_namespace = {}
+      @instance.my_namespace?.should be_true
+    end
+    
+    it "should define a setting under a namespace" do
+      @definer.string 'app.name'
+      
+      @instance = MyClass.new
+      @instance.app.name?.should == false
+      @instance.app.name.should == nil
+      @instance.app.name = "Hi"
+      @instance.app.name.should == "Hi"
+    end
+    
+    it "should know nil" do
+      @definer.namespace 'app', :default => true
+      
+      @instance = MyClass.new
+      @instance.app?.should == true
+      @instance.app = nil
+      @instance.app?.should == false
+    end
+    
+    it "should know {}" do
+      @definer.namespace 'app', :default => false
+      
+      @instance = MyClass.new
+      @instance.app?.should == false
+      @instance.app = {}
+      @instance.app?.should == true
+    end
+    
+    it "should know true" do
+      @definer.namespace 'app', :default => false
+      
+      @instance = MyClass.new
+      @instance.app?.should == false
+      @instance.app = true
+      @instance.app?.should == true
+    end
+    
+    it "should know false" do
+      @definer.namespace 'app', :default => true
+      
+      @instance = MyClass.new
+      @instance.app?.should == true
+      @instance.app = false
+      @instance.app?.should == false
+    end
+    
+  end
+  
+  describe "nested namespaces" do
+    
+    it "should define a nested namespace" do
+      @definer.namespace 'parent.child'
+      
+      @instance = MyClass.new
+      @instance.parent.child.should_not be_nil
+      
+      @instance.parent.empty?.should == true
+      @instance.parent.child.empty?.should == true
+    end
+    
+    it "should define a nested setting with default true" do
+      @definer.namespace 'parent.child', :default => true
+      
+      @instance = MyClass.new
+      
+      @instance.parent.empty?.should == false
+      @instance.parent.child.empty?.should == false
+      
+      @instance.parent.child?.should be_true
+      @instance.parent.child = nil
+      @instance.parent.child?.should be_false
+      
+      @instance.parent.empty?.should == true
+      @instance.parent.child.empty?.should == true
+    end
+    
+    it "should define a nested setting with default false" do
+      @definer.namespace 'parent.child', :default => false
+      
+      @instance = MyClass.new
+      
+      @instance.parent.empty?.should == true
+      @instance.parent.child.empty?.should == true
+      
+      @instance.parent.child?.should be_false
+      @instance.parent.child = {}
+      @instance.parent.child?.should be_true
+      
+      @instance.parent.empty?.should == false
+      @instance.parent.child.empty?.should == false
+    end
+    
+  end
+  
+  describe "code" do
+    
+    it "should define a setting" do
+      @definer.code 'my_code'
+      
+      @instance = MyClass.new
+      @instance.my_code.should == nil
+      @instance.my_code = "1 + 1"
+      @instance.my_code.should == "1 + 1"
+    end
+    
+    it "should define a setting with a default" do
+      @definer.code 'my_code', :default => "2"
+      
+      @instance = MyClass.new
+      @instance.my_code.should == "2"
+      @instance.my_code = "1 + 1"
+      @instance.my_code.should == "1 + 1"
+    end
+    
+  end
+  
+  describe "class_eval" do
+    
+    it "should expose class_eval to override namespaces" do
+      @definer.namespace 'my_namespace'
+      @definer.class_eval 'my_namespace' do
+        def foo
+          "bar"
+        end
+      end
+      
+      @instance = MyClass.new
+      @instance.my_namespace.foo.should == "bar"
+    end
+    
+    it "should raise an error when the namespace isn't defined yet" do
+      @definer.namespace 'my_namespace'
+      lambda { @definer.class_eval('other_namespace') {} }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an error when the parent class doesn't allow custom instance classes" do
+      @definer.namespace 'my_namespace'
+      MyClass.settings["my_namespace"].instance_variable_set :@instance_class, nil
+      
+      lambda { @definer.class_eval('my_namespace') {} }.should raise_error(ArgumentError)
+    end
+    
+  end
+  
+  it "should over-ride inspect" do
+    Rapid::Setting::Definer.new(Object).inspect.class.should == String
+  end
+  
+end

data/spec/rapid/setting/instance_root_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Setting::InstanceRoot do
+  
+  it "should expose its binding" do
+    @class_hash = Rapid::Setting::ClassHash.new
+    @instance_hash = Rapid::Setting::InstanceRoot.new @class_hash
+    
+    @instance_hash.get_binding.should_not be_nil
+  end
+  
+  describe "namespaces" do
+    
+    before do
+      @class_hash = Rapid::Setting::ClassHash.new
+      @app = Rapid::Setting::Namespace::Base.new(:app)
+      @name = Rapid::Setting::StringSetting.new(:name, :namespace => @app)
+      
+      @class_hash[:app] = @app
+      @app[:name] = @name
+      
+      @instance_hash = Rapid::Setting::InstanceRoot.new @class_hash
+    end
+    
+    it "should load the namespaces from nested hashes" do
+      @instance_hash.load_hash :app => {:name => "Rapid"}
+      @instance_hash[:app][:name].should == "Rapid"
+    end
+    
+    it "should load the namespaces using dot-notation" do
+      @instance_hash.load_hash 'app.name' => "Rapid"
+      @instance_hash[:app][:name].should == "Rapid"
+    end
+    
+    it "should output the yaml in dot-notation" do
+      @instance_hash.load_hash 'app.name' => "Rapid"
+      @instance_hash.to_yaml.should == %(app.name: Rapid)
+    end
+    
+    it "should provide [] access to nested settings" do
+      @instance_hash.load_hash 'app.name' => "Rapid"
+      @instance_hash['app.name'].should == "Rapid"
+      
+      @instance_hash['app.invalid'].should == nil
+    end
+    
+  end
+  
+  describe "two-deep namespaces" do
+    
+    before do
+      @class_hash = Rapid::Setting::ClassHash.new
+      @app = Rapid::Setting::Namespace::Base.new(:app)
+      @author = Rapid::Setting::Namespace::Base.new(:author)
+      @name = Rapid::Setting::StringSetting.new(:name, :namespace => @autor)
+      
+      @class_hash[:app] = @app
+      @app[:author] = @author
+      @author[:name] = @name
+      
+      @instance_hash = Rapid::Setting::InstanceRoot.new @class_hash
+    end
+    
+    it "should load the namespaces from nested hashes" do
+      @instance_hash.load_hash :app => {:author => {:name => "Dan"} }
+      @instance_hash[:app][:author][:name].should == "Dan"
+    end
+    
+    it "should load the namespaces using dot-notation" do
+      @instance_hash.load_hash 'app.author.name' => "Dan"
+      @instance_hash[:app][:author][:name].should == "Dan"
+    end
+    
+    it "should output the yaml in dot-notation" do
+      @instance_hash.load_hash 'app.author.name' => "Dan"
+      @instance_hash.to_yaml.should == %(app.author.name: Dan)
+    end
+    
+    it "should provide [] access" do
+      @instance_hash.load_hash 'app.author.name' => "Dan"
+      @instance_hash['app.author.name'].should == "Dan"
+      
+      @instance_hash['app.author.invalid'].should == nil
+    end
+    
+    it "should know set?" do
+      @instance_hash.set?('app').should == false
+      @instance_hash.set?('app.author').should == false
+      @instance_hash.set?('app.author.name').should == false
+      @instance_hash.set?('app.author.invalid').should == false
+      
+      @instance_hash.load_hash 'app.author.name' => "Dan"
+      
+      @instance_hash.set?('app').should == true
+      @instance_hash.set?('app.author').should == true
+      @instance_hash.set?('app.author.name').should == true
+      @instance_hash.set?('app.author.invalid').should == false
+    end
+    
+  end
+  
+  describe "YAML" do
+    
+    before do
+      @class_hash = Rapid::Setting::ClassHash.new
+      @class_hash[:name] = Rapid::Setting::StringSetting.new(:name)
+      @class_hash[:version] = Rapid::Setting::StringSetting.new(:version)
+      
+      @instance_hash = Rapid::Setting::InstanceRoot.new @class_hash
+    end
+    
+    describe "loading" do
+      
+      def load_yaml content
+        @instance_hash.load_yaml content
+      end
+      
+      it "should load the hash with values" do
+        load_yaml %(name: Dan)
+        @instance_hash["name"].should == "Dan"
+      end
+      
+      it "should handle empty files" do
+        load_yaml %()
+        @instance_hash.empty?.should be_true
+      end
+      
+      it "should raise an error when an unknown setting is specified" do
+        load_yaml %(foo: bar)
+        @instance_hash.valid?.should be_false
+        @instance_hash.errors["foo"].should == ["can't be found"]
+      end
+      
+      it "should raise error when yaml is invalid" do
+        lambda { load_yaml %(foo: d\nea5#) }.should raise_error(Rapid::InvalidYamlError)
+      end
+      
+    end
+    
+    describe "to_yaml" do
+      
+      def to_yaml
+        @instance_hash.to_yaml
+      end
+      
+      it "should write current settings" do
+        @instance_hash["name"] = "Dan"
+        @instance_hash["version"] = "1.0"
+        
+        to_yaml.should == %(name: Dan\nversion: "1.0")
+      end
+      
+      it "should handle empty settings" do
+        to_yaml.should == %()
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/rapid/setting/namespace/base_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Setting::Namespace::Base do
+  
+  before do
+    Object.class_eval do
+      class MySkeleton
+        
+      end
+    end
+    
+    @skeleton = MySkeleton.new
+  end
+  
+  after do
+    Object.send(:remove_const, :MySkeleton) rescue nil
+  end
+  
+  describe "accessor class" do
+    
+    before do
+      @namespace = Rapid::Setting::Namespace::Base.new :app, :class => MySkeleton
+      
+      @name = Rapid::Setting::StringSetting.new :name, :namespace => @namespace
+      @version = Rapid::Setting::StringSetting.new :version, :namespace => @namespace
+      
+      @namespace.define_setting @name
+      @namespace.define_setting @version
+    end
+    
+    it "should know the full name" do
+      @version.full_name.should == "app.version"
+    end
+    
+    it "should initialize a class to hold the accessor methods" do
+      lambda { MySkeleton::Settings::App }.should_not raise_error
+    end
+    
+    it "should set the class's setting_name" do
+      MySkeleton::Settings::App.setting_name.should == "app"
+    end
+    
+    it "should generate the accessor methods" do
+      @instance = @namespace.load :name => "Dan", :version => "1.0"
+      @instance.name.should == "Dan"
+      @instance.version.should == "1.0"
+    end
+    
+  end
+  
+  describe "two-deep class" do
+    
+    before do
+      @namespace = Rapid::Setting::Namespace::Base.new :app, :class => MySkeleton
+      @author = Rapid::Setting::Namespace::Base.new :author, :namespace => @namespace, :class => MySkeleton
+      
+      @name = Rapid::Setting::StringSetting.new :name, :namespace => @author
+      @version = Rapid::Setting::StringSetting.new :version, :namespace => @author
+      
+      @namespace.define_setting @author
+      @author.define_setting @name
+      @author.define_setting @version
+    end
+    
+    it "should know the full name" do
+      @version.full_name.should == "app.author.version"
+    end
+    
+    it "should initialize a class to hold the accessor methods" do
+      lambda { MySkeleton::Settings::App }.should_not raise_error
+      lambda { MySkeleton::Settings::AppAuthor }.should_not raise_error
+    end
+    
+    it "should set the class's setting_name" do
+      MySkeleton::Settings::App.setting_name.should == "app"
+      MySkeleton::Settings::AppAuthor.setting_name.should == "author"
+    end
+    
+    it "should generate the accessor methods" do
+      @instance = @namespace.load :author => {:name => "Dan", :version => "1.0"}, :owner => "hi"
+      @instance.author.name.should == "Dan"
+      @instance.author.version.should == "1.0"
+    end
+    
+    it "should provide access to the owner" do
+      @instance = @namespace.load :owner => "hi"
+      @instance._root.should == "hi"
+      @instance.author._root.should == "hi"
+    end
+    
+  end
+  
+end

data/spec/rapid/setting/namespace/instance_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe Rapid::Setting::Namespace::Instance do
+  
+  it "should alias root as _root by default" do
+    obj = mock(:default_empty => true, :scalars => [])
+    @instance = Rapid::Setting::Namespace::Instance.new "hi", obj
+    @instance.root.should == "hi"
+    @instance._root.should == "hi"
+  end
+  
+end

data/spec/rapid/setting/nested_validations_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Setting::NestedValidations do
+  
+  before do
+    Object.class_eval do
+      class A
+        include ActiveModel::Validations
+        include Rapid::Setting::NestedValidations
+        attr_accessor :b, :value
+      end
+      
+      class B
+        include ActiveModel::Validations
+        include Rapid::Setting::NestedValidations
+        attr_accessor :root, :c, :value
+      end
+      
+      class C
+        include ActiveModel::Validations
+        include Rapid::Setting::NestedValidations
+        attr_accessor :root, :value
+      end
+    end
+    
+    @a = A.new
+    @a.b = B.new
+    @a.b.c = C.new
+  end
+  
+  after do
+    Object.send(:remove_const, :A) rescue nil
+    Object.send(:remove_const, :B) rescue nil
+    Object.send(:remove_const, :C) rescue nil
+  end
+  
+  def init_a
+    @a = A.new
+    @a.b = B.new
+    @a.b.c = C.new
+    
+    @a.b.root = @a
+    @a.b.c.root = @a
+    
+    @a
+  end
+  
+  it "should obey dot-operators in the if clause" do
+    C.send :validates_presence_of, :value, :if => 'root.value'
+    init_a
+    @a.b.c.valid?.should == true
+    @a.value = 2
+    @a.b.c.valid?.should == false
+  end
+  
+  it "should obey dot-operators in the unless clause" do
+    C.send :validates_presence_of, :value, :unless => 'root.value'
+    init_a
+    @a.b.c.valid?.should == false
+    @a.value = 2
+    @a.b.c.valid?.should == true
+  end
+  
+  it "should raise an error when validating an unknown nested value" do
+    @settings = mock('setting')
+    @settings.should_receive(:find_namespace).and_return(nil)
+    A.should_receive(:setting).and_return(@settings)
+    
+    lambda { A.validates_presence_of 'app.author' }.should raise_error(Rapid::UnknownSettingError)
+  end
+  
+end

data/spec/rapid/settings_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rapid::Settings do
+  
+  before do
+    Object.class_eval do
+      class MyClass
+        include Rapid::Settings
+        
+        setting.string 'foo'
+      end
+    end
+    
+    @instance = MyClass.new
+  end
+  
+  after do
+    Object.send(:remove_const, :MyClass) rescue nil
+  end
+  
+  describe "extract_nested_namespace" do
+    
+    it "should return the namespace and rest" do
+      Rapid::Settings.extract_nested_namespace("foo.bar").should == ["foo", "bar"]
+    end
+    
+    it "should return nil and original when not namespaced" do
+      Rapid::Settings.extract_nested_namespace("foo").should == [nil, "foo"]
+    end
+    
+    it "should handle nil" do
+      Rapid::Settings.extract_nested_namespace(nil).should == [nil, nil]
+    end
+    
+    it "should handle a symbol" do
+      Rapid::Settings.extract_nested_namespace(:foo).should == [nil, 'foo']
+    end
+    
+  end
+  
+  it "should expose the setting's bindings by default" do
+    @instance.get_binding.should_not be_nil
+  end
+  
+  it "should provide array-like access" do
+    @instance['foo'] = 'hi'
+    @instance['foo'].should == 'hi'
+    @instance.foo.should == 'hi'
+  end
+  
+end