appkernel 0.1.3 → 0.2.0

data/History.txt

@@ -1,6 +1,15 @@
-== 0.1.3 YYY-MM-DD
 
-* x major enhancements
+== 0.2.0 2009-10-07
+
+* 4 major enhancements
+  * functions now defined as classes, not via closures
+  * validation method, and validation chaining
+  * function currying
+  * 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
   * ability to provide defaults for function arguments.

data/Manifest.txt

@@ -5,12 +5,14 @@ README.rdoc
 Rakefile
 appkernel.gemspec
 lib/appkernel.rb
+lib/appkernel/curry.rb
 lib/appkernel/function.rb
-lib/appkernel/validation.rb
+lib/appkernel/types.rb
 script/console
 script/destroy
 script/generate
+spec/appkernel/curry_spec.rb
 spec/appkernel/function_spec.rb
-spec/appkernel/validation_spec.rb
+spec/appkernel/types_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/appkernel.gemspec

@@ -2,16 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{appkernel}
-  s.version = "0.1.3"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell"]
-  s.date = %q{2009-11-17}
+  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", "lib/appkernel.rb", "lib/appkernel/function.rb", "lib/appkernel/validation.rb", "script/console", "script/destroy", "script/generate", "spec/appkernel/function_spec.rb", "spec/appkernel/validation_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  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"]

data/lib/appkernel.rb

@@ -1,6 +1,7 @@
 
 class AppKernel
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
   require 'appkernel/function'
-  require 'appkernel/validation'
+  require 'appkernel/curry'
+  require 'appkernel/types'
 end

data/lib/appkernel/curry.rb

@@ -0,0 +1,27 @@
+
+class AppKernel
+  class Function
+    def self.curry(options)
+      Class.new(self).tap do |c|
+        c.options.curry(@options, options)
+      end
+    end
+    
+    class Options
+      def curry(parent, params)
+        @presets.merge! parent.canonicalize([params], nil, false)        
+        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"
+          end
+        end
+      end
+    end
+  end
+  
+
+end

data/lib/appkernel/function.rb

@@ -1,237 +1,237 @@
-require 'set'
+class AppKernel
 
-class AppKernel    
-  module Function
-    
-    def apply(fun, *args)
-      FunctionApplication.new(fun, *args)
-    end
-    
-    def self.included(mod)
-      class << mod
-        def function(symbol, &definition)
-          fun = ::AppKernel::FunctionDefinition.new(symbol, self, definition)
-          self.const_set(symbol, fun)
-          self.send(:define_method, symbol) do |*args|
-            FunctionApplication.apply_or_die(fun, *args)
-          end
-          if self.class == Module      
-            self.send(:module_function, symbol) 
-          else
-            class << self;self;end.send(:define_method, symbol) do |*args|
-              FunctionApplication.apply_or_die(fun, *args)
-            end
-          end
-        end
-        
-        def apply(fun, *args)
-          FunctionApplication.new(fun, *args)
-        end
-      end
+  class OptionsError < ArgumentError
+
+    def initialize(errors)
+      super(errors.first)
     end
+
   end
   
-  class FunctionApplication
-    
-    attr_reader :return_value, :errors, :function, :args
-    
-    def initialize(fun, *args)
-      @function = fun
-      @errors = {}
-      @args = Arguments.new(self, *args)
-      @return_value = self.class.do_apply(self)
+  class IllegalOptionError < StandardError; end
+
+  class Function
+    class << self
+      def inherited(subclass)
+        super(subclass)
+        subclass.send(:include, InstanceMethods)
+        subclass.extend(ClassMethods)
+        subclass.prepare!
+      end
     end
-    
-    def successful?
-      @errors.empty?
+
+    class Result
+      attr_reader :errors
+      attr_accessor :return_value
+
+      def initialize
+        @errors = Errors.new
+      end
+
+      def successful?
+        @errors.empty?
+      end
+
+      def verify!
+        raise OptionsError, @errors unless successful?
+      end
     end
-    
-    def options
-      @args.canonical
+
+    class Errors
+      include Enumerable
+
+      def initialize
+        @errors = Hash.new {|h, k| h[k] = []}
+        @all = []
+      end
+
+      def add(tag, message)
+        @errors[tag] << message if tag
+        @all << message
+      end
+
+      def each(&block)
+        @all.each(&block)
+      end
+
+      def [](tag)
+        @errors[tag]
+      end
+
+      def length
+        @all.length
+      end
+
+      def empty?
+        @all.empty?
+      end
     end
-    
-    class Arguments   
+
+    module ClassMethods
       
-      attr_reader :canonical
-               
-      def initialize(app, *args)
-        fun = app.function
-        @app = app
-        @canonical = {}
-        @required = Set.new(fun.options.values.select {|o| o.required?})      
-        @optorder = fun.indexed_options  
-
-        for arg in args
-          if (arg.is_a?(Hash))
-            arg.each do |k,v|
-              if opt = fun.options[k.to_sym]
-                set opt, v
-              else
-                raise FunctionCallError, "#{fun.name}: unknown option :#{k}"
-              end 
+      def options
+        @options
+      end
+
+      def option(name, modifiers = {})
+        @options.add(name, modifiers)
+      end
+
+      def prepare!
+        @options = Options.new
+      end
+
+      def call(*args)
+        apply(*args).tap {|result|
+          result.verify!
+        }.return_value
+      end
+
+      def apply(*args)
+        Result.new.tap do |result|
+          @options.canonicalize(args, result.errors).tap do |params|
+            if result.successful?
+              new(params).tap do |function|
+                function.validate(Validator.new(result.errors))
+                if result.successful?
+                  result.return_value = function.execute
+                end
+              end
             end
-          elsif opt = @optorder.shift
-            set opt, arg
-          end
-        end
-        for opt in fun.options.values
-          if @canonical[opt.name].nil? && !opt.default.nil?
-            @canonical[opt.name] = opt.default
-            @required.delete opt
           end
         end
-        for opt in @required
-          app.errors[opt.name] = "missing required option '#{opt.name}'"
-        end
-        for name in fun.options.keys
-          @canonical[name] = nil if @canonical[name].nil?
-        end        
       end
-      
-      def set(opt, value)
-        resolved = opt.resolve(@app, value)      
-        if !resolved.nil?
-          @canonical[opt.name] = resolved
-          @required.delete opt
-        elsif !value.nil? && opt.required? 
-          @required.delete opt
-          @required.delete opt
-          @app.errors[opt.name] = "no such value '#{value}' for required option '#{opt.name}'"          
-        end
+    end
+
+    class Validator
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def check(condition, message = "valditation failed")
+        @errors.add(nil, message) unless condition
       end
     end
-    
-    class << self
-      
-      def apply_or_die(fun, *args)
-        app = new(fun, *args)
-        if app.successful?
-          app.return_value
-        else
-          raise ValidationError, app
+
+    module InstanceMethods
+      def initialize(params)
+        for k, v in params
+          self.instance_variable_set("@#{k}", v)
         end
       end
-      
-      def do_apply(app)
-        fun = app.function      
-        app.errors.merge! fun.validation.validate(app.options) if app.successful?
-        if app.successful?
-          scope = Object.new
-          scope.extend fun.mod
-          for k,v in app.options do
-            scope.instance_variable_set("@#{k}", v)
-          end
-          scope.instance_eval &fun.impl
-        end
+
+      def execute
+        #do something
       end
-    end    
-  end
-  
-  class FunctionDefinition
-    
-    attr_reader :name, :mod, :impl, :options, :validation
-    
-    def initialize(name, mod, definition)
-      @name = name
-      @mod = mod
-      @options = {}
-      @impl = lambda {}
-      @validation = ::AppKernel::Validation::Validator.new(self)
-      self.instance_eval &definition
-    end
-    
-    def option(name, params = {})
-      name = name.to_sym
-      @options[name] = Option.new(name, params)
-    end
-    
-    def indexed_options
-      @options.values.select {|o| o.index}.sort_by {|a| a.index}
-    end
-    
-    def execute(&impl)
-      @impl = impl
-    end
-    
-    def validate(&checks)
-      @validation = AppKernel::Validation::Validator.new(self, &checks)
-    end
 
-    def to_s
-      "#{@name}()"
-    end
-            
-    class Option
-      ID = lambda {|o| o}
-      attr_reader :name, :index, :default
-      def initialize(name, params)
-        @name = name.to_sym
-        @index = params[:index]
-        @required = params[:required] == true
-        @finder = params[:find]
-        @types = params[:type] ? [params[:type]].flatten : nil
-        @default = params[:default]
-        validate!
+      def validate(this)
+        
+        #do something
       end
+    end
+
+    class Options
       
-      def validate!
-        if @default
-          if @types
-            raise OptionError, "#{@default} is not a kind of #{@types.join('|')}" unless @types.detect {|t| @default.kind_of?(t)}
-          elsif @required
-            Kernel.warn "option '#{@name}' unecessarily marked as required. It has a default value"
-          end
-        end
+      attr_reader :options
+      
+      def initialize
+        @options = {}
+        @indexed = []
+        @required = []
+        @defaults = []
+        @presets = {}
       end
-                  
-      def required?
-        @required
+
+      def add(name, modifiers)
+        ingest Option.new(name, modifiers)
       end
       
-      def optional?
-        !@required
+      def ingest(o)        
+        @options[o.name] = o
+        if o.index
+          @indexed[o.index] = o
+          @indexed.compact!
+        end
+        @required << o.name if o.required?
+        @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                
       end
-      
-      def resolve(app, value)
-        if value.nil?
-          nil
-        elsif @types 
-          if @types.detect {|t| value.is_a?(t)}
-            value
-          elsif @finder
-            lookup(app, value)
-          else
-            raise OptionError, "Don't know how to convert #{value.class}:#{value} -> #{@type}"
+
+      def canonicalize(args, errors, augment = true)
+        @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
+            end
+          end
+          if augment
+            for k in @defaults
+              canonical[k] = @options[k].default unless canonical[k]
+            end
+            canonical.reject! {|k,v| v.nil?}
+            for k in @required - canonical.keys
+              errors.add(k, "missing required option '#{k}'")
+            end
           end
-        elsif @finder
-          lookup(app, value)
-        else
-          value
         end
       end
       
-      def lookup(app, value)
-        result = @finder.call(value)
-        app.errors[@name] = "couldn't find '#{@name}': #{value}" if result.nil? 
-        result
-      end                 
-    end
-    
-    class Validator
-    end
-  end
-  
-  class FunctionCallError < StandardError; end
-  class OptionError < StandardError; end
-  
-  class ValidationError < StandardError
-    def initialize(application)
-      @app = application
-    end
-    
-    def message
-      "#{@app.function.name}: #{@app.errors.values.first}"
+      class Option
+
+        attr_reader :name, :index, :type, :default
+
+        def initialize(name, modifiers)
+          @name = name.to_sym
+          @index = modifiers[:index]
+          @required = modifiers[:required] == true
+          @lookup = modifiers[:lookup] || modifiers[:parse]
+          @type = modifiers[:type]
+          @default = modifiers[:default]
+        end
+
+        def required?
+          @required
+        end
+        
+        def default?
+          !@default.nil?
+        end
+
+        def resolve(o)
+          if o.nil? then nil  
+          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)
+            else
+              raise OptionsError, "don't know how to convert #{o} into #{@type}"
+            end
+          else
+            @lookup ? @lookup.call(o) : o
+          end                    
+        end
+      end
     end
   end
-    
 end