ns-options 0.4.1 → 1.0.0.rc1

data/test/unit/{ns-options/option_test.rb → option_tests.rb}

@@ -1,96 +1,142 @@
 require 'assert'
+require 'ns-options/option'
+require 'ns-options/boolean'
 
 class NsOptions::Option
 
-  class BaseTest < Assert::Context
+  class BaseTests < Assert::Context
     desc "NsOptions::Option"
     setup do
-      @rules = { :default => "development", :require => true }
-      @args = [:stage, String, @rules]
-      @option = NsOptions::Option.new(*@args)
+      @rules  = { :default => "development" }
+      @option = NsOptions::Option.new(:stage, nil, @rules)
     end
     subject{ @option }
 
-    should have_class_method :rules, :args
+    should have_class_methods :rules, :args
     should have_accessors :name, :value, :type_class, :rules
+    should have_imeths :is_set?, :required?, :reset
 
-    should "have set the name" do
-      assert_equal "stage", subject.name
+    should "know its name" do
+      assert_equal :stage, subject.name
     end
 
-    should "have set the type class" do
-      assert_equal String, subject.type_class
+    should "know its type class" do
+      assert_equal Object, subject.type_class
     end
 
-    should "have set the rules" do
-      assert_equal(@rules, subject.rules)
+    should "know its rules" do
+      exp_rules = {
+        :default => "development",
+        :args => []
+      }
+      assert_equal exp_rules, subject.rules
     end
 
-    should "have defaulted value based on the rules" do
-      assert_equal subject.rules[:default], subject.value
+    should "not be required? by default" do
+      assert_equal false, subject.required?
     end
 
-    should "return true with a call to #required?" do
-      assert_equal true, subject.required?
+  end
+
+  class ParseArgsTests < BaseTests
+    desc "when parsing args"
+    setup do
+      @pname, @ptype_class, @prules  = NsOptions::Option.args([:stage, String, @rules])
     end
 
-    should "allow setting the value to nil" do
-      subject.value = nil
-      assert_nil subject.value
+    should "parse the name arg and convert to a string" do
+      assert_equal "stage", @pname
+
+      @pname, @ptype_class, @prules = NsOptions::Option.args(['test'])
+      assert_equal 'test', @pname
+    end
+
+    should "parse the type_class arg and default it to Object" do
+      assert_equal String, @ptype_class
+
+      @pname, @ptype_class, @prules = NsOptions::Option.args(['test'])
+      assert_equal Object, @ptype_class
+    end
+
+    should "parse the type_class arg and default it to a given default type class" do
+      assert_equal String, @ptype_class
+
+      @pname, @ptype_class, @prules = NsOptions::Option.args(['test'], Fixnum)
+      assert_equal Fixnum, @ptype_class
+    end
+
+    should "parse option rules arguments, defaulting to {:args => []}" do
+      assert_equal @rules, @prules
+
+      @pname, @ptype_class, @prules = NsOptions::Option.args(['test'])
+      assert_equal({:args => []}, @prules)
     end
+
   end
 
-  class ParseRulesTests < BaseTest
-    desc "parsing rules"
+  class DefaultRuleTests < BaseTests
+    desc "using the :default rule"
     setup do
-      @cases = [nil, {}, {:args => 'is'}].map do |c|
-        subject.class.rules(c)
-      end
+      @option = NsOptions::Option.new(:opt, Object, :default => "something")
     end
 
-    should "always return them as a Hash" do
-      @cases.each { |c| assert_kind_of Hash, c }
+    should "have defaulted value based on the rule" do
+      assert_equal 'something', subject.value
     end
 
-    should "always return with an array args rule" do
-      @cases.each do |c|
-        assert c.has_key? :args
-        assert_kind_of Array, c[:args]
-      end
+    should "allow overwriting the default value" do
+      assert_nothing_raised { subject.value = "overwritten" }
+      assert_equal "overwritten", subject.value
+    end
+
+    should "allow setting the value to nil" do
+      assert_nothing_raised { subject.value = nil }
+      assert_nil subject.value
+    end
+
+    should "return the value to its default when `reset` is called" do
+      subject.value = "overwritten"
+      subject.reset
+
+      assert_equal 'something', subject.value
     end
 
   end
 
-  class ParseArgsTests < BaseTest
-    desc "when parsing args"
+  class RequiredRuleTests < BaseTests
+    desc "using the :required rule"
     setup do
-      @prules, @ptype_class, @pname = subject.class.args(*@args)
+      @option = NsOptions::Option.new(:opt, Object, :required => true)
     end
 
-    should "parse option rules arguments, defaulting to {:args => []}" do
-      assert_equal @rules, @prules
-
-      @prules, @ptype_class, @pname = subject.class.args('test')
-      assert_equal({:args => []}, @prules)
+    should "return true with a call to #required?" do
+      assert_equal true, subject.required?
     end
 
-    should "parse the name arg and convert to a string" do
-      assert_equal "stage", @pname
+  end
 
-      @prules, @ptype_class, @pname = subject.class.args('test')
-      assert_equal 'test', @pname
+  class ParseRulesTests < BaseTests
+    desc "parsing rules"
+    setup do
+      @cases = [nil, {}, {:args => 'is'}].map do |c|
+        NsOptions::Option.rules(c)
+      end
     end
 
-    should "parse the type_class arg and default it to Object" do
-      assert_equal String, @ptype_class
+    should "always return them as a Hash" do
+      @cases.each { |c| assert_kind_of Hash, c }
+    end
 
-      @prules, @ptype_class, @pname = subject.class.args('test')
-      assert_equal Object, @ptype_class
+    should "always return with an array args rule" do
+      @cases.each do |c|
+        assert c.has_key? :args
+        assert_kind_of Array, c[:args]
+      end
     end
 
   end
 
-  class IsSetTest < BaseTest
+  class IsSetTests < BaseTests
     desc "is_set method"
     setup do
       @type_class = Class.new(String) do
@@ -101,7 +147,6 @@ class NsOptions::Option
 
       end
       @special = NsOptions::Option.new(:no_blank, @type_class)
-
       @boolean = NsOptions::Option.new(:boolean, NsOptions::Boolean)
     end
 
@@ -125,7 +170,7 @@ class NsOptions::Option
 
   end
 
-  class EqualityOperatorTest < BaseTest
+  class EqualityOperatorTests < BaseTests
     desc "== operator"
     setup do
       @first = NsOptions::Option.new(:stage, String)
@@ -142,9 +187,10 @@ class NsOptions::Option
       @first.value = "staging"
       assert_not_equal @first, @second
     end
+
   end
 
-  class WithNativeTypeClassTest < BaseTest
+  class WithNativeTypeClassTests < BaseTests
     desc "with a native type class (Float)"
     setup do
       @option = NsOptions::Option.new(:something, Float)
@@ -168,9 +214,10 @@ class NsOptions::Option
       subject.value = new_value
       assert_equal new_value.to_f, subject.value
     end
+
   end
 
-  class WithSymbolTypeClasstest < BaseTest
+  class WithSymbolTypeClasstests < BaseTests
     desc "with a Symbol as a type class"
     setup do
       @option = NsOptions::Option.new(:something, Symbol)
@@ -192,13 +239,14 @@ class NsOptions::Option
     end
 
     should "error on anything that doesn't define #to_sym" do
-      assert_raises(NoMethodError) do
+      assert_raises(NsOptions::Option::CoerceError) do
         subject.value = true
       end
     end
+
   end
 
-  class WithHashTypeClassTest < BaseTest
+  class WithHashTypeClassTests < BaseTests
     desc "with a Hash as a type class"
     setup do
       @option = NsOptions::Option.new(:something, Hash)
@@ -210,9 +258,10 @@ class NsOptions::Option
       subject.value = new_value
       assert_equal new_value, subject.value
     end
+
   end
 
-  class WithArrayTypeClassTest < BaseTest
+  class WithArrayTypeClassTests < BaseTests
     desc "with an Array as a type class"
     setup do
       @option = NsOptions::Option.new(:something, Array)
@@ -224,21 +273,10 @@ class NsOptions::Option
       subject.value = new_value
       assert_equal new_value, subject.value
     end
-  end
 
-  class WithoutTypeClassTest < BaseTest
-    desc "without a type class provided"
-    setup do
-      @option = NsOptions::Option.new(:something, nil)
-    end
-    subject{ @option }
-
-    should "have default it to Object" do
-      assert_equal Object, subject.type_class
-    end
   end
 
-  class WithTypeClassArgErrorTests < BaseTest
+  class WithTypeClassArgErrorTests < BaseTests
     desc "setting a value with arg error"
     setup do
       @err = begin
@@ -254,18 +292,21 @@ class NsOptions::Option
       @option = NsOptions::Option.new(:something, SuperSuperTestTest)
     end
 
-    should "reraise the arg error, including its type_class in the error message" do
+    should "reraise the arg error, with a custom message and backtrace" do
       err = begin
         @option.value = "arg error should be raised"
       rescue Exception => err
         err
       end
-      assert_equal ArgumentError, err.class
-      assert_included @option.type_class.to_s, err.message
+
+      assert_equal NsOptions::Option::CoerceError,  err.class
+      assert_included @option.type_class.to_s,      err.message
+      assert_included 'test/unit/option_tests.rb:', err.backtrace.first
     end
+
   end
 
-  class WithAValueOfTheSameClassTest < BaseTest
+  class WithAValueOfTheSameClassTests < BaseTests
     desc "with a value of the same class"
     setup do
       @class = Class.new
@@ -277,9 +318,10 @@ class NsOptions::Option
       @option.value = value
       assert_same value, @option.value
     end
+
   end
 
-  class WithAValueKindOfTest < BaseTest
+  class WithAValueKindOfTests < BaseTests
     desc "with a value that is a kind of the class"
     setup do
       @class = Class.new
@@ -292,9 +334,10 @@ class NsOptions::Option
       @option.value = value
       assert_same value, @option.value
     end
+
   end
 
-  class ProcHandlingTests < BaseTest
+  class ProcHandlingTests < BaseTests
     setup do
       class KindOfProc < Proc; end
       @a_string      = "a string"
@@ -342,17 +385,17 @@ class NsOptions::Option
     end
   end
 
-  class WithReturnValueTests < BaseTest
+  class WithReturnValueTests < BaseTests
     setup do
       # test control values
-      @string    = NsOptions::Option.new(:string, String)
-      @symbol    = NsOptions::Option.new(:symbol, Symbol)
-      @integer   = NsOptions::Option.new(:integer, Integer)
-      @float     = NsOptions::Option.new(:float, Float)
-      @hash      = NsOptions::Option.new(:hash, Hash)
-      @array     = NsOptions::Option.new(:array, Array)
-      @proc      = NsOptions::Option.new(:proc, Proc)
-      @lazy_proc = NsOptions::Option.new(:lazy_proc)
+      @string    = NsOptions::Option.new :string,    String
+      @symbol    = NsOptions::Option.new :symbol,    Symbol
+      @integer   = NsOptions::Option.new :integer,   Integer
+      @float     = NsOptions::Option.new :float,     Float
+      @hash      = NsOptions::Option.new :hash,      Hash
+      @array     = NsOptions::Option.new :array,     Array
+      @proc      = NsOptions::Option.new :proc,      Proc
+      @lazy_proc = NsOptions::Option.new :lazy_proc, Object
 
       # custom return value
       class HostedAt
@@ -402,9 +445,10 @@ class NsOptions::Option
       @hosted_at.value = "path/to/resource/"
       assert_equal '/path/to/resource', @hosted_at.value
     end
+
   end
 
-  class WithArgsTest < BaseTest
+  class WithArgsTests < BaseTests
     desc "with args rule"
     setup do
       @class = Class.new do
@@ -413,50 +457,68 @@ class NsOptions::Option
           self.args = args
         end
       end
-      @value = "amazing"
     end
 
-    class AsArrayTest < WithArgsTest
+    class AsArrayTests < WithArgsTests
       desc "as an array"
       setup do
         @args = [ true, false, { :hash => "yes" } ]
         @option = NsOptions::Option.new(:something, @class, { :args => @args })
-        @option.value = @value
+        @option.value = "amazing"
       end
 
       should "pass the args to the type class with the value" do
-        expected = @args.dup.insert(0, @value)
+        expected = ["amazing", *@args]
         assert_equal expected, subject.value.args
       end
+
     end
 
-    class AsSingleValueTest < WithArgsTest
+    class AsSingleValueTests < WithArgsTests
       desc "as a single value"
       setup do
         @args = lambda{ "something" }
         @option = NsOptions::Option.new(:something, @class, { :args => @args })
-        @option.value = @value
+        @option.value = "amazing"
       end
 
       should "pass the single value to the type class with the value" do
-        expected = [*@args].insert(0, @value)
+        expected = ["amazing", *@args]
         assert_equal expected, subject.value.args
       end
+
     end
 
-    class AsNilValueTest < WithArgsTest
+    class AsNilValueTests < WithArgsTests
       desc "as a nil value"
       setup do
         @args = nil
         @option = NsOptions::Option.new(:something, @class, { :args => @args })
-        @option.value = @value
+        @option.value = "amazing"
+      end
+
+      should "just pass the value to the type class and that's it" do
+        expected = ["amazing"]
+        assert_equal expected, subject.value.args
+      end
+
+    end
+
+    class AsEmptyArrayValueTests < WithArgsTests
+      desc "as an empty Array value"
+      setup do
+        @args = []
+        @option = NsOptions::Option.new(:something, @class, { :args => @args })
+        @option.value = "amazing"
       end
 
-      should "just pass the value to the type class" do
-        expected = [@value]
+      should "just pass the value to the type class and that's it" do
+        expected = ["amazing"]
         assert_equal expected, subject.value.args
       end
+
     end
+
   end
 
 end

data/test/unit/options_tests.rb

@@ -0,0 +1,152 @@
+require 'assert'
+require 'ns-options/options'
+
+class NsOptions::Options
+
+  class BaseTests < Assert::Context
+    desc "NsOptions::Options"
+    setup do
+      @options = NsOptions::Options.new
+    end
+    subject{ @options }
+
+    should have_accessor :[]
+    should have_imeths :keys, :each, :empty?
+    should have_imeths :add, :rm, :get, :set, :required_set?
+
+    should "only use strings for keys (indifferent access)" do
+      subject['string_key'] = true
+      subject[:symbol_key]  = true
+
+      assert_includes 'string_key', subject.keys
+      assert_includes 'symbol_key', subject.keys
+      assert_not_includes :string_key, subject.keys
+    end
+
+  end
+
+  class AddTests < BaseTests
+    desc "add method"
+
+    should "add options" do
+      assert_nil subject[:my_string]
+      subject.add(:my_string, NsOptions::Option.new(:my_string))
+      assert subject[:my_string]
+    end
+
+    should "should work with both string and symbol names" do
+      assert_nil subject[:my_string]
+      subject.add('my_string', NsOptions::Option.new('my_string'))
+      assert subject[:my_string]
+    end
+
+    should "return the option added" do
+      added_opt = subject.add(:something, NsOptions::Option.new(:something))
+      assert_kind_of NsOptions::Option, added_opt
+    end
+
+    should "build options with args when adding" do
+      subject.add(:my_float, NsOptions::Option.new(:my_float, Float, :default => 1.0))
+
+      assert_equal Float, subject[:my_float].type_class
+      assert_equal 1.0,   subject[:my_float].rules[:default]
+    end
+
+  end
+
+  class RmTests < BaseTests
+    desc "rm method"
+    setup do
+      @options.add(:my_string, NsOptions::Option.new(:my_string))
+    end
+
+    should "remove the option definition from the collection" do
+      assert subject[:my_string]
+
+      subject.rm(:my_string)
+      assert_nil subject[:my_string]
+    end
+
+    should "should work with both string and symbol names" do
+      assert subject[:my_string]
+
+      subject.rm('my_string')
+      assert_nil subject[:my_string]
+    end
+
+  end
+
+  class GetTests < BaseTests
+    desc "get method"
+    setup do
+      opt = NsOptions::Option.new(:my_string, Object, :default => "something")
+      @options.add(:my_string, opt)
+    end
+
+    should "return the named option value" do
+      assert_equal "something", subject.get(:my_string)
+    end
+
+    should "should work with both string and symbol names" do
+      assert_equal "something", subject.get('my_string')
+    end
+
+  end
+
+  class SetTests < BaseTests
+    desc "set method"
+    setup do
+      @options.add(:my_string, NsOptions::Option.new(:my_string))
+    end
+
+    should "set option values" do
+      assert_nil subject[:my_string].value
+      subject.set(:my_string, "something")
+
+      assert_equal "something", subject.get(:my_string)
+    end
+
+    should "should work with both string and symbol names" do
+      assert_nil subject[:my_string].value
+      subject.set('my_string', "something")
+
+      assert_equal "something", subject.get(:my_string)
+    end
+
+  end
+
+  class RequiredSetTests < BaseTests
+    desc "required_set? method"
+    setup do
+      @options.add(:first,  NsOptions::Option.new(:first,  String, :required => true))
+      @options.add(:second, NsOptions::Option.new(:second, String, :required => true))
+      @options.add(:third,  NsOptions::Option.new(:third,  String))
+    end
+
+    should "return true when all required options are set" do
+      subject.set(:first, "first")
+      subject.set(:second, "second")
+
+      assert_equal true, subject.required_set?
+    end
+
+    should "return false if one required option is not set" do
+      subject.set(:first, "first")
+      subject.set(:third, "third")
+
+      assert_equal false, subject.required_set?
+    end
+
+    should "not change because of options that aren't required" do
+      subject.set(:first, "first")
+      subject.set(:second, "second")
+      subject.set(:third, "third")
+      assert_equal true, subject.required_set?
+
+      subject.set(:third, nil)
+      assert_equal true, subject.required_set?
+    end
+
+  end
+
+end

data/test/unit/proxy_method_tests.rb

@@ -0,0 +1,87 @@
+require 'assert'
+require 'ns-options/proxy_method'
+
+class NsOptions::RootMethods
+
+  class BaseTests < Assert::Context
+    desc "NsOptions::RootMethods"
+    setup do
+      @pm = NsOptions::ProxyMethod.new(Module.new, 'whatever', 'a thing')
+    end
+    subject { @pm }
+
+    should have_imeths :define_on_class?, :define, :validate
+
+  end
+
+  class ValidateTests < BaseTests
+    desc "validate meth"
+    setup do
+      @io = StringIO.new(@out = "")
+      @caller = ["a test caller"]
+    end
+
+    should "return false for not recommended methods" do
+      pm = NsOptions::ProxyMethod.new(Module.new, :option, 'a thing')
+      assert_equal false, pm.validate(@io, @caller)
+
+      pm = NsOptions::ProxyMethod.new(Module.new, "anything_else", 'a thing')
+      assert_equal true, pm.validate(@io, @caller)
+    end
+
+    should "write a warning and any caller info" do
+      NsOptions::ProxyMethod.new(Module.new, :ns, 'a thing').validate(@io, @caller)
+
+      assert_match "WARNING: ", @out
+      assert_match @caller.first, @out
+    end
+
+    should "be called when calling `define'" do
+      NsOptions::ProxyMethod.new(Module.new, :ns, 'a thing').define(@io, @caller)
+
+      assert_match "WARNING: ", @out
+      assert_match @caller.first, @out
+    end
+
+  end
+
+  class ModuleTests < BaseTests
+    desc "defined on a module"
+    setup do
+      @pm = NsOptions::ProxyMethod.new(@the_module = Module.new, 'on_module', 'a thing')
+      @pm.define
+    end
+
+    should "know its not defining on a class" do
+      assert_not subject.define_on_class?
+    end
+
+    should "define a singleton method that builds a ns" do
+      assert_responds_to 'on_module', @the_module
+    end
+
+  end
+
+  class ClassTests < BaseTests
+    desc "defined on a class"
+    setup do
+      @pm = NsOptions::ProxyMethod.new(@the_class = Class.new, 'on_class', 'a thing')
+      @pm.define
+    end
+
+    should "know its defining on a class" do
+      assert subject.define_on_class?
+    end
+
+    should "define a singleton method that builds a ns" do
+      assert_responds_to 'on_class', @the_class
+    end
+
+    should "define an instance method that builds a ns from its singleton" do
+      a_class = @the_class.new
+      assert_responds_to 'on_class', a_class
+    end
+
+  end
+
+end