appkernel 0.1.3 → 0.2.0

data/lib/appkernel/types.rb

@@ -0,0 +1,25 @@
+class Integer
+  def self.to_option(spec)
+    spec.to_i
+  end
+end
+
+class Float
+  def self.to_option(spec)
+    spec.to_f
+  end
+end
+
+class AppKernel
+  
+  Boolean = [TrueClass, FalseClass]
+  
+  def Boolean.to_option(o)
+    case o.to_s.downcase.strip
+    when "true", "t", "on", "y", "yes"
+      true
+    else
+      false
+    end
+  end
+end

data/spec/appkernel/curry_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Function Currying " do
+  
+  before(:each) do
+    @mult = Class.new(AppKernel::Function).class_eval do
+      self.tap do
+        option :lhs, :index => 1, :type => Numeric, :required => true
+        option :rhs, :index => 2, :type => Numeric, :required => true
+                
+        def execute
+          @lhs * @rhs
+        end
+        
+      end
+    end        
+    
+  end
+  
+  it "new functions to be created by fixing values of specified options" do    
+    @mult.curry(2).tap do |double|
+      double.call(3).should == 6
+      double.call(:rhs => 10).should == 20
+    end
+    
+  end
+  
+  it "is an error to curry options that do not exists" do
+    lambda {
+      @mult.curry(:hello => "world")
+    }.should raise_error(AppKernel::OptionsError)
+  end
+  
+  it "the curried options will not be overriden and in fact will raise an error if an attempt is made to do so" do
+    lambda {
+      @mult.curry(:lhs => 2).call(:lhs => 4, :rhs => 5)
+    }.should raise_error(AppKernel::OptionsError)
+  end
+  
+  it "requires all curried options to go through resolution and type matching" do
+    Class.new(AppKernel::Function).class_eval do
+      option :int, :type => Integer
+      option :float, :type => Float
+      
+      def execute
+        @float + @int
+      end
+      
+      self.curry(:float => "3.14").call(:int => 5).should == 8.14
+    end
+  end
+  
+  it "is an error to have a nil value for a curried option if that option is required" do
+    lambda {
+      @mult.curry(:lhs => nil)
+    }.should raise_error(AppKernel::OptionsError)
+  end
+  
+  it "automatically nils out an option if it is curried with nil" do
+    Class.new(AppKernel::Function).class_eval do
+      option :one
+      option :two
+      
+      def execute
+        [@one, @two]
+      end
+      
+      curry(:one => nil).call(:two => 2).should == [nil,2]
+    end
+  end
+  
+  it "allows functions to be curried multiple times" do
+    @mult.curry(:lhs => 2).curry(:rhs => 3).call.should == 6
+  end
+end

data/spec/appkernel/function_spec.rb

@@ -1,271 +1,278 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-  
+
 describe AppKernel::Function do
-  
+
+  # Called before each example.
   before(:each) do
-    @mod = Module.new do |mod|
-      mod.module_eval do
-        include AppKernel::Function
-      end
-    end
-    extend @mod
-    @klass = Class.new.class_eval do
-      include AppKernel::Function; self
-    end
+    @function = Class.new(AppKernel::Function)
   end
-  
-  it "allows modules to define an function functions" do
-    @mod.module_eval do
-      function :Say do        
+
+  def class_eval(&block)
+    @function.class_eval(&block)
+  end
+
+
+  describe "Calling Conventions" do
+    it "allows modules to define an function functions that takes options" do
+      class_eval do
         option :word
-        
-        execute do
+
+        def execute
           @word
         end
       end
-      Say(:word => "hello").should == "hello"
-    end
-  end
-  
-  it "allows certain options to be the default option" do
-    function :Say do
-      option :greeting, :index => 0
-      option :to, :index => 1
-      option :extra
-      
-      execute do
-        "#{@greeting} #{@to}#{(', ' + @extra) if @extra}" 
-      end            
+
+      @function.call(:word => "hello").should == "hello"
     end
-    Say("Hello", "Charles", :extra => "How are you?").should == "Hello Charles, How are you?"
-    Say("Hello", "Charles").should == "Hello Charles"
-    Say(:greeting => "Hello", :to => "Charles").should == "Hello Charles"    
-  end
-  
-  it "allows classes that include the module to also use the commands from that module" do
-    @mod.module_eval do
-      function :Included do
-        execute do
-          "It worked!"
+
+    it "allows certain options to be the default option" do
+
+      class_eval do
+        option :greeting, :index => 0
+        option :to, :index => 1
+        option :extra
+
+        def execute
+          "#{@greeting} #{@to}#{(', ' + @extra) if @extra}"
         end
       end
+      @function.call("Hello", "Charles", :extra => "How are you?").should == "Hello Charles, How are you?"
+      @function.call("Hello", "Charles").should == "Hello Charles"
+      @function.call(:greeting => "Hello", :to => "Charles").should == "Hello Charles"
     end
-    mod = @mod
-    Class.new(Object).class_eval do
-      include mod
-      self
-    end.new.instance_eval do
-      Included().should == "It worked!"
-    end
-  end
-  
-  it "allows classes to define functions as well as modules" do
-    @klass.class_eval do
-      function :Say do
-        option :word, :index => 1
-        execute do
-          @word
+
+
+    it "can be called by using the apply method instead of invoking it directly" do
+      class_eval do
+        option :desc, :index => 1
+
+        def execute
+          "FiveAlive is a #{@desc}"
         end
-      end      
-    end
-  end
-  
-  it "allows functions in the same module to be accessible without namespacing" do
-    function :First do
-      execute do
-        Second()
       end
+      result = @function.apply("candy bar")
+      result.return_value.should == "FiveAlive is a candy bar"
+      result.successful?.should be(true)
     end
-    
-    function :Second do
-      execute do
-        "Hello"
+
+    it "can have required options, but they are never required by default" do
+      class_eval do
+        option :greeting, :index => 1, :required => true
+        option :to, :index => 2, :required => true
+        option :extra, :index => 3
+      end
+
+      @function.apply("Hello", "World", "I'm doing fine.").tap do |result|
+        result.successful?.should be(true)
+      end
+
+      @function.apply.tap do |result|
+        result.return_value.should be(nil)
+        result.should_not be_successful
+        result.errors[:greeting].should_not be_empty
+        result.errors[:to].should_not be_empty
+        result.errors[:extra].should be_empty
+
+        result.errors.length.should be(2)
       end
     end
-    
-    First().should == "Hello"
-  end
-  
-  it "can be called by using the apply method instead of invoking it directly" do
-    function :FiveAlive do
-      option :desc, :index => 1
-      execute do
-        "FiveAlive is a #{@desc}"
+
+    it "raises an error immediately if you try to call a function that has invalid arguments" do
+      class_eval do
+        option :mandatory, :required => true
       end
-    end  
-    result = apply(@mod::FiveAlive, "candy bar")
-    result.return_value.should == "FiveAlive is a candy bar"
-    result.successful?.should be(true)
-  end
-  
-  it "can have required options, but they are never required by default" do
-    function :Say do
-      option :greeting, :index => 1, :required => true
-      option :to, :index => 2, :required => true
-      option :extra, :index => 3
-    end      
-    result = apply(@mod::Say, "Hello", "World", "I'm doing fine.")
-    result.successful?.should be(true)
-    result = apply(@mod::Say)
-    result.return_value.should be(nil)
-    result.successful?.should be(false)
-    result.errors[:greeting].should_not be(nil)
-    result.errors[:to].should_not be(nil)
-    result.errors[:extra].should be(nil)
-  end
-  
-  it "raises an error immediately if you try to call a function that has invalid arguments" do
-    function :Harpo do
-      option :mandatory, :required => true
+
+      lambda {
+        @function.call()
+      }.should raise_error(AppKernel::OptionsError)
     end
 
-    lambda {
-      Harpo()
-    }.should raise_error(AppKernel::ValidationError)
-  end
-  
-  it "allows validation of its arguments" do
-    function :Picky do
-      option :arg, :index => 1                
-      validate do
-        @arg.check @arg == 5 && @arg != 6, "must be 5 and not be 6"
-      end      
-    end  
-
-    apply(@mod::Picky, 5).successful?.should be(true)
-    result = apply(@mod::Picky, 6)
-    result.successful?.should be(false)
-    result.errors[:arg].should == "must be 5 and not be 6"
-    
-    result = apply(@mod::Picky, 7)
-    result.successful?.should be(false)
-    result.errors[:arg].should == "must be 5 and not be 6"
+    it "allows validation of its arguments" do
+      class_eval do
+        option :arg, :index => 1
+
+        def validate(this)
+          this.check(@arg == 5 && @arg != 6, "'arg' must be 5 and not be 6")
+        end
+
+      end
+
+      @function.apply(5).should be_successful
+      @function.apply(6).tap do |result|
+        result.should_not be_successful
+        result.errors.to_a.should == ["'arg' must be 5 and not be 6"]
+      end
+
+    end
   end
-  
+
   describe "Option Resolution" do
-    it "can take a find parameter in the function definition which tells it how to lookup arguments" do
-      function :TakesInt do
-        option :num, :index => 1, :find => proc {|s| s.to_i}
-        
-        execute do
+    it "can take a lookup parameter in the function definition which tells it how to lookup arguments" do
+      class_eval do
+        option :num, :index => 1, :lookup => proc {|s| s.to_i}
+
+        def execute
           @num
         end
       end
-      
-      TakesInt("5").should == 5
+
+      @function.call("5").should == 5
     end
     
-    describe "Default Values" do
-      it "allows for any option to have a default value" do
-        function :HasDefault do
-          option :value, :default => 5
-          
-          execute{@value}
-        end
+    it "has a :parse options which are aliases for :lookup" do
+      class_eval do
+        option :num1, :index => 1, :lookup => proc {|s| s.to_i}
+        option :num2, :index => 2, :parse => proc {|s| s.to_i}
         
-        HasDefault().should == 5
-      end
-      
-      it "requires that the default value be the same as the option type if that is specified" do
-        lambda {
-          function :InvalidDefault do
-            option :value, :type => Integer, :default => "NOT_INT"
-          end
-        }.should raise_error
+        def execute
+          [@num1,@num2]
+        end
       end
       
-      it "warns if an option has a default and is also required" do
-        Kernel.should_receive(:warn)
-        function :QuestionableDefault do
-          option :value, :required => true, :default => 5
+      @function.call("1", "2").should == [1,2]
+    end
+    
+    it "has default parsers/lookups if the type is specified" do
+      class_eval do
+        option :num, :type => Integer
+        option :float, :type => Float
+        
+        def execute
+          OpenStruct.new({
+            :num => @num,
+            :float => @float
+          })
         end
       end
       
-      it "sets a default option even if that option is explicitly passed in as nil" do
-        function :ExplicitNil do
-          option :value, :default => 'fun'
-          execute{@value}
-        end
-        
-        ExplicitNil(:value => nil).should == 'fun'
+      @function.call(:num => "5", :float => "3.14").tap do |result|
+        result.num.should == 5
+        result.float.should == 3.14
       end
     end
     
     it "doesn't do an argument conversion if the argument is already of the correct type" do
-      function :TakesInt do
-        option :num, :index => 1, :type => Integer, :find => proc {|s| raise StandardError, "Hey, don't call me!"}
-        execute {@num}
+      class_eval do
+        option :num, :index => 1, :type => Integer, :lookup => proc {|s| raise StandardError, "Hey, don't call me!"}
+        
+        def execute
+          @num
+        end
       end
       lambda {
-        TakesInt(5).should == 5
-      }.should_not raise_error
+        @function.call(5)
+      }.should_not raise_error        
     end
     
-    it "an option can have multiple valid types" do
-      function :MultipleValidOptionTypes do
-        option :bool, :index => 1, :type => [TrueClass, FalseClass], :find => proc {|s| s == "true"}
-        execute {@bool}
+    it "accepts nil as a valid instance of all types" do
+      class_eval do
+        option :num, :index => 1, :type => Numeric
       end
       
-      MultipleValidOptionTypes("true").should be(true)
-      MultipleValidOptionTypes("false").should be(false)
-      MultipleValidOptionTypes(true).should be(true)
-      MultipleValidOptionTypes(false).should be(false)
-    end
-    
-    it "raises an exception if it can't tell how to find a complex type" do
-      weird = Class.new
-      function :TakesWeirdObject do
-        option :weird, :type => weird
-        execute {@weird}
-      end
-      
-      lambda {
-        TakesWeirdObject(:weird => "weird")
-      }.should raise_error
-      
-      werd = weird.new
-      TakesWeirdObject(:weird => werd).should == werd
+      @function.call.should be_nil
+      @function.call(:num => nil).should be_nil
     end
     
     it "triggers an error if an option is required and after trying to find it, it is still nil." do
-      objects = {:foo => 'bar', :baz => "bang", }
-      
-      function :Lookup do
-        option :obj, :index => 1, :required => true, :find => proc {|key| objects[key]}
-        execute {@obj}
+     objects = {:foo => 'bar', :baz => "bang" }
+    
+      class_eval do
+        option :obj, :index => 1, :required => true, :lookup => proc {|key| objects[key]}
+        def execute
+          @obj
+        end
       end
       
-      Lookup(:foo).should == 'bar'
-      Lookup(:baz).should == 'bang'
-      lambda { 
-        Lookup(:bif)        
-      }.should raise_error
+      @function.call(:foo).should == 'bar'
+      @function.call(:baz).should == 'bang'
+      lambda {
+        @function.call(:bif)
+      }.should raise_error    
     end
     
     it "triggers an error if an option is unknown" do
-      function(:Noop) {}
-      Noop()
-      lambda {
-        Noop(:foo => 'bar')
-      }.should raise_error(AppKernel::FunctionCallError)
+     lambda {
+       @function.call(:foo => 'bar')
+     }.should raise_error(AppKernel::OptionsError)
     end
     
-    it "allows false as a default value" do
-      function :FalseDefault do
-        option :bool, :default => false
-        execute {@bool}
+  
+    describe "Default Values" do
+      it "allows for any option to have a default value" do
+        class_eval do
+          option :value, :default => 5
+
+          def execute
+            @value
+          end
+        end
+
+        @function.call.should == 5
+      end
+
+      it "requires that the default value be the same as the option type if that is specified" do
+        lambda {
+          class_eval do
+            option :value, :type => Integer, :default => "NOT_INT"
+          end
+        }.should raise_error(AppKernel::IllegalOptionError)
       end
       
-      FalseDefault().should be(false)
-    end
-    
-  end
+      it "sets a default option even if that option is explicitly passed in as nil" do
+       class_eval do
+        option :value, :default => 'fun'
   
-  def function(sym, &body)
-    @mod.module_eval do
-      function sym, &body
+        def execute
+          @value
+        end
+       end
+       @function.call(:value => nil).should == 'fun'
+      end
+            
+      it "allows false as a default value" do
+        class_eval do
+          option :bool, :index => 1, :default => false
+          def execute
+            @bool
+          end
+        end
+        @function.call().should be(false)
+      end        
     end
+
+    describe "Complex Types" do
+      it "takes options that have multiple valid types" do
+        class_eval do
+          option :bool, :index => 1, :type => [TrueClass, FalseClass], :parse => proc {|s| s == "true"}          
+          def execute
+            @bool
+          end
+        end
+      
+       @function.call("true").should be(true)
+       @function.call("false").should be(false)
+       @function.call(true).should be(true)
+       @function.call(false).should be(false)
+      end
+      
+      it "raises an exception if it can't tell how to find a complex type" do
+       weird = Class.new
+       class_eval do
+        option :weird, :type => weird
+        def execute
+          @weird
+        end
+       end     
+       lambda {
+         @function.call(:weird => "weird")
+       }.should raise_error
+      
+       weird.new.tap do |w|
+         @function.call(:weird => w).should == w
+       end
+      end
+    end
+
   end
-  
-end
+
+end