parameters 0.2.3 → 0.3.0

data/spec/parameters_spec.rb

@@ -24,41 +24,47 @@ describe Parameters do
   end
 
   context "in a Class" do
+    subject { TestParameters }
+
+    let(:inherited_class) { InheritedParameters }
+
     it "should provide parameters" do
-      TestParameters.params.should_not be_empty
+      subject.params.should_not be_empty
     end
 
     it "should have default values for parameters" do
-      TestParameters.param_value(:var_with_default).should == 'thing'
+      subject.param_value(:var_with_default).should == 'thing'
     end
 
     it "should provide class methods for paremters" do
-      TestParameters.var = 1
-      TestParameters.var.should == 1
+      subject.var = 1
+      subject.var.should == 1
     end
 
     it "should inherite the super-classes parameters" do
-      InheritedParameters.has_param?(:var).should == true
-      InheritedParameters.has_param?(:child_var).should == true
+      inherited_class.has_param?(:var).should == true
+      inherited_class.has_param?(:child_var).should == true
     end
 
     it "should provide direct access to the parameter objects" do
-      param = TestParameters.get_param(:var)
+      param = subject.get_param(:var)
 
       param.should_not be_nil
       param.name.should == :var
     end
 
     it "should raise a ParamNotFound exception when directly accessing non-existent parameter objects" do
-      lambda { TestParameters.get_param(:unknown) }.should raise_error(Parameters::ParamNotFound)
+      lambda {
+        subject.get_param(:unknown)
+      }.should raise_error(Parameters::ParamNotFound)
     end
 
     it "should provide descriptions for parameters" do
-      TestParameters.describe_param(:var).should_not be_empty
+      subject.describe_param(:var).should_not be_empty
     end
 
     it "should be able to initialize parameters" do
-      obj = TestParameters.new
+      obj = subject.new
 
       obj.params.should_not be_empty
     end
@@ -84,7 +90,7 @@ describe Parameters do
     end
 
     it "should be able to create an object with initial parameter values" do
-      obj = TestParameters.new(:var => 2, :var_with_default => 'stuff')
+      obj = subject.new(:var => 2, :var_with_default => 'stuff')
 
       obj.var.should == 2
       obj.var_with_default.should == 'stuff'
@@ -92,130 +98,147 @@ describe Parameters do
   end
 
   context "in an Object" do
-    before(:each) do
-      @test = TestParameters.new
-      @test_inherited = InheritedParameters.new
-    end
+    subject { TestParameters.new }
+
+    let(:inherited_params) { InheritedParameters.new }
 
     it "should provide direct access to all parameters" do
-      @test.params[:var].should_not be_nil
-      @test.params[:var_with_default].should_not be_nil
+      subject.params[:var].should_not be_nil
+      subject.params[:var_with_default].should_not be_nil
     end
 
     it "should have default values for parameters" do
-      @test.param_value(:var_with_default).should == 'thing'
+      subject.param_value(:var_with_default).should == 'thing'
     end
 
     it "should provide instance methods for parameters" do
-      @test.var = 2
-      @test.var.should == 2
+      subject.var = 2
+      subject.var.should == 2
     end
 
     it "should set instance variables for paramters" do
-      @test.instance_variable_get(:@var_with_default).should == 'thing'
+      subject.instance_variable_get(:@var_with_default).should == 'thing'
 
-      @test.var = 3
-      @test.instance_variable_get(:@var).should == 3
+      subject.var = 3
+      subject.instance_variable_get(:@var).should == 3
     end
 
     it "should allow using lambdas for the default values of parameters" do
-      test2 = TestParameters.new
+      other_params = TestParameters.new
 
-      @test.var_with_lambda.should_not == test2.var_with_lambda
+      subject.var_with_lambda.should_not == other_params.var_with_lambda
     end
 
     it "should contain the parameters from all ancestors" do
-      @test_inherited.has_param?(:var).should == true
-      @test_inherited.has_param?(:child_var).should == true
+      inherited_params.has_param?(:var).should == true
+      inherited_params.has_param?(:child_var).should == true
     end
 
     it "should provide direct access to the parameter objects" do
-      @param = @test.get_param(:var)
+      @param = subject.get_param(:var)
 
       @param.should_not be_nil
       @param.name.should == :var
     end
 
     it "should raise a ParamNotFound exception when directly accessing non-existent parameter objects" do
-      lambda { @test.get_param(:unknown) }.should raise_error(Parameters::ParamNotFound)
+      lambda {
+        subject.get_param(:unknown)
+      }.should raise_error(Parameters::ParamNotFound)
+    end
+
+    it "should allow setting arbitrary parameters" do
+      subject.set_param(:var,2)
+
+      subject.get_param(:var).value.should == 2
+    end
+
+    it "should raise a ParamNotFound exception when setting non-existent parameters" do
+      lambda {
+        subject.set_param(:unknown,2)
+      }.should raise_error(Parameters::ParamNotFound)
     end
 
     it "should allow for setting parameters en-mass" do
-      @test.params = {:var => 3, :var_with_default => 7}
+      subject.params = {:var => 3, :var_with_default => 7}
 
-      @test.param_value(:var).should == 3
-      @test.param_value(:var_with_default).should == 7
+      subject.param_value(:var).should == 3
+      subject.param_value(:var_with_default).should == 7
     end
 
     it "should allow for setting parameters en-mass from another object" do
       obj = TestParameters.new(:var => 5, :var_with_default => 'hello')
-      @test.params = obj.params
+      subject.params = obj.params
 
-      @test.var.should == 5
-      @test.var_with_default.should == 'hello'
+      subject.var.should == 5
+      subject.var_with_default.should == 'hello'
     end
 
     it "should allow for setting parameters en-mass from another class" do
-      @test.params = OtherParameters.params
+      subject.params = OtherParameters.params
 
-      @test.var.should be_nil
-      @test.var_with_default.should == 'other'
+      subject.var.should be_nil
+      subject.var_with_default.should == 'other'
     end
 
     it "should provide descriptions for parameters" do
-      @test.describe_param(:var).should_not be_empty
+      subject.describe_param(:var).should_not be_empty
     end
 
     it "should require that certain parameters have non nil values" do
       lambda {
-        @test.instance_eval { require_params(:var_without_default) }
+        subject.instance_eval { require_params(:var_without_default) }
       }.should raise_error(Parameters::MissingParam)
     end
   end
 
   describe "runtime" do
+    subject { TestParameters.new }
+
     before(:each) do
-      @test = TestParameters.new
+      subject.parameter :new_param
+
+      subject.parameter :new_param_with_default,
+                        :default => 5
 
-      @test.parameter :new_param
-      @test.parameter :new_param_with_default,
-                      :default => 5
-      @test.parameter :new_param_with_lambda,
-                      :default => lambda { |obj| obj.new_param_with_default + 2 }
+      subject.parameter :new_param_with_lambda,
+                        :default => lambda { |obj|
+                          obj.new_param_with_default + 2
+                        }
     end
 
     it "should allow for the addition of parameters" do
-      @test.has_param?(:new_param).should == true
+      subject.has_param?(:new_param).should == true
     end
 
     it "should provide direct access to all parameters" do
-      @test.params[:new_param].should_not be_nil
-      @test.params[:new_param_with_default].should_not be_nil
-      @test.params[:new_param_with_lambda].should_not be_nil
+      subject.params[:new_param].should_not be_nil
+      subject.params[:new_param_with_default].should_not be_nil
+      subject.params[:new_param_with_lambda].should_not be_nil
     end
 
     it "should add reader methods for parameters" do
-      @test.new_param.should be_nil
+      subject.new_param.should be_nil
     end
 
     it "should add writer methods for parameters" do
-      @test.new_param = 10
-      @test.new_param.should == 10
+      subject.new_param = 10
+      subject.new_param.should == 10
     end
 
     it "should set the instance variables of parameters" do
-      @test.instance_variable_get(:@new_param_with_default).should == 5
+      subject.instance_variable_get(:@new_param_with_default).should == 5
 
-      @test.new_param_with_default = 10
-      @test.instance_variable_get(:@new_param_with_default).should == 10
+      subject.new_param_with_default = 10
+      subject.instance_variable_get(:@new_param_with_default).should == 10
     end
 
     it "should initialize parameters with default values" do
-      @test.new_param_with_default.should == 5
+      subject.new_param_with_default.should == 5
     end
 
     it "should initialize pamareters with default lambda values" do
-      @test.new_param_with_lambda.should == 7
+      subject.new_param_with_lambda.should == 7
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-gem 'rspec', '~> 2.0.0'
+gem 'rspec', '~> 2.4'
 require 'rspec'
 
 require 'parameters/version'

data/spec/types/array_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'parameters/types/array'
+require 'parameters/types/integer'
+
+describe Parameters::Types::Array do
+  let(:array) { [1, 2, 3] }
+
+  subject { described_class }
+
+  describe "coerce" do
+    it "should call #to_a" do
+      subject.coerce(array.enum_for).should == array
+    end
+  end
+
+  context "instance" do
+    let(:numbers) { %w[1 2 3] }
+
+    subject { described_class.new(Parameters::Types::Integer.new) }
+
+    it "should have a Ruby type" do
+      subject.to_ruby.should == Array[Integer]
+    end
+
+    describe "#===" do
+      it "should check the type of each element" do
+        subject.should_not === numbers
+
+        subject.should === array
+      end
+    end
+
+    describe "#coerce" do
+      it "should coerce each element" do
+        subject.coerce(numbers).should == array
+      end
+    end
+  end
+end

data/spec/types/boolean_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'parameters/types/boolean'
+
+describe Parameters::Types::Boolean do
+  subject { described_class }
+
+  describe "#===" do
+    it "should match true" do
+      subject.should === true
+    end
+
+    it "should match false" do
+      subject.should === false
+    end
+
+    it "should not match anything else" do
+      subject.should_not === 1
+    end
+  end
+
+  describe "#coerce" do
+    it "should map false to false" do
+      subject.coerce(false).should == false
+    end
+
+    it "should map 'false' to false" do
+      subject.coerce('false').should == false
+    end
+
+    it "should map :false to false" do
+      subject.coerce(:false).should == false
+    end
+
+    it "should map nil to false" do
+      subject.coerce(nil).should == false
+    end
+
+    it "should map everything else to true" do
+      subject.coerce(:foo).should == true
+    end
+  end
+end

data/spec/types/class_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'classes/custom_type'
+require 'parameters/types/class'
+
+describe Parameters::Types::Class do
+  let(:base_class) { CustomType }
+  let(:value) { :foo }
+
+  subject { described_class.new(base_class) }
+
+  it "should have a base-class" do
+    subject.base_class.should == base_class
+  end
+
+  describe "#===" do
+    it "should check if the value inherits from the base-class" do
+      subject.should === base_class.new(value)
+
+      subject.should_not === Object.new
+    end
+  end
+
+  describe "#coerce" do
+    it "should pass the value to the base-class" do
+      obj = subject.coerce(value)
+
+      obj.should be_kind_of(base_class)
+      obj.value.should == value
+    end
+  end
+end

data/spec/types/date_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'parameters/types/date'
+
+describe Parameters::Types::Date do
+  subject { described_class }
+
+  describe "coerce" do
+    let(:string) { '2010-02-18'        }
+    let(:date)   { Date.new(2010,2,18) }
+    let(:time)   { Time.parse(string)  }
+
+    it "should call #to_date when possible" do
+      subject.coerce(time).should == date
+    end
+
+    it "should parse Strings" do
+      subject.coerce(string).should == date
+    end
+  end
+end

data/spec/types/date_time_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'parameters/types/date_time'
+
+describe Parameters::Types::DateTime do
+  subject { described_class }
+
+  describe "coerce" do
+    let(:string)    { '2010-02-18T00:36:31-08:00' }
+    let(:time)      { Time.parse(string)          }
+    let(:date_time) { DateTime.parse(string)      }
+
+    it "should call #to_datetime when possible" do
+      subject.coerce(time).should == date_time
+    end
+
+    it "should parse Strings" do
+      subject.coerce(string).should == date_time
+    end
+  end
+end

data/spec/types/float_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'parameters/types/float'
+
+describe Parameters::Types::Float do
+  subject { described_class }
+
+  describe "coerce" do
+    it "should call #to_f" do
+      subject.coerce('-0.001').should == -0.001
+    end
+  end
+end

data/spec/types/hash_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'parameters/types/hash'
+require 'parameters/types/symbol'
+require 'parameters/types/integer'
+
+describe Parameters::Types::Hash do
+  let(:array) { [:a, 1, :b, 2]     }
+  let(:hash)  { {:a => 1, :b => 2} }
+
+  describe "coerce" do
+    subject { described_class }
+
+    it "should accept Arrays" do
+      subject.coerce(array).should == hash
+    end
+
+    it "should call #to_hash" do
+      subject.coerce(hash).should == hash
+    end
+  end
+
+  context "instance" do
+    context "with key-type" do
+      let(:string_keys) { {'a' => 1, 'b' => 2} }
+
+      subject { described_class.new(Parameters::Types::Symbol,Parameters::Types::Object) }
+
+      it "should have a Ruby type" do
+        subject.to_ruby.should == Hash[Symbol => Object]
+      end
+
+      describe "#===" do
+        it "should check the type of each key" do
+          subject.should_not === string_keys
+
+          subject.should === hash
+        end
+      end
+
+      describe "#coerce" do
+        it "should coerce each key" do
+          subject.coerce(string_keys).should == hash
+        end
+      end
+    end
+
+    context "with value-type" do
+      let(:string_values) { {:a => '1', :b => '2'} }
+
+      subject { described_class.new(Parameters::Types::Object,Parameters::Types::Integer) }
+
+      it "should have a Ruby type" do
+        subject.to_ruby.should == Hash[Object => Integer]
+      end
+
+      describe "#===" do
+        it "should check the type of each value" do
+          subject.should_not === string_values
+
+          subject.should === hash
+        end
+      end
+
+      describe "#coerce" do
+        it "should coerce each value" do
+          subject.coerce(string_values).should == hash
+        end
+      end
+    end
+  end
+end