action_tree 0.1.1 → 0.2.0

data/lib/action_tree/basic/query.rb

@@ -0,0 +1,211 @@
+
+
+# When a request is matched against an action tree,
+# (or rather, its root node), a chain of query objects
+# is built, and the last one returned.
+#
+# Each query object wraps a node, and the query path is the 
+# list of queries leading from the root down to the item matched.
+#
+# When no node matches, a query object is still returned,
+# with different behaviour, and #found? => false
+
+class ActionTree::Basic::Query
+
+  include ActionTree::Basic::Shared
+  include ActionTree::Errors
+
+  # The {Node} wrapped by this query.
+  # @return [Node]
+  attr_reader :node
+
+  # The parent `Query` in the chain, or `nil` if first.
+  # @return [Query]
+  attr_reader :parent
+
+  # The path fragment matched by this single `Query`.
+  # @return [String]
+  attr_reader :fragment
+
+  # The action namespace specified for this `Query`.
+  # @return [String]
+  attr_reader :namespace
+
+  # ==
+
+  # Queries should be created by calling Node#match
+  #
+  # @api private
+  #
+  def initialize(node, parent, fragment, namespace)
+    @node       = node
+    @parent     = parent
+    @fragment   = fragment
+    @namespace  = namespace
+  end
+
+  # Wether the request was successfully matched.
+  # @return [Boolean]
+  def found?
+    @node && @node.actions[@namespace]
+  end
+
+  # Inverse of {Query#found?}
+  # @return [Boolean]
+  def not_found?; !found?;  end
+
+  # The chain of `Query` objects wrapping the matched nodes
+  # along the requested path.
+  # @return [Array]
+  def query_path
+    @query_path ||= @parent ? @parent.query_path << self : [self]
+  end
+
+  # Same as {Query#query_path}, but only include {Query} objects that
+  # map to a real node.
+  # @return [Array]
+  def match_path
+    @match_path ||= query_path.select(&:node)
+  end
+
+  # The nodes along the {Query#match_path}
+  # @return [Array]
+  def node_path
+    @node_path ||= match_path.map(&:node)
+  end
+
+  # The matched request path
+  # @return [String]
+  def path
+    query_path.map(&:fragment).join('/')
+  end
+
+  # Do an additional lookup beneath this `Query`.
+  # @return [Query]
+  def match(path)
+    path = parse_path(path)
+    path.empty? ? self : match_one(path.shift).match(path)
+  end
+  alias :query :match
+
+  # Run the matched action along with hooks and processors
+  #
+  # @param [Hash] vars Instance variables to be set in the action
+  # evaluation scope.
+  #
+  # @return [Object] The (processed) result of running the action.
+  def run(vars={})
+    scope = ActionTree::EvalScope.new(
+      vars, default_vars, captures, helper_mixins)
+    begin
+      raise NotFound unless found?
+      run_everything(scope, vars)
+    rescue Exception => err
+      handler = handler_for(err)
+      handler ? scope.instance_exec(err, &handler) : raise
+    end
+  end
+
+
+  # The configuration inherited through the matched nodes,
+  # made available in the scope through @_conf.
+  def config
+    @config ||= node_path.inject(dialect::CONFIG) do |conf, node|
+      conf.merge(node.config)
+    end
+  end
+
+  # A hash of values captured by the query
+  def captures
+    return parent.captures unless @node
+
+    @captures ||= @parent ? 
+      @node.read_captures(@fragment, @parent.captures.dup) :
+        ActionTree::CaptureHash.new
+  end
+
+  private
+
+  # Variables for the execution scope
+  def default_vars
+    {
+      :_conf  => config,
+      :_query => self 
+    }
+  end
+
+  # the helpers mixed into the action scope
+  def helper_mixins
+    [dialect::Helpers] + node_path.map(&:helper_scope)
+  end
+
+  def parse_path(path)
+    case path
+      when Array then path
+      else path.to_s.gsub(/(^\/)|(\/$)/, '').split('/')
+    end
+  end
+
+  def inherit_via_nodes(&blk)
+    n = node_path.reverse.detect(&blk)
+    blk.call(n) if n
+  end
+
+  ### Helpers for matching during queries
+
+  # Return a child {Query} wrapping the {Node} matching `fragment`
+  def match_one(fragment)
+    self.class.new(
+      get_child(fragment),
+      self, fragment, @namespace
+      )
+  end
+
+  # Return the child {Node} matching `fragment`
+  def get_child(fragment)
+    @node.children.find {|n| n.match?(fragment) } if @node
+  end
+
+  ### Helpers for running actions
+
+  # Run hooks, action and processors; the whole shebang.
+  def run_everything(scope, vars)
+    apply scope, :before_hooks
+    result = scope.instance_eval(&@node.actions[@namespace])
+    result = process(scope, result)
+    apply scope, :after_hooks
+    result
+  end
+
+  # Run all hooks of `hook_type` in an {EvalScope}
+  def apply(scope, hook_type)
+    node_path.each do |node|
+      node.send(hook_type).each do |prc|
+        scope.instance_eval(&prc)
+      end
+    end
+  end
+
+  # Postprocess result by running it through the chain
+  # of defined processors.
+  # @see Query#processors
+  def process(scope, result)
+    processors.inject(result) do |result, processor|
+      scope.instance_exec(result, &processor)
+    end
+  end
+
+  # The chain of processors, defined using {Node#processor} and
+  # {Node#deep_processor}.
+  def processors
+    @processors = (@node ? @node.processors : []) +
+      node_path.reverse.map(&:deep_processors).flatten
+  end
+
+  # The proc defined to handle `err` using {Node#handle}, or `nil`.
+  def handler_for(err)
+    err = err.class unless err.is_a?(Class)
+    inherit_via_nodes {|n| n.exception_handlers[err] }
+  end
+end
+

data/lib/action_tree/basic/shared.rb

@@ -0,0 +1,25 @@
+
+# Conatins instance methods shared between
+# {Basic::Node} and {Basic::Query}. Part of {ActionTree::Basic} and therefore available to all ActionTree dialects.
+
+module ActionTree::Basic::Shared
+  
+  # The dialect that this {Node} or {Query} belongs to.
+  # The dialect is the module namespace containing the
+  # {Node} and {Query} classes.
+  # 
+  # @example
+  #   a = ActionTree::Basic.new
+  #   a.is_a?(ActionTree::Basic::Node) #=> true
+  #   a.dialect #=> ActionTree::Basic
+  #
+  # @see ActionTree::Basic
+  #
+  # @return [Module] the dialect of the current node or query
+  def dialect
+	self.class.name.split('::')[0..-2].
+	  inject(Kernel) do |current, next_const|
+		current.const_get(next_const)
+	  end
+  end
+end

data/lib/action_tree/capture_hash.rb

@@ -1,19 +1,44 @@
 
+# Accumulates captured variables during a query match.
+# Subclasses `Hash`, providing a non-destructive
+# {CaptureHash#add} method, and merging.
+#
+# @see ActionTree::Basic::Query#captures
+# @api private
 
 class ActionTree::CaptureHash < Hash
+
+  # {CaptureHash#add} each key and value in the given Hash.
+  #
+  # @return [CaptureHash] self, after merging
+  #
   def merge!(hsh)
-    hsh.each {|k, v| add(k,v) }
+    hsh.each {|k,v| add(k,v) }
+    self
   end
 
-  def merge(hsh)
-    dup.merge!(hsh)
+  # Nondestructive version of {CaptureHash#merge!}
+  #
+  # @return [CaptureHash]
+  def merge(*args)
+    dup.merge!(*args)
   end
 
+  # Add a specified value to a specified key.
+  #
+  # Depending on the value already at the specified key:
+  # 
+  # * `Array`: append the new value
+  # * `nil`: replace with new value
+  # * else: wrap existing value followed by new value in an Array
+  #
+  # @return [CaptureHash] self, after adding
   def add(key, value)
     case self[key]
       when nil    then self[key] = value
       when Array  then self[key] << value
       else             self[key] = [self[key], value]
     end
+    self
   end
 end

data/lib/action_tree/components/rack.rb

@@ -0,0 +1,52 @@
+
+require 'rack'
+
+
+
+
+
+module ActionTree::Components::Rack
+
+  require 'action_tree/components/rack/request.rb'
+  require 'action_tree/components/rack/response.rb'
+
+  CONFIG = {}
+
+  module NodeMethods
+
+    def call(env)
+      request   = Request.new(env)
+      response  = Response.new
+
+      response.finish do
+
+      end
+    
+      response.write match(
+        Rack::Utils.unescape(request.path_info)
+        ).run(request.request_method.to_sym, {
+          :request => request,
+          :response => response,
+          :get => request.GET,
+          :post => request.POST
+          })
+
+      response.finish
+    end
+  end
+
+  module QueryMethods
+  end
+
+  module Helpers
+    # FROM SINATRA:
+    # redirect
+    # content_type
+    def get(   loc=nil, &blk); action(loc, :get,    &blk);  end
+    def put(   loc=nil, &blk); action(loc, :put,    &blk);  end
+    def post(  loc=nil, &blk); action(loc, :post,   &blk);  end
+    def delete(loc=nil, &blk); action(loc, :delete, &blk);  end
+  end
+end
+
+

data/lib/action_tree/components/rack/request.rb

@@ -0,0 +1,59 @@
+
+# Subclass of Rack::Request. Copied from [Sinatra](http://sinatrarb.com).
+#
+# @see http://rack.rubyforge.org/doc/classes/Rack/Request.html Rack::Request
+
+
+class ActionTree::Component::Rack::Request < Rack::Request
+
+   def self.new(env)
+      env['actiontree.request'] ||= super
+    end
+
+    # Returns an array of acceptable media types for the response
+    def accept
+      @env['actiontree.accept'] ||= begin
+        entries = @env['HTTP_ACCEPT'].to_s.split(',')
+        entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+      end
+    end
+
+    def preferred_type(*types)
+      return accept.first if types.empty?
+      types.flatten!
+      accept.detect do |pattern|
+        type = types.detect { |t| File.fnmatch(pattern, t) }
+        return type if type
+      end
+    end
+
+    alias accept? preferred_type
+    alias secure? ssl?
+
+    def forwarded?
+      @env.include? "HTTP_X_FORWARDED_HOST"
+    end
+
+    def route
+      @route ||= begin
+        path = Rack::Utils.unescape(path_info)
+        path.empty? ? "/" : path
+      end
+    end
+
+    def path_info=(value)
+      @route = nil
+      super
+    end
+
+    private
+
+    def accept_entry(entry)
+      type, *options = entry.gsub(/\s/, '').split(';')
+      quality = 0 # we sort smalles first
+      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
+      [type, [quality, type.count('*'), 1 - options.size]]
+    end
+
+end
+

data/lib/action_tree/components/rack/response.rb

@@ -0,0 +1,10 @@
+
+  # The response object. Subclass of `Rack::Response`.
+  # 
+  # @see http://rack.rubyforge.org/doc/classes/Rack/Response.html Rack::Response
+  # @see http://rack.rubyforge.org/doc/classes/Rack/Response/Helpers.html Rack::ResponseHelpers
+  #
+  class Response < Rack::Response
+    
+    # Nothing here yet.
+  end

data/lib/action_tree/components/tilt.rb

@@ -0,0 +1,65 @@
+
+require 'tilt'
+
+module ActionTree::Components::Tilt
+
+  CONFIG = {:template_path => 'views'}
+
+  module NodeMethods
+    def templates
+      @templates ||= {}
+    end
+
+    def template(*args)
+      tilt    = args.find {|a| a.is_a?(Tilt::Template) }
+      name    = args.find {|a| a.is_a?(Symbol) }
+      source  = args.find {|a| a.is_a?(String) }
+      options = args.find {|a| a.is_a?(Hash) }
+
+      unless tilt
+        path = File.join(@conf[:template_path], source)
+        tilt = Tilt.new(path, nil, options)
+      end
+      templates[name] = tilt
+    end
+  end
+
+  module QueryMethods
+    
+    # Hash of templates like :name => [tmpl1, tmpl2, ...]
+    def templates
+      @templates ||= node_chain.inject({}) do |hsh, node|
+        hsh[name] ||= []
+        hsh[name] << node.templates[name]
+      end
+    end
+  end
+
+  module Helpers
+    
+    # Public: Renders a template
+    def render(*args, &blk)
+      tilt    = args.find {|a| a.is_a?(Tilt::Template) }
+      name    = args.find {|a| a.is_a?(Symbol) }
+      source  = args.find {|a| a.is_a?(String) }
+      options = args.find {|a| a.is_a?(Hash) }
+
+      if tilt && source
+        path = File.join(config[:template_path], source)
+        tilt = Tilt.new(path, nil, options)
+      end
+
+      templates = @_match.templates[name]
+
+      default :type, templates.first.class.default_mime_type
+
+      result =  tilt ? tilt.render(self, options, &blk) : nil
+
+      templates.reverse.inject(result) do |r, template|
+        template.render(self) { r }
+      end
+    end
+  end
+end
+
+