pakyow-presenter 0.8.0 → 0.9.0

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

@@ -1,76 +1,16 @@
 module Pakyow
   module Presenter
     module DocHelpers
-      def breadth_first(doc)
-        queue = [doc]
-        until queue.empty?
-          node = queue.shift
-          catch(:reject) {
-            yield node
-            queue.concat(node.children)
-          }
-        end
+      def self.self_closing_tag?(tag)
+        %w[area base basefont br hr input img link meta].include? tag
       end
 
-      def path_to(child)
-        path = []
-
-        return path if child == @doc
-
-        child.ancestors.each {|a|
-          # since ancestors goes all the way to doc root, stop when we get to the level of @doc
-          break if a.children.include?(@doc)
-
-          path.unshift(a.children.index(child))
-          child = a
-        }
-
-        return path
-      end
-
-      def path_within_path?(child_path, parent_path)
-        parent_path.each_with_index {|pp_step, i|
-          return false unless pp_step == child_path[i]
-        }
-
-        true
+      def self.form_field?(tag)
+        %w[input select textarea button].include? tag
       end
 
-      def doc_from_path(path)
-        o = @doc
-
-        # if path is empty we're at self
-        return o if path.empty?
-
-        path.each {|i|
-          if child = o.children[i]
-            o = child
-          else
-            break
-          end
-        }
-
-        return o
-      end
-
-      def view_from_path(path)
-        view = View.from_doc(doc_from_path(path))
-        view.related_views << self
-
-        # workaround for nokogiri in jruby (see https://github.com/sparklemotion/nokogiri/issues/1060)
-        view.doc.document.errors = []
-
-        return view
-      end
-
-      def to_html
-        @doc.to_html
-      end
-
-      alias :to_s :to_html
-
-      def ==(o)
-        self.class == o.class && self.to_html == o.to_html
+      def self.tag_without_value?(tag)
+        %w[select].include? tag
       end
     end
   end

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

@@ -1,10 +1,33 @@
+require 'forwardable'
+
 module Pakyow
+  module Helpers; end
+
   module AppHelpers
     extend Forwardable
 
-    def_delegators :@presenter, :store, :store=, :content, :view, :view=, 
-    :partial, :template, :template=, :page, :page=, :path, :path=, :compose,
-    :composer, :container
+    def_delegators :@presenter, :store, :store=, :content, :view=,
+    :template=, :page=, :path, :path=, :compose, :composer
+
+    def view
+      ViewContext.new(@presenter.view, context)
+    end
+
+    def partial(*args)
+      ViewContext.new(@presenter.partial(*args), context)
+    end
+
+    def template
+      ViewContext.new(@presenter.template, context)
+    end
+
+    def page
+      ViewContext.new(@presenter.page, context)
+    end
+
+    def container(*args)
+      ViewContext.new(@presenter.container(*args), context)
+    end
 
     def presenter
       @presenter

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

@@ -0,0 +1,321 @@
+module Pakyow
+  module Presenter
+    class NokogiriDoc
+      PARTIAL_REGEX = /<!--\s*@include\s*([a-zA-Z0-9\-_]*)\s*-->/
+
+      attr_accessor :doc, :scopes
+
+      def breadth_first(doc)
+        queue = [doc]
+        until queue.empty?
+          node = queue.shift
+          catch(:reject) {
+            yield node
+            queue.concat(node.children)
+          }
+        end
+      end
+
+      def path_to(child)
+        path = []
+
+        return path if child == @doc
+
+        child.ancestors.each {|a|
+          # since ancestors goes all the way to doc root, stop when we get to the level of @doc
+          break if a.children.include?(@doc)
+
+          path.unshift(a.children.index(child))
+          child = a
+        }
+
+        return path
+      end
+
+      def path_within_path?(child_path, parent_path)
+        parent_path.each_with_index {|pp_step, i|
+          return false unless pp_step == child_path[i]
+        }
+
+        true
+      end
+
+      def doc_from_path(path)
+        o = @doc
+
+        # if path is empty we're at self
+        return o if path.empty?
+
+        path.each {|i|
+          if child = o.children[i]
+            o = child
+          else
+            break
+          end
+        }
+
+        return o
+      end
+
+      def view_from_path(path)
+        view = View.from_doc(doc_from_path(path))
+        view.related_views << self
+
+        # workaround for nokogiri in jruby (see https://github.com/sparklemotion/nokogiri/issues/1060)
+        view.doc.document.errors = []
+
+        return view
+      end
+
+      def to_html
+        @doc.to_html
+      end
+
+      alias :to_s :to_html
+
+      def title=(title)
+        return if @doc.nil?
+
+        if o = @doc.css('title').first
+          o.inner_html = Nokogiri::HTML::fragment(title.to_s)
+        elsif o = @doc.css('head').first
+          o.add_child(Nokogiri::HTML::fragment("<title>#{title}</title>"))
+        end
+      end
+
+      def title
+        return unless o = @doc.css('title').first
+        o.inner_text
+      end
+
+      def self.from_doc(doc)
+        instance = allocate
+        instance.doc = doc
+        return instance
+      end
+
+      def initialize(html)
+        if html.match(/<html.*>/)
+          @doc = Nokogiri::HTML::Document.parse(html)
+        else
+          @doc = Nokogiri::HTML.fragment(html)
+        end
+      end
+
+      def initialize_copy(original_doc)
+        super
+
+        # this solves a memory leak that I believe is being
+        # caused by Nokogiri; don't like this approach much
+        # since it negatively affects performance
+        #
+        # https://gist.github.com/bryanp/2048ae4a38f94c9d97ef
+        if original_doc.is_a?(Nokogiri::HTML::DocumentFragment)
+          @doc = Nokogiri::HTML.fragment(original_doc.doc.to_html)
+        else
+          @doc = original_doc.doc.dup
+        end
+      end
+
+      def soft_copy
+        dup
+      end
+
+      def set_attribute(name, value)
+        @doc[name.to_s] = value
+      end
+
+      def get_attribute(name)
+        @doc[name.to_s]
+      end
+
+      def remove_attribute(name)
+        @doc.remove_attribute(name.to_s)
+      end
+
+      def update_attribute(name, value)
+        if !@doc.is_a?(Nokogiri::XML::Element) && @doc.children.count == 1
+          @doc.children.first[name] = value
+        else
+          @doc.set_attribute(name, value)
+        end
+      end
+
+      def remove
+        if @doc.parent.nil?
+          # best we can do is to remove the children
+          @doc.children.remove
+        else
+          @doc.remove
+        end
+      end
+
+      def clear
+        return if @doc.blank?
+        @doc.inner_html = ''
+      end
+
+      def text
+        @doc.inner_text
+      end
+
+      def text=(text)
+        @doc.content = text.to_s
+      end
+
+      def html
+        @doc.inner_html
+      end
+
+      def html=(html)
+        @doc.inner_html = Nokogiri::HTML.fragment(html.to_s)
+      end
+
+      def append(appendable)
+        content = appendable.is_a?(NokogiriDoc) ? appendable.doc : appendable
+        @doc.add_child(content)
+      end
+
+      def prepend(prependable)
+        content = prependable.is_a?(NokogiriDoc) ? prependable.doc : prependable
+        if first_child = @doc.children.first
+          first_child.add_previous_sibling(content)
+        else
+          @doc = content
+        end
+      end
+
+      def after(insertable)
+        content = insertable.is_a?(NokogiriDoc) ? insertable.doc : insertable
+        @doc.after(content)
+      end
+
+      def before(insertable)
+        content = insertable.is_a?(NokogiriDoc) ? insertable.doc : insertable
+        @doc.before(content)
+      end
+
+      def replace(replacement)
+        content = replacement.is_a?(NokogiriDoc) ? replacement.doc : replacement
+
+        if @doc.parent.nil?
+          @doc.children.remove
+          @doc.inner_html = content
+        else
+          @doc.replace(content)
+        end
+      end
+
+      def scope(name)
+        scopes.select { |b| b[:scope] == name }
+      end
+
+      def prop(scope_name, prop_name)
+        return [] unless scope = scopes.select { |b| b[:scope] == scope_name }[0]
+        scope[:props].select { |b| b[:prop] == prop_name }
+      end
+
+      def container(name)
+        container = @containers[name.to_sym]
+        return container[:doc]
+      end
+
+      def scopes
+        find_scopes
+      end
+
+      def containers
+        find_containers
+      end
+
+      def partials
+        find_partials
+      end
+
+      def ==(o)
+        to_html == o.to_html
+      end
+
+      def tagname
+        @doc.name
+      end
+
+      def option(value: nil)
+        @doc.css('option[value="' + value.to_s + '"]').first
+      end
+
+      private
+
+      # returns an array of hashes that describe each scope
+      def find_scopes(doc = @doc, ignore_root = false)
+        scopes = []
+        breadth_first(doc) {|o|
+          next if o == doc && ignore_root
+          next if !scope = o[Config.presenter.scope_attribute]
+
+          scopes << {
+            :doc => NokogiriDoc.from_doc(o),
+            :scope => scope.to_sym,
+            :props => find_props(o)
+          }
+
+          if o == doc
+            # this is the root node, which we need as the first hash in the
+            # list of scopes, but we don't want to nest other scopes inside
+            # of it in this case
+            scopes.last[:nested] = []
+          else
+            scopes.last[:nested] = find_scopes(o, true)
+            # reject so children aren't traversed
+            throw :reject
+          end
+        }
+
+        return scopes
+      end
+
+      # 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: NokogiriDoc.from_doc(e) }
+        }
+
+        return containers
+      end
+
+      def find_props(o)
+        props = []
+        breadth_first(o) {|so|
+          # don't go into deeper scopes
+          throw :reject if so != o && so[Config.presenter.scope_attribute]
+
+          next unless prop = so[Config.presenter.prop_attribute]
+          props << { :prop => prop.to_sym, :doc => NokogiriDoc.from_doc(so) }
+        }
+
+        return props
+      end
+
+      def find_partials
+        partials = {}
+
+        @doc.traverse { |e|
+          next unless e.is_a?(Nokogiri::XML::Comment)
+          next unless match = e.to_html.strip.match(PARTIAL_REGEX)
+
+          name = match[1]
+          partials[name.to_sym] = NokogiriDoc.from_doc(e)
+        }
+
+        return partials
+      end
+
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Pakyow
 
       class << self
         def load(path)
-          format   = Utils::String.split_at_last_dot(path)[-1]
+          format   = String.split_at_last_dot(path)[-1]
           name     = File.basename(path, '.*').to_sym
           contents = FileTest.file?(path) ? File.read(path) : nil
 
@@ -14,7 +14,6 @@ module Pakyow
       end
 
       attr_reader :path, :contents
-      attr_accessor :composer
 
       def initialize(name, contents, path, format = :html)
         @name, @contents, @path, @format = name, contents, path, format
@@ -45,7 +44,7 @@ module Pakyow
           raise MissingContainer, "No container named #{container} in #{@path}"
         }
 
-        return container.to_html
+        return container.doc
       end
 
       def info(key = nil)
@@ -67,21 +66,13 @@ module Pakyow
         @containers.each_pair { |name, container| yield(name, container) }
       end
 
-      def composer=(composer)
-        @composer = composer
-
-        @containers.each do |name, container|
-          container.composer = composer
-        end
-      end
-
       private
 
       def parse_info
         info = parse_front_matter(@contents)
         info = {} if !info || !info.is_a?(Hash)
 
-        @info.merge!(Utils::Hash.symbolize(info))
+        @info.merge!(Hash.symbolize(info))
       end
 
       def parse_content
@@ -96,11 +87,11 @@ module Pakyow
 
         @contents.scan(within_regex) do |m|
           container_name = m[0].to_sym
-          @containers[container_name] = Container.new(m[1], @format)
+          @containers[container_name] = Container.new(m[1])
         end
 
         # find default content
-        @containers[:default] = Container.new(@contents.gsub(within_regex, ''), @format)
+        @containers[:default] = Container.new(@contents.gsub(within_regex, ''))
       end
 
       def parse_front_matter(contents)