manveru-innate 2009.02.06

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/core_compatibility/basic_object.rb

@@ -0,0 +1,9 @@
+class BasicObject
+  # Remove all but these methods
+  # NOTE: __id__ is not there in 1.9, but would give a warning in 1.8
+  KEEP = %w[== equal? ! != instance_eval instance_exec __send__ __id__]
+
+  (instance_methods - KEEP).each do |im|
+    undef_method(im)
+  end
+end unless defined?(BasicObject)

data/lib/innate/core_compatibility/string.rb

@@ -0,0 +1,3 @@
+class String # Dirty hack, but Rack needs it?
+  alias each each_line unless 'String'.respond_to?(:each)
+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
+
+    def setup(env)
+      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,81 @@
+module Innate
+
+  # This is a dynamic routing mapper used to outsmart Rack::URLMap
+  # Every time a mapping is changed a new Rack::URLMap will be put into
+  # Innate::DynaMap::CACHE[:map]
+  class DynaMap
+    MAP = {}
+    CACHE = {}
+
+    # Delegate the call to the current Rack::URLMap instance.
+    #
+    # NOTE: Currently Rack::URLMap will destructively modify PATH_INFO and
+    #       SCRIPT_NAME, which leads to incorrect routing as parts of the
+    #       PATH_INFO are cut out if they matched once.
+    #       Here I repair this damage and hope that my patch to rack will be
+    #       accepted.
+    def self.call(env)
+      if app = CACHE[:map]
+        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
+      else
+        raise "Nothing mapped yet"
+      end
+    end
+
+    # Map node to location, create a new Rack::URLMap instance and cache it.
+    def self.map(location, node)
+      return unless location
+      MAP[location.to_s] = node
+      CACHE[:map] = Rack::URLMap.new(MAP)
+    end
+  end
+
+  module_function
+
+  # Maps the given +object+ or +block+ to +location+, +object+ must respond to
+  # #call in order to be of any use.
+  #
+  # Usage with passed +object+:
+  #
+  #   Innate.map('/', lambda{|env| [200, {}, "Hello, World"] })
+  #   Innate.at('/').call({}) # => [200, {}, "Hello, World"]
+  #
+  # Usage 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+.
+  #
+  # Usage:
+  #
+  #   class Hello
+  #     include Innate::Node
+  #     map '/'
+  #   end
+  #
+  #   Innate.at('/') # => Hello
+  def at(location)
+    DynaMap::MAP[location.to_s]
+  end
+
+  # Returns one of the paths the given +object+ is mapped to.
+  #
+  # Usage:
+  #
+  #   class Hello
+  #     include Innate::Node
+  #     map '/'
+  #   end
+  #
+  #   Innate.to(Hello) # => '/'
+  def to(object)
+    DynaMap::MAP.invert[object]
+  end
+end

data/lib/innate/helper.rb

@@ -0,0 +1,195 @@
+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)
+    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
+    EXTS = %w[rb so bundle]
+
+    # By default, lib/innate/ is added to the PATH, you may add your
+    # application root here so innate will look in your own helper/ directory.
+    PATH = []
+
+    # The namespaces that may container helper modules.
+    # Lookup is done from left to right.
+    POOL = []
+
+    # all of the following are singleton methods
+
+    module_function
+
+    def add_pool(pool)
+      POOL.unshift(pool)
+      POOL.uniq!
+    end
+
+    add_pool(Helper)
+
+    def add_path(path)
+      PATH.unshift(File.expand_path(path))
+      PATH.uniq!
+    end
+
+    add_path(File.dirname(__FILE__))
+    add_path('')
+
+    # 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.empty?
+      mods = each(*names, &block)
+      into.include(*mods)
+    rescue NoMethodError
+      into.__send__(:include, *mods)
+    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)
+      name = name.to_s.split('_').map{|e| e.capitalize}.join
+      POOL.each do |namespace|
+        if found = namespace.constants.grep(/^#{name}$/i).first
+          return namespace.const_get(found)
+        end
+      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 File.expand_path(found)
+      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 = '*')
+      "{#{paths.join(',')}}/helper/#{name}.{#{EXTS.join(',')}}"
+    end
+
+    # In case you want to do something better.
+    def paths
+      PATH
+    end
+  end
+end

data/lib/innate/helper/aspect.rb

@@ -0,0 +1,62 @@
+module Innate
+  module Helper
+
+    # Provides before/after wrappers for actions
+    module Aspect
+      AOP = Hash.new{|h,k| h[k] = Hash.new{|hh,kk| hh[kk] = {} }}
+
+      def self.included(into)
+        into.extend(SingletonMethods)
+      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)
+        yield
+        aspect_call(:after, method)
+        aspect_call(:after_all, method)
+      end
+
+      module SingletonMethods
+        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
+      end
+    end
+  end
+end

data/lib/innate/helper/cgi.rb

@@ -0,0 +1,39 @@
+autoload(:CGI, 'cgi') # in case you want to use html_unescape
+
+module Innate
+
+  # Shortcuts to some CGI methods
+
+  module Helper
+    module CGI
+      # shortcut for Rack::Utils.escape
+      def url_encode(*args)
+        Rack::Utils.escape(*args.map{|a| a.to_s })
+      end
+
+      # shortcut for Rack::Utils.unescape
+      def url_decode(*args)
+        Rack::Utils.unescape(*args.map{|a| a.to_s })
+      end
+
+      # shortcut for Rack::Utils.escape_html
+      def html_escape(string)
+        Rack::Utils.escape_html(string)
+      end
+
+      # shortcut for CGI.unescapeHTML
+      def html_unescape(string)
+        ::CGI.unescapeHTML(string.to_s)
+      end
+
+      # safely escape all HTML and code
+      def h(string)
+        Rack::Utils.escape_html(string).gsub(/#([{@$]@?)/, '#\1')
+      end
+
+      # one-letter versions help in case like #{h foo.inspect}
+      # ERb/ERuby/Rails compatible
+      alias u url_encode
+    end
+  end
+end