puffer_pages 0.1.1 → 0.5.0

data/lib/puffer_pages/extensions/context.rb

@@ -0,0 +1,31 @@
+module PufferPages
+  module Extensions
+    module Liquid
+      module Context
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :resolve, :interpolation
+        end
+
+        def resolve_with_interpolation key
+          if key.is_a? Symbol
+            scope = @scopes.detect { |s| s.key? key }
+            scope ||= @environments.detect { |s| s.key? key }
+            scope[key] if scope
+          else
+            resolved = resolve_without_interpolation key
+            if resolved.is_a?(String) && key =~ /^"(.*)"$/
+              resolved.gsub!(/\#\{(.*?)\}/) do
+                ::Liquid::Variable.new($1).render(self)
+              end
+            end
+            resolved
+          end
+        end
+      end
+    end
+  end
+end
+
+Liquid::Context.send :include, PufferPages::Extensions::Liquid::Context

data/lib/puffer_pages/extensions/core.rb

@@ -1,17 +1,10 @@
-Kernel.class_eval do
-  def swallow_nil
-    yield
-  rescue NoMethodError
-    nil
-  end
-end
-
 Array.class_eval do
   def arranged
     arranged = ActiveSupport::OrderedHash.new
     insertion_points = [arranged]
     depth = 0
     each do |node|
+      next if node.depth > depth && insertion_points.last.keys.last && node.parent_id != insertion_points.last.keys.last.id
       insertion_points.push insertion_points.last.values.last if node.depth > depth
       (depth - node.depth).times { insertion_points.pop } if node.depth < depth
       insertion_points.last.merge! node => ActiveSupport::OrderedHash.new

data/lib/puffer_pages/extensions/pagenator.rb

@@ -0,0 +1,69 @@
+module PufferPages
+  module Extensions
+    module Pagenator # There is no error in module name
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_puffer_pages_options
+        self._puffer_pages_options = {:pagenated => false}
+      end
+
+      module ClassMethods
+        def inherited(klass)
+          super
+          klass._puffer_pages_options = _puffer_pages_options.dup
+        end
+
+        def puffer_pages options = {}
+          _puffer_pages_options[:pagenated] = true
+          _puffer_pages_options[:only] = Array.wrap(options[:only]).map(&:to_s).presence
+          _puffer_pages_options[:except] = Array.wrap(options[:except]).map(&:to_s).presence
+          _puffer_pages_options[:scope] = options[:scope]
+        end
+      end
+
+      def _normalize_options options
+        super
+        if options[:puffer_page] || _puffer_pages_action?
+          scope = options[:puffer_scope].presence || _puffer_pages_options[:scope].presence
+          page = options.values_at(:puffer_page, :partial, :action, :file).delete_if(&:blank?).first
+          options[:puffer_page] = _puffer_pages_template(page, scope)
+          options[:layout] = 'puffer_page'
+        end
+      end
+
+    private
+
+      def _puffer_pages_action?
+        if only = _puffer_pages_options[:only]
+          only.include?(action_name)
+        elsif except = _puffer_pages_options[:except]
+          !except.include?(action_name)
+        else
+          _puffer_pages_options[:pagenated]
+        end
+      end
+
+      def _puffer_pages_template suggest, scope = nil
+        return suggest if suggest.is_a?(PufferPages::Page)
+
+        scope = case scope
+        when Proc
+          scope.call(self)
+        when String, Symbol
+          send scope
+        else
+          scope
+        end
+
+        PufferPages::Page.controller_scope(scope).find_view_page(
+          suggest.presence || request.path_info,
+          :formats => lookup_context.formats
+        )
+      end
+
+    end
+  end
+end
+
+ActionController::Base.send :include, PufferPages::Extensions::Pagenator

data/lib/puffer_pages/extensions/renderer.rb

@@ -0,0 +1,31 @@
+module PufferPages
+  module Extensions
+    module Renderer
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :render, :puffer_pages
+      end
+
+      def render_with_puffer_pages(context, options)
+        if options.key?(:puffer_page) && options[:puffer_page].is_a?(PufferPages::Page)
+          render_puffer_page(context, options)
+        else
+          render_without_puffer_pages(context, options)
+        end
+      end
+
+      def render_puffer_page(context, options)
+        _puffer_page_renderer.render(context, options)
+      end
+
+    private
+
+      def _puffer_page_renderer #:nodoc:
+        @_puffer_page_renderer ||= PufferPages::Renderer.new(@lookup_context)
+      end
+    end
+  end
+end
+
+ActionView::Renderer.send :include, PufferPages::Extensions::Renderer

data/lib/puffer_pages/globalize/migrator.rb

@@ -0,0 +1,23 @@
+require 'globalize'
+
+module PufferPages
+  module Globalize
+    class Migrator < ::Globalize::ActiveRecord::Migration::Migrator
+      def create_translation_table
+        connection.create_table(translations_table_name, id: false) do |t|
+          t.uuid :id, primary_key: true
+          t.uuid "#{table_name.sub(/^#{table_name_prefix}/, '').singularize}_id"
+          t.string :locale
+          fields.each do |name, options|
+            if options.is_a? Hash
+              t.column name, options.delete(:type), options
+            else
+              t.column name, options
+            end
+          end
+          t.timestamps
+        end
+      end
+    end
+  end
+end

data/lib/puffer_pages/handlers.rb

@@ -0,0 +1,29 @@
+module PufferPages
+  module Handlers
+    class HandlerMissing < Exception; end
+
+    def self.handlers
+      @handlers ||= HashWithIndifferentAccess.new
+    end
+
+    def self.register klass, *types
+      handlers.merge! Hash[types.flatten.map { |type| [type, klass.new(type)] }]
+    end
+
+    def self.process type, *args
+      raise HandlerMissing.new("Can not find handler for '#{type}' type") unless handlers[type]
+      handlers[type].process(*args)
+    end
+
+    def self.select
+      handlers.values.map { |handler| [
+        I18n.t("puffer_pages.handlers.#{handler.type}"),
+        handler.type,
+        { 'data-codemirror-mode' => handler.codemirror_mode }
+      ] }
+    end
+  end
+end
+
+require 'puffer_pages/handlers/base'
+require 'puffer_pages/handlers/yaml'

data/lib/puffer_pages/handlers/base.rb

@@ -0,0 +1,21 @@
+module PufferPages
+  module Handlers
+    class Base
+      attr_reader :type
+
+      def initialize type
+        @type = type
+      end
+
+      def process renderable, context = nil
+        renderable.render context
+      end
+
+      def codemirror_mode
+        'text/x-liquid-html'
+      end
+    end
+  end
+end
+
+PufferPages::Handlers.register PufferPages::Handlers::Base, :html

data/lib/puffer_pages/handlers/yaml.rb

@@ -0,0 +1,20 @@
+module PufferPages
+  module Handlers
+    class Yaml < Base
+      def process renderable, context = nil
+        renderable.self_and_ancestors.where(handler: 'yaml').reverse.each_with_object({}) do |renderable, result|
+          load_arguments = [renderable.render(context)]
+          load_arguments.push renderable.name if YAML.method(:load).arity == -2
+          hash = YAML.load *load_arguments
+          result.deep_merge! hash
+        end
+      end
+
+      def codemirror_mode
+        'text/x-liquid-yaml'
+      end
+    end
+  end
+end
+
+PufferPages::Handlers.register PufferPages::Handlers::Yaml, :yaml

data/lib/puffer_pages/helpers.rb

@@ -0,0 +1,14 @@
+module PufferPages
+  module Helpers
+    def puffer_pages_context
+      drops = assigns.each_with_object({}) do |(key, value), result|
+        result[key] = value if value.respond_to?(:to_liquid)
+      end
+      registers = assigns.each_with_object({}) do |(key, value), result|
+        result[key] = value
+      end
+
+      { drops: drops, registers: registers.merge!(:controller => controller) }
+    end
+  end
+end

data/lib/puffer_pages/liquid/backend.rb

@@ -0,0 +1,16 @@
+module PufferPages
+  module Liquid
+    class Backend
+      include ::I18n::Backend::Simple::Implementation
+
+      def load_translations; end
+      def store_translations(*args); end
+      def initialized?; true; end
+
+      def translations
+        Contextuality.page_translations || {}
+      end
+
+    end
+  end
+end

data/lib/puffer_pages/liquid/file_system.rb

@@ -2,31 +2,55 @@ module PufferPages
   module Liquid
     class FileSystem < ::Liquid::BlankFileSystem
 
-      def read_template_file(template_path, context)
-        case template_type template_path
+      def read_template_file template_path, context
+        source = case template_type(template_path)
         when :snippet then
           template_path = template_path.gsub(/^snippets\//, '')
-          snippet = ::Snippet.find_by_name(template_path)
-          raise ::Liquid::FileSystemError, "No such snippet '#{template_path}' found" unless snippet
-          snippet.body
+          snippet = snippet(template_path)
+          raise ::Liquid::FileSystemError,
+            "No such snippet '#{template_path}' found" unless snippet
+          snippet
         when :layout then
           template_path = template_path.gsub(/^layouts\//, '')
-          layout = ::Layout.find_by_name(template_path)
-          raise ::Liquid::FileSystemError, "No such layout '#{template_path}' found" unless layout
-          layout.body
+          layout = layout(template_path)
+          raise ::Liquid::FileSystemError,
+            "No such layout '#{template_path}' found" unless layout
+          layout
+        when :super then
+          page_part = context[:processed]
+          raise ::Liquid::FileSystemError,
+            "Can not render super page_part outside the page_part context" unless page_part.is_a?(PufferPages::PagePart)
+          parent_part = page_part.parent
+          raise ::Liquid::FileSystemError,
+            "No super page_part found for #{page_part.name}" unless parent_part
+          parent_part
         when :page_part then
-          page_part = context.registers[:page].part(template_path)
-          raise ::Liquid::FileSystemError, "No such page_part '#{template_path}' found for current page" unless page_part
-          page_part.body
+          page_part = context.registers[:page].inherited_page_part(template_path)
+          raise ::Liquid::FileSystemError,
+            "No such page_part '#{template_path}' found for current page" unless page_part
+          page_part
         end
+
+        source.respond_to?(:render) ? source : ::Liquid::Template.parse(source)
       end
 
       def template_type template_path
-        return :snippet if template_path.start_with? 'snippets/'
+        return :super if template_path == :super
         return :layout if template_path.start_with? 'layouts/'
+        return :snippet if template_path.start_with? 'snippets/'
         return :page_part
       end
 
+      def snippet name
+        @snippets_cache ||= {}
+        @snippets_cache[name] ||= PufferPages::Snippet.find_snippet(name)
+      end
+
+      def layout name
+        @layouts_cache ||= {}
+        @layouts_cache[name] ||= PufferPages::Layout.find_layout(name)
+      end
+
     end
   end
 end

data/lib/puffer_pages/liquid/page_drop.rb

@@ -2,57 +2,60 @@ module PufferPages
   module Liquid
     class PageDrop < ::Liquid::Drop
 
-      include ActionController::UrlFor
-      include Rails.application.routes.url_helpers
+      delegate *(PufferPages::Page.statuses.map {|s| "#{s}?"} << {:to => :page})
+      delegate :id, :slug, :created_at, :updated_at, :to => :page
 
-      delegate *(Page.statuses.map {|s| "#{s}?"} << {:to => :page})
-      delegate :id, :name, :title, :description, :keywords, :created_at, :updated_at, :to => :page
-
-      def initialize page, current_page = nil, controller = nil
-        @page, @current_page, @controller = page, current_page, controller
+      def initialize page
+        @page = page
       end
 
-      %w(parent root).each do |attribute|
-        define_method attribute do
-          instance_variable_get("@#{attribute}") || instance_variable_set("@#{attribute}", self.class.new(page.parent, current_page, controller))
-        end
+      def name
+        @context ? page.render(page.name, @context) : page.name
       end
 
-      %w(ancestors self_and_ancestors children self_and_children siblings self_and_siblings descendants, self_and_descendants).each do |attribute|
+      %w(parent root ancestors self_and_ancestors children self_and_children siblings
+         self_and_siblings descendants, self_and_descendants).each do |attribute|
         define_method attribute do
-          instance_variable_get("@#{attribute}") || instance_variable_set("@#{attribute}", page.send(attribute).map{ |ac| self.class.new(ac, current_page, controller)})
+          instance_variable_get("@#{attribute}") ||
+            instance_variable_set("@#{attribute}", page.send(attribute))
         end
       end
 
       def path
-        puffer_page_path page.to_location
+        controller.puffer_pages.puffer_page_path page.to_location
       end
 
       def url
-        puffer_page_url page.to_location
+        controller.puffer_pages.puffer_page_url page.to_location
       end
 
       def current?
-        page == current_page
+        current_page && page == current_page
       end
 
       def ancestor?
-        page.is_ancestor_of? current_page
+        current_page && page.is_ancestor_of?(current_page)
       end
 
-      def == drop
-        id == drop.send(:page).id
+      def == other
+        page == other.send(:page)
       end
 
-      def before_method method
-        swallow_nil{page.part(method).body}
+      def before_method name
+        page_part = page.inherited_page_part(name)
+        page_part.handle(@context) if page_part && @context
       end
 
     private
+      attr_reader :page
 
-      attr_reader :page, :current_page, :controller
-      delegate :env, :request, :to => :controller, :allow_nil => true
+      def current_page
+        @current_page ||= @context.registers[:page] if @context
+      end
 
+      def controller
+        @controller ||= @context.registers[:controller] if @context
+      end
     end
   end
 end

data/lib/puffer_pages/liquid/tags/array.rb

@@ -0,0 +1,39 @@
+module PufferPages
+  module Liquid
+    module Tags
+
+      class Array < ::Liquid::Tag
+        Syntax = /^(#{::Liquid::VariableSignature}+)\s*=\s*(.*)\s*/
+
+        def initialize(tag_name, markup, tokens)
+          if markup =~ Syntax
+            @variable_name = $1
+            @items = variables_from_string($2)
+          else
+            raise SyntaxError.new("Syntax Error in 'array' - Valid syntax: array array_name = item[, item ...]")
+          end
+
+          super
+        end
+
+        def render(context)
+          context[@variable_name] = @items.map { |item| context[item] }
+          ''
+        end
+
+      private
+
+        def variables_from_string(markup)
+          markup.split(',').map do |var|
+            var.strip =~ /\s*(#{::Liquid::QuotedFragment})\s*/
+            $1 ? $1 : nil
+          end.compact
+        end
+
+      end
+
+    end
+  end
+end
+
+Liquid::Template.register_tag('array', PufferPages::Liquid::Tags::Array)