innate 2009.04

data/lib/innate/cache/memory.rb

@@ -0,0 +1,22 @@
+module Innate
+  class Cache
+    # Memory cache is simply a Hash with the Cache::API, it's the reference
+    # implementation for every other cache.
+
+    class Memory < Hash
+      include Cache::API
+
+      def cache_store(*args)
+        super{|key, value| self[key] = value }
+      end
+
+      def cache_fetch(*args)
+        super{|key| self[key] }
+      end
+
+      def cache_delete(*args)
+        super{|key| delete(key) }
+      end
+    end
+  end
+end

data/lib/innate/cache/yaml.rb

@@ -0,0 +1,17 @@
+require 'yaml/store'
+
+module Innate
+  class Cache
+    # Keeps every cache in a separate file like this:
+    #
+    # /tmp/innate-cache-yaml/delta-manveru-session.yaml
+    class YAML
+      include Cache::API
+      include Cache::FileBased
+
+      STORE = ::YAML::Store
+      DIR = 'innate-cache-yaml'
+      EXT = '.yaml'
+    end
+  end
+end

data/lib/innate/current.rb

@@ -0,0 +1,37 @@
+require 'innate/request'
+require 'innate/response'
+
+module Innate
+  # Uses STATE to scope request/response/session per Fiber/Thread so we can
+  # reach them from anywhere in the code without passing around the objects
+  # directly.
+  class Current
+    extend Trinity
+
+    def initialize(app, *rest)
+      if rest.empty?
+        @app = app
+      else
+        @app = Rack::Cascade.new([app, *rest])
+      end
+    end
+
+    # Wrap into STATE, run setup and call the app inside STATE.
+
+    def call(env)
+      STATE.wrap do
+        setup(env)
+        @app.call(env)
+      end
+    end
+
+    # Setup new Request/Response/Session for this request/response cycle.
+    # The parameters are here to allow Ramaze to inject its own classes.
+    def setup(env, request = Request, response = Response, session = Session)
+      req = STATE[:request] = request.new(env)
+      res = STATE[:response] = response.new
+      STATE[:actions] = []
+      STATE[:session] = Session.new(req, res)
+    end
+  end
+end

data/lib/innate/dynamap.rb

@@ -0,0 +1,96 @@
+module Innate
+  class URLMap < Rack::URLMap
+    def initialize(map = {})
+      @originals = map
+      super
+    end
+
+    # super may raise when given invalid locations, so we only replace the
+    # `@originals` if we are sure the new map is valid
+    def remap(map)
+      value = super
+      @originals = map
+      value
+    end
+
+    def map(location, object)
+      return unless location and object
+      remap(@originals.merge(location.to_s => object))
+    end
+
+    def delete(location)
+      @originals.delete(location)
+      remap(@originals)
+    end
+
+    def at(location)
+      @originals[location]
+    end
+
+    def to(object)
+      @originals.invert[object]
+    end
+
+    def to_hash
+      @originals.dup
+    end
+
+    def call(env)
+      raise "Nothing mapped yet" if @originals.empty?
+      super
+    end
+  end
+
+  DynaMap = URLMap.new
+
+  # script_name, path_info = env['SCRIPT_NAME'], env['PATH_INFO']
+  # answer = app.call(env)
+  # env.merge!('SCRIPT_NAME' => script_name, 'PATH_INFO' => path_info)
+  # answer
+
+  module SingletonMethods
+    # Maps the given +object+ or +block+ to +location+, +object+ must respond to
+    # #call in order to be of any use.
+    #
+    # @example with passed +object+
+    #
+    #   Innate.map('/', lambda{|env| [200, {}, "Hello, World"] })
+    #   Innate.at('/').call({}) # => [200, {}, "Hello, World"]
+    #
+    # @example with passed +block+
+    #
+    #   Innate.map('/'){|env| [200, {}, ['Hello, World!']] }
+    #   Innate.at('/').call({})
+    def map(location, object = nil, &block)
+      DynaMap.map(location, object || block)
+    end
+
+    # Answer with object at +location+.
+    #
+    # @example
+    #
+    #   class Hello
+    #     include Innate::Node
+    #     map '/'
+    #   end
+    #
+    #   Innate.at('/') # => Hello
+    def at(location)
+      DynaMap.at(location)
+    end
+
+    # Returns one of the paths the given +object+ is mapped to.
+    #
+    # @example
+    #
+    #   class Hello
+    #     include Innate::Node
+    #     map '/'
+    #   end
+    #
+    #   Innate.to(Hello) # => '/'
+    def to(object)
+      DynaMap.to(object)
+    end
+  end
+end

data/lib/innate/helper.rb

@@ -0,0 +1,183 @@
+module Innate
+
+  # Acts as name-space for helpers
+  module Helper
+    # Public instance methods of helpers in here will be recognized as actions
+    LOOKUP = EXPOSE = Set.new
+
+    # Usually called from Innate::Node::included
+    # We also include Innate::Trinity here, as it may be needed in models when
+    # you use helper methods there.
+    def self.included(into)
+      into.extend(HelperAccess)
+      into.__send__(:include, Trinity)
+      into.helper(*HelpersHelper.options[:default])
+    end
+  end
+
+  # Provides access to #helper method without polluting the name-space any
+  # further.
+  module HelperAccess
+
+    # Convenience method used by Innate::Node.
+    #
+    # Usage:
+    #
+    #   class Hi
+    #     extend Innate::HelperAccess
+    #     helper :cgi, :link, :aspect
+    #   end
+    #
+    # This will require the helpers and call:
+    #
+    #     Hi.include(Innate::Helper::CGI)
+    #     Hi.include(Innate::Helper::Link)
+    #     Hi.include(Innate::Helper::Aspect)
+    def helper(*helpers)
+      HelpersHelper.each_include(self, *helpers)
+    end
+  end
+
+  # Here come the utility methods used from the HelperAccess#helper method, we
+  # do this to keep method count at a minimum and because HelpersHelper is such
+  # an awesome name that just can't be wasted.
+  #
+  # Usage if you want to only extend with helpers:
+  #
+  #   class Hi
+  #     Innate::HelpersHelper.each_extend(self, :cgi, :link, :aspect)
+  #   end
+  #
+  # Usage if you only want to include helpers:
+  #
+  #   class Hi
+  #     Innate::HelpersHelper.each_include(self, :cgi, :link, :aspect)
+  #   end
+  #
+  # Usage for iteration:
+  #
+  #   Innate::HelpersHelper.each(:cgi, :link, :aspect) do |mod|
+  #     p mod
+  #   end
+  #
+  # Usage for translating helpers to modules:
+  #
+  #   p Innate::HelpersHelper.each(:cgi, :link, :aspect)
+  module HelpersHelper
+    include Optioned
+
+    options.dsl do
+      o "Paths that will be searched for helper files",
+        :paths, [Dir.pwd, File.dirname(__FILE__)]
+
+      o "Namespaces that will be searched for helper modules",
+        :namespaces, [Helper]
+
+      o "Filename extensions considered for helper files",
+        :exts, %w[rb so bundle]
+
+      o "Default helpers, added on inclusion of the Helper module",
+        :default, [:aspect, :cgi, :flash, :link, :render, :redirect, :send_file]
+    end
+
+    EXTS = %w[rb so bundle]
+
+    # all of the following are singleton methods
+
+    module_function
+
+    # Yield all the modules we can find for the given names of helpers, try to
+    # require them if not available.
+    #
+    # NOTE: Unlike usual #each, this will actually return an Array of the found
+    #       modules instead of the given +*names+
+    #
+    #
+    # Usage:
+    #
+    #   Innate::HelpersHelper.each(:cgi, :link, :aspect) do |mod|
+    #     p mod
+    #   end
+
+    def each(*names)
+      names.map do |name|
+        if name.class == Module
+          yield(name) if block_given?
+          name
+        elsif mod = get(name)
+          yield(mod) if block_given?
+          mod
+        elsif try_require(name)
+          redo
+        else
+          raise LoadError, "Helper #{name} not found"
+        end
+      end
+    end
+
+    # Shortcut to extend +into+ with Helper modules corresponding to +*names+.
+    # +into+ has to respond to #extend.
+    #
+    # Usage:
+    #
+    #   class Hi
+    #     Innate::HelpersHelper.each_extend(self, :cgi, :link, :aspect)
+    #   end
+    def each_extend(into, *names, &block)
+      return if names.empty?
+      into.extend(*each(*names, &block))
+    end
+
+    # Shortcut to include Helper modules corresponding to +*names+ on +into+.
+    # +into+ has to respond to #include.
+    # #__send__(:include) is used in case #include raises due to being
+    # private/protected
+    #
+    # in case #include is a private/protected method.
+    #
+    # Usage:
+    #
+    #   class Hi
+    #     Innate::HelpersHelper.each_include(self, :cgi, :link, :aspect)
+    #   end
+    def each_include(into, *names, &block)
+      return if names.compact.empty?
+      into.__send__(:include, *each(*names, &block))
+    end
+
+    # Based on a simple set of rules we will first construct the most likely
+    # name for the helper and then grep the constants in the Innate::Helper
+    # module for any matches.
+    #
+    # helper :foo_bar # => FooBar
+    # helper :foo # => Foo
+    def get(name)
+      module_name = /^#{name.to_s.dup.delete('_')}$/i
+
+      options.namespaces.each do |namespace|
+        found = namespace.constants.grep(module_name).first
+        return namespace.const_get(found) if found
+      end
+
+      nil
+    end
+
+    # Figure out files that might have the helper we ask for and then require
+    # the first we find, if any.
+    def try_require(name)
+      if found = Dir[glob(name)].first
+        require(found) || true
+      else
+        raise(LoadError, "Helper #{name} not found")
+      end
+    end
+
+    # Return a nice list of filenames in correct locations with correct
+    # filename-extensions.
+    def glob(name = '*')
+      exts, paths = options.exts, options.paths
+      paths.uniq!
+      "{#{paths.join(',')}}/helper/#{name}.{#{exts.join(',')}}"
+    end
+  end
+end

data/lib/innate/helper/aspect.rb

@@ -0,0 +1,124 @@
+module Innate
+  module Helper
+
+    # Provides before/after wrappers for actions
+    #
+    # This helper is essential for proper working of {Action#render}.
+    module Aspect
+      AOP = Hash.new{|h,k| h[k] = Hash.new{|hh,kk| hh[kk] = {} }}
+
+      def self.included(into)
+        into.extend(SingletonMethods)
+        into.add_action_wrapper(5.0, :aspect_wrap)
+      end
+
+      # Consider objects that have Aspect included
+      def self.ancestral_aop(from)
+        aop = {}
+        from.ancestors.reverse.map{|anc| aop.merge!(AOP[anc]) if anc < Aspect }
+        aop
+      end
+
+      def aspect_call(position, name)
+        return unless aop = Aspect.ancestral_aop(self.class)
+        return unless block = at_position = aop[position]
+
+        block = at_position[name.to_sym] unless at_position.is_a?(Proc)
+
+        instance_eval(&block) if block
+      end
+
+      def aspect_wrap(action)
+        return yield unless method = action.name
+
+        aspect_call(:before_all, method)
+        aspect_call(:before, method)
+        result = yield
+        aspect_call(:after, method)
+        aspect_call(:after_all, method)
+
+        result
+      end
+
+      # This awesome piece of hackery implements action AOP.
+      #
+      # The so-called aspects are simply methods that may yield the next aspect
+      # in the chain, this is similar to racks concept of middleware, but instead
+      # of initializing with an app we simply pass a block that may be yielded
+      # with the action being processed.
+      #
+      # This gives us things like logging, caching, aspects, authentication, etc.
+      #
+      # Add the name of your method to the trait[:wrap] to add your own method to
+      # the wrap_action_call chain.
+      #
+      # @example adding your method
+      #
+      #   class MyNode
+      #     Innate.node '/'
+      #
+      #     private
+      #
+      #     def wrap_logging(action)
+      #       Innate::Log.info("Executing #{action.name}")
+      #       yield
+      #     end
+      #
+      #     trait[:wrap]
+      #   end
+      #
+      #
+      # methods may register
+      # themself in the trait[:wrap] and will be called in left-to-right order,
+      # each being passed the action instance and a block that they have to yield
+      # to continue the chain.
+      #
+      # @param [Action] action instance that is being passed to every registered method
+      # @param [Proc] block contains the instructions to call the action method if any
+      #
+      # @see Action#render
+      # @author manveru
+      def wrap_action_call(action, &block)
+        wrap = SortedSet.new
+        action.node.ancestral_trait_values(:wrap).each{|sset| wrap.merge(sset) }
+        head, *tail = wrap.map{|k,v| v }
+        tail.reverse!
+        combined = tail.inject(block){|s,v| lambda{ __send__(v, action, &s) } }
+        __send__(head, action, &combined)
+      end
+
+      module SingletonMethods
+        include Traited
+
+        def before_all(&block)
+          AOP[self][:before_all] = block
+        end
+
+        def before(name, &block)
+          AOP[self][:before][name] = block
+        end
+
+        def after_all(&block)
+          AOP[self][:after_all] = block
+        end
+
+        def after(name, &block)
+          AOP[self][:after][name] = block
+        end
+
+        def wrap(name, &block)
+          before(name, &block)
+          after(name, &block)
+        end
+
+        def add_action_wrapper(order, method_name)
+          if wrap = trait[:wrap]
+            wrap.merge(SortedSet[[order, method_name]])
+          else
+            trait :wrap => SortedSet[[order, method_name]]
+          end
+        end
+      end
+    end
+  end
+end