action_tree 0.1.0

data/TODO

@@ -0,0 +1,32 @@
+
+
+
+
+dialect mixins
+  templating
+
+rewrite tests
+tests for:
+  variable scope copy
+  after hooks
+  action namespaces
+  running different action layers
+  get, put, post, delete
+  postprocessors
+  mounting
+  layers & application
+
+
+documentation for:
+  postprocessors
+  action namespaces
+  new mounting
+  layer application
+    ActionTree.layer
+    Node.apply(layer)
+  mounting versus layer application
+  get, put, post, and update helpers
+  DSL shorthands/aliases
+  applying plugins
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/action_tree/basic/match.rb

@@ -0,0 +1,132 @@
+
+
+
+
+class ActionTree::Basic::Match
+
+  include ::ActionTree::DialectHelper
+
+  DEFAULT_HELPERS = []
+
+  attr_reader :node, :selected_scope, :parent, :fragment
+
+  def initialize(node, parent, fragment)
+    @node, @parent, @fragment = node, parent, fragment
+  end
+
+  def found?; @node; end
+
+  def captures
+    @captures ||= read_captures
+  end
+
+  def match_chain
+    @match_chain ||= @parent ? @parent.match_chain << self : [self]
+  end
+
+  def valid_match_chain
+    @valid_match_chain ||= match_chain.select(&:node)
+  end
+
+  def node_chain
+    @node_chain ||= valid_match_chain.map(&:node)
+  end
+
+  def path
+    match_chain.map(&:fragment).join('/')
+  end
+
+  # Run the action; first the before filters within the match chain, then the actions, then the postprocessors, then the after filters, returning the return value of the last evaluated action.
+  def run(namespace=:default, *scope_sources)
+
+    eval_scope = ::ActionTree::EvalScope.new(
+      *helper_mixins, *scope_sources, captures,
+      *DEFAULT_HELPERS,
+      {:__match => self}
+      )
+
+    hooks(:before_hooks).each {|prc| eval_scope.instance_eval(&prc) }
+    result = eval_scope.instance_eval(&main_action(namespace))
+    hooks(:after_hooks).each  {|prc| eval_scope.instance_eval(&prc) }
+
+    postprocessors.inject(result) do |result, postprocessor|
+      eval_scope.instance_exec(result, &postprocessor)
+    end
+  end
+
+
+  # Return @self@ or a descendant matching @path@, or a {NotFound} if not found.
+  def match(path)
+    path = parse_path(path)
+    return self if path.empty?
+    return self unless found?
+
+    fragment = path.shift
+    @node.children.each do |child|
+      if child.match?(fragment)
+        return self.class.new(
+          child, self, fragment).match(path)
+      end
+    end
+
+    self.class.new(nil, self, fragment) # not found
+  end
+
+  private
+    def parse_path(path)
+      case path
+        when Array then path
+        else path.to_s.gsub(/(^\/)|(\/$)/, '').split('/')
+      end
+    end
+
+    def not_found_handler
+      node_chain.reverse.each do |node|
+        return node.not_found_handler if node.not_found_handler
+      end; nil
+    end
+
+    def read_captures
+      hsh = ::ActionTree::CaptureHash.new
+
+      match_chain[1..-1].each do |m|
+        if m.found? && m.node.capture_names.any?
+          raw_captures = m.fragment.match(m.node.regexp).captures
+          m.node.capture_names.each_with_index do |name, i|
+            hsh.add(name, raw_captures[i])
+          end
+        end
+      end
+      hsh
+    end
+
+    def main_action(namespace)
+      (found? ?
+        @node.action_namespaces[namespace] :
+        not_found_handler
+      ) || Proc.new { nil }
+    end
+
+    def helper_mixins
+      node_chain.map(&:helper_scope)
+    end
+
+    def hooks(type)
+      node_chain.map {|n| n.send(type) }.flatten
+    end
+
+    def postprocessors
+      @node ? @node.postprocessors : []
+    end
+
+    def inherit_via_node_chain(&blk)
+      n = node_chain.reverse.detect(&blk)
+      n ? blk.call(n) : nil
+    end
+
+end
+
+
+
+
+

data/lib/action_tree/basic/node.rb

@@ -0,0 +1,180 @@
+
+class ActionTree::Basic::Node
+
+  include ::ActionTree::DialectHelper
+
+  attr_reader   :token, :children, :helper_scope,
+                :action_namespaces, :before_hooks,
+                :after_hooks, :postprocessors
+  attr_accessor :not_found_handler
+
+
+  def initialize(path=[], &blk)
+    path = parse_path(path)
+    @token          = path.shift
+    @children       = Set.new
+    @helper_scope   = Module.new
+    @before_hooks   = []
+    @after_hooks    = []
+    @postprocessors = []
+    @action_namespaces = {}
+    @not_found_handler = nil
+    route(path, &blk) if block_given?
+  end
+
+  # INSPECTION
+
+  def inspect
+    "#<#{self.class}:#{self.object_id.to_s(16)} #{display_name} >"
+  end
+
+  def display_name
+    case @token
+      when String then @token
+      when Symbol then @token.inspect
+      when Regexp then @token.source
+      when nil    then '(nil)'
+    end + ' ' + [
+      @actions.size.to_s,
+      @before_hooks.size,
+      @after_hooks.size
+      ].join(', ')
+  end
+
+  def printout(stack='')
+    stack + display_name + "\n" +
+    @children.map {|c| c.printout(stack + '  ') }.join
+  end
+
+  # MATCHING
+  
+  def regexp
+    @regexp ||=
+      Regexp.new('^' + case @token
+        when Regexp then "(#{@token.source})"
+        when Symbol then '(.+)'
+        when String then @token.gsub(/:\w+/, '(.+)')
+        #when nil    then '\/*'
+      end + '$')
+  end
+
+  def match?(path_fragment)
+    !!path_fragment.match(regexp)
+  end
+
+  def capture_names
+    case @token
+      when Regexp then ['match']
+      when Symbol then [@token.to_s]
+      when String
+        @token.scan(/:\w+/).map {|m| m[1..-1] }
+    end
+  end
+
+
+  # DSL
+
+  def route(location=nil, &blk)
+    descend(location).instance_eval(&blk) if blk
+    self
+  end
+  alias :with :route
+  alias :w :route
+  alias :r :route
+  alias :_ :route
+  def apply(layer); route(&layer); end
+
+  def action(location=nil, namespace=:default, &blk)
+    descend(location).action_namespaces[namespace] = blk
+    self
+  end
+  alias :a :action
+  alias :o :action
+  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
+
+  def helpers(location=nil, &blk)
+    descend(location).helper_scope.module_eval(&blk)
+  end
+
+  def before(location=nil, &blk)
+    descend(location).before_hooks << blk if blk
+  end
+  alias :b :before
+
+  def after(location=nil, &blk)
+    descend(location).after_hooks << blk if blk
+  end
+
+  def not_found(location=nil, &blk)
+    descend(location).not_found_handler = blk if blk
+  end
+  alias :x :not_found
+
+  def postprocessor(location=nil, &blk)
+    descend(location).postprocessors << blk if blk
+  end
+  alias :p :postprocessor
+
+  def mount(node, location=nil)
+      if node.token
+        descend(location).children < node
+      else
+        raise 'root nodes can not be mounted. apply a layer instead.'
+      end
+  end
+
+  
+  # LOOKUPS
+
+  def match(path=[])
+    dialect::Match.new(self, nil, nil).match(path)
+  end
+
+  def descend(path)
+    loc = parse_path(path)
+    if loc.empty? then self else
+      token = loc.shift
+      (get_child(token) || make_child(token)).descend(loc)
+    end
+  end
+
+
+  private
+
+    def get_child(token)
+      @children.each do |child|
+        return child if child.token == token
+      end; nil
+    end
+
+    def make_child(token)
+      child = self.class.new(token)
+      @children << child
+      child
+    end
+
+    # convert any valid path syntax to array syntax
+    def parse_path(path)
+      case path
+        when nil            then []
+        when Array          then path
+        when Regexp, Symbol then [path]
+        when String         then parse_string_path(path)
+        else
+          raise "invalid path #{path}"
+      end
+    end
+
+    # convert a string to array path syntax
+    def parse_string_path(path)
+      path.gsub(/(^\/)|(\/$)/, ''). # remove trailing slashes
+        split('/').map do |str|     # split tokens
+          str.match(/^:\w+$/) ?     # replace ':c' with :c
+            str[1..-1].to_sym : str
+        end
+    end
+end
+

data/lib/action_tree/capture_hash.rb

@@ -0,0 +1,19 @@
+
+
+class ActionTree::CaptureHash < Hash
+  def merge!(hsh)
+    hsh.each {|k, v| add(k,v) }
+  end
+
+  def merge(hsh)
+    dup.merge!(hsh)
+  end
+
+  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
+  end
+end

data/lib/action_tree/dialect_helper.rb

@@ -0,0 +1,12 @@
+
+module ActionTree::DialectHelper
+
+  # access to the dialect namespace
+  def dialect
+    modules = self.class.name.split('::')
+    modules.pop
+    modules.inject(Kernel) do |current, next_const|
+      current.const_get(next_const)
+    end
+  end
+end

data/lib/action_tree/eval_scope.rb

@@ -0,0 +1,23 @@
+
+# The scope in which matched actions are run. Used to copy instance variables, define instance variables from captures, and extend helper method modules.
+
+class ActionTree::EvalScope
+  def initialize(*ingredients)
+    ingredients.each do |ing|
+      case ing
+        when Hash
+          ing.each do |name, value|
+            instance_variable_set(:"@#{name}", value)
+          end
+        when Module
+          extend ing
+        else
+          ing.instance_variables.each do |name|
+            self.instance_variable_set(name,
+              ing.instance_variable_get(name)
+              )
+          end
+      end
+    end
+  end
+end

data/lib/action_tree/plugins/tilt.rb

@@ -0,0 +1,65 @@
+
+
+
+require 'tilt'
+
+module ActionTree::Plugins::Tilt
+
+  CACHE = Tilt::Cache.new
+
+  module NodeMixin
+    # sets a default, optionally namespaced, layout for this and
+    # descending nodes
+    def layout(path, namespace=nil)
+      layout_namespaces[namespace] = path
+    end
+
+    def layout_namespaces
+      @layout_namespaces ||= {}
+    end
+
+    # sets a default view folder path for this and descending nodes.
+    def view_path(path=nil)
+      path ? @view_path = path : @view_path
+    end
+  end
+
+  module MatchMixin
+    def view_path
+      inherit_via_node_chain(&:view_path) || '.'
+    end
+
+    def layout(namespace=nil)
+      inherit_via_node_chain do |node|
+        node.layout_namespaces[namespace]
+      end
+    end
+  end
+
+
+  module Helpers
+
+    def render(path, layout_namespace=nil, &blk)
+      path = ::File.join(@__match.view_path, path)
+      
+      template = ::ActionTree::Plugins::Tilt::CACHE.fetch(
+        path) { Tilt.new(path, nil, {}) }
+      
+      if respond_to?(:content_type)
+        content_type(template.class.default_mime_type)
+      end
+
+      result = template.render(self, &blk)
+
+      layout = @__match.layout(layout_namespace)
+      if layout && !%w{sass scss less coffee}.include?(File.extname(path))
+        render(layout, :AbSoLuTeLy_No_LaYoUt) { result }
+      else
+        result
+      end
+    end
+
+  end
+
+end
+