ns-options 0.4.1 → 1.0.0.rc1

data/lib/ns-options/options.rb

@@ -1,76 +1,50 @@
+require 'ns-options/option'
+
 module NsOptions
 
-  class Options < Hash
-    attr_accessor :key, :parent, :namespaces
+  class Options
 
-    def initialize(key, parent = nil)
-      self.key = key.to_s
-      self.parent = parent
-      self.namespaces = NsOptions::Namespaces.new
+    def initialize
+      @hash = Hash.new
     end
 
-    def [](name)
-      super(name.to_sym)
-    end
-    def []=(name, value)
-      super(name.to_sym, value)
-    end
+    # for hash with indifferent access behavior
+    def [](name);         @hash[name.to_s];         end
+    def []=(name, value); @hash[name.to_s] = value; end
 
-    def add(*args)
-      option = NsOptions::Option.new(*args)
-      self[option.name] = option
+    def keys(*args, &block);   @hash.keys(*args, &block);   end
+    def each(*args, &block);   @hash.each(*args, &block);   end
+    def empty?(*args, &block); @hash.empty?(*args, &block); end
+
+    def add(name, opt)
+      self[name] = opt
     end
 
-    def del(name)
-      self[name] = nil
+    def rm(name)
+      @hash.delete(name.to_s)
     end
-    alias :remove :del
 
     def get(name)
-      option = self[name]
-      option and option.value
+      (option = self[name]) ? option.value : nil
     end
 
     def set(name, new_value)
       self[name].value = new_value
-      self[name]
-    end
-
-    def is_defined?(name)
-      !!self[name]
     end
 
     def required_set?
-      self.values.reject{|option| !option.required? }.inject(true) do |bool, option|
-        bool && option.is_set?
-      end
+      are_all_these_options_set? required_options
     end
 
-    def add_namespace(name, key = nil, parent = nil, &block)
-      key ||= name
-      self.namespaces.add(name, key, parent, &block)
-    end
+    private
 
-    def get_namespace(name)
-      self.namespaces[name]
+    def are_all_these_options_set?(options)
+      options.inject(true) {|bool, opt| bool && opt.is_set?}
     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
+    def required_options
+      @hash.values.reject{|opt| !opt.required? }
     end
 
   end
-
 end

data/lib/ns-options/proxy.rb

@@ -1,4 +1,5 @@
 require 'ns-options'
+require 'ns-options/proxy_method'
 
 module NsOptions::Proxy
 
@@ -8,89 +9,75 @@ module NsOptions::Proxy
 
   NAMESPACE = "__proxy_options__"
 
-  class << self
+  def self.included(receiver)
+    NsOptions::RootMethods.new(receiver, NAMESPACE).define
+    receiver.class_eval { extend  ProxyMethods }
+    receiver.class_eval { include ProxyMethods } if receiver.kind_of?(Class)
 
-    def included(receiver)
-      NsOptions::Helper.define_root_namespace_methods(receiver, NAMESPACE)
-      receiver.class_eval { extend ProxyMethods }
-      receiver.class_eval { include ProxyMethods } if receiver.kind_of?(Class)
+    if receiver.kind_of?(Class)
+      receiver.class_eval do
 
-      if receiver.kind_of?(Class)
-        receiver.class_eval do
-
-          # default initializer method
-          def initialize(configs={})
-            self.apply(configs || {})
-          end
+        # This hook copies the proxy definition to any subclasses
+        def self.inherited(subclass)
+          subclass.__proxy_options__.build_from(self.__proxy_options__)
+        end
 
-          # equality method override for class-instance proxies
-          def ==(other_proxy_instance)
-            __proxy_options__ == other_proxy_instance.__proxy_options__
-          end
+        # default initializer method
+        def initialize(configs=nil)
+          self.apply(configs || {})
+        end
 
+        # equality method override for class-instance proxies
+        def ==(other_proxy_instance)
+          __proxy_options__ == other_proxy_instance.__proxy_options__
         end
-      else # Module
-        receiver.class_eval do
 
-          # default initializer method
-          def self.new(configs={})
-            self.apply(configs || {})
-          end
+      end
+    else # Module
+      receiver.class_eval do
 
+        # default initializer method
+        def self.new(configs=nil)
+          self.apply(configs || {})
         end
+
       end
     end
-
   end
 
   module ProxyMethods
 
     # pass thru namespace methods to the proxied NAMESPACE handler
 
-    def option(*args, &block)
-      __proxy_options__.option(*args, &block)
+    def option(name, *args, &block)
+      __proxy_options__.option(name, *args, &block)
+      NsOptions::ProxyMethod.new(self, name, 'an option').define($stdout, caller)
     end
     alias_method :opt, :option
 
-    def namespace(*args, &block)
-      __proxy_options__.namespace(*args, &block)
+    def namespace(name, *args, &block)
+      __proxy_options__.namespace(name, *args, &block)
+      NsOptions::ProxyMethod.new(self, name, 'a namespace').define($stdout, caller)
     end
     alias_method :ns, :namespace
 
-    def apply(*args, &block)
-      __proxy_options__.apply(*args, &block)
-    end
-
-    def to_hash(*args, &block)
-      __proxy_options__.to_hash(*args, &block)
-    end
-
-    def each(*args, &block)
-      __proxy_options__.each(*args, &block)
-    end
-
-    def define(*args, &block)
-      __proxy_options__.define(*args, &block)
-    end
-
-    def required_set?(*args, &block)
-      __proxy_options__.required_set?(*args, &block)
-    end
+    def apply(*args, &block);   __proxy_options__.apply(*args, &block);   end
+    def to_hash(*args, &block); __proxy_options__.to_hash(*args, &block); end
+    def each(*args, &block);    __proxy_options__.each(*args, &block);    end
+    def define(*args, &block);  __proxy_options__.define(*args, &block);  end
 
-    def valid?(*args, &block)
-      __proxy_options__.valid?(*args, &block)
-    end
+    def required_set?(*args, &block); __proxy_options__.required_set?(*args, &block); end
+    def valid?(*args, &block);        __proxy_options__.valid?(*args, &block);        end
 
     def inspect(*args, &block)
-      # __proxy_options__.inspect(*args, &block)
-      "#<#{self.class}:#{'0x%x' % (self.object_id << 1)}:#{__proxy_options__.options.key} #{__proxy_options__.to_hash.inspect}>"
+      "#<#{self.class}:#{'0x%x' % (self.object_id << 1)}:#{__proxy_options__.__name__} #{__proxy_options__.to_hash.inspect}>"
     end
 
     # for everything else, send to the proxied NAMESPACE handler
-    # at this point it really just enables setting dynamic options
+    # at this point it really just enables dynamic options writers
 
     def method_missing(meth, *args, &block)
-      if (po = self.__proxy_options__) && po.respond_to?(meth.to_s)
+      if (po = __proxy_options__) && po.respond_to?(meth.to_s)
         po.send(meth.to_s, *args, &block)
       else
         super

data/lib/ns-options/proxy_method.rb

@@ -0,0 +1,54 @@
+require 'ns-options/namespace'
+require 'ns-options/option'
+
+module NsOptions
+  class ProxyMethod
+
+    # This class handles defining proxy class methods for classes or modules
+    # and an additional instance method for classes.
+
+    def initialize(define_on, name, kind)
+      @define_on, @name, @kind = define_on, name, kind
+      @meth_extension_mixin = Module.new
+      @meth_extension_mixin.class_eval proxy_meth_code
+    end
+
+    def define_on_class?
+      !!@define_on.kind_of?(::Class)
+    end
+
+    def define(io=nil, from_caller=nil)
+      validate(io || $stdout, from_caller || caller)
+
+      # covers defining the class-level method on Modules or Classes
+      @define_on.send :extend, @meth_extension_mixin
+
+      # covers defining the instance-level method on Classes
+      @define_on.send :include, @meth_extension_mixin if define_on_class?
+    end
+
+    def validate(io, from_caller)
+      return true unless not_recommended_meth_names.include?(@name.to_sym)
+
+      io.puts "WARNING: Defining #{@kind} with the name `#{@name}' overwrites a"\
+              " method NsOptions::Proxy depends on and may cause it to not"\
+              " behave correctly."
+      io.puts from_caller.first
+      false
+    end
+
+    private
+
+    def proxy_meth_code
+      "def #{@name}(*args, &block); __proxy_options__.#{@name}(*args, &block); end"
+    end
+
+    def not_recommended_meth_names
+      [ :option, :opt, :namespace, :ns,
+        :define, :inspect, :method_missing, :respond_to?,
+        :apply, :to_hash, :each, :required_set?, :valid?,
+      ]
+    end
+
+  end
+end

data/lib/ns-options/root_methods.rb

@@ -0,0 +1,77 @@
+require 'ns-options/namespace'
+
+module NsOptions
+  class RootMethods
+
+    # This class handles defining a root namespace class method for classes
+    # or modules and an additional instance method for classes. For classes, the
+    # instance method will build an entirely new namespace, distinct from  the
+    # class level namespace but with an identical definition
+
+    def initialize(define_on, name)
+      @define_on, @name     = define_on, name
+      @class_meth_extension = Module.new
+      @instance_meth_mixin  = Module.new
+    end
+
+    def define_on_class?
+      !!@define_on.kind_of?(::Class)
+    end
+
+    def define(io=nil, from_caller=nil)
+      validate(io || $stdout, from_caller || caller)
+
+      # covers defining the class-level method on Modules or Classes
+      @class_meth_extension.class_eval class_meth_extension_code
+      @define_on.send :extend, @class_meth_extension
+
+      if define_on_class?
+        # covers defining the instance-level method on Classes
+        @instance_meth_mixin.class_eval instance_meth_mixin_code
+        @define_on.send :include, @instance_meth_mixin
+      end
+    end
+
+    def validate(io, from_caller)
+      return true unless [:options, :opts, :namespace, :ns].include?(@name.to_sym)
+
+      io.puts "WARNING: Defining an option namespace with the name `#{@name}'"\
+              " overwrites a method NsOptions depends on.  You won't be able to"\
+              " define any additional option namespaces using the `#{@name}'"\
+              " method."
+      io.puts from_caller.first
+      false
+    end
+
+    private
+
+    def class_meth_extension_code
+      %{
+        def #{@name}(*args, &block)
+          unless @#{@name}
+            @#{@name} = NsOptions::Namespace.new('#{@name}', *args, &block)
+            if respond_to?('superclass') && superclass &&
+               superclass.respond_to?('#{@name}') &&
+               superclass.#{@name}.kind_of?(NsOptions::Namespace)
+              @#{@name}.build_from(superclass.#{@name})
+            end
+          end
+          @#{@name}
+        end
+      }
+    end
+
+    def instance_meth_mixin_code
+      %{
+        def #{@name}(*args, &block)
+          unless @#{@name}
+            @#{@name} = NsOptions::Namespace.new('#{@name}', *args, &block)
+            @#{@name}.build_from(self.class.#{@name})
+          end
+          @#{@name}
+        end
+      }
+    end
+
+  end
+end

data/lib/ns-options/version.rb

@@ -1,3 +1,3 @@
 module NsOptions
-  VERSION = "0.4.1"
+  VERSION = "1.0.0.rc1"
 end

data/lib/ns-options.rb

@@ -1,16 +1,26 @@
-require 'ns-options/has_options'
-require 'ns-options/helper'
-require 'ns-options/namespace'
-require 'ns-options/namespaces'
-require 'ns-options/option'
-require 'ns-options/options'
+require 'ns-options/root_methods'
 require 'ns-options/proxy'
-require 'ns-options/version' if !defined?(NsOptions::VERSION)
 
 module NsOptions
 
   def self.included(receiver)
-    receiver.send(:include, HasOptions)
+    receiver.class_eval { extend NsOptions::DSL }
+  end
+
+  module DSL
+
+    # This is the main DSL method for creating a namespace of options for your
+    # class/module. This will define a class method for classes/modules and
+    # an additional instance method for classes.
+
+    def options(name, *args, &block)
+      NsOptions::RootMethods.new(self, name).define($stdout, caller)
+      self.send(name, *args, &block)
+    end
+    alias_method :opts,      :options
+    alias_method :namespace, :options
+    alias_method :ns,        :options
+
   end
 
 end

data/ns-options.gemspec

@@ -4,8 +4,8 @@ require File.expand_path('../lib/ns-options/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Collin Redding"]
   gem.email         = ["collin.redding@reelfx.com"]
-  gem.description   = %q{Define and use namespaced options with a clean interface.}
-  gem.summary       = %q{Define and use namespaced options with a clean interface.}
+  gem.description   = %q{A DSL for defining, organizing and accessing options.}
+  gem.summary       = %q{A DSL for defining, organizing and accessing options.}
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
@@ -14,6 +14,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = NsOptions::VERSION
 
-  gem.add_development_dependency("assert",        ["~>0.7"])
-  gem.add_development_dependency("assert-mocha",  ["~>0.1"])
+  gem.add_development_dependency("assert", ["~>0.8"])
 end

data/test/helper.rb

@@ -1,21 +1,14 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
-require 'logger'
-require 'ns-options'
-
-require 'test/support/app'
-require 'test/support/user'
-
-require 'assert-mocha'
-
 module NsOptions
   module TestOutput
 
     module_function
 
     def capture
-      out = StringIO.new
-      $stdout = out
+      out = ""
+      io = StringIO.new(out)
+      $stdout = io
       yield
       return out
     ensure

data/test/support/app.rb

@@ -1,11 +1,13 @@
+require 'ns-options'
 require 'ns-options/boolean'
+require 'logger'
 
 module App
 
   # mixin on just the top-level NsOptions variant
   include NsOptions
 
-  options(:settings, "settings:app") do
+  options(:settings) do
     option :root,   Pathname
     option :stage
     option :logger, Logger

data/test/support/proxy.rb

@@ -1,3 +1,5 @@
+require 'ns-options'
+
 module SomeProxy
   include NsOptions::Proxy
 
@@ -14,6 +16,8 @@ module SomeProxy
 
   end
 
+  class SomeOtherThing < SomeThing; end
+
   opt :some, SomeThing, :default => { :value1 => 1 }
   opt :some_prime, SomeThing, :default => { :value1 => 'one' }
   opt :stuff, :default => []

data/test/support/type_class_proxy.rb

@@ -0,0 +1,29 @@
+require 'ns-options'
+
+class DefaultTypeClass < Struct.new(:value); end
+
+class TypeClassProxy
+  include NsOptions::Proxy
+
+  option_type_class DefaultTypeClass
+
+  opt :value1             # test that DefaultTypeClass is used
+
+  ns :more do
+    opt :more1            # that it is used recursively
+  end
+
+  ns :strings do
+    opt_type_class String
+    opt :string1          # that it can be over written
+  end
+
+  ns :objs, Object do
+    type_class Object
+    opt :obj1             # and that it can be reset to the default
+  end
+
+end
+
+class InheritedTypeClassProxy < TypeClassProxy; end
+class DoubleInheritedTypeClassProxy < InheritedTypeClassProxy; end

data/test/support/user.rb

@@ -1,14 +1,14 @@
+require 'ns-options'
 require 'ns-options/boolean'
 
 class User
 
-  # mixin using the specific HasOptions variant
-  include NsOptions::HasOptions
+  include NsOptions
 
-  options(:preferences, 'user-preferences') do
+  options(:preferences) do
     option :home_url
-    option :show_messages,  NsOptions::Boolean, :require => true
-    option :font_size,      Integer,            :default => 12
+    option :show_messages,  NsOptions::Boolean, :required => true
+    option :font_size,      Integer,            :default  => 12
 
     namespace :view do
       option :color

data/test/{integration/app_test.rb → system/app_tests.rb}

@@ -1,8 +1,9 @@
 require 'assert'
+require 'test/support/app'
 
 module App
 
-  class BaseTest < Assert::Context
+  class BaseTests < Assert::Context
     desc "the App module"
     setup do
       @module = App
@@ -13,7 +14,7 @@ module App
 
   end
 
-  class DefineTest < BaseTest
+  class DefineTests < BaseTests
     desc "defined"
     setup do
       stage = @stage = "test"
@@ -32,9 +33,9 @@ module App
     end
     subject{ @module.settings }
 
-    should have_instance_methods :namespace, :option, :define, :options, :metaclass
+    should have_instance_methods :namespace, :option, :define
     should have_accessors :stage, :root, :logger
-    should have_instance_methods :sub
+    should have_readers   :sub
 
     should "have set the stage to 'test'" do
       assert_equal @stage, subject.stage
@@ -46,7 +47,7 @@ module App
 
     should "have set the logger to the passed logger" do
       assert_equal @logger, subject.logger
-      assert_same @logger, subject.logger
+      assert_same  @logger, subject.logger
     end
 
     should "have set its self_stage option to its stage" do
@@ -56,13 +57,14 @@ module App
 
   end
 
-  class SubNamespaceTest < DefineTest
+  class SubNamespaceTests < DefineTests
     desc "the sub namespace"
     subject{ @module.settings.sub }
 
     should "have set the run_commands option" do
       assert_equal @run, subject.run_commands
     end
+
   end
 
 end

data/test/{integration/proxy_test.rb → system/proxy_tests.rb}

@@ -39,3 +39,15 @@ class SomeProxySomeThingTests < SomeProxyIntTests
   end
 
 end
+
+class SomeProxySomeOtherThingTests < SomeProxyIntTests
+  desc "that has a class inherited from another proxy object"
+  setup do
+    @proxy = SomeProxy::SomeOtherThing.new
+  end
+
+  # should "have the same definition as its superclass"
+  should have_namespace :more
+  should have_options :value1, :value2
+
+end