parameters 0.3.1 → 0.4.0

data/ChangeLog.md

@@ -1,3 +1,8 @@
+### 0.4.0 / 2011-12-29
+
+* Added {Parameters::Options}.
+* Added {Parameters::Types} which handles type coercion for Parameters.
+
 ### 0.3.1 / 2011-12-16
 
 * Do not coerce `nil` values.

data/lib/parameters/class_methods.rb

@@ -4,16 +4,14 @@ require 'parameters/extensions/meta'
 
 module Parameters
   module ClassMethods
-    def included(base)
-      base.extend ClassMethods
-    end
-
     #
     # @return [Hash]
     #   Parameters for the class.
     #
+    # @api semipublic
+    #
     def params
-      @_params ||= {}
+      @parameters ||= {}
     end
 
     #
@@ -26,6 +24,8 @@ module Parameters
     #   Test.params = {:x => 5, :y => 2}
     #   # => {:x=>5, :y=>2}
     #
+    # @api semipublic
+    #
     def params=(values)
       values.each do |name,value|
         if has_param?(name)
@@ -64,6 +64,8 @@ module Parameters
     # @example
     #   parameter 'var', :default => 3, :description => 'my variable' 
     #
+    # @api public
+    #
     def parameter(name,options={})
       name = name.to_sym
 
@@ -77,6 +79,11 @@ module Parameters
         get_param(name).value = value
       end
 
+      # define the ? method, to determine if the parameter is set
+      meta_def("#{name}?") do
+        !!get_param(name).value
+      end
+
       # define the reader instance methods for the parameter
       define_method(name) do
         get_param(name).value
@@ -87,6 +94,11 @@ module Parameters
         get_param(name).value = value
       end
 
+      # define the ? method, to determine if the parameter is set
+      define_method("#{name}?") do
+        !!get_param(name).value
+      end
+
       # create the new parameter
       new_param = Parameters::ClassParam.new(
         name,
@@ -107,6 +119,8 @@ module Parameters
     #   Specifies whether or not there is a class parameter with the
     #   specified name.
     #
+    # @api semipublic
+    #
     def has_param?(name)
       name = name.to_sym
 
@@ -131,6 +145,8 @@ module Parameters
     # @raise [ParamNotFound]
     #   No class parameter with the specified name could be found.
     #
+    # @api semipublic
+    #
     def get_param(name)
       name = name.to_sym
 
@@ -162,6 +178,8 @@ module Parameters
     #
     # @since 0.3.0
     #
+    # @api semipublic
+    #
     def set_param(name,value)
       name = name.to_sym
 
@@ -182,8 +200,10 @@ module Parameters
     # @yield [param]
     #   The block that will be passed each class parameter.
     #
+    # @api semipublic
+    #
     def each_param(&block)
-      ancestors.each do |ancestor|
+      ancestors.reverse_each do |ancestor|
         if ancestor.included_modules.include?(Parameters)
           ancestor.params.each_value(&block)
         end
@@ -201,6 +221,8 @@ module Parameters
     # @raise [ParamNotFound]
     #   No class parameter with the specified name could be found.
     #
+    # @api semipublic
+    #
     def describe_param(name)
       get_param(name).description
     end
@@ -214,6 +236,8 @@ module Parameters
     # @raise [ParamNotFound]
     #   No class parameter with the specified name could be found.
     #
+    # @api semipublic
+    #
     def param_value(name)
       get_param(name).value
     end

data/lib/parameters/class_param.rb

@@ -72,8 +72,8 @@ module Parameters
     def to_s
       text = @name.to_s
 
-      text << " [#{@value.inspect}]" if @value
-      text << "\t#{@description}" if @description
+      text << "\t[#{@value.inspect}]" if @value
+      text << "\t#{@description}"     if @description
 
       return text
     end

data/lib/parameters/instance_param.rb

@@ -25,6 +25,8 @@ module Parameters
     # @param [Object] value
     #   The initial value for the instance parameter.
     #
+    # @api semipublic
+    #
     def initialize(object,name,type=nil,description=nil,value=nil)
       super(name,type,description)
 
@@ -76,8 +78,8 @@ module Parameters
     def to_s
       text = @name.to_s
 
-      text << " [#{value.inspect}]" if value
-      text << "\t#{@description}" if @description
+      text << "\t[#{value.inspect}]" if value
+      text << "\t#{@description}"    if @description
 
       return text
     end

data/lib/parameters/module_methods.rb

@@ -0,0 +1,28 @@
+require 'parameters/class_methods'
+
+module Parameters
+  module ModuleMethods
+    #
+    # Ensures that the module will re-extend Parameters::ClassMethods,
+    # when included.
+    #
+    def included(base)
+      base.extend ClassMethods
+
+      if base.kind_of?(Module)
+        # re-extend the ModuleMethods
+        base.extend ModuleMethods
+      end
+    end
+
+    #
+    # Ensures that the module will initialize parameters, when extended
+    # into an Object.
+    #
+    def extended(object)
+      each_param do |param|
+        object.params[param.name] = param.to_instance(object)
+      end
+    end
+  end
+end

data/lib/parameters/options.rb

@@ -0,0 +1,222 @@
+require 'parameters/param'
+require 'parameters/types'
+
+require 'optparse'
+
+module Parameters
+  #
+  # @since 0.4.0
+  #
+  module Options
+    # The usage messages for various Parameter {Types}.
+    USAGES = {
+      Types::Integer  => 'NUM',
+      Types::Float    => 'DEC',
+      Types::Symbol   => 'NAME',
+      Types::Time     => 'TIME',
+      Types::DateTime => 'DATE|TIME',
+      Types::Date     => 'DATE',
+      Types::Regexp   => 'REGEXP',
+      Types::URI      => 'URI',
+      Types::Array    => 'VALUE [...]',
+      Types::Set      => 'VALUE [...]',
+      Types::Hash     => 'NAME:VALUE [...]'
+    }
+
+    # The OptionParser acceptance classes for various Parameter {Types}.
+    ACCEPTS = {
+      Types::Object   => Object,
+      Types::Boolean  => TrueClass,
+      Types::Integer  => Integer,
+      Types::Float    => Float,
+      Types::Symbol   => Symbol,
+      Types::String   => String,
+      Types::Time     => String,
+      Types::DateTime => String,
+      Types::Date     => String,
+      Types::URI      => String
+    }
+
+    #
+    # Returns the option flag for the given parameter.
+    #
+    # @param [Param] param
+    #   The parameter.
+    #
+    # @return [String]
+    #   The option flag.
+    #
+    # @api semipublic
+    #
+    def self.flag(param)
+      name = param.name.to_s.gsub('_','-')
+
+      if param.type == Types::Boolean
+        "--[no-]#{name}"
+      else
+        "--#{name}"
+      end
+    end
+
+    #
+    # Returns the Usage String for the parameter.
+    #
+    # @param [Param] param
+    #   The parameter.
+    #
+    # @return [String]
+    #   The Usage String.
+    #
+    # @api semipublic
+    #
+    def self.usage(param)
+      name = param.name.to_s
+
+      type_usage = lambda { |type|
+        if type.class == Types::Hash
+          type_usage[type.key_type] + ':' + 
+          type_usage[type.value_type] + ' [...]'
+        elsif type.class <= Types::Array
+          type_usage[type.element_type] + ' [...]'
+        elsif (type == Types::String) ||
+              (type == Types::Object)
+          name.upcase
+        else
+          USAGES[type]
+        end
+      }
+
+      return type_usage[param.type]
+    end
+
+    #
+    # Returns the OptionParser acceptance class for the parameter.
+    #
+    # @param [Param] param
+    #   The parameter.
+    #
+    # @return [Class]
+    #   The acceptance class.
+    #
+    # @api semipublic
+    #
+    def self.accepts(param)
+      type = param.type
+
+      if type <= Types::Hash
+        Hash
+      elsif type <= Types::Array
+        Array
+      else
+        ACCEPTS[type]
+      end
+    end
+
+    #
+    # Defines an option for the parameter.
+    #
+    # @param [OptionParser] opts
+    #   The option parser.
+    #
+    # @param [Param] param
+    #   The parameter.
+    #
+    # @param [Hash] options
+    #   Additional options for the option.
+    #
+    # @option options [String] :flag
+    #   The short flag for the option.
+    #
+    # @option options [String] :usage
+    #   The USAGE String for the option.
+    #
+    # @api public
+    #
+    def self.define(opts,param,options={})
+      short_flag = options[:flag]
+      long_flag  = flag(param)
+      usage      = (options[:usage] || self.usage(param))
+
+      args  = []
+
+      args << short_flag if short_flag
+      args << if usage
+                "#{long_flag} [#{usage}]"
+              else
+                long_flag
+              end
+
+      args << accepts(param)
+
+      args << "#{param.description}."           if param.description
+      args << "Default: #{param.value.inspect}" if param.value
+
+      if param.type <= Types::Hash
+        opts.on(*args) do |value|
+          if param.value.nil?
+            param.value = value
+          else
+            param.value.merge!(param.coerce(value))
+          end
+        end
+      elsif param.type <= Types::Array
+        opts.on(*args) do |value|
+          if param.value.nil?
+            param.value = value
+          else
+            param.value += param.coerce(value)
+          end
+        end
+      else
+        opts.on(*args) do |value|
+          param.value = value
+        end
+      end
+    end
+
+    #
+    # Defines an OptionParser for a set of parameters.
+    #
+    # @param [Parameter] object
+    #   The Class or Object which included Parameters.
+    #
+    # @param [OptionParser] opts
+    #   The option parser to define the parameter options within.
+    #
+    # @yield [opts]
+    #   If a block is given, it will be passed the newly created OptionParser.
+    #
+    # @yieldparam [OptionParser] opts
+    #   The newly created OptionParser.
+    #
+    # @return [OptionParser]
+    #   The defined OptionParser.
+    #
+    # @api public
+    #
+    def self.parser(object)
+      OptionParser.new do |opts|
+        object.each_param do |param|
+          define(opts,param)
+        end
+
+        yield opts if block_given?
+      end
+    end
+
+    protected
+
+    # accept pattern for Symbols
+    OptionParser.accept(Symbol, /[A-Za-z][A-Za-z0-9_-]*/) do |s,|
+      s.to_sym if s
+    end
+
+    # accept pattern for Hashes
+    OptionParser.accept(Hash, /[^\s:]*:[^\s:]*(\s+[^\s:]*:[^\s:])*/) do |s,|
+      if s
+        Hash[s.split.map { |key_value| key_value.split(':',2) }]
+      end
+    end
+
+  end
+end

data/lib/parameters/param.rb

@@ -24,6 +24,8 @@ module Parameters
     # @param [String, nil] description
     #   The description of the parameter.
     #
+    # @api semipublic
+    #
     def initialize(name,type=nil,description=nil)
       @name = name.to_sym
       @type = if (type.kind_of?(Types::Type)) ||
@@ -36,8 +38,6 @@ module Parameters
       @description = description
     end
 
-    protected
-
     #
     # Coerces the value into the param type.
     #
@@ -47,6 +47,8 @@ module Parameters
     # @return [Object]
     #   The coerced value.
     #
+    # @api semipublic
+    #
     def coerce(value)
       if (value.nil? || (@type === value))
         value

data/lib/parameters/parameters.rb

@@ -1,5 +1,6 @@
 require 'parameters/exceptions'
 require 'parameters/class_methods'
+require 'parameters/module_methods'
 require 'parameters/class_param'
 require 'parameters/instance_param'
 require 'parameters/exceptions'
@@ -8,6 +9,11 @@ require 'parameters/extensions/meta'
 module Parameters
   def self.included(base)
     base.extend ClassMethods
+
+    if base.kind_of?(Module)
+      # add Module specific methods
+      base.extend Parameters::ModuleMethods
+    end
   end
 
   #
@@ -17,9 +23,13 @@ module Parameters
   # @param [Hash] values
   #   The names and values to initialize the instance parameters to.
   #
+  # @api public
+  #
   def initialize_params(values={})
-    self.class.each_param do |param|
-      self.params[param.name] = param.to_instance(self)
+    if self.class.included_modules.include?(Parameters)
+      self.class.each_param do |param|
+        self.params[param.name] = param.to_instance(self)
+      end
     end
 
     self.params = values if values.kind_of?(Hash)
@@ -30,6 +40,8 @@ module Parameters
   # is passed in as the first argument, it will be used to set the values
   # of parameters described within the `Hash`.
   #
+  # @api public
+  #
   def initialize(*args,&block)
     initialize_params(args.first)
   end
@@ -61,6 +73,8 @@ module Parameters
   # @example
   #   obj.parameter('var',:default => 3, :description => 'my variable')
   #
+  # @api public
+  #
   def parameter(name,options={})
     name    = name.to_sym
 
@@ -74,6 +88,10 @@ module Parameters
       def #{name}=(new_value)
         get_param(#{name.inspect}).value = new_value
       end
+
+      def #{name}?
+        !!get_param(#{name.inspect}).value
+      end
     }
 
     # create the new parameter
@@ -94,6 +112,8 @@ module Parameters
   # @return [Hash]
   #   The parameteres of the class and it's ancestors.
   #
+  # @api semipublic
+  #
   def class_params
     self.class.params
   end
@@ -102,8 +122,10 @@ module Parameters
   # @return [Hash]
   #   The instance parameters of the object.
   #
+  # @api semipublic
+  #
   def params
-    @_params ||= {}
+    @parameters ||= {}
   end
 
   #
@@ -116,6 +138,8 @@ module Parameters
   #   obj.params = {:x => 5, :y => 2}
   #   # => {:x=>5, :y=>2}
   #
+  # @api semipublic
+  #
   def params=(values)
     values.each do |name,value|
       name = name.to_sym
@@ -138,6 +162,8 @@ module Parameters
   # @yield [param]
   #   The block that will be passed each instance parameter.
   #
+  # @api semipublic
+  #
   def each_param(&block)
     self.params.each_value(&block)
   end
@@ -150,6 +176,8 @@ module Parameters
   # @example
   #   obj.has_param?('rhost') # => true
   #
+  # @api semipublic
+  #
   def has_param?(name)
     self.params.has_key?(name.to_sym)
   end
@@ -169,6 +197,8 @@ module Parameters
   # @example
   #   obj.get_param('var') # => InstanceParam
   #
+  # @api semipublic
+  #
   def get_param(name)
     name = name.to_sym
 
@@ -200,6 +230,8 @@ module Parameters
   #
   # @since 0.3.0
   #
+  # @api semipublic
+  #
   def set_param(name,value)
     name = name.to_sym
 
@@ -225,6 +257,8 @@ module Parameters
   # @example
   #   obj.describe_param('rhost') # => "remote host"
   #
+  # @api semipublic
+  #
   def describe_param(name)
     get_param(name).description
   end
@@ -244,6 +278,8 @@ module Parameters
   # @example
   #   obj.param_value('rhost') # => 80
   #
+  # @api semipublic
+  #
   def param_value(name)
     get_param(name).value
   end
@@ -260,6 +296,8 @@ module Parameters
   # @raise [MissingParam]
   #   One of the instance parameters was not set.
   #
+  # @api public
+  #
   def require_params(*names)
     names.each do |name|
       name = name.to_s

data/lib/parameters/types/array.rb

@@ -17,6 +17,18 @@ module Parameters
         @element_type = element_type
       end
 
+      #
+      # The element type of the Array type.
+      #
+      # @return [Object]
+      #   The default element type.
+      #
+      # @since 0.4.0
+      #
+      def self.element_type
+        Object
+      end
+
       #
       # Coerces a value into an Array.
       #
@@ -46,6 +58,22 @@ module Parameters
         self.class.to_ruby[@element_type.to_ruby]
       end
 
+      #
+      # Compares the instance type with another type.
+      #
+      # @param [Array, Type] other
+      #   The other type to compare against.
+      #
+      # @return [::Boolean]
+      #   Specificies whether the instance type has the same element type
+      #   as the other Array instance type.
+      #
+      # @since 0.4.0
+      #
+      def ==(other)
+        super(other) && (@element_type == other.element_type)
+      end
+
       #
       # Determines if the value is an Array.
       #

data/lib/parameters/types/hash.rb

@@ -15,11 +15,35 @@ module Parameters
       #
       # @param [Type] value_type
       #
-      def initialize(key_type,value_type)
+      def initialize(key_type=Object,value_type=Object)
         @key_type   = key_type
         @value_type = value_type
       end
 
+      #
+      # The key type of the Hash type.
+      #
+      # @return [Object]
+      #   The default key type.
+      #
+      # @since 0.4.0
+      #
+      def self.key_type
+        Object
+      end
+
+      #
+      # The value type of the Hash type.
+      #
+      # @return [Object]
+      #   The default value type.
+      #
+      # @since 0.4.0
+      #
+      def self.value_type
+        Object
+      end
+
       #
       # Coerces a value into a Hash.
       #
@@ -54,6 +78,25 @@ module Parameters
         ::Hash[@key_type.to_ruby => @value_type.to_ruby]
       end
 
+      #
+      # Compares the instance type with another type.
+      #
+      # @param [Hash, Type] other
+      #   The other type to compare against.
+      #
+      # @return [::Boolean]
+      #   Specificies whether the instance type has the same key/value
+      #   types as the other Hash instance type.
+      #
+      # @since 0.4.0
+      #
+      def ==(other)
+        super(other) && (
+          (@key_type   == other.key_type) &&
+          (@value_type == other.value_type)
+        )
+      end
+
       #
       # Determines if the Hash, and all keys/values, are related to the Type.
       #

data/lib/parameters/types/type.rb

@@ -46,6 +46,58 @@ module Parameters
       def self.coerce(value)
       end
 
+      #
+      # Compares the instance type to another instance type.
+      #
+      # @param [Type] other
+      #   The other instance type.
+      #
+      # @return [::Boolean]
+      #   Specifies that the type has the same class as the other instance
+      #   type.
+      #
+      # @since 0.4.0
+      #
+      def ==(other)
+        self.class == other.class
+      end
+
+      #
+      # Determines if the instance of the type is related to another Type.
+      #
+      # @param [Type] type
+      #   The other type class.
+      #
+      # @return [::Boolean]
+      #   Specifies whether the instance of the type inherites from another
+      #   type.
+      #
+      # @since 0.4.0
+      #
+      def <(other)
+        if other.kind_of?(Type)
+          self.class <= other.class
+        else
+          self.class <= other
+        end
+      end
+
+      #
+      # Compares the type to another instance or class type.
+      #
+      # @param [Type] type
+      #   The other instance or class type.
+      #
+      # @return [::Boolean]
+      #   Specifies whether the instance type inherits from the other
+      #   class type, or shares the same class as the other instance type.
+      #
+      # @since 0.4.0
+      #
+      def <=(other)
+        (self < other) || (self == other)
+      end
+
       #
       # @see ===
       #

data/lib/parameters/version.rb

@@ -1,4 +1,4 @@
 module Parameters
   # The version of parameters
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/spec/classes/option_parameters.rb

@@ -0,0 +1,30 @@
+require 'parameters'
+
+class OptionParameters
+
+  include Parameters
+
+  parameter :path, :description => 'Path to the file'
+
+  parameter :with_foo, :description => 'Multiword param name'
+
+  parameter :type, :type        => Symbol,
+                   :description => 'Type to use'
+
+  parameter :count, :type        => Integer,
+                    :default     => 100,
+                    :description => 'Max count'
+
+  parameter :names, :type        => Array[String],
+                    :description => 'Names to search for'
+
+  parameter :ids, :type        => Set[Integer],
+                  :description => 'IDs to search for'
+
+  parameter :verbose, :type        => true,
+                      :description => 'Enable version'
+
+  parameter :mapping, :type        => Hash[Symbol => Integer],
+                      :description => 'Mapping of names to integers'
+
+end

data/spec/options_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'classes/option_parameters'
+require 'parameters/options'
+
+describe Parameters::Options do
+  let(:object) { OptionParameters.new }
+  let(:params) { object.params        }
+
+  describe "flag" do
+    it "should prefix the name with '--'" do
+      subject.flag(params[:path]).should == '--path'
+    end
+
+    it "should replace '_' characters with '-'" do
+      subject.flag(params[:with_foo]).should == '--with-foo'
+    end
+
+    it "should include '[no-]' for Boolean params" do
+      subject.flag(params[:verbose]).should == '--[no-]verbose'
+    end
+  end
+
+  describe "usage" do
+    it "should use the param name for params without a type" do
+      subject.usage(params[:path]).should == 'PATH'
+    end
+
+    it "should use the param type to derive the USAGE String" do
+      subject.usage(params[:count]).should == 'NUM'
+    end
+
+    context "complex types" do
+      it "should recognize Array params" do
+        subject.usage(params[:names]).should == 'NAMES [...]'
+      end
+
+      it "should recognize Set params" do
+        subject.usage(params[:ids]).should == 'NUM [...]'
+      end
+
+      it "should recognize Hash params" do
+        subject.usage(params[:mapping]).should == 'NAME:NUM [...]'
+      end
+    end
+  end
+
+  describe "accepts" do
+    it "should map Object params to Object" do
+      subject.accepts(params[:path]).should == Object
+    end
+
+    it "should map Boolean params to TrueClass" do
+      subject.accepts(params[:verbose]).should == TrueClass
+    end
+
+    it "should map Array params to Array" do
+      subject.accepts(params[:names]).should == Array
+    end
+
+    it "should map Set params to Array" do
+      subject.accepts(params[:ids]).should == Array
+    end
+
+    it "should map Hash params to Hash" do
+      subject.accepts(params[:mapping]).should == Hash
+    end
+  end
+
+  describe "parser" do
+    subject { Parameters::Options.parser(object) }
+
+    it "should set the param values" do
+      path = 'foo.rb'
+
+      subject.parse(['--path', path])
+
+      object.path.should == path
+    end
+
+    context "Symbol params" do
+      it "should accept identifier values" do
+        type = :foo
+
+        subject.parse(['--type', type.to_s])
+
+        object.type.should == type
+      end
+
+      it "should reject non-identifier values" do
+        lambda {
+          subject.parse(['--type', '10'])
+        }.should raise_error(OptionParser::InvalidArgument)
+      end
+    end
+
+    context "Array params" do
+      it "should merge multiple values together" do
+        name1 = 'foo'
+        name2 = 'bar'
+
+        subject.parse(['--names', name1, '--names', name2])
+
+        object.names.should == [name1, name2]
+      end
+    end
+
+    context "Set params" do
+      it "should merge multiple values together" do
+        id1 = 10
+        id2 = 20
+
+        subject.parse(['--ids', id1.to_s, '--ids', id2.to_s])
+
+        object.ids.should == Set[id1, id2]
+      end
+    end
+
+    context "Hash params" do
+      it "should accept 'key:value' pairs" do
+        hash = {:foo => 1}
+
+        subject.parse(['--mapping', 'foo:1'])
+
+        object.mapping.should == hash
+      end
+      
+      it "should reject non 'key:value' pairs" do
+        lambda {
+          subject.parse(['--mapping', 'foo'])
+        }.should raise_error(OptionParser::InvalidArgument)
+      end
+
+      it "should merge multiple values together" do
+        hash = {:foo => 1, :bar => 2}
+
+        subject.parse(['--mapping', 'foo:1', '--mapping', 'bar:2'])
+
+        object.mapping.should == hash
+      end
+    end
+  end
+end

data/spec/parameters_spec.rb

@@ -36,11 +36,19 @@ describe Parameters do
       subject.param_value(:var_with_default).should == 'thing'
     end
 
-    it "should provide class methods for paremters" do
+    it "should provide class reader/writter methods for paremters" do
       subject.var = 1
       subject.var.should == 1
     end
 
+    it "should provide class ? method to check if the parameter is set" do
+      subject.var = nil
+      subject.var?.should == false
+
+      subject.var = 2
+      subject.var?.should == true
+    end
+
     it "should inherite the super-classes parameters" do
       inherited_class.has_param?(:var).should == true
       inherited_class.has_param?(:child_var).should == true
@@ -111,11 +119,19 @@ describe Parameters do
       subject.param_value(:var_with_default).should == 'thing'
     end
 
-    it "should provide instance methods for parameters" do
+    it "should provide instance reader/writter methods for parameters" do
       subject.var = 2
       subject.var.should == 2
     end
 
+    it "should provide instance ? methods to check if the parameter was set" do
+      subject.var = nil
+      subject.var?.should == false
+
+      subject.var = 2
+      subject.var?.should == true
+    end
+
     it "should set instance variables for paramters" do
       subject.instance_variable_get(:@var_with_default).should == 'thing'
 
@@ -226,6 +242,14 @@ describe Parameters do
       subject.new_param.should == 10
     end
 
+    it "should define ? method to determine if the parameter is set" do
+      subject.new_param = nil
+      subject.new_param?.should == false
+
+      subject.new_param = 10
+      subject.new_param?.should == true
+    end
+
     it "should set the instance variables of parameters" do
       subject.instance_variable_get(:@new_param_with_default).should == 5
 

data/spec/types/array_spec.rb

@@ -14,14 +14,23 @@ describe Parameters::Types::Array do
   end
 
   context "instance" do
-    let(:numbers) { %w[1 2 3] }
+    let(:element_type) { Parameters::Types::Integer }
+    let(:numbers)      { %w[1 2 3]                  }
 
-    subject { described_class.new(Parameters::Types::Integer.new) }
+    subject { described_class.new(element_type) }
 
     it "should have a Ruby type" do
       subject.to_ruby.should == Array[Integer]
     end
 
+    it "should be equal to another Array type with the same element-type" do
+      subject.should == described_class.new(element_type)
+    end
+
+    it "should be related to the Array type" do
+      subject.should < described_class
+    end
+
     describe "#===" do
       it "should check the type of each element" do
         subject.should_not === numbers

data/spec/types/hash_spec.rb

@@ -20,10 +20,20 @@ describe Parameters::Types::Hash do
   end
 
   context "instance" do
+    it "should be related to the Array type" do
+      subject.should < described_class
+    end
+
     context "with key-type" do
-      let(:string_keys) { {'a' => 1, 'b' => 2} }
+      let(:key_type)    { Parameters::Types::Symbol }
+      let(:value_type)  { Parameters::Types::Object }
+      let(:string_keys) { {'a' => 1, 'b' => 2}      }
+
+      subject { described_class.new(key_type,value_type) }
 
-      subject { described_class.new(Parameters::Types::Symbol,Parameters::Types::Object) }
+      it "should be equal to another Hash type with the same key/value types" do
+        subject.should == described_class.new(key_type,value_type)
+      end
 
       it "should have a Ruby type" do
         subject.to_ruby.should == Hash[Symbol => Object]
@@ -45,9 +55,15 @@ describe Parameters::Types::Hash do
     end
 
     context "with value-type" do
-      let(:string_values) { {:a => '1', :b => '2'} }
+      let(:key_type)      { Parameters::Types::Object  }
+      let(:value_type)    { Parameters::Types::Integer }
+      let(:string_values) { {:a => '1', :b => '2'}     }
+
+      subject { described_class.new(key_type,value_type) }
 
-      subject { described_class.new(Parameters::Types::Object,Parameters::Types::Integer) }
+      it "should be equal to another Hash type with the same key/value types" do
+        subject.should == described_class.new(key_type,value_type)
+      end
 
       it "should have a Ruby type" do
         subject.to_ruby.should == Hash[Object => Integer]

data/spec/types/set_spec.rb

@@ -15,14 +15,23 @@ describe Parameters::Types::Set do
   end
 
   context "instance" do
-    let(:numbers) { %w[1 2 3] }
+    let(:element_type) { Parameters::Types::Integer }
+    let(:numbers)      { %w[1 2 3]                  }
 
-    subject { described_class.new(Parameters::Types::Integer.new) }
+    subject { described_class.new(element_type) }
 
     it "should have a Ruby type" do
       subject.to_ruby.should == Set[Integer]
     end
 
+    it "should be equal to another Set type with the same element-type" do
+      subject.should == described_class.new(element_type)
+    end
+
+    it "should be related to the Array type" do
+      subject.should < described_class
+    end
+
     describe "#===" do
       it "should check the type of each element" do
         subject.should_not === numbers

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parameters
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-16 00:00:00.000000000 Z
+date: 2011-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ore-tasks
-  requirement: &14692280 !ruby/object:Gem::Requirement
+  requirement: &23003040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '0.4'
   type: :development
   prerelease: false
-  version_requirements: *14692280
+  version_requirements: *23003040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &14691740 !ruby/object:Gem::Requirement
+  requirement: &23002520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.4'
   type: :development
   prerelease: false
-  version_requirements: *14691740
+  version_requirements: *23002520
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &14691220 !ruby/object:Gem::Requirement
+  requirement: &23002020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '0.7'
   type: :development
   prerelease: false
-  version_requirements: *14691220
+  version_requirements: *23002020
 description: Parameters allows you to add annotated variables to your classes which
   may have configurable default values.
 email: postmodern.mod3@gmail.com
@@ -73,6 +73,8 @@ files:
 - lib/parameters/extensions/meta.rb
 - lib/parameters/extensions/meta/object.rb
 - lib/parameters/instance_param.rb
+- lib/parameters/module_methods.rb
+- lib/parameters/options.rb
 - lib/parameters/param.rb
 - lib/parameters/parameters.rb
 - lib/parameters/types.rb
@@ -101,9 +103,11 @@ files:
 - spec/classes/custom_type.rb
 - spec/classes/inherited_parameters.rb
 - spec/classes/module_parameters.rb
+- spec/classes/option_parameters.rb
 - spec/classes/other_parameters.rb
 - spec/classes/test_parameters.rb
 - spec/instance_param_spec.rb
+- spec/options_spec.rb
 - spec/parameters_spec.rb
 - spec/spec_helper.rb
 - spec/types/array_spec.rb
@@ -151,6 +155,7 @@ summary: Allows you to add annotated variables to your classes
 test_files:
 - spec/class_param_spec.rb
 - spec/instance_param_spec.rb
+- spec/options_spec.rb
 - spec/parameters_spec.rb
 - spec/types/array_spec.rb
 - spec/types/boolean_spec.rb