ns-options 0.1.0

data/test/integration/user_test.rb

@@ -0,0 +1,57 @@
+require 'assert'
+
+class User
+
+  class BaseTest < Assert::Context
+    desc "the User class"
+    setup do
+      @class = User
+    end
+    subject{ @class }
+
+    should have_instance_methods :options, :preferences
+  end
+
+  class ClassPreferencesTest < BaseTest
+    desc "preferences"
+    subject{ @class.preferences }
+
+    should have_instance_methods :namespace, :option, :define, :options, :metaclass
+    should have_accessors :home_url, :show_messages, :font_size
+  end
+
+  class InstanceTest < BaseTest
+    desc "instance"
+    setup do
+      @instance = @class.new
+    end
+    subject{ @instance }
+
+    should have_instance_methods :preferences
+  end
+
+  class PreferencesTest < InstanceTest
+    desc "preferences"
+    setup do
+      @preferences = @instance.preferences
+      @preferences.home_url = "/home"
+      @preferences.show_messages = false
+      @preferences.font_size = 15
+    end
+    subject{ @preferences }
+
+    should have_instance_methods :namespace, :option, :define, :options, :metaclass
+    should have_accessors :home_url, :show_messages, :font_size
+
+    should "have set the home_url" do
+      assert_equal "/home", subject.home_url
+    end
+    should "have set show_messages" do
+      assert_equal false, subject.show_messages
+    end
+    should "have set the font_size" do
+      assert_equal 15, subject.font_size
+    end
+  end
+
+end

data/test/support/app.rb

@@ -0,0 +1,12 @@
+module App
+  include NsOptions::HasOptions
+  options(:settings, "settings:app") do
+    option :root,   Pathname
+    option :stage
+    option :logger, Logger
+
+    namespace :sub do
+      option :run_commands, NsOptions::Option::Boolean
+    end
+  end
+end

data/test/support/user.rb

@@ -0,0 +1,13 @@
+class User
+  include NsOptions::HasOptions
+  options(:preferences, 'user-preferences') do
+    option :home_url
+    option :show_messages,  NsOptions::Option::Boolean, :require => true
+    option :font_size,      Integer,                    :default => 12
+  end
+
+  def preferences_key
+    "user_#{self.object_id}"
+  end
+
+end

data/test/unit/ns-options/has_options_test.rb

@@ -0,0 +1,67 @@
+require 'assert'
+
+module NsOptions::HasOptions
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::HasOptions"
+    setup do
+      @class = Class.new do
+        include NsOptions::HasOptions
+
+        def configs_key
+          "random_class_#{self.object_id}"
+        end
+      end
+      @instance = @class.new
+    end
+    subject{ @instance }
+
+    should have_class_methods :options
+  end
+
+  class OptionsTest < BaseTest
+    desc "options method"
+
+    class WithAKeyTest < OptionsTest
+      desc "with a key"
+      setup do
+        @key = "configs-key"
+        @class.options(:configs, @key) do
+          option :something
+        end
+        @instance = @class.new
+      end
+      subject{ @instance }
+
+      should have_class_method :configs
+      should have_instance_method :configs
+
+      should "have used the provided key when creating the namespace" do
+        assert_kind_of NsOptions::Namespace, subject.class.configs
+        assert_kind_of NsOptions::Namespace, subject.configs
+        assert_equal @key, subject.class.configs.options.key
+        assert_match @key, subject.configs.options.key
+      end
+      should "have used the provided block to define the namespace" do
+        assert_respond_to :something, subject.configs
+        assert_respond_to :something=, subject.configs
+        assert subject.configs.options.fetch(:something)
+      end
+    end
+    class WithoutAKeyTest < OptionsTest
+      desc "without a key"
+      setup do
+        @name = "configs"
+        @class.options(@name.to_sym)
+        @instance = @class.new
+      end
+      subject{ @instance }
+
+      should "have used the name for the key when creating the namespace" do
+        assert_equal @name, subject.class.configs.options.key
+        assert_match @name, subject.configs.options.key
+      end
+    end
+  end
+
+end

data/test/unit/ns-options/helper_test.rb

@@ -0,0 +1,63 @@
+require 'assert'
+
+module NsOptions::Helper
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::Helper"
+    setup do
+      @module = NsOptions::Helper
+    end
+    subject{ @module }
+
+    should have_instance_methods :new_namespace, :new_child_namespace, :fetch_and_define_option
+
+  end
+
+  class NewNamespaceTest < BaseTest
+    desc "new_namespace method"
+    setup do
+      @parent = @module.new_namespace("parent")
+      @child = @module.new_namespace("child", @parent) do
+        option :something
+      end
+    end
+
+    should "have created a parent namespace" do
+      assert_equal "parent", @parent.options.key
+    end
+    should "have created a child namespace" do
+      assert_equal "child", @child.options.key
+      assert_equal @parent, @child.options.parent
+      assert @child.options[:something]
+    end
+  end
+  
+  class NewChildNamespaceTest < BaseTest
+    desc "new_child_namespace method"
+    setup do
+      @parent = @module.new_namespace("parent")
+      @mock_class = mock()
+      @mock_class.stubs(:super_settings).returns(@parent)
+      @first_owner = mock()
+      @first_owner.stubs({ :class => @mock_class })
+      @first = @module.new_child_namespace(@first_owner, "super_settings") do
+        option :something
+      end
+      @second_owner = User.new
+      @second = @module.new_child_namespace(@second_owner, "preferences")
+    end
+    
+    should "have created a child namespace" do
+      class_name = @mock_class.to_s.split('::').last.downcase
+      key = "#{@parent.options.key}:#{class_name}_#{@first_owner.object_id}"
+      assert_equal key, @first.options.key
+      assert_equal @parent, @first.options.parent
+      assert @first.options[:something]
+    end    
+    should "have created a second child namespace" do
+      key = "#{@second.options.parent.options.key}:#{@second_owner.preferences_key}"
+      assert_equal key, @second.options.key
+    end
+  end
+
+end

data/test/unit/ns-options/namespace_test.rb

@@ -0,0 +1,232 @@
+require 'assert'
+
+class NsOptions::Namespace
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::Namespace"
+    setup do
+      @key = "options"
+      @namespace = NsOptions::Namespace.new(@key)
+    end
+    subject{ @namespace }
+
+    should have_accessors :metaclass, :options
+    should have_instance_methods :option, :namespace, :required_set?, :define
+
+    should "have set it's metaclass accessor" do
+      assert subject.metaclass
+    end
+    should "have created a new options collection and set it's options accessor" do
+      assert subject.options
+      assert_kind_of NsOptions::Options, subject.options
+      assert_equal @key, subject.options.key
+      assert_nil subject.options.parent
+    end
+  end
+
+  class OptionTest < BaseTest
+    desc "option method"
+    setup do
+      @name = :something
+      @type = NsOptions::Option::Boolean
+      @rules = { :default => true }
+      @namespace.option(@name, @type, @rules)
+    end
+    subject{ @namespace }
+
+    should "have added the option to the namespace's options collection" do
+      assert(option = subject.options[@name])
+      assert_equal @name.to_s, option.name
+      assert_equal @type, option.type_class
+      assert_equal @rules, option.rules
+    end
+  end
+
+  class OptionWithNoTypeTest < BaseTest
+    desc "option method with no type specified"
+    setup do
+      @name = :something
+      @namespace.option(@name)
+    end
+    subject{ @namespace }
+
+    should "default the type to String" do
+      assert(option = subject.options[@name])
+      assert_equal String, option.type_class
+    end
+  end
+
+  class OptionMethodsTest < OptionTest
+    desc "defined methods"
+
+    should have_instance_methods :something, :something=
+
+    should "be writable through the defined writer" do
+      assert_nothing_raised{ subject.something = false }
+      assert_equal false, subject.something
+    end
+    should "be writable through the reader with args" do
+      assert_nothing_raised{ subject.something true }
+      assert_equal true, subject.something
+    end
+  end
+
+  class NamespaceTest < BaseTest
+    desc "namespace method"
+    setup do
+      @namespace.namespace(:something) do
+        option :something_else
+      end
+      @namespace.namespace(:another, "special_key")
+    end
+    subject{ @namespace }
+
+    should "have added a namespace to the namespace's options collection" do
+      assert(namespace = subject.options.namespaces[:something])
+      assert_equal "#{subject.options.key}:something", namespace.options.key
+      assert_equal subject, namespace.options.parent
+      assert namespace.options[:something_else]
+    end
+    should "allow passing a special key to the namespace" do
+      assert(namespace = subject.options.namespaces[:another])
+      assert_equal "#{subject.options.key}:special_key", namespace.options.key
+    end
+  end
+
+  class NamespaceMethodsTest < NamespaceTest
+    desc "defined methods"
+
+    should have_instance_methods :something
+
+    should "be return the namespace using the reader" do
+      assert_equal subject.options.namespaces[:something], subject.something
+    end
+    should "define the namespace with the reader and a block" do
+      subject.something do
+        option :another
+      end
+      assert subject.something.options[:another]
+    end
+  end
+
+  class DefineTest < BaseTest
+    desc "define method"
+
+    class BlockWithoutArityTest < BaseTest
+      desc "with a block with no arity"
+
+      should "instance eval the block in the scope of the namespace" do
+        scope = nil
+        subject.define do
+          scope = self
+        end
+        assert_equal subject, scope
+      end
+    end
+    class BlockWithArityTest < BaseTest
+      desc "with a block with arity"
+
+      should "yield the namespace to the block" do
+        yielded = nil
+        subject.define do |namespace|
+          yielded = namespace
+        end
+        assert_equal subject, yielded
+      end
+    end
+    class NoBlockTest < BaseTest
+      desc "with no block"
+
+      should "return the namespace" do
+        assert_equal subject, subject.define
+      end
+    end
+  end
+
+  class MethodMissingTest < BaseTest
+    desc "method missing"
+    setup do
+      @parent = @namespace
+      @parent.options.add(:something)
+      @parent.options.set(:something, "amazing")
+      @namespace = NsOptions::Namespace.new("child", @parent)
+    end
+
+    class ReaderForAKnownOptionTest < MethodMissingTest
+      desc "as a reader for a known option"
+      setup do
+        @result = @namespace.something
+      end
+
+      should "have defined the option on the namespace" do
+        defined_methods = subject.metaclass.public_instance_methods(false).map(&:to_sym)
+        assert_includes :something, defined_methods
+        assert_includes :something=, defined_methods
+        assert_equal "amazing", @result
+      end
+    end
+    class WriterForAKnownOptionTest < MethodMissingTest
+      desc "as a reader for a known option"
+      setup do
+        @namespace.something = "even more amazing"
+      end
+
+      should "have defined the option on the namespace" do
+        defined_methods = subject.metaclass.public_instance_methods(false).map(&:to_sym)
+        assert_includes :something, defined_methods
+        assert_includes :something=, defined_methods
+        assert_equal "even more amazing", subject.something
+      end
+    end
+    class DynamicWriterTest < MethodMissingTest
+      desc "with a writer for an unknown option"
+      setup do
+        @namespace.something_not_defined = "you know it"
+        @namespace.another_not_defined = true
+        @namespace.even_more_not_defined = 12
+      end
+
+      should "have defined the accessors and added the option" do
+        defined_methods = subject.metaclass.public_instance_methods(false).map(&:to_sym)
+        assert subject.options[:something_not_defined]
+        assert_includes :something_not_defined, defined_methods
+        assert_includes :something_not_defined=, defined_methods
+        assert_equal "you know it", subject.something_not_defined
+      end
+      should "use the class of the value for the option's type class" do
+        assert_equal String, subject.options[:something_not_defined].type_class
+        assert_equal Integer, subject.options[:even_more_not_defined].type_class
+        assert_equal NsOptions::Option::Boolean, subject.options[:another_not_defined].type_class
+      end
+    end
+  end
+
+  class RespondToTest < BaseTest
+    desc "respond to"
+    setup do
+      @namespace.options.add(:something)
+    end
+
+    should "return true when the reader of an option is requested without the reader defined" do
+      assert_not_includes :something, subject.class.public_instance_methods(false).map(&:to_sym)
+      assert_not_includes :something, subject.metaclass.public_instance_methods(false).map(&:to_sym)
+      assert_equal true, subject.respond_to?(:something)
+    end
+  end
+
+  class WithAParentTest < BaseTest
+    desc "with a parent"
+    setup do
+      @key = "options"
+      @parent = @namespace
+      @namespace = NsOptions::Namespace.new(@key, @parent)
+    end
+    subject{ @namespace }
+
+    should "have set it's options accessor and stored it's parent on it" do
+      assert subject.options
+      assert_equal @parent, subject.options.parent
+    end
+  end
+
+end

data/test/unit/ns-options/namespaces_test.rb

@@ -0,0 +1,55 @@
+require 'assert'
+
+class NsOptions::Namespaces
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::Namespaces"
+    setup do
+      @namespaces = NsOptions::Namespaces.new
+    end
+    subject{ @namespaces }
+
+    should have_instance_methods :add, :get
+
+    should "be a kind of a hash" do
+      assert_kind_of Hash, subject
+    end
+    should "only use symbols for keys" 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 AddTest < BaseTest
+    desc "add method"
+    setup do
+      @parent = NsOptions::Namespace.new(:parent)
+      @namespaces.add(:a_name, "a-key", @parent) do
+        option :an_option
+      end
+    end
+    subject{ @namespaces }
+
+    should "have created a new namespace and added it to itself" do
+      assert(namespace = subject[:a_name])
+      assert_kind_of NsOptions::Namespace, namespace
+      assert_equal "a-key", namespace.options.key
+      assert_equal @parent, namespace.options.parent
+      assert namespace.options[:an_option]
+    end
+  end
+
+  class GetTest < AddTest
+    desc "get method"
+    
+    should "return the namespace matching the name" do
+      assert(namespace = subject.get("a_name"))
+      assert_equal subject[:a_name], namespace
+    end
+  end
+
+end

data/test/unit/ns-options/option/boolean_test.rb

@@ -0,0 +1,67 @@
+require 'assert'
+
+class NsOptions::Option::Boolean
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::Option::Boolean"
+    setup do
+      @boolean = NsOptions::Option::Boolean.new(true)
+    end
+    subject{ @boolean }
+
+    should have_accessors :actual
+  end
+
+  class WithTruthyValuesTest < BaseTest
+    desc "with truthy values"
+    setup do
+      @boolean = NsOptions::Option::Boolean.new(false)
+    end
+
+    should "have set actual to true with true" do
+      subject.actual = true
+      assert_equal true, subject.actual
+    end
+    should "have set actual to true with 'true'" do
+      subject.actual = 'true'
+      assert_equal true, subject.actual
+    end
+    should "have set actual to true with 1" do
+      subject.actual = 1
+      assert_equal true, subject.actual
+    end
+    should "have set actual to true with '1'" do
+      subject.actual = '1'
+      assert_equal true, subject.actual
+    end
+  end
+
+  class WithFalsyValuesTest < BaseTest
+    desc "with falsy values"
+    setup do
+      @boolean = NsOptions::Option::Boolean.new(true)
+    end
+
+    should "have set actual to false with false" do
+      subject.actual = false
+      assert_equal false, subject.actual
+    end
+    should "have set actual to false with 'false'" do
+      subject.actual = 'false'
+      assert_equal false, subject.actual
+    end
+    should "have set actual to false with 0" do
+      subject.actual = 0
+      assert_equal false, subject.actual
+    end
+    should "have set actual to false with '0'" do
+      subject.actual = '0'
+      assert_equal false, subject.actual
+    end
+    should "have set actual to false with nil" do
+      subject.actual = nil
+      assert_equal false, subject.actual
+    end
+  end
+
+end