methodic 0.2 → 1.1

data/AUTHORS

@@ -0,0 +1,8 @@
+Author : 
+  Romain GEORGES <romain@ultragreen.net>
+        - code
+	- inline documentation
+	- specs
+	- Documentation
+Ruby Gem maintener : 
+  Romain GEORGES <romain@ultragreen.net>

data/COPYRIGHT

@@ -0,0 +1,24 @@
+methodic Copyright (c) 2012 Ultragreen Software, Romain GEORGES
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ 
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+ 

data/ChangeLog

@@ -0,0 +1,17 @@
+methodic :
+- initial dev. version
+ - version 0.1 (unstable)
+	Romain GEORGES
+- initial finished release
+ - version 0.2 (testing, released)
+	Romain GEORGES
+- documented, specified and tested first production release
+ - version 1.0 (RC)
+	Romain GEORGES
+   - WARN : DEPRECATED : (NO COMPATIBILITY) method #specify_default_value_of become #specify_default_value
+   - WARN : DEPRECATED : (NO COMPATIBILITY) method #specify_defaults_values_of become #specify_defaults_values
+   - NEW : validate_known_options flag in Mehodic::get_options (second args)
+   - NEW : #specify_known_option and #specify_known_options for exhaustive options control (see manual)
+- patched version
+ - version 1.1 (RC2)
+	Romain GEORGES

data/Gemfile

@@ -4,4 +4,5 @@ gem "rspec", :require => "spec"
 gem "rake"
 gem "yard"
 gem "rdoc"
-gem "rcov"
+gem "rcov"
+gem "roodi"

data/Gemfile.lock

@@ -7,6 +7,8 @@ GEM
     rcov (1.0.0)
     rdoc (3.12)
       json (~> 1.4)
+    roodi (2.2.0)
+      ruby_parser (~> 2.3.0)
     rspec (2.9.0)
       rspec-core (~> 2.9.0)
       rspec-expectations (~> 2.9.0)
@@ -15,6 +17,9 @@ GEM
     rspec-expectations (2.9.0)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.9.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.2.0)
     yard (0.7.5)
     yard-rspec (0.1)
       yard
@@ -26,6 +31,7 @@ DEPENDENCIES
   rake
   rcov
   rdoc
+  roodi
   rspec
   yard
   yard-rspec

data/INSTALL

@@ -0,0 +1,7 @@
+How to install methodic ?
+=========================
+
+Please install the gem version via RubyGems : 
+
+$ su -
+# gem ins methodic

data/Rakefile

@@ -9,6 +9,15 @@ require 'code_statistics'
 require 'rspec/core/rake_task'
 require 'yard'
 require 'yard/rake/yardoc_task.rb'
+require "rake/tasklib"
+require "roodi"
+require "roodi_task"
+ 
+ 
+RoodiTask.new() do | t |
+t.patterns = %w(lib/**/*.rb spec/**/*.rb features/**/*.rb)
+t.config = "ultragreen_roodi_coding_convention.yml"
+end
 
 
 CLEAN.include('*.tmp','*.old')

data/doc/manual.rdoc

@@ -1 +1,71 @@
 =Methodic
+
+== Content
+
+Author:: Romain GEORGES <romain@ultragreen.net> 
+Version:: 1.2
+WWW:: http://www.ultragreen.net/projects/methodic
+
+== Description 
+
+Methodic is a macro-like utility to help test, validate, control options passed by an Hash param to a method, it could help you to merge with defaults values, 
+It raise explained exceptions and return false if the validations steps failed.
+
+== Installation
+
+In a valid Ruby environment :
+
+   $ sudo zsh
+   # gem ins methodic
+
+== Implementation 
+
+* [Methodic]
+* [Methodic::Options]
+
+== Example
+
+=== Without known options control
+
+  require 'rubygems'                                                                                                                                                                             
+  require 'methodic'
+  [...]                                                                                                                                                                                          
+  # in a method                                                                                                                                                                                  
+  def amethod ( _options = {})                                                                                                                                                                   
+    myOptions = Methodic::get_options(_options) do |m|                                                                                                                                           
+      m.specify_default_value_of :country => 'France'                                                                                                                                            
+      m.specify_classes_of :name => String, :surname => String, :age => Fixnum, :country => String                                                                                               
+      m.specify_presence_of :name                                                                                                                                                                
+      m.specify_presence_of :surname                                                                                                                                                             
+      m.specify_formats_of :name => /\w+/, :surname => /\w+/, :country => /\w+/                                                                                                                  
+      m.merge!                                                                                                                                                                                   
+    end                                                                                                                                                                                          
+    # processing method                                                                                                                                                                          
+  end                                                                                                                                                                                    
+  [...]  
+
+=== With known options control
+
+  require 'rubygems'                                                                                                                                                                             
+  require 'methodic'
+  [...]                                                                                                                                                                                          
+  # in a method                                                                                                                                                                                  
+  def amethod ( _options = {})                                                                                                                                                                   
+    myOptions = Methodic::get_options(_options,true) do |m|
+      # all others definitions MUST be included in known options list (explained in Spec), so :                                                                                                             m.specify_known_options [:country,:name,:surname, :age]          
+      m.specify_default_value_of :country => 'France'                                                                                                                                            
+      m.specify_classes_of :name => String, :surname => String, :age => Fixnum, :country => String                                                                                               
+      m.specify_presence_of :name                                                                                                                                                                
+      m.specify_presence_of :surname                                                                                                                                                             
+      m.specify_formats_of :name => /\w+/, :surname => /\w+/, :country => /\w+/                                                                                                                  
+      m.merge!                                                                                                                                                                                   
+    end                                                                                                                                                                                          
+    # processing method                                                                                                                                                                          
+  end                                                                                                                                                                                    
+  [...]  
+
+
+== Copyright
+
+<pre>Methodic (c) 2012 Romain GEORGES <romain@ultragreen.net> for Ultragreen Software </pre>
+

data/lib/methodic.rb

@@ -1,64 +1,260 @@
+#!/usr/bin/env ruby
+# Copyright Ultragreen (c) 2012
+#---
+# Author : Romain GEORGES 
+# type : gem component library 
+# obj : Methodic Module
+#---
 
+# module Methodic 
+# @author Romain GEORGES <romain@ultragreen.net>
+# @see http://www.ultragreen.net/projects/methodic
+# @version 0.2
+# @note this module include a class, but please use the module method Methodic::get_options to Build a Methodic::Options instance
+# @example Complete usage 
+#    require 'rubygems'
+#    require 'methodic'
+#    [...]
+#    # in a method
+#    def amethod ( _options = {})
+#      myOptions = Methodic::get_options(_options,true) do |m|
+#        m.specify_known_options [:country,:name,:surname,:age]
+#        m.specify_default_value :country => 'France'
+#        m.specify_classes_of :name => String, :surname => String, :age => Fixnum, :country => String
+#        m.specify_presence_of :name
+#        m.specify_presence_of :surname
+#        m.specify_formats_of :name => /\w+/, :surname => /\w+/, :country => /\w+/
+#        m.merge
+#      end
+#      # processing method
+#    end
+#    [...]
 module Methodic
+
+  # class Options
+  # an Options utility class
+  # @note please do not instantiate with Options::new use Methodic::get_options
+  # @example Complete usage 
+  #    require 'rubygems'
+  #    require 'methodic'
+  #    [...]
+  #    # in a method
+  #    def amethod ( _options = {})
+  #      myOptions = Methodic::get_options(_options,true) do |m|
+  #        m.specify_known_options [:country,:name,:surname,:age]
+  #        m.specify_default_value :country => 'France'
+  #        m.specify_classes_of :name => String, :surname => String, :age => Fixnum, :country => String
+  #        m.specify_presence_of :name
+  #        m.specify_presence_of :surname
+  #        m.specify_formats_of :name => /\w+/, :surname => /\w+/, :country => /\w+/
+  #        m.merge
+  #      end
+  #      # processing method
+  #    end
+  #    [...]
   class Options < Hash
+
+    # @example writing
+    #   myOptions = Methodic::get_options(options)
+    #   myOptions.known = [:name]
+    #   myOptions.known.push :surname
+    # @example reading
+    #   p myOptions.known 
+    #   => [ :name, :surname ]
+    # @attr [Hash] the list of all options assumed for a method 
+   attr_accessor :known
     
-    attr_accessor :classes
+    # @example writing
+    #   myOptions = Methodic::get_options(options)
+    #   myOptions.classes = {:name => String }
+    #   myOptions.classes[:surname] = String
+    # @example reading
+    #   p myOptions.classes 
+    #   => { :name => String, :surname => String }
+    # @attr [Hash] classes a hash table of some options associated with their corresponding types or classes
+   attr_accessor :classes
+
+    # @attr [Array] mandatories the full list of mandatories options
+    # @example writing
+    #   myOptions = Methodic::get_options(options)
+    #   myOptions.mandatories = [:name]
+    #   myOptions.mandatories.push :surname
+    # @example reading
+    #   p myOptions.mandatories 
+    #   => [ :name, :surname ]
     attr_accessor :mandatories
+
+    # @attr [Hash] defaults a hash table of some options with defaults values
+    # @example writing
+    #   myOptions = Methodic::get_options(options)
+    #   myOptions.defaults = {:name => 'John' }
+    #   myOptions.defaults[:surname] = 'Doe'
+    # @example reading
+    #   p myOptions.defaults 
+    #   => { :name => 'John', :surname => 'Doe' }
     attr_accessor :defaults
+
+    # @attr [Hash] formats a hash table of some options with their corresponding
+    # @example writing
+    #   myOptions = Methodic::get_options(options)
+    #   myOptions.formats = {:name => /\w+/ }
+    #   myOptions.defaults[:surname] = /\w+/
+    # @example reading
+    #   p myOptions.defaults 
+    #   => { :name => /\w+/, :surname => /\w+/ }
     attr_accessor :formats
     
-    def initialize(_options = {})
+    # initializer for [Options]
+    # @note please do not use standalone, build from module method Methodic::get_options
+    # @param [Hash] _options the options hash (define for the method you would prototype)
+    # @note _options keys must be symbols
+    # @example prototype for informational only
+    #   Methodic::Options::new({:toto => 'titi', :tutu => 'tata'})
+    # @return [Options] self
+    def initialize(_options = {},_validate_known_options = false)
+
+      raise ArgumentError::new('Argument _options must be a Hash') unless _options.class == Hash or _options.class == Methodic::Options # ;) reintrance and cascading
+      raise ArgumentError::new('keys must be Symbol') unless _options.keys.select{|i| i.class == Symbol }.size ==  _options.keys.size 
       self.replace _options
       @defaults = Hash::new
       @formats = Hash::new
       @classes = Hash::new
+      @known = Array::new
       @mandatories = Array::new
+      @validate_known_options = _validate_known_options
+      yield self if block_given?
     end
     
+
+    # read only accessor on the [Hash] slef keys
+    # @return [Array] self.keys the keys of The Options object itself
+    # @example usage
+    #   options = {:name => 'Doe', :surname => 'John'}
+    #   p myOptions = Methodic::get_options(options)
+    #   => { :name => String, :surname => String }
+    #   p myOptions.options 
+    #   => [:name, :surname]
     def options 
-      return @classes.keys
+      return self.keys
     end
 
-    def specify_default_value_of(values)
+    
+    # pretty accessor for specifying the default(s) value(s)  for options
+    # @param [Hash] values a value definition, keys are symbols
+    # @return [hash] @defaults merged with values
+    # @example usage
+    #    myOptions = Methodic::get_options(_options)
+    #    myOptions.specify_default_value :name => 'Doe'
+    #    myOptions.specify_defaults_values :name => 'Doe', :surname => 'John'
+    def specify_default_value(values)
       @defaults.merge! values
-    end
-    alias :specify_defaults_values_of :specify_default_value_of
+      return @defaults
+   end
+    alias :specify_defaults_values :specify_default_value
     
+    # pretty accessor for specifying classes of options
+    # @param [Hash] values a value definition, keys are symbols
+    # @return [hash] @classes merged with values
+    # @note classes must be precised in Ruby not a string like Fixnum, Hash, Array, String
+    # @example usage
+    #    myOptions = Methodic::get_options(_options)
+    #    myOptions.specify_class_of :name => String
+    #    myOptions.specify_classes_of :name => String, :surname => String
     def specify_class_of(values)
+
       @classes.merge! values
+
+      return @classes
+
     end
     alias :specify_classes_of :specify_class_of
     
+    # pretty accessor for specifying mandatories options
+    # @param [Array] values a Array of symbols or a unique symbol
+    # @return [Array] @mandatories merged with values
+    # @example usage
+    #    myOptions = Methodic::get_options(_options)
+    #    myOptions.specify_presence_of :name 
+    #    myOptions.specify_presences_of [ :name, :surname ]
     def specify_presence_of(values) 
       @mandatories << values
       @mandatories.flatten!
+      @mandatories.uniq!
+      return @mandatories 
     end
     alias :specify_presences_of :specify_presence_of
+
+
+    # pretty accessor for specifying known options
+    # @param [Array] values a Array of symbols or a unique symbol
+    # @return [Array] @known merged with values
+    # @example usage
+    #    myOptions = Methodic::get_options(_options)
+    #    myOptions.specify_known_option :name 
+    #    myOptions.specify_known_options [ :name, :surname ]
+    def specify_known_option(values) 
+      @known << values
+      @known.flatten!
+      @known.uniq!
+      return @known 
+    end
+    alias :specify_known_options :specify_known_option
     
+    # pretty accessor for specifying the format of options
+    # @param [Hash] values a value definition, keys are symbols
+    # @return [hash] @formats merged with values
+    # @note formats must be Regular Expression
+    # @example usage
+    #    myOptions = Methodic::get_options(_options)
+    #    myOptions.specify_format_of :name => /\w+/
+    #    myOptions.specify_formats_of :name => /\w+/, :surname => /\w+/
     def specify_format_of(values)
       @formats.merge! values
+      return @formats
     end
     alias :specify_formats_of :specify_format_of
     
+    # pretty accessor for specifying condition for options
+    # @todo implementation of conditions
     def specify_condition_for
       raise NotYetImplemented
     end
     alias :specify_conditions_for :specify_condition_for
     
+    # default values merge method 
+    # merge @defaults with self 
+    # @return [self|Options]
+    # @example usage
+    #    myOptions = Methodic::get_options(:name = 'Walker')
+    #    myOptions.specify_default_value_of :surname => 'John'
+    #    p myOptions                                                                                                                                                                                  
+    #      # =>{:surname=>"John", :name=>"Doe"}
+    #    myOptions.merge
+    #    p myOptions
+    #      # =>{:surname=>"John", :name=>"Walker"} 
     def merge_with_defaults
-      self.replace(@defaults.merge self)
+      self.replace( @defaults.merge self)
+      return self
     end
-    
+    alias :merge :merge_with_defaults
+    # Validation method for options, start the validation for classes, options, formats, presences
+    # @return [true|false] if validations failed or succeed
+    # @raise ArgumentError for each kind of validations, that could failed
+    # @note order for validation and Exception raising : Options inclusion >> Classes matching >> Mandatories Options presences >> Formats matching
     def validate
       table = []
-      table.push validate_options_and_classes unless @classes.empty?
-      table.push validate_formats unless @formats.empty?
+      raise ArgumentError::new("Option : known list of options empty.") and return false if @known.empty? and @validate_known_options
+      table.push validate_known_options if @validate_known_options
+      table.push validate_classes unless @classes.empty?
       table.push validate_presences unless @mandatories.empty?
+      table.push validate_formats unless @formats.empty?
+
       return true unless table.include?(false) 
     end
     alias :validate! :validate
     
     private
+    # private method for the formats validation step
     def validate_formats
       self.each do |option,value|
         if @formats.key? option then
@@ -69,6 +265,24 @@ module Methodic
       return true
     end
 
+    # private method for known options validation step
+    def validate_known_options
+      @mandatories.each do |mdt|
+        raise ArgumentError::new("Mandatories options :#{mdt} is not a known options") and return false unless @known.include?(mdt)
+      end
+      @classes.each do |aclass,value|
+        raise ArgumentError::new("Classes definition :#{aclass} => #{value} is not a known options") and return false unless @known.include?(aclass)
+      end
+      @formats.each do |format,value|
+        raise ArgumentError::new("Formats definition :#{format} => #{value} is not a known options") and return false unless @known.include?(format)
+      end
+      @defaults.each do |default,value|
+        raise ArgumentError::new("Defaults value definition :#{default} => #{value} is not a known options") and return false unless @known.include?(default)
+      end
+      return true
+    end
+
+    # private method for mandatories presence validation step
     def validate_presences
       @mandatories.each do |mdt|
         raise ArgumentError::new("Missing option : #{mdt}") and return false unless self.include?(mdt)
@@ -76,15 +290,29 @@ module Methodic
       return true
     end
     
-    def validate_options_and_classes
-      self.each do |option,value|
-        raise ArgumentError::new("Unknown option : #{option}") and return fasle unless @classes.include?(option)
-        raise ArgumentError::new("Option : #{option} type mismatch must be a #{@classes[option]}") and return false unless value.class == @classes[option]
+    # private method for classes validation step
+    def validate_classes
+      @classes.each do |option,value|
+        raise ArgumentError::new("Option : #{option} type mismatch must be a #{value}") and return false unless self[option].class == value
       end
       return true
     end
   end
-  def Methodic::get_options(_options = {})
-    return Methodic::Options::new(_options)
+
+  # Module method factory to build [Options] instance
+  # @return [Options] instance
+  # @param [Hash] _options the options [Hash] from the method, you want to prototype
+  # @example usage
+  #  myOptions = Methodic::get_options({:foo => 'bar'})
+  #  p myOptions.class
+  #  => Options
+  # @note _options key must be symbols
+  def Methodic::get_options(_options = {},_validate_known_options=false)
+    return Methodic::Options::new(_options,_validate_known_options)
   end
+ 
+  # Exception Class for not yet implemented methods Exceptions
+  class NotYetImplemented < Exception; end
+
+
 end

data/methodic.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = %q{methodic}
   s.author = "Romain GEORGES"
-  s.version = "0.2"
-  s.date = %q{2012-03-21}
+  s.version = "1.1"
+  s.date = %q{2013-02-14}
   s.summary = %q{Methodic : Hash table options specification and validation componant}
   s.email = %q{romain@ultragreen.net}
   s.homepage = %q{http://www.ultragreen.net}
@@ -12,6 +12,7 @@ Gem::Specification.new do |s|
   s.bindir = nil
   s.required_ruby_version = '>= 1.8.1'
   s.add_development_dependency "rspec", ">= 2.0.0"
-  s.rdoc_options << '--title' << 'Methodic : Ge�m documentation' << '--main' << 'doc/manual.rdoc' << '--line-numbers' << '--diagram'
+  s.rdoc_options << '--title' << 'Methodic : Gem documentation' << '--main' << 'doc/manual.rdoc' << '--line-numbers' 
+  # << '--diagram'
   s.rubyforge_project = "nowarning"
 end

data/spec/methodic_spec.rb

@@ -0,0 +1,363 @@
+require'rubygems'
+require'rspec'
+require 'lib/methodic'
+
+describe Methodic do
+ 
+  before :all do
+    $test_methodic_options = Methodic::get_options :name => 'Doe', :surname => 'John'
+    $test_methodic_options_with_known_options = Methodic::get_options({:name => 'Doe', :surname => 'John'},true)
+  end
+  before :each do 
+    $test_methodic_options.mandatories = []
+    $test_methodic_options.formats = {}
+    $test_methodic_options.defaults = {}
+    $test_methodic_options.classes = {}
+  end
+  subject { Methodic }
+  specify { subject.should be_an_instance_of Module}
+  context Methodic::Options do 
+    subject { Methodic::Options }
+    specify { subject.should be_an_instance_of Class }
+    it "should respond to all methods of a Hash" do
+      Hash::new.methods.each do |method|
+        $test_methodic_options.should respond_to(method)
+      end
+    end
+    context "#new(_options) (initialization)" do
+      context "Exception case" do
+         it "should raise ArgumentError if _options is not a Hash" do
+           [ 'a string', 12 ,Array::new,true,false].each do |item|
+             lambda{ Methodic::Options::new(item)}.should raise_error ArgumentError
+           end
+         end
+        it "should not raise ArgumentError if no arg is passed to initializer" do
+          lambda{ Methodic::Options::new}.should_not raise_error 
+        end
+        it "should not raise ArgumentError if an Hash arg is passed to initializer" do
+          lambda{ Methodic::Options::new  :name => 'Doe' }.should_not raise_error
+        end
+        it "should raise ArgumentError if an Hash arg is passed to initializer but with keys different of Symbol" do
+          lambda{ Methodic::Options::new 'titi' => 'tutu'}.should raise_error ArgumentError 
+        end
+        it "should not raise ArgumentError if two arg is passed to initializer, second arg has a boolean value, must be object" do
+          lambda{ Methodic::Options::new({:name => 'Doe'},true) }.should_not raise_error ArgumentError
+        end
+
+        it "should raise ArgumentError if more than two arg is passed to initializer" do
+          lambda{ Methodic::Options::new({:name => 'Doe'},{:surname => 'John'},true) }.should raise_error ArgumentError
+        end
+        
+      end
+
+    end
+    context "Instance Attributs" do
+      context "#classes R/W" do
+        it { $test_methodic_options.should respond_to("classes") }
+        it { $test_methodic_options.should respond_to("classes=") }
+
+        it "should be true that #classes must return a Hash" do 
+          $test_methodic_options.classes.class.should eq(Hash)
+        end
+        it "#classes[] affectation must be possible and #classes must respond this affectation" do
+          $test_methodic_options.classes[:test] = String
+          $test_methodic_options.classes.should eq({:test => String})
+        end
+        
+      end
+      context "#defaults R/W" do
+        it { $test_methodic_options.should respond_to("defaults") }
+        it { $test_methodic_options.should respond_to("defaults=") }
+        
+        it "should be true that #defaults must return a Hash" do
+          $test_methodic_options.defaults.class.should eq(Hash)
+        end
+        it "#defaults[] affectation must be possible and #defaults must respond this affectation" do
+          $test_methodic_options.defaults[:test] = "value"
+          $test_methodic_options.defaults.should eq({ :test => "value"})
+        end
+      end
+
+      context "#formats R/W" do
+        it { $test_methodic_options.should respond_to("formats") }
+        it { $test_methodic_options.should respond_to("formats=") }
+        
+        it "should be true that #formats must return a Hash" do
+            $test_methodic_options.formats.class.should eq(Hash)
+        end
+        it "#formats[] affectation must be possible and #formats must respond this affectation" do
+          $test_methodic_options.formats[:test] = '.*' 
+          $test_methodic_options.formats.should eq({ :test => '.*' })
+        end
+      end
+
+      context "#mandatories R/W" do
+        it { $test_methodic_options.should respond_to("mandatories") }
+        it { $test_methodic_options.should respond_to("mandatories=") }
+
+        it "should be true that #mandatories must return a Array" do
+            $test_methodic_options.mandatories.class.should eq(Array)
+        end
+        it "#mandatories.push affectation must be possible and #mandatories must respond this affectation" do
+          $test_methodic_options.mandatories.push :test
+          $test_methodic_options.mandatories.should eq([:test])
+        end
+      end
+      context "#known R/W" do
+        it { $test_methodic_options.should respond_to("known") }
+        it { $test_methodic_options.should respond_to("known=") }
+        
+        it "should be true that #known must return a Array" do
+            $test_methodic_options.known.class.should eq(Array)
+        end
+        it "#known.push affectation must be possible and #known must respond this affectation" do
+          $test_methodic_options.known.push :test
+          $test_methodic_options.known.should include :test
+        end
+      end
+    end
+    context "Instance methods" do
+      
+      context "#options" do
+        it { $test_methodic_options.should respond_to("options") }
+        it "should be true that #options must return a Array" do
+          $test_methodic_options.options.class.should eq(Array)
+        end
+        it "should respond an Array of options keys" do
+          $test_methodic_options.options.each do |item|
+            [:name,:surname].should include item
+          end 
+        end
+      end
+      
+      context "#specify_default_value" do
+        it { $test_methodic_options.should respond_to("specify_default_value") }
+        it { $test_methodic_options.should respond_to("specify_defaults_values") }    
+        it "should merge default value hash record in defaults attribut" do
+
+          $test_methodic_options.specify_default_value :test => 'value'
+          $test_methodic_options.defaults[:test].should eq 'value'
+          $test_methodic_options.defaults.count.should eq 1
+        end
+        it "should redefine a new default value for a previous key" do 
+          $test_methodic_options.specify_default_value :test => 'value'
+          $test_methodic_options.defaults[:test].should eq 'value'
+          $test_methodic_options.specify_default_value :test => 'newvalue'
+          $test_methodic_options.defaults[:test].should eq 'newvalue'
+        end
+      end
+      
+      context "#specify_class_of" do 
+        it { $test_methodic_options.should respond_to("specify_class_of") }
+        it { $test_methodic_options.should respond_to("specify_classes_of") }
+        it "should merge class hash record in classes attribut" do
+
+          $test_methodic_options.specify_class_of :test => String
+          $test_methodic_options.classes[:test].should eq String
+          $test_methodic_options.classes.count.should eq 1
+        end
+        it "should redefine a new class value for a previous key" do
+          $test_methodic_options.specify_class_of :test => String
+          $test_methodic_options.classes[:test].should eq String
+          $test_methodic_options.specify_class_of :test => Integer
+          $test_methodic_options.classes[:test].should eq Integer
+
+        end
+      end
+
+
+
+
+
+      context "#specify_condition_for" do
+        it { $test_methodic_options.should respond_to("specify_condition_for") }
+        it { $test_methodic_options.should respond_to("specify_conditions_for") }
+        it { lambda{ $test_methodic_options.specify_condition_for}.should raise_error Methodic::NotYetImplemented }
+      end
+
+      context "#specify_format_of" do
+        it { $test_methodic_options.should respond_to("specify_format_of") }
+        it { $test_methodic_options.should respond_to("specify_formats_of") }
+        it "should merge format hash record in formats attribut" do
+          $test_methodic_options.formats = {}
+          $test_methodic_options.specify_format_of :test => '.*'
+          $test_methodic_options.formats[:test].should eq '.*'
+          $test_methodic_options.formats.count.should eq 1
+        end
+        it "should redefine a new format value for a previous format key" do
+          $test_methodic_options.specify_format_of :test => '.*'
+          $test_methodic_options.formats[:test].should eq '.*'
+          $test_methodic_options.specify_format_of :test => '\d*'
+          $test_methodic_options.formats[:test].should eq '\d*' 
+        end
+      end
+
+      context "#specify_presence_of" do
+        it { $test_methodic_options.should respond_to("specify_presence_of") }
+        it { $test_methodic_options.should respond_to("specify_presences_of") }
+        it "should merge presence Array record in mandatories attribut" do
+          $test_methodic_options.specify_presence_of :test
+          $test_methodic_options.mandatories.should include(:test)
+          $test_methodic_options.mandatories.count.should eq 1
+          $test_methodic_options.specify_presence_of :test
+          $test_methodic_options.mandatories.should include(:test)
+          $test_methodic_options.mandatories.count.should eq 1
+        end
+      end
+
+      context "#specify_known_option" do
+        it { $test_methodic_options.should respond_to("specify_known_option") }
+        it { $test_methodic_options.should respond_to("specify_known_options") }
+        it "should merge known Array record in known attribut" do
+          $test_methodic_options.specify_known_option :test
+          $test_methodic_options.known.should include(:test)
+          $test_methodic_options.known.count.should eq 1
+          $test_methodic_options.specify_known_option :test
+          $test_methodic_options.known.should include(:test)
+          $test_methodic_options.known.count.should eq 1
+        end
+      end
+
+      context "#validate" do
+        
+        it { $test_methodic_options.should respond_to("validate") }
+        it { $test_methodic_options.should respond_to("validate!") }
+        
+        
+        context "1/ validate known options" do
+          context "@validate_known_options = false (default)" do            
+            it "should not raise ArgumentError if mandatories is not fully include in the known options list" do
+              $test_methodic_options.known = []
+              $test_methodic_options.specify_presences_of [ :name, :surname]
+              $test_methodic_options.specify_known_options [ :surname]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should not raise ArgumentError if an option in options list not in the known options list" do
+              $test_methodic_options.known = []
+              $test_methodic_options.specify_known_options [ :surname ]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should not raise if all given options in options list is in known options " do
+              $test_methodic_options.known = []
+              $test_methodic_options.specify_known_options [ :name, :surname, :optional ]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should not raise ArgumentError if formats made a reference to an unknown options" do
+              $test_methodic_options.known = []
+              $test_methodic_options.specify_format_of :nickname => /.*/
+              $test_methodic_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should not raise ArgumentError if classes made a reference to an unknown options" do
+              $test_methodic_options.known = []
+              $test_methodic_options[:nickname] = 'Jeedoe'
+              $test_methodic_options.specify_class_of :nickname => String
+              $test_methodic_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should not raise ArgumentError if default made a reference to an unknown options" do
+              $test_methodic_options.known = []
+              $test_methodic_options.specify_default_value :nickname => 'Jeedoe'
+              $test_methodic_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+            end
+
+          end
+          context "@validate_known_options = true" do            
+            it "should raise ArgumentError if mandatories is not fully include in the known options list" do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options.specify_presences_of [ :name, :surname ]
+              $test_methodic_options_with_known_options.specify_known_options [ :surname ]
+              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+            end
+            it "should raise ArgumentError if an option in options list not in the known options list" do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options.specify_known_options [ :surname]
+              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+            end
+            it "should not raise if all given options in options list is in known options " do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options.specify_known_options [ :name, :surname,:optional]
+              lambda{$test_methodic_options_with_known_options.validate!}.should_not raise_error ArgumentError
+            end
+            it "should raise ArgumentError if formats made a reference to an unknown options" do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options.specify_format_of :nickname => /.*/
+              $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+            end
+            it "should raise ArgumentError if classes made a reference to an unknown options" do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options[:nickname] = 'Jeedoe'
+              $test_methodic_options_with_known_options.specify_class_of :nickname => String
+              $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+            end
+            it "should raise ArgumentError if default made a reference to an unknown options" do
+              $test_methodic_options_with_known_options.known = []
+              $test_methodic_options_with_known_options.specify_default_value :nickname => 'Jeedoe'
+              $test_methodic_options_with_known_options.specify_known_options [ :surname, :name ]
+              lambda{$test_methodic_options_with_known_options.validate!}.should raise_error ArgumentError
+            end
+            
+          end
+          
+        end
+
+        context "2/ validate classes" do
+          it "should raise ArgumentError if an options don't match a class definition" do 
+            $test_methodic_options.specify_classes_of :name => Integer, :surname => String
+            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError 
+
+          end
+          it "should not raise if options match class definition" do 
+            $test_methodic_options.specify_classes_of :name => String, :surname => String
+            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError 
+          end
+        end
+        context "3/ validate mandatories" do
+          it "should raise ArgumentError if a mandatory option not in options list" do
+            $test_methodic_options.specify_presences_of [ :name , :surname, :nickname, :age ]
+            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError
+
+          end
+          it "should not raise if mandatory options and options list match" do
+            $test_methodic_options.specify_presences_of [ :name , :surname ]
+            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+          end
+        end
+        context "4/ validate formats" do
+          it "should raise ArgumentError if an option in options list not have the good registered formats" do
+            $test_methodic_options.specify_formats_of :name => /.*/, :surname => /toto.*/
+            lambda{$test_methodic_options.validate!}.should raise_error ArgumentError
+
+          end
+          it "should not raise if all options in options list match formats definitions " do
+            $test_methodic_options.specify_formats_of :name => /.*/, :surname => /.*/
+            lambda{$test_methodic_options.validate!}.should_not raise_error ArgumentError
+          end
+        end
+
+
+      end 
+      context "#merge_with_defaults" do
+        it { $test_methodic_options.should respond_to("merge_with_defaults") }
+        it { $test_methodic_options.should respond_to("merge") }
+        it "should merge defaults values and don't override with options" do 
+          $test_methodic_options.specify_defaults_values :name => 'Smith', :surname => 'Paul', :nickname => 'Jeedoe'
+          $test_methodic_options.merge_with_defaults
+          $test_methodic_options[:name].should eq "Doe"
+          $test_methodic_options[:surname].should eq "John"
+          $test_methodic_options[:nickname].should eq "Jeedoe"
+
+        end
+      end
+    end
+  end
+  context "Methodic::get_options" do
+    it "should return a Methodic::Options Object" do
+      Methodic::get_options({:name => 'Doe', :surname => 'John'}).should be_an_instance_of Methodic::Options
+    end
+  end
+  
+end  

data/ultragreen_roodi_coding_convention.yml

@@ -0,0 +1,25 @@
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:             
+  line_count: 300
+ClassNameCheck:                  
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+#ClassVariableCheck:
+CyclomaticComplexityBlockCheck:  
+  complexity: 4
+CyclomaticComplexityMethodCheck: 
+  complexity: 10
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:            
+  line_count: 30 
+MethodNameCheck:                 
+  pattern: !ruby/regexp /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ 
+# MissingForeignKeyIndexCheck:
+ModuleLineCountCheck:            
+  line_count: 500
+ModuleNameCheck:          
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:            
+  parameter_count: 5
+ 

metadata

@@ -1,12 +1,11 @@
 --- !ruby/object:Gem::Specification 
 name: methodic
 version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: 
+  prerelease: false
   segments: 
-  - 0
-  - 2
-  version: "0.2"
+  - 1
+  - 1
+  version: "1.1"
 platform: ruby
 authors: 
 - Romain GEORGES
@@ -14,18 +13,16 @@ autorequire:
 bindir: 
 cert_chain: []
 
-date: 2012-03-21 00:00:00 +01:00
+date: 2013-02-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
         - 2
         - 0
@@ -46,10 +43,16 @@ files:
 - lib/methodic.rb
 - spec/init_spec.rb
 - spec/spec_helper.rb
+- spec/methodic_spec.rb
 - Gemfile
 - Gemfile.lock
 - methodic.gemspec
 - Rakefile
+- COPYRIGHT
+- INSTALL
+- AUTHORS
+- ChangeLog
+- ultragreen_roodi_coding_convention.yml
 has_rdoc: true
 homepage: http://www.ultragreen.net
 licenses: []
@@ -57,37 +60,32 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- "Methodic : Ge\xC3m documentation"
+- "Methodic : Gem documentation"
 - --main
 - doc/manual.rdoc
 - --line-numbers
-- --diagram
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 53
       segments: 
       - 1
       - 8
       - 1
       version: 1.8.1
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: nowarning
-rubygems_version: 1.4.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: "Methodic : Hash table options specification and validation componant"