methlab 0.0.5 → 0.0.6

data/README

@@ -139,6 +139,7 @@ consequences.
   (e.g., "def foo(&block)"). Proc can be used now, but it's
   not very "rubyish" syntax for the user.
 * Better handling in Modules (def self.meth(...))
+* Default values
 
 === THANKS
 --------

data/Rakefile

@@ -63,3 +63,7 @@ task :build => [:gem, :repackage]
 task :distclean => [:clobber_package, :clobber_rdoc]
 desc "Clean the source tree"
 task :clean => [:distclean]
+
+task :to_blog => [:clobber_rdoc, :rdoc] do
+    sh "rm -r $git/blog/content/docs/methlab && mv rdoc $git/blog/content/docs/methlab"
+end

data/lib/methlab.rb

@@ -48,6 +48,10 @@
 #     * Returning false/nil will raise a generic error.
 #     * Returning a new exception object (e.g., ArgumentError.new) will raise your error as close to the call point as possible.
 #     * Raising yourself will raise in the validation routine, which will probably be confusing. Please use the above method.
+#   * A symbol is a pragma that implies a constraint -- see below.
+#   * A hash is a way of specifying a pragma (or check) with a parameter:
+#     * :respond_to calls Object#respond_to? on the method named as the value (a symbol) 
+#     * :default specifies a default argument. This is still checked, so get it right!
 # * If you need more than one constraint per parameter, enclose these constraints within an array.
 # * Depending on the type of method you're constructing, there will be additional constraints both implied and explictly allowed:
 #   * named methods do not require any items by default, they must be specified as required.
@@ -55,7 +59,7 @@
 #
 module MethLab
 
-    VERSION = "0.0.5"
+    VERSION = "0.0.6"
 
     # Integrates MethLab into all namespaces. It does this by patching itself
     # into ::main and Module.
@@ -67,6 +71,51 @@ module MethLab
         ::Module.send(:include, self)
     end
 
+    # internal, please do not use directly.
+    #
+    # used to set defaults on parameters that require one
+    def self.set_defaults(signature, params, kind=:array)
+        params = params[0] if kind == :hash
+
+        signature.each_with_index do |value, index|
+            case kind
+            when :array
+                if value.kind_of?(Array)
+                    if hashes = value.find_all { |x| x.kind_of?(Hash) } and !hashes.empty?
+                        hashes.each do |hash|
+                            if hash.has_key?(:default) and (params.length - 1) < index
+                                params[index] = hash[:default]
+                            end
+                        end
+                    end
+                end
+            when :hash
+                if value[1].kind_of?(Array)
+                    if hashes = value[1].find_all { |x| x.kind_of?(Hash) } and !hashes.empty?
+                        hashes.each do |hash|
+                            if hash.has_key?(:default) and !params.has_key?(value[0]) 
+                                params[value[0]] = hash[:default]
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+    
+    # internal, please do not use directly.
+    #
+    # used to perform our standard checks that are supplied via hash.
+    def self.check_hash_types(value_key, value_value, value, key)
+        case value_key
+        when :respond_to
+            unless value.respond_to?(value_value)
+                return ArgumentError.new("value of argument '#{key}' does not respond to '#{value_value}'")
+            end
+        end
+        return nil
+    end
+
     # internal, please do not use directly.
     #
     # used to perform our standard checks.
@@ -75,7 +124,12 @@ module MethLab
         when Array
             value_sig.flatten.each do |vs|
                 ret = check_type(vs, value, key)
-                return ret unless ret.nil?
+                return ret if ret
+            end
+        when Hash
+            value_sig.each do |value_key, value_value| # GUH
+                ret = check_hash_types(value_key, value_value, value, key)
+                return ret if ret
             end
         when Class 
             unless value.kind_of?(value_sig)
@@ -127,9 +181,9 @@ module MethLab
                 return ArgumentError.new("argument #{key} does not exist in prototype")
             end
 
-            if !signature[key].nil?
+            if signature[key]
                 ret = check_type(signature[key], value, key)
-                return ret unless ret.nil?
+                return ret if ret
             end
         end
 
@@ -151,9 +205,9 @@ module MethLab
                 return ArgumentError.new("argument '#{key}' does not exist in prototype")
             end
 
-            if !signature[key].nil?
+            if signature[key]
                 ret = check_type(signature[key], value, key)
-                return ret unless ret.nil?
+                return ret if ret
             end
         end
 
@@ -193,6 +247,7 @@ module MethLab
         end
         
         proc do |*args| 
+            MethLab.set_defaults(signature, args, :array)
             params = MethLab.validate_array_params(signature, args)
             raise params if params.kind_of?(Exception)
             block.call(params)
@@ -204,7 +259,7 @@ module MethLab
     # or module. Currently cannot be a class method.
     def def_ordered(method_name, *args, &block)
         self.send(:define_method, method_name, &build_ordered(*args, &block)) 
-        method_name
+        return method_name
     end
 
     # Builds an unbound method as a proc with named (Hash) parameters.
@@ -227,6 +282,8 @@ module MethLab
         signature = args[0]
 
         proc do |*args|
+            args = [{}] if args.empty?
+            MethLab.set_defaults(signature, args, :hash)
             params = MethLab.validate_params(signature, *args)
             raise params if params.kind_of?(Exception)
             block.call(params)
@@ -238,7 +295,7 @@ module MethLab
     # or module. Currently cannot be a class method.
     def def_named(method_name, *args, &block)
         self.send(:define_method, method_name, &build_named(*args, &block))
-        method_name
+        return method_name
     end
 
     # Similar to MethLab#build_ordered, but builds attributes similar to
@@ -254,15 +311,22 @@ module MethLab
     #   myobj.set_me = "String" # valid
     #
     def def_attr(method_name, arg)
+
         self.send(:define_method, (method_name.to_s + "=").to_sym) do |value| 
             signature = [arg]
             params = MethLab.validate_array_params(signature, [value])
             raise params if params.kind_of?(Exception)
-            send(:instance_variable_set, "@" + method_name.to_s, value)
+            send(:instance_variable_set, "@" + method_name.to_s, params[0])
         end
 
         self.send(:define_method, method_name) do
-            instance_variable_get("@" + method_name.to_s)
+            unless self.instance_variables.select { |x| x == "@#{method_name}" }[0]
+                args = []
+                MethLab.set_defaults([arg], args, :array)
+                send(:instance_variable_set, "@#{method_name}", args[0])
+            end
+
+            instance_variable_get("@#{method_name}")
         end
     end
 

data/test/test_checks.rb

@@ -33,6 +33,16 @@ class CheckedClass
     def_ordered(:proc_raise, proc { |x| ArgumentError.new("foo") }) do |params|
         params
     end
+
+    def_named(:has_named_rt, :stuff => {:respond_to => :replace}) do |params|
+        params[:stuff]
+    end
+
+    def_ordered(:has_ordered_rt, {:respond_to => :replace}) do |params|
+        params[0]
+    end
+
+    def_attr :rt, {:respond_to => :replace}
 end
 
 $named_proc = build_named(:stuff => String) do |params|
@@ -156,4 +166,28 @@ class TestChecks < Test::Unit::TestCase
 
         assert_equal(@checked.set_me, "Foo")
     end
+
+    def test_06_respond_to
+        assert(@checked.respond_to?(:has_named_rt))
+        assert(@checked.respond_to?(:has_ordered_rt))
+        assert(@checked.respond_to?(:rt))
+
+        assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
+            @checked.rt = nil
+        end
+
+        assert_raises(ArgumentError.new("value of argument '0' does not respond to 'replace'")) do
+            @checked.has_ordered_rt(nil)
+        end
+        
+        assert_raises(ArgumentError.new("value of argument 'stuff' does not respond to 'replace'")) do
+            @checked.has_named_rt(:stuff => nil)
+        end
+
+        @checked.rt = "foo"
+
+        assert(@checked.rt, "foo")
+        assert(@checked.has_ordered_rt("foo"), "foo")
+        assert(@checked.has_named_rt(:stuff => "foo"), "foo")
+    end
 end

data/test/test_defaults.rb

@@ -0,0 +1,60 @@
+begin
+    require 'rubygems'
+    gem 'test-unit'
+rescue LoadError
+end
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+require 'methlab'
+
+MethLab.integrate
+
+class DefaultClass
+    def_named(:named, 
+              :foo => [String, {:default => "foo"}, :required], 
+              :bar => [String, {:default => "bar"}] 
+             ) do |params|
+                 params
+             end
+    
+    def_ordered(:ordered, 
+                [String, {:default => "foo"}, :required], 
+                [String, {:default => "bar"}]
+               ) do |params|
+                   params
+               end
+
+    def_attr :ml_attr, [String, {:default => "foo"}]
+end
+
+class TestDefaults < Test::Unit::TestCase
+    def setup
+        @default = DefaultClass.new
+    end
+
+    def test_01_named
+        assert(@default.respond_to?(:named))
+
+        assert_equal(@default.named, {:foo => "foo", :bar => "bar"})
+        assert_equal(@default.named(:foo => "fixme"), {:foo => "fixme", :bar => "bar"})
+        assert_equal(@default.named(:foo => "fixme", :bar => "woot"), {:foo => "fixme", :bar => "woot"})
+    end
+
+    def test_02_ordered
+        assert(@default.respond_to?(:ordered))
+
+        assert_equal(@default.ordered, ["foo", "bar"])
+        assert_equal(@default.ordered("fixme"), ["fixme", "bar"])
+        assert_equal(@default.ordered("fixme", "woot"), ["fixme", "woot"])
+    end
+
+    def test_03_attr
+        assert(@default.respond_to?(:ml_attr))
+
+        assert_equal(@default.ml_attr, "foo")
+        @default.ml_attr = "bar"
+        assert_equal(@default.ml_attr, "bar")
+    end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Erik Hollensbe
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-01 00:00:00 -04:00
+date: 2010-05-10 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -29,6 +29,7 @@ extra_rdoc_files: []
 files: 
 - lib/methlab.rb
 - test/test_checks.rb
+- test/test_defaults.rb
 - test/test_integrate.rb
 - Rakefile
 - README