appkernel 0.2.0 → 0.3.0

data/History.txt

@@ -1,6 +1,13 @@
-
+== 0.3.0 2010-04-12
+* 3 major enhancement
+  * specify list parameters
+  * allow list parameters to be greedy and slurp lots of arguments.
+* 3 minor enhancements
+  * automatically convert default values into canonical types.
+  * add a default conversion for URI::HTTP 
+  * better error reporting
+  
 == 0.2.0 2009-10-07
-
 * 4 major enhancements
   * functions now defined as classes, not via closures
   * validation method, and validation chaining
@@ -8,7 +15,6 @@
   * generic handlers for looking up appkernel values
 
 == 0.1.3 2009-08-31
-
 * 4 major enhancements
   * functions defined in the same scope can call themselves
   * validations can call function in the same module
@@ -16,15 +22,13 @@
   * allow multiple classes in the :type option attribute
 
 == 0.1.2 2009-07-01
-
-* 1 major enhancment:
+* 1 major enhancement:
   * can't remember for the life of me what it was. Are you really reading this?
 
 * 1 major enhancement:
   * functioning prototype which allows you to create portable, self-validating functions
 
 == 0.1.1 2009-06-30
-
 * 1 major enhancement:
   * functioning prototype which allows you to create portable, self-validating functions
 

data/Rakefile

@@ -1,28 +1,37 @@
 require 'rubygems'
-gem 'hoe', '>= 2.1.0'
-require 'hoe'
-require 'fileutils'
 
-$:.unshift File.dirname(__FILE__) + '/lib'
-require 'appkernel'
+$gemspec = Gem::Specification.new do |gemspec|
+  manifest = Rake::FileList.new("**/*")
+  manifest.exclude "**/*.gem"  
+  gemspec.name = "appkernel"
+  gemspec.version = "0.3.0"
+  gemspec.summary = "Functional Programming by Contract for Ruby"
+  gemspec.description = "validate, call, and curry your way to fun and profit!"
+  gemspec.email = "cowboyd@thefrontside.net"
+  gemspec.authors = ["Charles Lowell"]
+  gemspec.require_paths = ["lib"]
+  gemspec.files = manifest.to_a
+end
+
+desc "Build gem"
+task :gem do
+  Gem::Builder.new($gemspec).build
+end
 
-Hoe.plugin :newgem
-# Hoe.plugin :website
-# Hoe.plugin :cucumber_features
+desc "Build gemspec"
+task :gemspec do
+  File.open("#{$gemspec.name}.gemspec", "w") do |f|
+    f.write($gemspec.to_ruby)
+  end
+end
+
+task :clean do
+  sh "rm -rf *.gem"
+end
 
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.spec 'appkernel' do
-  self.developer 'Charles Lowell', 'cowboyd@thefrontside.net'
-  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
-  self.rubyforge_name       = self.name # TODO this is default value
-  # self.extra_deps         = [['activesupport','>= 2.0.2']]
 
+for file in Dir['tasks/*.rake']
+  load file
 end
 
-require 'newgem/tasks'
-Dir['tasks/**/*.rake'].each { |t| load t }
 
-# TODO - want other tests/tasks run by default? Add them to the list
-# remove_task :default
-# task :default => [:spec, :features]

data/appkernel.gemspec

@@ -2,34 +2,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{appkernel}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell"]
-  s.date = %q{2009-10-06}
-  s.description = %q{AppKernel is a microframework for capturing your application in terms of minute, self-validating functions. 
-Once defined, these functions can be used in rails, cocoa, an sms gateway, or wherever you want to take them.}
-  s.email = ["cowboyd@thefrontside.net"]
-  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt"]
-  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "appkernel.gemspec", "lib/appkernel.rb", "lib/appkernel/curry.rb", "lib/appkernel/function.rb", "lib/appkernel/types.rb", "script/console", "script/destroy", "script/generate", "spec/appkernel/curry_spec.rb", "spec/appkernel/function_spec.rb", "spec/appkernel/types_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
-  s.homepage = %q{http://github.com/cowboyd/appkernel}
-  s.post_install_message = %q{PostInstall.txt}
-  s.rdoc_options = ["--main", "README.rdoc"]
+  s.date = %q{2010-04-12}
+  s.description = %q{validate, call, and curry your way to fun and profit!}
+  s.email = %q{cowboyd@thefrontside.net}
+  s.files = ["appkernel.gemspec", "History.txt", "lib", "lib/appkernel", "lib/appkernel/curry.rb", "lib/appkernel/function.rb", "lib/appkernel/tap.rb", "lib/appkernel/types.rb", "lib/appkernel.rb", "pkg", "PostInstall.txt", "Rakefile", "README.rdoc", "script", "script/console", "script/destroy", "script/generate", "spec", "spec/appkernel", "spec/appkernel/curry_spec.rb", "spec/appkernel/function_spec.rb", "spec/appkernel/types_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks", "tasks/rspec.rake"]
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{appkernel}
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{AppKernel is a microframework for capturing your application in terms of minute, self-validating functions}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Functional Programming by Contract for Ruby}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<hoe>, [">= 2.3.3"])
     else
-      s.add_dependency(%q<hoe>, [">= 2.3.3"])
     end
   else
-    s.add_dependency(%q<hoe>, [">= 2.3.3"])
   end
 end

data/lib/appkernel.rb

@@ -4,4 +4,5 @@ class AppKernel
   require 'appkernel/function'
   require 'appkernel/curry'
   require 'appkernel/types'
+  require 'appkernel/tap'
 end

data/lib/appkernel/curry.rb

@@ -9,14 +9,17 @@ class AppKernel
     
     class Options
       def curry(parent, params)
-        @presets.merge! parent.canonicalize([params], nil, false)        
+        errors = Errors.new
+        presets = parent.canonicalize([params], errors, false)
+        raise ArgumentError, errors.all.join('; ') unless errors.empty?
+        @presets.merge! presets
         applied, unapplied = parent.options.values.partition {|o| @presets.has_key?(o.name)}
         unapplied.each do |option|
           ingest option
         end
         applied.each do |option|
           if option.required? && @presets[option.name].nil?
-            raise AppKernel::OptionsError, "required option '#{option.name}' may not be nil"
+            raise ArgumentError, "required option '#{option.name}' may not be nil"
           end
         end
       end

data/lib/appkernel/function.rb

@@ -1,12 +1,4 @@
 class AppKernel
-
-  class OptionsError < ArgumentError
-
-    def initialize(errors)
-      super(errors.first)
-    end
-
-  end
   
   class IllegalOptionError < StandardError; end
 
@@ -33,11 +25,13 @@ class AppKernel
       end
 
       def verify!
-        raise OptionsError, @errors unless successful?
+        raise ArgumentError, @errors.all.join('; ') unless successful?
       end
     end
 
     class Errors
+      attr_reader :all
+
       include Enumerable
 
       def initialize
@@ -79,6 +73,18 @@ class AppKernel
 
       def prepare!
         @options = Options.new
+        call = Module.new.tap do |mod|
+          unless self.name.nil? || self.name.empty?
+            fun = self
+            path = self.name.split(/::/)
+            simple_name = path[path.length - 1]
+            fun_name = simple_name.gsub(/(\w)([A-Z])([a-z])/) {"#{$1}_#{$2.downcase}#{$3}"}.downcase
+            mod.send(:define_method, fun_name) do |*args|
+              fun.call(*args)
+            end
+          end
+        end
+        self.const_set(:Call, call)
       end
 
       def call(*args)
@@ -108,8 +114,8 @@ class AppKernel
         @errors = errors
       end
 
-      def check(condition, message = "valditation failed")
-        @errors.add(nil, message) unless condition
+      def check(condition, message = "valditation failed", tag=nil)
+        @errors.add(tag, message) unless condition
       end
     end
 
@@ -140,6 +146,7 @@ class AppKernel
         @required = []
         @defaults = []
         @presets = {}
+        @greedy = nil
       end
 
       def add(name, modifiers)
@@ -148,63 +155,127 @@ class AppKernel
       
       def ingest(o)        
         @options[o.name] = o
-        if o.index
-          @indexed[o.index] = o
-          @indexed.compact!
-        end
+        @indexed[o.index] = o if o.index
         @required << o.name if o.required?
-        @defaults << o.name if o.default?
+        @defaults << o.name if o.default?        
         if o.default? && o.type
-          raise IllegalOptionError, "option '#{o.name}' is not a #{o.type}" unless o.default.kind_of?(o.type)
-        end                
+          if Enumerable === o.type 
+            if not o.type.detect {|t| o.default.kind_of?(t)}
+              raise IllegalOptionError, "default value #{o.default.inspect} for option '#{o.name}' is not in #{o.type.inspect}"
+            end            
+          elsif not o.default.kind_of?(o.type)
+            raise IllegalOptionError, "default value #{o.default.inspect} for option '#{o.name}' is not a #{o.type}"
+          end
+        end
+        if o.greedy?
+          raise IllegalOptionError, "a function may not have more than one greedy option. has (#{@greedy.name}, #{o.name})" if @greedy
+          @greedy = o
+        end
+        raise IllegalOptionError, "a greedy option may not have an index" if o.greedy? && o.index
       end
 
+
+
+      #first, exctract all hash options
+      #if we find one we love, use it
+      #otherwise, if there's a slurpy option, throw it on the pile
+      #otherwise, it's an error.
       def canonicalize(args, errors, augment = true)
+        indexed = @indexed.compact
+        positionals, parameters, rest = comb(args)
+        unless @greedy
+          errors.add(nil,"too many arguments (#{positionals.length} for #{indexed.length})") if positionals.length > indexed.length
+          for hash in rest
+            for k,v in hash
+              errors.add(k, "unknown option '#{k}'")
+            end
+          end
+          return unless errors.empty?
+        end
         @presets.dup.tap do |canonical|
-          indexed = @indexed.dup
-          for arg in args
-            case arg
-              when Hash
-                resolved = {}
-                for k,v in arg
-                  if opt = @options[k]
-                    resolved[k] = opt.resolve(v)
-                  else
-                    raise OptionsError, "unknown option '#{k}'"
-                  end
-                end
-                canonical.merge! resolved
-              else
-                if opt = indexed.shift
-                  canonical[opt.name] = opt.resolve arg
-                else
-                  raise ArgumentError, "too many arguments"
-                end
+          canonical[@greedy.name] = rest if @greedy
+          for name,value in parameters
+            canonical[name] = @options[name].resolve(value)
+          end          
+          positionals.length.times do |i|          
+            if opt = indexed[i]
+              canonical[opt.name] = opt.resolve(positionals[i])
             end
           end
+          if @greedy
+            canonical[@greedy.name] = @greedy.resolve(rest)
+          end          
           if augment
             for k in @defaults
               canonical[k] = @options[k].default unless canonical[k]
             end
-            canonical.reject! {|k,v| v.nil?}
+            canonical.reject! {|k,v| v.nil? || (@options[k] && @options[k].list? && v.empty?)}
             for k in @required - canonical.keys
               errors.add(k, "missing required option '#{k}'")
             end
+          end          
+        end      
+      end
+      
+      def comb(args)
+        positionals = []
+        parameters = {}
+        rest_parameters = {}
+        rest = []
+        index = @indexed.compact.length
+        for arg in args
+          if Hash === arg
+            for name,value in arg
+              key = name.to_sym
+              if opt = @options[key]
+                parameters[opt.name] = value
+              else
+                rest_parameters[key] = value
+              end
+            end
+          elsif index > 0
+            index -= 1
+            positionals << arg
+          else
+            rest << arg
           end
         end
+        rest << rest_parameters unless rest_parameters.empty?
+        return positionals, parameters, rest
       end
       
       class Option
+        
+        class ::Symbol
+          def [](*dontcare)
+            Option.new(self, :list => true)
+          end
 
-        attr_reader :name, :index, :type, :default
+          def *(*dontcare)
+            Option.new(self, :list => true, :greedy => true)
+          end
+        end
+        
+        attr_reader :name, :index, :type, :default, :modifiers
 
-        def initialize(name, modifiers)
+        def initialize(name, modifiers = {})
+          if name.kind_of?(Option)
+            modifiers = modifiers.merge(name.modifiers)
+          end
           @name = name.to_sym
+          @modifiers = modifiers
           @index = modifiers[:index]
           @required = modifiers[:required] == true
           @lookup = modifiers[:lookup] || modifiers[:parse]
           @type = modifiers[:type]
-          @default = modifiers[:default]
+          @list = modifiers[:list]
+          @greedy = modifiers[:greedy]
+          begin
+            @default = resolve(modifiers[:default])            
+          rescue StandardError => e
+            raise IllegalOptionError, "invalid default value for option '#{name}': #{e.message}"
+          end
+          
         end
 
         def required?
@@ -214,18 +285,36 @@ class AppKernel
         def default?
           !@default.nil?
         end
+        
+        def list?
+          @list
+        end
+        
+        def greedy?
+          @greedy
+        end
+                
+        def to_sym
+          @name
+        end
 
-        def resolve(o)
-          if o.nil? then nil  
+        def resolve(o, single = false)
+          if o.nil? then nil
+          elsif @list && !single
+            o.kind_of?(Array) ? o.map {|v| resolve(v,true)} : [resolve(o, true)]  
           elsif @type
             if @type.kind_of?(Class) && o.kind_of?(@type) then o
             elsif @type.kind_of?(Enumerable) && @type.detect {|t| o.kind_of?(t)} then o
             elsif @lookup
               @lookup.call(o)
             elsif @type.respond_to?(:to_option)
-              @type.to_option(o)
+              begin
+                @type.to_option(o)
+              rescue StandardError => e
+                raise ArgumentError, "don't know how to convert #{o} into #{@type}: #{e}"
+              end
             else
-              raise OptionsError, "don't know how to convert #{o} into #{@type}"
+              raise ArgumentError, "don't know how to convert #{o} into #{@type}"
             end
           else
             @lookup ? @lookup.call(o) : o

data/lib/appkernel/tap.rb

@@ -0,0 +1,8 @@
+unless Object.method_defined?(:tap)
+  class Object
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/lib/appkernel/types.rb

@@ -22,4 +22,21 @@ class AppKernel
       false
     end
   end
+end
+
+require 'net/http'
+class URI::HTTP
+  def self.to_option(spec)
+    uri = URI.parse(spec)
+    case uri.scheme
+    when "http" then uri
+    when nil then to_option("http://#{spec}")
+    else
+      if uri.host.nil?
+        to_option("http://#{spec}")
+      else
+        raise "#{spec.inspect} is not a valid http url"
+      end
+    end
+  end
 end

data/spec/appkernel/curry_spec.rb

@@ -13,28 +13,26 @@ describe "Function Currying " do
         end
         
       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    
   end
   
   it "is an error to curry options that do not exists" do
     lambda {
       @mult.curry(:hello => "world")
-    }.should raise_error(AppKernel::OptionsError)
+    }.should raise_error(ArgumentError)
   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)
+    }.should raise_error(ArgumentError)
   end
   
   it "requires all curried options to go through resolution and type matching" do
@@ -53,7 +51,7 @@ describe "Function Currying " do
   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)
+    }.should raise_error(ArgumentError)
   end
   
   it "automatically nils out an option if it is curried with nil" do

data/spec/appkernel/function_spec.rb

@@ -2,7 +2,6 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe AppKernel::Function do
 
-  # Called before each example.
   before(:each) do
     @function = Class.new(AppKernel::Function)
   end
@@ -10,8 +9,15 @@ describe AppKernel::Function do
   def class_eval(&block)
     @function.class_eval(&block)
   end
+  
+  def funcall(*args)
+    @function.call(*args)
+  end
 
-
+  def funapply(*args)
+    @function.apply(*args)
+  end
+  
   describe "Calling Conventions" do
     it "allows modules to define an function functions that takes options" do
       class_eval do
@@ -77,14 +83,31 @@ describe AppKernel::Function do
       end
     end
 
+    it "does not care what order the positional arguments were specified in" do
+      class_eval do
+        option :to, :index => 1
+        option :greeting, :index => 0
+
+        def execute
+          @greeting.should == "Hello"
+          @to.should == "World"
+        end
+      end
+
+      @function.call("Hello", "World")
+    end
+  end
+
+  describe "Error Handling" do
+      
     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
 
       lambda {
-        @function.call()
-      }.should raise_error(AppKernel::OptionsError)
+        funcall()
+      }.should raise_error(ArgumentError)
     end
 
     it "allows validation of its arguments" do
@@ -104,6 +127,20 @@ describe AppKernel::Function do
       end
 
     end
+    
+    it "allows associating arbitrary tags with errors" do
+      class_eval do
+        def validate(this)
+          this.check(false, "Not!", :tag)
+        end
+      end
+      
+      @function.apply.errors[:tag].should_not be_nil
+    end
+    
+    it "supports hash syntax for specifying error tags"
+    
+    it "throws a tag instead of OptionsError validation error if tag is an instance of Error"
   end
 
   describe "Option Resolution" do
@@ -193,10 +230,9 @@ describe AppKernel::Function do
     it "triggers an error if an option is unknown" do
      lambda {
        @function.call(:foo => 'bar')
-     }.should raise_error(AppKernel::OptionsError)
+     }.should raise_error(ArgumentError)
     end
-    
-  
+      
     describe "Default Values" do
       it "allows for any option to have a default value" do
         class_eval do
@@ -213,11 +249,22 @@ describe AppKernel::Function do
       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
+            option :value, :type => Integer, :default => Object.new            
+          end          
         }.should raise_error(AppKernel::IllegalOptionError)
       end
       
+      it "will try to convert default values into the option type before setting them" do
+        class_eval do
+          option :value, :type => Integer, :default => "1"
+          def execute
+            @value
+          end          
+        end
+        
+        @function.call.should == 1
+      end 
+      
       it "sets a default option even if that option is explicitly passed in as nil" do
        class_eval do
         option :value, :default => 'fun'
@@ -273,6 +320,134 @@ describe AppKernel::Function do
       end
     end
 
+    describe "Option with multiple values" do
+      
+      it "can automatically convert themselves into an array" do
+        class_eval do
+          option :arguments[], :index => 0
+          def execute
+            @arguments
+          end
+        end
+        funcall(1).should == [1]
+      end
+      
+      it "leaves argument alone if it is already an array" do
+        class_eval do
+          option :args[], :index => 0
+          def execute;@args;end
+        end        
+        funcall([1]).should == [1]
+      end
+            
+      it "converts all the arguments in an array to their expected types" do
+        class_eval do
+          option :integers*[], :type => Integer
+          def execute
+            @integers
+          end          
+        end
+        funcall("1","2","3").should == [1,2,3]
+      end
+      
+      it "must be non-empty if it is required" do
+        class_eval do
+          option :args[], :required => true, :index => 0
+        end
+        funapply(:args => []).should_not be_successful
+      end
+      
+    end
+
+    describe "Greedy Options" do
+      
+      it "can have a greedy option which slurps all remaining arguments" do
+        class_eval do
+          option :arguments*[]
+          def execute
+            @arguments
+          end          
+        end
+        funcall(1,2,3,4).should == [1,2,3,4]
+      end
+      
+      it "may not have more than one greedy option" do
+        expect {
+          class_eval do
+            option :greedy*[]
+            option :greedytoo*[]
+          end
+        }.to raise_error(AppKernel::IllegalOptionError)
+      end
+      it "may not have an index" do
+        expect {
+          class_eval do
+              option :greedy*[], :index => 0
+          end
+          }.to raise_error(AppKernel::IllegalOptionError)        
+      end
+      
+      it "defaults to the empty array" do
+        class_eval do
+          option :greedy*[]
+        end
+        def execute
+          @greedy.should == []
+        end
+      end
+      
+      context "with hash options" do
+        it "will slurp all hashes from the end of the argument list" do
+          class_eval do
+            option :greedy*[]
+          end
+          def execute
+            @greedy.should == [1,2,3, {:foo => 'bar', :baz => 'bif'}]
+          end
+        
+          @function.call(1,2,4, :foo => 'bar', :baz => 'bif')
+        end
+        
+        it "will slurp hashes from the begining of the argument list" do
+          class_eval do
+            option :greedy*[]
+            def execute
+              @greedy.should == [1,2,3, {:foo => 'bar'}]
+            end
+          end
+          @function.call({:foo => 'bar'},1,2,3)
+        end
+                
+        it "will extract those arguments which it knows, but leave those which it does not" do
+          class_eval do
+            option :known
+            option :greedy*[]
+            
+            def execute
+              @known.should == 'factor'
+              @greedy.should == [1,2,{:three => 'four', :five => 'six'}]
+            end
+          end
+          
+          @function.call(1,2,:known => 'factor', :three => 'four', :five => "six")
+        end
+    
+      end
+    end
+  end
+  
+  describe "Invocation" do
+    it "has a module that contains a method which will invoke that function with call" do
+      class AppKernel::TestFunction < AppKernel::Function
+        def execute
+          "hi there"          
+        end
+      end
+      Object.new.tap do |obj|
+        obj.extend(AppKernel::TestFunction::Call)
+        obj.test_function().should == "hi there"
+      end
+    end
   end
 
 end

data/spec/appkernel/types_spec.rb

@@ -22,7 +22,7 @@ describe "Type Conversion" do
     it "can call with a boolean function" do
       function = Class.new(AppKernel::Function).class_eval do
         self.tap do
-          option :bool, :type => AppKernel::Boolean, :index => 1
+          option :bool, :type => AppKernel::Boolean, :index => 1, :default => false
           def execute
             @bool
           end
@@ -44,6 +44,35 @@ describe "Type Conversion" do
     end
   end
   
+  require 'net/http'
+  describe URI::HTTP do
+    it "converts URI::HTTP" do
+      t(URI::HTTP, "http://google.com:2020/search").tap do |uri|
+        uri.should be_kind_of(URI::HTTP)
+        uri.scheme.should == "http"
+        uri.host.should == "google.com"
+        uri.port.should == 2020
+        uri.path.should == "/search"
+      end
+    end
+    
+    it "can guess the protocol if you don't provide it'" do |uri|
+      t(URI::HTTP, "google.com:4098/search").tap do |uri|
+        uri.should be_kind_of(URI::HTTP)
+        uri.scheme.should == 'http'
+        uri.host.should == "google.com"
+        uri.port.should == 4098
+        uri.path.should == "/search"        
+      end
+    end
+    
+    it "does something, we know not yet what when you give some other protocol" do
+      lambda {
+        t(URI::HTTP, "ldap://funbones.com")
+      }.should raise_error(StandardError)
+    end
+  end
+  
   def t(type, str)
     type.to_option(str)
   end

data/spec/spec_helper.rb

@@ -8,3 +8,8 @@ end
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'appkernel'
+
+def rputs(msg)
+  puts(ERB::Util.h(msg) + "<br/>")
+end
+

data/tasks/rspec.rake

@@ -0,0 +1,13 @@
+begin
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.spec_files = FileList['spec/**/*_spec.rb']
+  end
+rescue LoadError => e
+  desc "Run specs"
+  task :spec do
+    puts "rspec is required to run specs (gem install rspec)"
+  end
+end
+

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: appkernel
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Charles Lowell
@@ -9,43 +14,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 -05:00
+date: 2010-04-13 00:00:00 -05:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.3.3
-    version: 
-description: |-
-  AppKernel is a microframework for capturing your application in terms of minute, self-validating functions. 
-  Once defined, these functions can be used in rails, cocoa, an sms gateway, or wherever you want to take them.
-email: 
-- cowboyd@thefrontside.net
+dependencies: []
+
+description: validate, call, and curry your way to fun and profit!
+email: cowboyd@thefrontside.net
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- PostInstall.txt
+extra_rdoc_files: []
+
 files: 
-- History.txt
-- Manifest.txt
-- PostInstall.txt
-- README.rdoc
-- Rakefile
 - appkernel.gemspec
-- lib/appkernel.rb
+- History.txt
 - lib/appkernel/curry.rb
 - lib/appkernel/function.rb
+- lib/appkernel/tap.rb
 - lib/appkernel/types.rb
+- lib/appkernel.rb
+- PostInstall.txt
+- Rakefile
+- README.rdoc
 - script/console
 - script/destroy
 - script/generate
@@ -54,34 +45,36 @@ files:
 - spec/appkernel/types_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- tasks/rspec.rake
 has_rdoc: true
-homepage: http://github.com/cowboyd/appkernel
+homepage: 
 licenses: []
 
-post_install_message: PostInstall.txt
-rdoc_options: 
-- --main
-- README.rdoc
+post_install_message: 
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: appkernel
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: AppKernel is a microframework for capturing your application in terms of minute, self-validating functions
+summary: Functional Programming by Contract for Ruby
 test_files: []
 

data/Manifest.txt

@@ -1,18 +0,0 @@
-History.txt
-Manifest.txt
-PostInstall.txt
-README.rdoc
-Rakefile
-appkernel.gemspec
-lib/appkernel.rb
-lib/appkernel/curry.rb
-lib/appkernel/function.rb
-lib/appkernel/types.rb
-script/console
-script/destroy
-script/generate
-spec/appkernel/curry_spec.rb
-spec/appkernel/function_spec.rb
-spec/appkernel/types_spec.rb
-spec/spec.opts
-spec/spec_helper.rb