pakyow-presenter 0.8rc1 → 0.8.rc4

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

@@ -0,0 +1,126 @@
+module Pakyow
+  module Presenter
+    class Page
+      MATTER_MATCHER = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+
+      class << self
+        def load(path)
+          format   = StringUtils.split_at_last_dot(path)[-1]
+          name     = File.basename(path, '.*').to_sym
+          contents = FileTest.file?(path) ? File.read(path) : nil
+
+          return Page.new(name, contents, path, format)
+        end
+      end
+
+      attr_reader :contents, :path
+
+      def initialize(name, contents, path, format = :html)
+        @name, @contents, @path, @format = name, contents, path, format
+
+        @info    = {}
+        @content = {}
+
+        unless @contents.nil?
+          parse_info
+          parse_content
+        end
+
+        partials
+      end
+
+      def initialize_copy(original_page)
+        super
+
+        # copy content
+        @content = {}
+        original_page.content.each_pair do |k, v|
+          @content[k] = v.dup
+        end
+      end
+
+      def build(partial_map)
+        partials.each do |container, partial_list|
+          partial_list.each do |partial_name|
+            regex = /<!--\s*@include\s*#{partial_name}\s*-->/
+            @content[container].gsub!(regex, partial_map[partial_name].to_s)
+
+            partial_map.delete(partial_name)
+          end
+        end
+
+        # we have more partials
+        if partial_map.count > 0
+          # initiate another build if content contains partials
+          build(partial_map) if partials(true).count > 0
+        end
+
+        return self
+      end
+
+      def content(container = nil)
+        return container.nil? ? @content : @content[container.to_sym]
+      end
+
+      def template
+        @info[:template] || :pakyow
+      end
+
+      def ==(page)
+        @contents == page.contents
+      end
+
+      def partials(refind = false)
+        @partials = (!@partials || refind) ? find_partials : @partials
+      end
+
+      private
+
+      def parse_info
+        info = parse_front_matter(@contents)
+        info = {} if !info || !info.is_a?(Hash)
+
+        @info = HashUtils.symbolize(info)
+      end
+
+      def parse_content
+        # remove yaml front matter
+        @contents.gsub!(/---(.|\n)*---/, '')
+
+        # process contents
+        @contents = Presenter.process(@contents, @format)
+
+        # find content in named containers
+        within_regex = /<!--\s*@within\s*([a-zA-Z0-9\-_]*)\s*-->(.*?)<!--\s*\/within\s*-->/m
+
+        @contents.scan(within_regex) do |m|
+          container = m[0].to_sym
+          @content[container] = m[1]
+        end
+
+        # find default content
+        @content[:default] = @contents.gsub(within_regex, '')
+      end
+
+      # returns an array of hashes, each with the partial name and doc
+      def find_partials
+        partials = {}
+
+        partial_regex = /<!--\s*@include\s*([a-zA-Z0-9\-_]*)\s*-->/
+        @content.each do |name, content|
+          content.scan(partial_regex) do |m|
+            partials[name] ||= []
+            partials[name] << m[0].to_sym
+          end
+        end
+
+        return partials
+      end
+
+      def parse_front_matter(contents)
+        matter = YAML.load(contents.match(MATTER_MATCHER).to_s)
+        return matter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Pakyow
+  module Presenter
+    class Partial
+      include DocHelpers
+
+      class << self
+        def load(path)
+          format    = StringUtils.split_at_last_dot(path)[-1]
+          contents  = File.read(path)
+          name      = File.basename(path, '.*')[1..-1].to_sym
+
+          return self.new(name, contents, format)
+        end
+      end
+
+      def initialize(name, contents, format = :html)
+        @name = name
+
+        processed = Presenter.process(contents, format)
+        @doc = Nokogiri::HTML.fragment(processed)
+      end
+    end
+  end
+end

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

@@ -1,255 +1,188 @@
 module Pakyow
   module Presenter
-    class Presenter < PresenterBase
+    class Presenter
       class << self
-        attr_accessor :proc
-      end
+        def process(contents, format)
+          format = format.to_sym
 
-      attr_accessor :current_context, :parser_store, :view_store
+          unless app = Pakyow.app
+            return contents
+          end
 
-      def initialize
-        reset_state
-        reset_bindings
-      end
+          unless presenter = app.presenter
+            return contents
+          end
 
-      def scope(name, set = :default, &block)
-        @bindings[set] ||= {}
+          unless processor = presenter.processor_store[format]
+            Pakyow.logger.warn("No processor defined for extension #{format}") unless format == :html
+            return contents
+          end
 
-        bs = Bindings.for(block)
-        @bindings[set][name] = bs
-        bs
+          return processor.call(contents)
+        end
       end
 
-      def bindings(scope)
-        #TODO think about merging on launch instead
-        @bindings.inject(Bindings.new) { |bs, b| bs.merge(b[1][scope]) }
-      end
+      Pakyow::App.before(:init) {
+        @presenter = Presenter.new
+      }
 
-      def reset_bindings(set = :default)
-        @bindings ||= {}
-        @bindings[set] = {}
-      end
+      Pakyow::App.after(:match) {
+        @presenter = Pakyow.app.presenter.dup
+        @presenter.prepare_for_request(@request)
+      }
 
-      def current_view_lookup_store
-        @view_stores[self.view_store]
-      end
+      Pakyow::App.after(:route) {
+        if @presenter.presented?
+          @found = true
+          @response.body = [@presenter.content]
+        else
+          @found = false unless found?
+        end
+      }
 
-      #
-      # Methods that are called by core. This is the interface that core expects a Presenter to have
-      #
+      Pakyow::App.after(:load) {
+        @presenter.load
+      }
 
-      def load
-        load_views
+      Pakyow::App.after(:error) {
+        unless config.app.errors_in_browser
+          @response.body = [@presenter.content] if @presenter.presented?
+        end
+      }
+
+      attr_accessor :processor_store, :binder, :path, :template, :page
 
-        self.reset_bindings
-        self.instance_eval(&Presenter.proc) if Presenter.proc
+      def initialize
+        setup
       end
 
-      def prepare_for_request(request)
-        reset_state()
-        @request = request
+      def setup
+        @view, @template, @page = nil
+        @constructed = false
+        self.store   = :default
+      end
 
-        if @request && @request.route_path && !@request.route_path.is_a?(Regexp) && @request.route_path.index(':')
-          @view_path = StringUtils.remove_route_vars(@request.route_path)
+      def store(name = nil)
+        if name
+          @view_stores[name]
         else
-          @view_path = @request && @request.working_path
+          @view_stores[@store]
         end
-        @root_path = self.current_view_lookup_store.root_path(@view_path)
-      end
-      
-      def reset
-        @request = nil
-        reset_state
-      end
-      
-      def presented?
-        #TODO the right thing to do?
-        self.ensure_root_view_built
-        
-        @presented
-      end
-      
-      def content
-        return unless view
-        request_container = @request.params[:_container] if @request
-        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 store=(name)
+        @store = name
 
-      def view_for_path(abstract_path, is_root_view=false, klass=View)
-        real_path = self.current_view_lookup_store.real_path(abstract_path)
-        klass.new(real_path, is_root_view)
+        return unless @path
+        setup_for_path
       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)
+      def load
+        load_processors
+        load_views
+        load_bindings
       end
 
-      def view
-        ensure_root_view_built
-        @root_view
-      end
+      def prepare_for_request(request)        
+        @request = request
 
-      def view=(v)
-        # TODO: Why is it important to dup here?
-        @root_view = View.new(v)
-        @root_view_is_built = true
-        @presented = true
+        if @request.has_route_vars?
+          @path = StringUtils.remove_route_vars(@request.route_path)
+        else
+          @path = @request.path
+        end
 
-        # reset paths
-        @view_path = nil
-        @root_path = nil
+        setup
       end
 
-      def root
-        @is_compiled = false
-        @root ||= View.root_at_path(@root_path) 
+      def presented?
+        ensure_construction
+        @constructed
       end
 
-      def root=(v)
-        @is_compiled = false
-        @root = v
+      def content
+        return unless view
+        view.to_html
       end
 
-      def limit_to_container(id)
-        @container_name = id
+      def view
+        ensure_construction
+        @view
       end
 
-      def view_path
-        @view_path
+      def partial(name)
+        store.partial(@path, name)
       end
 
-      def view_path=(path)
-        @is_compiled = false
-        @view_path = path
+      def view=(view)
+        @view = view
+        @constructed = true
       end
 
-      def root_path
-        @root_path
-      end
+      def template=(template)
+        unless template.is_a?(Template)
+          # get template by name
+          template = store.template(template)
+        end
 
-      def root_path=(abstract_path)
-        @is_compiled = false
-        @root = nil
-        @root_path = abstract_path
+        @template = template
+        @constructed = false
       end
 
-      # Call as part of View DSL for DOM manipulation
-      #
-
-      def with_container(container, &block)
-        v = self.view.find("##{container}").first
-        ViewContext.new(v).instance_exec(v, &block)
+      def page=(page)
+        @page = page
+        @constructed = false
       end
 
-      #
-      # Used by LazyView
-      #
-
-      def ensure_root_view_built
-        build_root_view unless @root_view_is_built
+      def path=(path)
+        @path = path
+        setup_for_path(true)
       end
 
-      #
-      protected
-      #
+      def ensure_construction
+        # only construct once
+        return if @constructed
 
-      def reset_state
-        @view_store = :default
-        @presented = false
-        @root_path = nil
-        @root_view_is_built = false
-        @root_view = nil
-        @view_path = nil
-        @container_name = nil
-      end
+        # if no template/page was found, we can't construct
+        return if @template.nil? || @page.nil?
 
-      def build_root_view
-        @root_view_is_built = true
+        # construct
+        @view = @template.dup.build(@page)
+        @constructed = true
+      end
 
-        return unless v_p = @view_path
+      protected
 
-        return unless view_info = self.current_view_lookup_store.view_info(v_p)
-        @root_path ||= view_info[:root_view]
+      def setup_for_path(explicit = false)
+        self.template = store.template(@path)
+        self.page     = store.page(@path)
+        self.view     = store.view(@path)
 
-        if Configuration::Base.presenter.view_caching
-          r_v = @populated_root_view_cache.get([v_p, @root_path]) {
-            populate_view(LazyView.new(@root_path, true), view_info[:views])
-          }
-            @root_view = r_v.dup
-            @presented = true
-        else
-          @root_view = populate_view(LazyView.new(@root_path, true), view_info[:views])
-          @presented = true
-        end
-      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
+        @constructed = true
+      rescue MissingView => e # catches no view path error
+        explicit ? raise(e) : Pakyow.logger.debug(e.message)
+        @constructed = false
       end
 
       def load_views
         @view_stores = {}
-        Configuration::Presenter.view_stores.each_pair {|name, path|
-          @view_stores[name] = ViewLookupStore.new(path)
-        }
-
-        if Configuration::Base.presenter.view_caching then
-          @populated_root_view_cache = build_root_view_cache(self.current_view_lookup_store.view_info)
-        end
-      end
 
-      def build_root_view_cache(view_info)
-        cache = Pakyow::Cache.new
-        view_info.each{|dir,info|
-          r_v = LazyView.new(info[:root_view], true)
-          populate_view(r_v, info[:views])
-          key = [dir, info[:root_view]]
-          cache.put(key, r_v)
+        Config::Presenter.view_stores.each_pair {|name, path|
+          @view_stores[name] = ViewStore.new(path, name)
         }
-        cache
       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)
-        top_view.containers.each {|e|
-          next unless path = views[e[:name]]
+      def load_bindings
+        @binder = Binder.instance.reset
 
-          v = populate_view(View.new(path), views)
-          self.reset_container(e[:doc])
-          self.add_content_to_container(v, e[:doc])
+        Pakyow::App.bindings.each_pair {|set_name, block|
+          @binder.set(set_name, &block)
         }
-        top_view
-      end
-
-      def parser(format, &block)
-        @parser_store ||= {}
-        @parser_store[format.to_sym] = block
       end
 
-      def add_content_to_container(content, container)
-        content = content.doc unless content.class == String || content.class == Nokogiri::HTML::DocumentFragment || content.class == Nokogiri::XML::Element
-        container.add_child(content)
+      def load_processors
+        @processor_store = Pakyow::App.processors
       end
-
-      def reset_container(container)
-        container.inner_html = ''
-      end
-
     end
   end
 end

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

@@ -0,0 +1,79 @@
+module Pakyow
+  module Presenter
+    class Template
+      include DocHelpers
+      attr_accessor :name, :doc
+
+      class << self
+        def load(path)
+          format    = StringUtils.split_at_last_dot(path)[-1]
+          contents  = File.read(path)
+          name      = File.basename(path, '.*').to_sym
+
+          return self.new(name, contents, format)
+        end
+      end
+
+      def initialize(name, contents, format = :html)
+        @name = name
+
+        if contents.is_a?(Nokogiri::HTML::Document)
+          @doc = contents
+        else
+          processed = Presenter.process(contents, format)
+          @doc = Nokogiri::HTML::Document.parse(processed)
+        end
+
+        containers
+      end
+
+      def initialize_copy(original_template)
+        super
+
+        # copy doc
+        @doc = original_template.doc.dup
+      end
+
+      def container(name = :default)
+        container = @containers[name.to_sym]
+        return view_from_path(container[:path])
+      end
+
+      def containers(refind = false)
+        @containers = (!@containers || refind) ? find_containers : @containers
+      end
+
+      def build(page)
+        # add content to each container
+        containers.each do |container|
+          name = container[0]
+
+          if content = page.content(name)
+            container(name).replace(content)
+          else
+            Pakyow.logger.debug "No content for '#{name}' in page '#{page.path}'"
+          end
+        end
+
+        return View.from_doc(doc)
+      end
+
+      private
+
+      # returns an array of hashes, each with the container name and doc
+      def find_containers
+        containers = {}
+
+        @doc.traverse {|e|
+          next unless e.is_a?(Nokogiri::XML::Comment)
+          next unless match = e.text.strip.match(/@container( ([a-zA-Z0-9\-_]*))*/)
+          name = match[2] || :default
+
+          containers[name.to_sym] = { doc: e, path: path_to(e) }
+        }
+
+        return containers
+      end
+    end
+  end
+end