pakyow-presenter 0.6.1

data/pakyow-presenter/CHANGES

@@ -0,0 +1,3 @@
+= 0.6.0 / 2011-08-20
+
+ * Initial gem release of 0.6.0 codebase

data/pakyow-presenter/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Bryan Powell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/pakyow-presenter/lib/pakyow-presenter.rb

@@ -0,0 +1,13 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+# Gems 
+require 'nokogiri'
+
+# Base
+require 'presenter/base'
+include Presenter
+
+require 'presenter/presenter'
+require 'presenter/configuration/base'
+require 'presenter/helpers'

data/pakyow-presenter/lib/presenter/base.rb

@@ -0,0 +1,11 @@
+module Pakyow
+  module Presenter
+    autoload :PresenterBase,    'core/presenter_base'
+    autoload :ViewLookupStore,  'presenter/view_lookup_store'
+    autoload :View,             'presenter/view'
+    autoload :LazyView,         'presenter/lazy_view'
+    autoload :Binder,           'presenter/binder'
+    autoload :Views,            'presenter/views'
+    autoload :ViewContext,      'presenter/view_context'
+  end
+end

data/pakyow-presenter/lib/presenter/binder.rb

@@ -0,0 +1,60 @@
+module Pakyow
+  module Presenter
+    class Binder
+      include Pakyow::GeneralHelpers
+
+      class << self
+        attr_accessor :options
+        
+        def binder_for(klass)
+          View.binders = {} unless View.binders
+          View.binders[klass.to_s.to_sym] = self
+        end
+        
+        def options_for(*args)
+          self.options = {} unless self.options
+          self.options[args[0]] = args[1]
+        end
+      end
+      
+      attr_accessor :bindable, :object
+      
+      def initialize(bindable, object)
+        self.bindable = bindable
+        self.object = object
+      end
+      
+      def fetch_options_for(attribute)
+        if self.class.options
+          if options = self.class.options[attribute]
+            unless options.is_a?(Array) || options.is_a?(Hash)
+              options = self.send(options)
+            end
+          
+            return options
+          end
+        end
+      end
+      
+      def action
+        unless routes = Pakyow.app.restful_routes[bindable.class.name.to_sym]
+          Log.warn "Attempting to bind object to #{bindable.class.name.downcase}[action] but could not find restful routes for #{bindable.class.name}."
+          return {}
+        end
+        
+        if id = bindable.id
+          self.object.add_child('<input type="hidden" name="_method" value="put">')
+          
+
+          action = routes[:update].gsub(':id', id.to_s)
+          method = "post"
+        else
+          action = routes[:create]
+          method = "post"
+        end
+        
+        return { :action => action, :method => method }
+      end
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/configuration/base.rb

@@ -0,0 +1,12 @@
+module Pakyow
+  module Configuration
+    autoload :Presenter, 'presenter/configuration/presenter'
+    
+    class Base
+      # Fetches the server configuration    
+      def self.presenter
+        Configuration::Presenter
+      end
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/configuration/presenter.rb

@@ -0,0 +1,32 @@
+module Pakyow
+  module Configuration
+    class Presenter
+      class << self
+        attr_accessor :view_caching, :javascripts, :stylesheets, :view_dir, :default_view
+        
+        # Location of javascripts
+        def javascripts
+          @javascripts || '/javascripts'
+        end
+        
+        # Location of stylesheets
+        def stylesheets
+          @stylesheets || '/stylesheets'
+        end
+
+        def view_dir
+          @view_dir || "#{Configuration::Base.app.root}/app/views"
+        end
+        
+        def view_caching
+          @view_caching || false
+        end
+
+        def default_view
+          @default_view || "pakyow.html"
+        end
+
+      end
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/helpers.rb

@@ -0,0 +1,8 @@
+module Pakyow
+  module Helpers
+    def presenter
+      Pakyow.app.presenter.current_context = self
+      Pakyow.app.presenter
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/lazy_view.rb

@@ -0,0 +1,42 @@
+module Pakyow
+  module Presenter
+    class LazyView < View
+
+      def to_html(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def add_content_to_container(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def find(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def repeat_for(*args, &block)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def reset_container(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def title=(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+      def bind(*args)
+        Pakyow.app.presenter.ensure_root_view_built
+        super
+      end
+
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/presenter.rb

@@ -0,0 +1,180 @@
+module Pakyow
+  module Presenter
+    class Presenter < PresenterBase
+      attr_accessor :current_context
+      
+      #
+      # Methods that are called by core. This is the interface that core expects a Presenter to have
+      #
+
+      def reload!
+        load_views
+      end
+      
+      def present_for_request(request)
+        @presented = false
+        @root_path = nil
+        @root_view_is_built = false
+        @root_view = nil
+        @view_path = nil
+        @container_name = nil
+        @request = request
+      end
+      
+      def presented?
+        @presented
+      end
+      
+      def content
+        return unless view
+        request_container = @request.params[:_container]
+        return view.to_html(request_container) if request_container
+        view.to_html(@container_name)
+      end
+
+      #
+      # Methods that a controller can call to get and modify the root view.
+      # Some are meant to be called directly and some make up a dsl for dom modification
+      #
+
+      # Call these directly
+      #
+
+      def view_for_path(abstract_path, is_root_view=false, klass=View)
+        real_path = @view_lookup_store.real_path(abstract_path)
+        klass.new(real_path, is_root_view)
+      end
+
+      def view_for_class(view_class, path_override=nil)
+        return view_for_path(path_override, view_class.default_is_root_view, view_class) if path_override
+        view_for_path(view_class.default_view_path, view_class.default_is_root_view, view_class)
+      end
+
+      def view
+        ensure_root_view_built
+        @root_view
+      end
+
+      def set_view(view)
+        @root_view = View.new(view)
+        @root_view_is_built = true
+        @presented = true
+        @view_path = nil
+        @root_path = nil
+      end
+
+      def limit_to_container(id)
+        @container_name = id
+      end
+
+      def use_view_path(path)
+        @view_path = path
+        @root_view_is_built = false
+      end
+
+      def view_path
+        @view_path
+      end
+
+      def use_root_view_file(abstract_view_file)
+        real_path = @view_lookup_store.real_path(abstract_view_file)
+        @root_path = real_path
+        @root_view_is_built = false
+      end
+
+      def use_root_view_at_view_path(abstract_view_dir)
+        @root_path = @view_lookup_store.view_info(abstract_view_dir)[:root_view]
+        @root_view_is_built = false
+      end
+      
+      # This is for creating views from within a controller using the route based lookup mechanism
+      def view_for_view_path(v_p, name, deep = false)
+        v = nil
+        view_info = @view_lookup_store.view_info(v_p)
+        vpath = view_info[:views][name] if view_info
+        v = View.new(vpath) if vpath
+        if v && deep
+          populate_view(v, view_info[:views])
+        end
+        v
+      end
+
+      def populate_view_for_view_path(view, v_p)
+        return view unless view_info = @view_lookup_store.view_info(v_p)
+        views = view_info[:views]
+        populate_view(view, views)
+        view
+      end
+
+      # Call as part of View DSL for DOM manipulation
+      #
+
+      def with_container(container, &block)
+        ViewContext.new(self.view.find("##{container}").first).instance_eval(&block)
+      end
+
+      #
+      # Used by LazyView
+      #
+
+      def ensure_root_view_built
+        build_root_view unless @root_view_is_built
+      end
+
+      #
+      protected
+      #
+      
+      def build_root_view
+        @root_view_is_built = true
+
+        if @view_path
+          v_p = @view_path
+        elsif @request.restful
+          v_p = restful_view_path(@request.restful)
+        elsif @request.route_spec && @request.route_spec.index(':')
+          v_p = StringUtils.remove_route_vars(@request.route_spec)
+        else
+          v_p = @request.env['PATH_INFO']
+        end
+        return unless v_p
+        return unless view_info = @view_lookup_store.view_info(v_p)
+
+        @presented = true
+        @root_path ||= view_info[:root_view]
+        @root_view = LazyView.new(@root_path, true)
+        views = view_info[:views]
+        populate_view(self.view, views)
+      end
+      
+      def restful_view_path(restful_info)
+        if restful_info[:restful_action] == :show
+          "#{StringUtils.remove_route_vars(@request.route_spec)}/show"
+        else
+          StringUtils.remove_route_vars(@request.route_spec)
+        end
+      end
+
+      def load_views
+        @view_lookup_store = ViewLookupStore.new("#{Configuration::Presenter.view_dir}")
+      end
+
+      # populates the top_view using view_store data by recursively building
+      # and substituting in child views named in the structure
+      def populate_view(top_view, views)
+        containers = top_view.elements_with_ids
+        containers.each {|e|
+          name = e.attr("id")
+          path = views[name]
+          if path
+            v = populate_view(View.new(path), views)
+            top_view.reset_container(name)
+            top_view.add_content_to_container(v, name)
+          end
+        }
+        top_view
+      end
+
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/view.rb

@@ -0,0 +1,408 @@
+module Pakyow
+  module Presenter
+    class View
+      class << self
+        attr_accessor :binders, :cache, :default_view_path, :default_is_root_view
+
+        def view_path(dvp, dirv=false)
+          self.default_view_path = dvp
+          self.default_is_root_view = dirv
+        end
+      end
+
+      attr_accessor :doc
+            
+      def initialize(arg=nil, is_root_view=false)
+        arg = self.class.default_view_path if arg.nil? && self.class.default_view_path
+        is_root_view = self.class.default_is_root_view if arg.nil? && self.class.default_is_root_view
+        
+        if arg.is_a?(Nokogiri::XML::Element)
+          @doc = arg
+        elsif arg.is_a?(Pakyow::Presenter::Views)
+          @doc = arg.first.doc.dup
+        elsif arg.is_a?(Pakyow::Presenter::View)
+          @doc = arg.doc.dup
+        elsif arg.is_a?(String)
+          if arg[0, 1] == '/'
+            view_path = "#{Configuration::Presenter.view_dir}#{arg}"
+          else
+            view_path = "#{Configuration::Presenter.view_dir}/#{arg}"
+          end
+          # Only load one time if view caching is enabled
+          self.class.cache ||= {}
+          
+          if !self.class.cache.has_key?(view_path) || !Configuration::Base.presenter.view_caching
+            if is_root_view then
+              self.class.cache[view_path] = Nokogiri::HTML::Document.parse(File.read(view_path))
+            else
+              self.class.cache[view_path] = Nokogiri::HTML.fragment(File.read(view_path))
+            end
+          end
+          
+          @doc = self.class.cache[view_path].dup
+        else
+          raise ArgumentError, "No View for you! Come back, one year."
+        end
+      end
+
+      def add_content_to_container(content, container)
+        # TODO This .css call works but the equivalent .xpath call doesn't
+        # Need to investigate why since the .css call is internally turned into a .xpath call
+        if @doc && o = @doc.css("##{container}").first
+          content = content.doc unless content.class == String || content.class == Nokogiri::HTML::DocumentFragment || content.class == Nokogiri::XML::Element
+          o.add_child(content)
+        end
+      end
+      
+      def add_resource(*args)
+        type, resource, options = args
+        options ||= {}
+        
+        content = case type
+          when :js  then '<script src="' + Pakyow::Configuration::Presenter.javascripts + '/' + resource.to_s + '.js"></script>'
+          when :css then '<link href="' + Pakyow::Configuration::Presenter.stylesheets + '/' + resource.to_s + '.css" rel="stylesheet" media="' + (options[:media] || 'screen, projection') + '" type="text/css">'
+        end
+        
+        if self.doc.fragment? || self.doc.element?
+          self.doc.add_previous_sibling(content)
+        else
+          self.doc.xpath("//head/*[1]").before(content)
+        end
+      end
+      
+      def remove_resource(*args)
+        type, resource, options = args
+        options ||= {}
+        
+        case type
+          when :js then self.doc.css("script[src='#{Pakyow::Configuration::Presenter.javascripts}/#{resource}.js']").remove
+          when :css then self.doc.css("link[href='#{Pakyow::Configuration::Presenter.stylesheets}/#{resource}.css']").remove
+        end
+      end
+      
+      def find(element)
+        group = Views.new
+        @doc.css(element).each {|e| group << View.new(e)}
+        
+        return group
+      end
+      
+      def in_context(&block)
+        ViewContext.new(self).instance_eval(&block)
+      end
+      
+      def bind(object, type = nil)
+        type = type || StringUtils.underscore(object.class.name)
+        
+        # This works: .//*
+        # Not this:   .//*[@itemprop or @name]
+        # WTF!
+        #
+        @doc.xpath('.//*').each do |o|
+          if attribute = o.get_attribute('itemprop')
+            selector = attribute
+          elsif name = o.get_attribute('name')            
+            selector = name
+          else
+            next
+          end
+          
+          next unless attribute
+          
+          if selector.include?('[')
+            type_len    = type.length
+            object_type = selector[0,type_len]
+            attribute   = selector[type_len + 1, attribute.length - type_len - 2]
+          else
+            object_type = nil
+            attribute = selector
+          end
+          
+          next if !object_type.nil? && object_type != type          
+          
+          binding = {
+            :element => o,
+            :attribute => attribute.to_sym,
+            :selector => selector
+          }
+          
+          bind_object_to_binding(object, binding, object_type.nil?)
+        end
+      end
+      
+      def repeat_for(objects, &block)
+        if o = @doc
+          objects.each do |object|
+            view = View.new(self)
+            view.bind(object)
+            ViewContext.new(view).instance_exec(object, &block) if block_given?
+            
+            o.add_previous_sibling(view.doc)
+          end
+          
+          o.remove
+        end
+      end
+
+      def reset_container(container)
+        if @doc && o = @doc.css("*[id='#{container}']").first
+          o.inner_html = ''
+        end
+      end
+
+      def title=(title)
+        if @doc
+          if o = @doc.css('title').first
+            o.inner_html = title
+          else
+            if o = @doc.css('head').first
+              o.add_child(Nokogiri::HTML::fragment("<title>#{title}</title>"))
+            end
+          end
+        end
+      end
+
+      def title
+        o = @doc.css('title').first
+        o.inner_html if o
+      end
+      
+      def to_html(container = nil)
+        if container
+          if o = @doc.css('#' + container.to_s).first
+            o.inner_html
+          else
+            ''
+          end
+        else
+          @doc.to_html
+        end
+      end
+
+      alias :to_s :to_html
+
+      # Allows multiple attributes to be set at once.
+      # root_view.find(selector).attributes(:class => my_class, :style => my_style)
+      #
+      def attributes(*args)
+        if args.empty?
+          @previous_method = :attributes
+          return self
+        else
+          args[0].each_pair { |name, value|
+            @previous_method = :attributes
+            self.send(name.to_sym, value)            
+          }
+        end
+      end
+      
+      def remove
+        self.doc.remove
+      end
+      
+      alias :delete :remove
+      
+      def add_class(val)
+        self.doc['class'] = "#{self.doc['class']} #{val}".strip
+      end
+      
+      def remove_class(val)
+        self.doc['class'] = self.doc['class'].gsub(val.to_s, '').strip if self.doc['class']
+      end
+      
+      def has_class(val)
+        self.doc['class'].include? val
+      end
+      
+      def clear
+        self.doc.inner_html = ''
+      end
+      
+      def text
+        self.doc.inner_text
+      end
+      
+      def content
+        self.doc.inner_html
+      end
+      
+      alias :html :content
+      
+      def content=(content)
+        return unless content
+        self.doc.inner_html = content.to_s
+      end
+      
+      alias :html= :content=
+      
+      def append(content)
+        self.doc.inner_html += content.to_s
+      end
+      
+      alias :render :append
+      
+      def +(value)
+        if @previous_method
+          append_value(val)
+        else
+          super
+        end
+      end
+      
+      def <<(value)
+        if @previous_method
+          append_value(val)
+        else
+          super
+        end
+      end
+      
+      def method_missing(method, *args)
+        return unless @previous_method == :attributes
+        @previous_method = nil
+        
+        if method.to_s.include?('=')
+          attribute = method.to_s.gsub('=', '')
+          value = args[0]
+
+          self.doc[attribute] = value
+        else
+          return self.doc[method.to_s]
+        end
+      end
+      
+      def class(*args)
+        if @previous_method == :attributes
+          method_missing(:class, *args)
+        else
+          super
+        end
+      end
+      
+      def id
+        if @previous_method == :attributes
+          method_missing(:id)
+        else
+          super
+        end
+      end
+
+      def elements_with_ids
+        elements = []
+        @doc.traverse {|e|
+          if e.has_attribute?("id")
+            elements << e
+          end
+        }
+        elements
+      end
+
+      protected
+
+      def append_value(value_to_append)
+        case @previous_method
+        when :content
+          append(value_to_append)
+        end
+        
+        @previous_method = nil
+      end
+      
+      def bind_object_to_binding(object, binding, wild = false)
+        binder = nil
+        
+        # fetch value
+        if object.is_a? Hash
+          value = object[binding[:attribute]]
+        else
+          if View.binders
+            b = View.binders[object.class.to_s.to_sym] and binder = b.new(object, binding[:element])
+          end
+          
+          if binder && binder.class.method_defined?(binding[:attribute])
+            value = binder.send(binding[:attribute])
+          else
+            if wild && !object.class.method_defined?(binding[:attribute])
+              return
+            elsif Configuration::Base.app.dev_mode == true && !object.class.method_defined?(binding[:attribute])
+              Log.warn("Attempting to bind object to #{binding[:html_tag]}#{binding[:selector].gsub('*', '').gsub('\'', '')} but #{object.class.name}##{binding[:attribute]} is not defined.")
+              return
+            else
+              value = object.send(binding[:attribute])
+            end
+          end
+        end
+        
+        if value.is_a? Hash
+          value.each do |k, v|
+            if k == :content
+              bind_value_to_binding(v, binding, binder)
+            else
+              binding[:element][k.to_s] = v.to_s
+            end
+          end
+        else
+          bind_value_to_binding(value, binding, binder)
+        end
+      end
+
+      def bind_value_to_binding(value, binding, binder)
+        if !self.self_closing_tag?(binding[:element].name)
+          if binding[:element].name == 'select'
+            if binder
+              if options = binder.fetch_options_for(binding[:attribute])
+                html = ''
+                is_group = false
+
+                options.each do |opt|
+                  if opt.is_a?(Array)
+                    if opt.first.is_a?(Array)
+                      opt.each do |opt2|
+                        html << '<option value="' + opt2[0].to_s + '">' + opt2[1].to_s + '</option>'
+                      end
+                    else
+                      html << '<option value="' + opt[0].to_s + '">' + opt[1].to_s + '</option>'
+                    end
+                  else
+                    html << "</optgroup>" if is_group
+                    html << '<optgroup label="' + opt.to_s + '">'
+                    is_group = true
+                  end
+                end
+
+                html << "</optgroup>" if is_group
+
+                binding[:element].inner_html = html
+              end
+            end
+
+            if opt = binding[:element].css('option[value="' + value.to_s + '"]').first
+              opt['selected'] = 'selected'
+            end
+          else
+            binding[:element].inner_html = value.to_s
+          end
+        elsif binding[:element].name == 'input' && binding[:element][:type] == 'checkbox'
+          if value == true || binding[:element].attributes['value'].value == value.to_s
+            binding[:element]['checked'] = 'checked'
+          else
+            binding[:element].delete('checked')
+          end
+        elsif binding[:element].name == 'input' && binding[:element][:type] == 'radio'
+          if binding[:element].attributes['value'].value == value.to_s
+            binding[:element]['checked'] = 'checked'
+          else
+            binding[:element].delete('checked')
+          end
+        else
+          binding[:element]['value'] = value.to_s
+        end
+      end
+      
+      def self_closing_tag?(tag)
+        %w[area base basefont br hr input img link meta].include? tag
+      end
+      
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/view_context.rb

@@ -0,0 +1,20 @@
+module Pakyow
+  module Presenter
+    class ViewContext
+      include Helpers
+      
+      def initialize(context)
+        @context = context
+        self
+      end
+      
+      def context
+        @context
+      end
+      
+      def method_missing(method, *args)
+        Pakyow.app.presenter.current_context.send(method, *args)
+      end
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/view_lookup_store.rb

@@ -0,0 +1,213 @@
+module Pakyow
+  module Presenter
+    class ViewLookupStore
+
+      # @view_store is a hash structured as:
+      #  {
+      #      :view_dirs => {
+      #                      "/route" => {
+      #                                    :root_view => "path/to/root/view",
+      #                                    :views => {
+      #                                                "view1_name" => "path/to/view1",
+      #                                                "view2_name" => "path/to/view2"
+      #                                              }
+      #                                  },
+      #                      "/route/sub" => {
+      #                                        :root_view => "path/to/root/view",
+      #                                        :views => {
+      #                                                    "view1_name" => "path/to/view1",
+      #                                                    "view2_name" => "path/to/view2"
+      #                                                  }
+      #                                      }
+      #                    },
+      #      :abstract_paths =>  {
+      #                            "/abstract/path/file.html" => "/abstract.root1/path/file.html",
+      #                            "/some/other/path" => "/some/other.root1/path.root2"
+      #                          }
+      #  }
+      # This takes into account that a view directory may have a .root suffix.
+      # This not only determines the root view for that route (and sub-routes) but that
+      # the route doesn't include the suffix but the path to a view does
+
+      attr_reader(:view_dir)
+
+      def initialize(view_dir)
+        @view_store = {:view_dirs => {}, :abstract_paths => {}}
+        return unless File.exist?(view_dir)
+
+        @view_dir = view_dir
+
+        # wack the ./ at the beginning if it's there
+        view_dir = view_dir.sub(/^\.\//,'')
+
+        # making this a variable in case we change whether we store relative or absolute paths to views
+        absolute_path_prefix = view_dir # set to '' to store absolute paths
+
+        default_views = {} # view_basename => path_to_view.html
+        if File.exist?(view_dir) then
+          default_root_view_file_path = "#{absolute_path_prefix}/#{Configuration::Presenter.default_view}"
+          # See if the top level index directory overrides the default root view
+          index_dirs = Dir.entries(view_dir).partition{|e| File.directory?("#{absolute_path_prefix}/#{e}") && e.start_with?('index.')}[0]
+          if index_dirs.length == 1
+            default_root_view_file_path = "#{absolute_path_prefix}/#{StringUtils.split_at_last_dot(index_dirs[0])[1]}.html"
+          end
+          # The logic depends on this traversing top down
+          DirUtils.walk_dir(view_dir) { |vpath|
+            if File.directory?(vpath)
+              parent,route = pakyow_path_to_route_and_parent(vpath, view_dir, :dir)
+              # root_view is same as parent unless this route overrides it
+              # views are a copy of parent views
+              route_root_path = @view_store[:view_dirs][parent] ? @view_store[:view_dirs][parent][:root_view] : default_root_view_file_path
+              route_views = @view_store[:view_dirs][parent] ? deep_hash_clone(@view_store[:view_dirs][parent][:views]) : deep_hash_clone(default_views)
+              # see if this route overrides root_view
+              route_part, root_part = StringUtils.split_at_last_dot(vpath)
+              if root_part && root_part.include?('/')
+                route_part, root_part = vpath, nil
+              end
+              if root_part
+                if File.exist?("#{vpath}/#{root_part}.html")
+                  route_root_path = "#{vpath}/#{root_part}.html".sub(absolute_path_prefix, '')
+                elsif route_views[root_part]
+                  route_root_path = route_views[root_part]
+                else
+                  if Configuration::Base.app.dev_mode == true
+                    Log.warn("Root view #{root_part} referenced in #{vpath.sub(absolute_path_prefix, '')} was not found.")
+                  else
+                    Log.error("Root view #{root_part} referenced in #{vpath.sub(absolute_path_prefix, '')} was not found.")
+                    raise "Root view #{root_part} referenced in #{vpath.sub(absolute_path_prefix, '')} was not found."
+                  end
+                end
+              end
+              @view_store[:view_dirs][route] =
+                  {
+                    :root_view => route_root_path,
+                    :views => route_views
+                  }
+              # set the abstract path for this dir
+              if route == '/'
+                r_p = '/'
+              else
+                r_p = vpath.sub(absolute_path_prefix, '')
+              end
+              @view_store[:abstract_paths][route] = r_p
+              # duplicate real path under routes permuted with leading/trailing slash
+              permute_route(route).each { |r| @view_store[:abstract_paths][r] = r_p } unless route == '/'
+            else
+              # files here are direct overrides of the route's views
+              parent,route = pakyow_path_to_route_and_parent(vpath, view_dir, :file)
+              view_key = File.basename(vpath,".*")
+              unless @view_store[:view_dirs][route]
+                @view_store[:view_dirs][route] = deep_hash_clone(@view_store[:view_dirs][parent])
+              end
+              @view_store[:view_dirs][route][:views][view_key] = vpath.sub(absolute_path_prefix, '')
+              # see if view overrides the root view
+              if File.basename(@view_store[:view_dirs][route][:root_view],".*") == view_key
+                @view_store[:view_dirs][route][:root_view] = vpath.sub(absolute_path_prefix, '')
+              end
+              # set the abstract path for this file
+              # duplicating real path under route without the leading slash
+              r_p = vpath.sub(absolute_path_prefix, '')
+              if route == '/'
+                @view_store[:abstract_paths]["/#{File.basename(vpath)}"] = r_p
+                @view_store[:abstract_paths][File.basename(vpath)] = r_p
+              else
+                route_with_leading_slash = "#{route}/#{File.basename(vpath)}"
+                route_without_leading_slash = route_with_leading_slash.sub('/','')
+                @view_store[:abstract_paths][route_with_leading_slash] = r_p
+                @view_store[:abstract_paths][route_without_leading_slash] = r_p
+              end
+            end
+          }
+        end
+
+        # adjust @view_store '.../index' entries to override the parent
+        @view_store[:view_dirs].each_pair {|route,info|
+          next unless File.basename(route) == "index"
+          parent = File.dirname(route)
+          @view_store[:view_dirs][parent] = info
+        }
+        # adjust @view_store entries to have a '.../index' counterpart where missing
+        index_counterparts = {}
+        @view_store[:view_dirs].each_pair {|route,info|
+          next if File.basename(route) == "index" || @view_store[:view_dirs]["#{route}/index"]
+          if route == "/"
+            index_counterparts["/index"] = info
+          else
+            index_counterparts["#{route}/index"] = info
+          end
+        }
+        index_counterparts.each_pair { |route,info|
+          @view_store[:view_dirs][route] = info
+        }
+        # Duplicate the info for each combination of route with and without a leading and ending slash
+        # All current keys have a leading slash and no trailing slash
+        slash_permutations = {}
+        @view_store[:view_dirs].each_pair {|route0,info|
+          unless route0 == '/' then
+            route1, route2, route3 = permute_route(route0)
+            slash_permutations[route1] = info
+            slash_permutations[route2] = info
+            slash_permutations[route3] = info
+          end
+        }
+        slash_permutations.each_pair { |route,info|
+          @view_store[:view_dirs][route] = info
+        }
+      end
+
+      def view_info(route = nil)
+        if route
+          return @view_store[:view_dirs][route]
+        else
+          return @view_store[:view_dirs]
+        end
+      end
+
+      def real_path(abstract_path)
+        @view_store[:abstract_paths][abstract_path]
+      end
+      
+      private
+
+      # path can be of the form prefix_path/this/route.root1/overrides/some.root2/root
+      # returns the path without the .root_view parts
+      def pakyow_path_to_route_and_parent(path, path_prefix, file_or_dir)
+        return "","/" if path == path_prefix
+        route_path = path.sub("#{path_prefix}/", "")
+        unless route_path.include?("/")
+          return "","/" if :file == file_or_dir
+          return "/","/#{StringUtils.split_at_last_dot(route_path)[0]}"
+        end
+        route = ""
+        parent = ""
+        segments = route_path.split('/')
+        segments.each_with_index {|s,i|
+          next if (i >= segments.length-1 && :file == file_or_dir)
+          route_part = StringUtils.split_at_last_dot(s)[0]
+          route << "/#{route_part}"
+          next if (i >= segments.length-2 && :file == file_or_dir) || (i >= segments.length-1 && :dir == file_or_dir)
+          parent << "/#{route_part}"
+        }
+        parent = "/" if parent == ""
+        return parent,route
+      end
+
+      # Gonna just use Marshal for now.
+      # Can change later if needed since we only need to work
+      # on hashes of symbols, strings and hashes.
+      def deep_hash_clone(h)
+        Marshal.load(Marshal.dump(h))
+      end
+
+      # Takes a route with a leading slash and no trailing slash (/route) and
+      # returns the three other permutaions (/route/, route/, and route).
+      def permute_route(route0)
+        route3 = route0.sub('/','')
+        route2 = "#{route3}/"
+        route1 = "#{route0}/"
+        return route1,route2,route3
+      end
+
+    end
+  end
+end

data/pakyow-presenter/lib/presenter/views.rb

@@ -0,0 +1,115 @@
+module Pakyow
+  module Presenter
+    class Views
+      include Enumerable
+      
+      def initialize
+        @views = []
+      end
+      
+      def each
+        @views.each { |v| yield(v) }
+      end
+      
+      def in_context(&block)
+        ViewContext.new(self).instance_eval(&block)
+      end
+      
+      def attributes(*args)
+        self.each {|e| e.attributes(*args)}
+        return self
+      end
+      
+      def remove
+        self.each {|e| e.remove}
+      end
+      
+      alias :delete :remove
+      
+      def add_class(val)
+        self.each {|e| e.add_class(val)}
+      end
+      
+      def remove_class(val)
+        self.each {|e| e.remove_class(val)}
+      end
+      
+      def clear
+        self.each {|e| e.clear}
+      end
+      
+      def text
+        self.map { |v| v.text }
+      end
+      
+      def content
+        self.map { |v| v.content }
+      end
+      
+      alias :html :content
+      
+      def content=(content)
+        self.each {|e| e.content = content}
+      end
+      
+      alias :html= :content=
+
+      def to_html
+        self.map { |v| v.to_html }.join('')
+      end
+
+      alias :to_s :to_html
+
+      def append(content)
+        self.each {|e| e.append(content)}
+      end
+      
+      alias :render :append
+      
+      def +(val)
+        self.each {|e| e + val}
+      end
+      
+      def <<(val)
+        if val.is_a? View
+          @views << val
+        else
+          self.each {|e| e << val}
+        end
+      end
+      
+      def method_missing(method, *args)
+        if method.to_s.include?('=')
+          self.each {|e| e.send(method, *args)}
+        else
+          self.map {|e| e.send(method, *args)}
+        end
+      end
+      
+      def class(*args)
+        method_missing(:class, *args)
+      end
+      
+      def id
+        method_missing(:id)
+      end
+      
+      def repeat_for(objects, &block)
+        # Repeat for first match
+        self.first.repeat_for(objects, &block)
+        
+        # Remove other matches
+        self.each {|e| e.doc.remove}
+      end
+      
+      def bind(object)
+        self.each {|e| e.bind(object)}
+      end
+      
+      def find(element)
+        views = Views.new
+        self.each {|e| e.find(element, &block).each { |v| views << v }}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: pakyow-presenter
+version: !ruby/object:Gem::Version 
+  hash: 5
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 1
+  version: 0.6.1
+platform: ruby
+authors: 
+- Bryan Powell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pakyow-core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  type: :runtime
+  version_requirements: *id002
+description: pakyow-presenter
+email: bryan@metabahn.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- pakyow-presenter/CHANGES
+- pakyow-presenter/README
+- pakyow-presenter/MIT-LICENSE
+- pakyow-presenter/lib/pakyow-presenter.rb
+- pakyow-presenter/lib/presenter/base.rb
+- pakyow-presenter/lib/presenter/binder.rb
+- pakyow-presenter/lib/presenter/configuration/base.rb
+- pakyow-presenter/lib/presenter/configuration/presenter.rb
+- pakyow-presenter/lib/presenter/helpers.rb
+- pakyow-presenter/lib/presenter/lazy_view.rb
+- pakyow-presenter/lib/presenter/presenter.rb
+- pakyow-presenter/lib/presenter/view.rb
+- pakyow-presenter/lib/presenter/view_context.rb
+- pakyow-presenter/lib/presenter/view_lookup_store.rb
+- pakyow-presenter/lib/presenter/views.rb
+homepage: http://pakyow.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- pakyow-presenter/lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pakyow-presenter
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: pakyow-presenter
+test_files: []
+