ns-options 0.1.1 → 0.2.0

data/lib/ns-options/namespace.rb

@@ -3,14 +3,21 @@ module NsOptions
   class Namespace
     attr_accessor :options, :metaclass
 
-    def initialize(key, parent = nil)
+    # Every namespace tracks a metaclass to allow for individual reader/writers for their options,
+    # without any collisions. Since every namespace is of the same class, defining option reader and
+    # writer methods directly on the class would make multiple namespaces with different options
+    # impossible.
+    def initialize(key, parent = nil, &block)
       self.metaclass = (class << self; self; end)
       self.options = NsOptions::Options.new(key, parent)
+      self.define(&block)
     end
 
+    # This is a helper to check if options that were defined as :required have been set.
     def required_set?
       self.options.required_set?
     end
+    alias :valid? :required_set?
 
     # Define an option for this namespace. Add the option to the namespace's options collection
     # and then define accessors for the option. With the following:
@@ -25,25 +32,9 @@ module NsOptions
     #
     # The defined option is returned as well.
     def option(*args)
+      NsOptions::Helper.advisor(self).is_this_option_ok?(args[0], caller)
       option = self.options.add(*args)
-
-      self.metaclass.class_eval <<-DEFINE_METHOD
-
-        def #{option.name}(*args)
-          if !args.empty?
-            self.send("#{option.name}=", *args)
-          else
-            self.options.get(:#{option.name})
-          end
-        end
-
-        def #{option.name}=(*args)
-          value = args.size == 1 ? args.first : args
-          self.options.set(:#{option.name}, value)
-        end
-
-      DEFINE_METHOD
-
+      NsOptions::Helper.define_option_methods(self, option)
       option
     end
 
@@ -64,19 +55,42 @@ module NsOptions
     # The defined namespaces is returned as well.
     def namespace(name, key = nil, &block)
       key = "#{self.options.key}:#{(key || name)}"
-      namespace = self.options.namespaces.add(name, key, self, &block)
-
-      self.metaclass.class_eval <<-DEFINE_METHOD
+      NsOptions::Helper.advisor(self).is_this_namespace_ok?(name, caller)
+      namespace = self.options.add_namespace(name, key, self, &block)
+      NsOptions::Helper.define_namespace_methods(self, name)
+      namespace
+    end
 
-        def #{name}(&block)
-          namespace = self.options.namespaces.get("#{name}")
-          namespace.define(&block) if block
-          namespace
+    # The opposite of #to_hash. Takes a hash representation of options and namespaces and mass
+    # assigns option values.
+    def apply(option_values = {})
+      option_values.each do |name, value|
+        namespace = self.options.namespaces[name]
+        if self.options[name] || !namespace
+          self.send("#{name}=", value)
+        elsif namespace && value.kind_of?(Hash)
+          namespace.apply(value)
         end
+      end
+    end
 
-      DEFINE_METHOD
+    # return a hash representation of the namespace
+    # use symbols for the hash
+    def to_hash
+      Hash.new.tap do |out|
+        self.options.each do |name, opt|
+          out[name.to_sym] = opt.value
+        end
+        self.options.namespaces.each do |name, value|
+          out[name.to_sym] = value.to_hash
+        end
+      end
+    end
 
-      namespace
+    # allow for iterating over the key/values of a namespace
+    # this uses #to_hash so you won't get option/namespace objs for the values
+    def each
+      self.to_hash.each { |k,v| yield k,v if block_given? }
     end
 
     # The define method is provided for convenience and commonization. The internal system
@@ -104,23 +118,27 @@ module NsOptions
     # 1. A reader of a 'known' option. This case is for an option that's been defined for an
     #    ancestor of this namespace but not directly for this namespace. In this case we fetch
     #    the options definition and use it to define the option directly for this namespace.
-    # 2. A writer of a 'known' option. This case is similar to the above, but instead we are
+    # 2. TODO
+    # 3. A writer of a 'known' option. This case is similar to the above, but instead we are
     #    wanting to write a value. We need to fetch the option definition, define it and then
     #    we write the option as we normally would.
-    # 3. A dynamic writer. The option is not 'known' to the namespace, so we use the value and it's
+    # 4. A dynamic writer. The option is not 'known' to the namespace, so we use the value and it's
     #    class to define the option for this namespace. Then we just use the writer as we normally
     #    would.
     def method_missing(method, *args, &block)
       option_name = method.to_s.gsub("=", "")
       value = args.size == 1 ? args[0] : args
       if args.empty? && self.respond_to?(option_name)
-        option = NsOptions::Helper.fetch_and_define_option(self, option_name)
+        option = NsOptions::Helper.find_and_define_option(self, option_name)
         self.send(option.name)
+      elsif args.empty? && (namespace = self.options.get_namespace(option_name))
+        NsOptions::Helper.find_and_define_namespace(self, option_name)
+        self.send(option_name)
       elsif !args.empty? && self.respond_to?(option_name)
-        option = NsOptions::Helper.fetch_and_define_option(self, option_name)
+        option = NsOptions::Helper.find_and_define_option(self, option_name)
         self.send("#{option.name}=", value)
       elsif !args.empty?
-        option = self.option(option_name, value.class)
+        option = self.option(option_name)
         self.send("#{option.name}=", value)
       else
         super
@@ -131,6 +149,10 @@ module NsOptions
       super || self.options.is_defined?(method.to_s.gsub("=", ""))
     end
 
+    def inspect(*args)
+      "#<#{self.class}:#{'0x%x' % (self.object_id << 1)}:#{self.options.key} #{self.to_hash.inspect}>"
+    end
+
   end
 
 end

data/lib/ns-options/namespaces.rb

@@ -10,7 +10,7 @@ module NsOptions
     end
 
     def add(name, key, parent = nil, &block)
-      self[name] = NsOptions::Helper.new_namespace(key, parent, &block)
+      self[name] = NsOptions::Namespace.new(key, parent, &block)
     end
 
     def get(name)

data/lib/ns-options/option.rb

@@ -1,31 +1,30 @@
 module NsOptions
 
   class Option
-    autoload :Boolean, 'ns-options/option/boolean'
-
     attr_accessor :name, :value, :type_class, :rules
 
-    def initialize(name, type_class, rules = {})
+    def initialize(name, type_class, rules={})
       self.name = name.to_s
-      self.type_class = self.usable_type_class(type_class)
+
+      # if a nil type_class is given, just use Object
+      # this makes the option accept any value with no type coercion
+      self.type_class = (type_class || Object)
+
       self.rules = rules
+      self.rules[:args] = (self.rules[:args] ? [*self.rules[:args]] : [])
       self.value = rules[:default]
     end
 
+    # if reading a lazy_proc, call the proc and return its coerced return val
+    # otherwise, just return the stored value
     def value
-      if self.type_class == NsOptions::Option::Boolean
-        @value and @value.actual
-      else
-        @value
-      end
+      self.lazy_proc?(@value) ? self.coerce(@value.call) : @value
     end
 
+    # if setting a lazy_proc, just store the proc off to be called when read
+    # otherwise, coerce and store the value being set
     def value=(new_value)
-      @value = if (new_value.kind_of?(self.type_class)) || new_value.nil?
-        new_value
-      else
-        self.coerce(new_value)
-      end
+      @value = self.lazy_proc?(new_value) ? new_value : self.coerce(new_value)
     end
 
     def is_set?
@@ -44,24 +43,27 @@ module NsOptions
 
     protected
 
-    def coerce(new_value)
+    # a value is considered to by a lazy eval proc if it some kind of a of
+    # Proc and the option it is being set on is not explicitly defined as some
+    # kind of Proc
+    # The allows you to set option values that should't be evaluated until they
+    # are being read
+    def lazy_proc?(value)
+      value.kind_of?(::Proc) && !self.type_class.ancestors.include?(::Proc)
+    end
+
+    def coerce(value)
+      return value if (value.kind_of?(self.type_class)) || value.nil?
+
       if [ Integer, Float, String ].include?(self.type_class)
         # ruby type conversion, i.e. String(1)
-        Object.send(self.type_class.to_s.to_sym, new_value)
+        Object.send(self.type_class.to_s.to_sym, value)
+      elsif self.type_class == Symbol
+        value.to_sym
       elsif self.type_class == Hash
-        {}.merge(new_value)
-      else
-        self.type_class.new(new_value)
-      end
-    end
-
-    def usable_type_class(type_class)
-      if type_class == Fixnum
-        Integer
-      elsif [ TrueClass, FalseClass ].include?(type_class)
-        NsOptions::Option::Boolean
+        {}.merge(value)
       else
-        (type_class || String)
+        self.type_class.new(value, *self.rules[:args])
       end
     end
 

data/lib/ns-options/options.rb

@@ -1,13 +1,12 @@
 module NsOptions
 
   class Options < Hash
-    attr_accessor :key, :parent, :children
-    alias :namespaces :children
+    attr_accessor :key, :parent, :namespaces
 
     def initialize(key, parent = nil)
       self.key = key.to_s
       self.parent = parent
-      self.children = NsOptions::Namespaces.new
+      self.namespaces = NsOptions::Namespaces.new
     end
 
     def [](name)
@@ -30,11 +29,7 @@ module NsOptions
 
     def get(name)
       option = self[name]
-      if option && !option.value.nil?
-        option.value
-      elsif self.parent_options
-        self.parent_options.get(name)
-      end
+      option and option.value
     end
 
     def set(name, new_value)
@@ -42,16 +37,8 @@ module NsOptions
       self[name]
     end
 
-    def fetch(name)
-      self[name] || (self.parent_options && self.parent_options.fetch(name))
-    end
-
     def is_defined?(name)
-      !!self[name] || !!(self.parent_options && self.parent_options.is_defined?(name))
-    end
-
-    def parent_options
-      self.parent and self.parent.options
+      !!self[name]
     end
 
     def required_set?
@@ -60,6 +47,31 @@ module NsOptions
       end
     end
 
+    def add_namespace(name, key = nil, parent = nil, &block)
+      key ||= name
+      self.namespaces.add(name, key, parent, &block)
+    end
+
+    def get_namespace(name)
+      self.namespaces[name]
+    end
+
+    def is_namespace_defined?(name)
+      !!self.get_namespace(name)
+    end
+
+    def build_from(options, namespace)
+      options.each do |key, option|
+        self.add(option.name, option.type_class, option.rules)
+        NsOptions::Helper.find_and_define_option(namespace, option.name)
+      end
+      options.namespaces.each do |name, ns|
+        new_namespace = self.add_namespace(name, ns.options.key, ns.options.parent)
+        NsOptions::Helper.find_and_define_namespace(namespace, name)
+        new_namespace.options.build_from(ns.options, new_namespace)
+      end
+    end
+
   end
 
 end

data/lib/ns-options/version.rb

@@ -1,3 +1,3 @@
 module NsOptions
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/ns-options.rb

@@ -6,4 +6,13 @@ module NsOptions
   autoload :Option,         'ns-options/option'
   autoload :Options,        'ns-options/options'
   autoload :VERSION,        'ns-options/version'
+  
+  module Errors
+    autoload :InvalidName, 'ns-options/errors/invalid_name'
+  end
+
+  def self.included(receiver)
+    receiver.send(:include, HasOptions)
+  end
+
 end

data/ns-options.gemspec

@@ -14,6 +14,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = NsOptions::VERSION
 
-  gem.add_development_dependency("assert",        ["~>0.6"])
+  gem.add_development_dependency("assert",        ["~>0.7"])
   gem.add_development_dependency("assert-mocha",  ["~>0.1"])
 end

data/test/helper.rb

@@ -1,14 +1,9 @@
-require 'logger'
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
-root_path = File.expand_path("../..", __FILE__)
-if !$LOAD_PATH.include?(root_path)
-  $LOAD_PATH.unshift(root_path)
-end
+require 'logger'
 require 'ns-options'
 
 require 'test/support/app'
 require 'test/support/user'
 
-if defined?(Assert)
-  require 'assert-mocha'
-end
+require 'assert-mocha'

data/test/integration/app_test.rb

@@ -39,24 +39,30 @@ module App
     should "have set the stage to 'test'" do
       assert_equal @stage, subject.stage
     end
+
     should "have set the root to this gem's dir" do
       assert_equal Pathname.new(@root_path), subject.root
     end
+
     should "have set the logger to the passed logger" do
       assert_equal @logger, subject.logger
       assert_same @logger, subject.logger
     end
+
+    should "have set its self_stage option to its stage" do
+      assert_equal @stage, subject.self_stage
+      assert_same @stage, subject.self_stage
+    end
+
   end
-  
+
   class SubNamespaceTest < DefineTest
     desc "the sub namespace"
     subject{ @module.settings.sub }
-    
+
     should "have set the run_commands option" do
-      assert_equal @run, subject.run_commands
-    end
-    should "have access to it's parent's options" do
-      assert_equal @stage, subject.stage
+      assert_kind_of NsOptions::Boolean, subject.run_commands
+      assert_equal @run, subject.run_commands.actual
     end
   end
 

data/test/integration/user_test.rb

@@ -10,6 +10,7 @@ class User
     subject{ @class }
 
     should have_instance_methods :options, :preferences
+
   end
 
   class ClassPreferencesTest < BaseTest
@@ -18,16 +19,44 @@ class User
 
     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
+      @class_preferences = @class.preferences
+      @class_preferences.home_url = "/something"
+      @preferences = @instance.preferences
     end
     subject{ @instance }
 
     should have_instance_methods :preferences
+
+    should "have a new namespace that is a different object than the class namespace" do
+      assert_equal @class_preferences.options.key, @preferences.options.key
+      assert_equal @class_preferences.options.parent, @preferences.options.parent
+      assert_not_same @class_preferences, @preferences
+    end
+    should "have the same options as the class namespace, but different objects" do
+      @class_preferences.options.each do |key, class_option|
+        option = @preferences.options[key]
+        assert_equal class_option.name, option.name
+        assert_equal class_option.type_class, option.type_class
+        assert_equal class_option.rules, option.rules
+        assert_not_same class_option, option
+      end
+      assert_not_equal @class_preferences.home_url, @preferences.home_url
+    end
+    should "have the same namespaces as the class namespace, but different objects" do
+      @class_preferences.options.namespaces.each do |name, class_namespace|
+        namespace = @preferences.options.namespaces[name]
+        assert_equal class_namespace.options.key, namespace.options.key
+        assert_equal class_namespace.options.parent, namespace.options.parent
+        assert_not_same class_namespace, namespace
+      end
+    end
   end
 
   class PreferencesTest < InstanceTest
@@ -37,21 +66,30 @@ class User
       @preferences.home_url = "/home"
       @preferences.show_messages = false
       @preferences.font_size = 15
+      @preferences.view.color = "green"
     end
     subject{ @preferences }
 
-    should have_instance_methods :namespace, :option, :define, :options, :metaclass
     should have_accessors :home_url, :show_messages, :font_size
+    should have_instance_methods :namespace, :option, :define, :options, :metaclass
+    should have_instance_methods :view
 
     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
+      assert_kind_of NsOptions::Boolean, subject.show_messages
+      assert_equal false, subject.show_messages.actual
     end
+
     should "have set the font_size" do
       assert_equal 15, subject.font_size
     end
+
+    should "have set the color option on the view sub namespace" do
+      assert_equal "green", subject.view.color
+    end
   end
 
 end

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'ns-options'

data/test/support/app.rb

@@ -1,12 +1,18 @@
+require 'ns-options/boolean'
+
 module App
-  include NsOptions::HasOptions
+
+  # mixin on just the top-level NsOptions variant
+  include NsOptions
+
   options(:settings, "settings:app") do
     option :root,   Pathname
     option :stage
     option :logger, Logger
+    option :self_stage, :default => Proc.new { self.stage }
 
     namespace :sub do
-      option :run_commands, NsOptions::Option::Boolean
+      option :run_commands, NsOptions::Boolean
     end
   end
 end

data/test/support/user.rb

@@ -1,13 +1,22 @@
+require 'ns-options/boolean'
+
 class User
+
+  # mixin using the specific HasOptions variant
   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
+    option :show_messages,  NsOptions::Boolean, :require => true
+    option :font_size,      Integer,            :default => 12
+
+    namespace :view do
+      option :color
+    end
   end
 
   def preferences_key
     "user_#{self.object_id}"
   end
 
-end
+end

data/test/unit/ns-options/{option/boolean_test.rb → boolean_test.rb}

@@ -1,11 +1,11 @@
 require 'assert'
 
-class NsOptions::Option::Boolean
+class NsOptions::Boolean
 
   class BaseTest < Assert::Context
-    desc "NsOptions::Option::Boolean"
+    desc "NsOptions::Boolean"
     setup do
-      @boolean = NsOptions::Option::Boolean.new(true)
+      @boolean = NsOptions::Boolean.new(true)
     end
     subject{ @boolean }
 
@@ -15,7 +15,7 @@ class NsOptions::Option::Boolean
   class WithTruthyValuesTest < BaseTest
     desc "with truthy values"
     setup do
-      @boolean = NsOptions::Option::Boolean.new(false)
+      @boolean = NsOptions::Boolean.new(nil)
     end
 
     should "have set actual to true with true" do
@@ -26,6 +26,14 @@ class NsOptions::Option::Boolean
       subject.actual = 'true'
       assert_equal true, subject.actual
     end
+    should "have set actual to true with 't'" do
+      subject.actual = 't'
+      assert_equal true, subject.actual
+    end
+    should "have set actual to true with 'T'" do
+      subject.actual = 'T'
+      assert_equal true, subject.actual
+    end
     should "have set actual to true with 1" do
       subject.actual = 1
       assert_equal true, subject.actual
@@ -39,7 +47,7 @@ class NsOptions::Option::Boolean
   class WithFalsyValuesTest < BaseTest
     desc "with falsy values"
     setup do
-      @boolean = NsOptions::Option::Boolean.new(true)
+      @boolean = NsOptions::Boolean.new(nil)
     end
 
     should "have set actual to false with false" do
@@ -50,6 +58,14 @@ class NsOptions::Option::Boolean
       subject.actual = 'false'
       assert_equal false, subject.actual
     end
+    should "have set actual to false with 'f'" do
+      subject.actual = 'f'
+      assert_equal false, subject.actual
+    end
+    should "have set actual to false with 'F'" do
+      subject.actual = 'F'
+      assert_equal false, subject.actual
+    end
     should "have set actual to false with 0" do
       subject.actual = 0
       assert_equal false, subject.actual