puffer_pages 0.1.1 → 0.5.0

data/db/migrate/20130110144030_add_handler_to_page_parts.rb

@@ -0,0 +1,9 @@
+class AddHandlerToPageParts < ActiveRecord::Migration
+  def self.up
+    add_column :page_parts, :handler, :string
+  end
+
+  def self.down
+    remove_column :page_parts, :handler
+  end
+end

data/db/migrate/20130118064524_add_locales_to_pages.rb

@@ -0,0 +1,9 @@
+class AddLocalesToPages < ActiveRecord::Migration
+  def self.up
+    add_column :pages, :locales, :text
+  end
+
+  def self.down
+    remove_column :pages, :locales
+  end
+end

data/gemfiles/Gemfile.rails-3-1

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'puffer', github: 'puffer/puffer'
+gem 'activeuuid', github: 'jashmenn/activeuuid'
+gem 'rails', '~> 3.1.0'

data/gemfiles/Gemfile.rails-3-2

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'puffer', github: 'puffer/puffer'
+gem 'activeuuid', github: 'jashmenn/activeuuid'
+gem 'rails', '~> 3.2.0'

data/gemfiles/Gemfile.rails-head

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'puffer', github: 'puffer/puffer'
+gem 'activeuuid', github: 'jashmenn/activeuuid'
+gem 'rails', github: 'rails/rails'

data/lib/puffer_pages.rb

@@ -1,4 +1,8 @@
 module PufferPages
+  autoload :SnippetsBase, 'puffer_pages/backends/controllers/snippets_base'
+  autoload :LayoutsBase, 'puffer_pages/backends/controllers/layouts_base'
+  autoload :PagesBase, 'puffer_pages/backends/controllers/pages_base'
+  autoload :OriginsBase, 'puffer_pages/backends/controllers/origins_base'
 
   class PufferPagesError < StandardError
   end
@@ -9,31 +13,63 @@ module PufferPages
   class LayoutMissed < PufferPagesError
   end
 
+  class ImportFailed < PufferPagesError
+  end
+
   mattr_accessor :primary_page_part_name
   self.primary_page_part_name = 'body'
 
   mattr_accessor :single_section_page_path
   self.single_section_page_path = false
 
-  mattr_accessor :codemirror_buttons
-  self.codemirror_buttons = [:fullscreen]
+  mattr_accessor :localize
+  self.localize = false
+
+  mattr_accessor :access_token
+  self.access_token = nil
+
+  mattr_accessor :export_path
+  self.export_path = '/admin/origins/export'
+
+  mattr_accessor :install_i18n_backend
+  self.install_i18n_backend = true
 
   def self.setup
     yield self
   end
 
+  def self.i18n_backend
+    @i18n_backend ||= PufferPages::Liquid::Backend.new
+  end
 end
 
 require 'puffer'
 require 'liquid'
+require 'uuidtools'
+require 'activeuuid'
 require 'nested_set'
+require 'contextuality'
 
+require 'puffer_pages/helpers'
 require 'puffer_pages/engine'
+require 'puffer_pages/backends'
+require 'puffer_pages/handlers'
+require 'puffer_pages/migrations'
+require 'puffer_pages/log_subscriber'
 require 'puffer_pages/extensions/core'
-require 'puffer_pages/extensions/mapper'
-require 'puffer_pages/extensions/controller'
+require 'puffer_pages/extensions/context'
+require 'puffer_pages/extensions/renderer'
+require 'puffer_pages/extensions/pagenator'
 
+require 'puffer_pages/liquid/tags/url'
 require 'puffer_pages/liquid/tags/yield'
-require 'puffer_pages/liquid/tags/stylesheets'
-require 'puffer_pages/liquid/tags/javascripts'
-require 'puffer_pages/liquid/tags/page_attribute'
+require 'puffer_pages/liquid/tags/array'
+require 'puffer_pages/liquid/tags/assets'
+require 'puffer_pages/liquid/tags/helper'
+require 'puffer_pages/liquid/tags/render'
+require 'puffer_pages/liquid/tags/scope'
+require 'puffer_pages/liquid/tags/super'
+require 'puffer_pages/liquid/tags/include'
+require 'puffer_pages/liquid/tags/partials'
+require 'puffer_pages/liquid/tags/translate'
+require 'puffer_pages/liquid/tags/javascript'

data/lib/puffer_pages/backends.rb

@@ -0,0 +1,16 @@
+module PufferPages
+  module Backends
+    autoload :Snippet, 'puffer_pages/backends/models/snippet'
+    autoload :Layout, 'puffer_pages/backends/models/layout'
+    autoload :Page, 'puffer_pages/backends/models/page'
+    autoload :PagePart, 'puffer_pages/backends/models/page_part'
+    autoload :Origin, 'puffer_pages/backends/models/origin'
+
+    module Mixins
+      autoload :Renderable, 'puffer_pages/backends/models/mixins/renderable'
+      autoload :Importable, 'puffer_pages/backends/models/mixins/importable'
+      autoload :Translatable, 'puffer_pages/backends/models/mixins/translatable'
+      autoload :Localable, 'puffer_pages/backends/models/mixins/localable'
+    end
+  end
+end

data/{app/controllers/puffer_pages → lib/puffer_pages/backends/controllers}/layouts_base.rb

@@ -1,9 +1,7 @@
 class PufferPages::LayoutsBase < Puffer::Base
-  unloadable
-
   setup do
     group :pages
-    model_name :layout
+    model_name :'puffer_pages/layout'
   end
 
   index do
@@ -12,7 +10,6 @@ class PufferPages::LayoutsBase < Puffer::Base
 
   form do
     field :name
-    field :body, :type => :codemirror
+    field :body, type: :codemirror, mode: 'text/x-liquid-html'
   end
-
 end

data/lib/puffer_pages/backends/controllers/origins_base.rb

@@ -0,0 +1,43 @@
+class PufferPages::OriginsBase < Puffer::Base
+  skip_before_filter :require_puffer_user, only: :export
+
+  member do
+    get :import
+  end
+
+  collection do
+    get :export, display: false
+  end
+
+  def import
+    @record = resource.member
+    @record.import!
+    redirect_to admin_origins_path
+  end
+
+  def export
+    if params[:token] == PufferPages.access_token
+      render json: resource.model.export_json
+    else
+      render nothing: true, status: 401
+    end
+  end
+
+  setup do
+    group :pages
+    model_name :'puffer_pages/origin'
+  end
+
+  index do
+    field :name
+    field :uri
+    field :token
+  end
+
+  form do
+    field :name
+    field :host
+    field :path
+    field :token
+  end
+end

data/lib/puffer_pages/backends/controllers/pages_base.rb

@@ -0,0 +1,52 @@
+class PufferPages::PagesBase < Puffer::TreeBase
+  helper :puffer_pages
+
+  setup do
+    group :pages
+    model_name :'puffer_pages/page'
+  end
+
+  tree do
+    #field :name, :render => :tree_page
+    field :name, render: -> { render :partial => 'tree_page', :object => record }
+  end
+
+  def new
+    @record = resource.new_member
+    if !@record.inherited_page_part(PufferPages.primary_page_part_name)
+      @record.page_parts.build :name => PufferPages.primary_page_part_name
+    end
+    respond_with @record
+  end
+
+  index do
+    field :name
+    field :slug
+    field :layout_name
+    field :status
+  end
+
+  # filter do
+  #   field :name
+  #   field :slug
+  #   field :layout_name
+  #   field :'page_parts.name'
+  #   field :'page_parts.body'
+  # end
+
+  form do
+    field :parent_id, type: :hidden
+    field :name
+    field :slug
+    field :layout_name, select: :possible_layouts, include_blank: false
+    field :status, select: :possible_statuses, include_blank: false
+    field :page_parts, type: :page_parts do
+      field :handler, type: :handlers, include_blank: false,
+        html: { 'data-codemirror-mode-select' => true }
+      field :body, type: :codemirror, input_only: true, mode: 'text/x-liquid-html'
+      field :name, type: :hidden, html: { data: { acts: 'name' } }
+      field :_destroy, type: :hidden, html: { data: { acts: 'destroy' } }
+    end
+    field :locales, type: :codemirror, mode: 'text/x-yaml'
+  end
+end

data/{app/controllers/puffer_pages → lib/puffer_pages/backends/controllers}/snippets_base.rb

@@ -1,9 +1,7 @@
 class PufferPages::SnippetsBase < Puffer::Base
-  unloadable
-
   setup do
     group :pages
-    model_name :snippet
+    model_name :'puffer_pages/snippet'
   end
 
   index do
@@ -12,7 +10,6 @@ class PufferPages::SnippetsBase < Puffer::Base
 
   form do
     field :name
-    field :body, :type => :codemirror
+    field :body, type: :codemirror, mode: 'text/x-liquid-html'
   end
-
 end

data/lib/puffer_pages/backends/models/layout.rb

@@ -0,0 +1,34 @@
+class PufferPages::Backends::Layout < ActiveRecord::Base
+  include ActiveUUID::UUID
+  include PufferPages::Backends::Mixins::Renderable
+  include PufferPages::Backends::Mixins::Importable
+  include PufferPages::Backends::Mixins::Translatable
+  self.abstract_class = true
+  self.table_name = :layouts
+
+  attr_protected
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  def self.find_layout(name)
+    where(:name => name).first
+  end
+
+  def render *args
+    _, context = normalize_render_options *args
+    render_template body, context, additional_render_options
+  end
+
+  def additional_render_options
+    { environment: { processed: self } }
+  end
+
+  def i18n_scope
+    [:layouts, name.to_sym]
+  end
+
+  def i18n_defaults
+    []
+  end
+end

data/lib/puffer_pages/backends/models/mixins/importable.rb

@@ -0,0 +1,42 @@
+module PufferPages
+  module Backends
+    module Mixins
+      module Importable
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def export_json
+            all
+          end
+
+          def import_destroy
+            destroy_all
+          end
+
+          def import_json json
+            data = json.is_a?(String) ? ActiveSupport::JSON.decode(json) : json.map(&:stringify_keys!)
+
+            import_destroy
+
+            data.each do |attributes|
+              associations = attributes.keys.each_with_object({}) do |attribute, hsh|
+                if scoped.reflect_on_association(attribute.to_sym)
+                  hsh[attribute] = attributes.delete(attribute)
+                end
+              end
+
+              attributes = attributes.with_indifferent_access
+              record = scoped.create!(attributes) do |record|
+                record.id = attributes[:id] if attributes[:id].present?
+              end
+
+              associations.each do |association, attributes|
+                record.send(association).import_json(attributes)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puffer_pages/backends/models/mixins/localable.rb

@@ -0,0 +1,65 @@
+module PufferPages
+  module Backends
+    module Mixins
+      module Localable
+        extend ActiveSupport::Concern
+
+        included do
+          serialize :locales, Locales
+
+          validate do
+            errors[:locales] = locales.error unless locales.valid?
+          end
+        end
+
+        def locales
+          value = read_attribute(:locales)
+          value.is_a?(Locales) ? value : Locales.new(value)
+        end
+
+        class Locales < ActiveSupport::HashWithIndifferentAccess
+          def initialize source
+            update (source.presence || {}).stringify_keys
+            super()
+          end
+
+          def valid?
+            !error
+          end
+
+          def error
+            translations
+          rescue ::SyntaxError => e
+            e.message
+          else
+            false
+          end
+
+          def translations
+            @translations ||= Hash[map do |(locale, yaml)|
+              load_arguments = [yaml]
+              load_arguments.push "<#{locale}>" if YAML.method(:load).arity == -2
+              result = YAML.load yaml
+              result = result.presence || {}
+              raise ::SyntaxError.new("(<#{locale}>): Locale should be a hash") unless result.is_a?(Hash)
+              [locale.to_sym, result.deep_symbolize_keys]
+            end]
+          end
+
+          class << self
+            def dump value
+              value = value.is_a?(Locales) ? value : Locales.new(value)
+              value ? YAML.dump(value.to_hash) : nil
+            end
+
+            def load value
+              return unless value
+              value = YAML.load(value) if value.is_a?(String)
+              value.is_a?(Locales) ? value : Locales.new(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puffer_pages/backends/models/mixins/renderable.rb

@@ -0,0 +1,153 @@
+module PufferPages
+  module Backends
+    module Mixins
+      module Renderable
+        extend ActiveSupport::Concern
+
+        def template
+          @template ||= ::Liquid::Template.parse(self)
+        end
+
+      private
+
+
+        # Method gets some arguments and returns source, context and additional
+        # depends on arguments properties
+        # Ex.
+        #  normalize_render_options Object, Liquid::Context, Hash
+        # => Object, Liquid::Context, Hash
+        #
+        #  normalize_render_options Liquid::Context, Hash
+        # => nil, Liquid::Context, Hash
+        #
+        #  normalize_render_options Object, Hash1, Hash2
+        # => Object, Hash1, Hash2
+        #
+        #  normalize_render_options Hash1, Hash2
+        # => nil, Hash1, Hash2
+        #
+        #  normalize_render_options Liquid::Context
+        # => nil, Liquid::Context, {}
+        #
+        #  normalize_render_options Hash
+        # => nil, Hash, {}
+        #
+        #  normalize_render_options Object, Hash
+        # => Object, Hash, {}
+        #
+        #  normalize_render_options Object, Liquid::Context
+        # => Object, Liquid::Context, {}
+        #
+        #  normalize_render_options
+        # => nil, {}, {}
+        #
+        #  normalize_render_options Object, Liquid::Contex, Hash, Hash
+        # => raise ArgumentError
+        def normalize_render_options *args
+          source, context, additional = nil, {}, {}
+          context_or_additional = args.extract_options!
+          case args.count
+          when 0
+            context = context_or_additional
+          when 1
+            case args.first
+            when ::Liquid::Context, ::Hash
+              context = args.first
+              additional = context_or_additional
+            else
+              source = args.first
+              context = context_or_additional
+            end
+          when 2
+            source, context = *args
+            additional = context_or_additional
+          else
+            raise ArgumentError.new("Wrong number of arguments (#{args.count.next} for 0-3)")
+          end
+
+          return source, merge_context(context, additional)
+        end
+
+        def merge_context context, additional
+          additional = normalize_context_options(additional)
+
+          if context.is_a?(::Liquid::Context)
+            context.merge additional[:drops]
+            context.merge additional[:environment]
+            context.registers.merge! additional[:registers]
+          else
+            context = normalize_context_options(context)
+            context[:drops].merge! additional[:drops]
+            context[:environment].merge! additional[:environment]
+            context[:registers].merge! additional[:registers]
+          end
+
+          context
+        end
+
+        def normalize_context_options options
+          detector = [:drops, :environment, :registers]
+          if options.is_a?(Hash) && (options.keys - detector == [])
+            drops = options[:drops] || {}
+            environment = options[:environment] || {}
+            registers = options[:registers] || {}
+          else
+            drops = options
+            environment = {}
+            registers = {}
+          end
+          {
+            drops: drops.stringify_keys,
+            environment: environment.symbolize_keys,
+            registers: registers.symbolize_keys
+          }
+        end
+
+        def render_template source, context = {}, additional = {}
+          template = source.respond_to?(:template) ? source.template : ::Liquid::Template.parse(source)
+          context = merge_context(context, additional)
+
+          if context.is_a?(::Liquid::Context)
+            instrument_render! context do
+              template.send(render_method, context)
+            end
+          else
+            tracker = PufferPages::Liquid::Tracker.new
+            context = merge_context(context, registers: {
+              :file_system => PufferPages::Liquid::FileSystem.new,
+              :tracker => tracker
+            })
+
+            instrument_render! context do
+              tracker.cleanup template.send(render_method,
+                context[:drops].merge!(context[:environment]),
+                registers: context[:registers])
+            end
+          end
+        end
+
+        def instrument_render! context, additional = {}, &block
+          context = merge_context(context, additional) if additional.present?
+
+          payload = { subject: self }
+          if context.is_a?(::Liquid::Context)
+            drops = context.scopes.each_with_object({}) { |scope, hash| hash.merge! scope }
+            payload.merge! drops: drops, registers: context.registers
+          else
+            payload.merge! drops: context[:drops], registers: context[:registers]
+          end
+
+          ActiveSupport::Notifications.instrument(instrument_name, payload, &block)
+        end
+
+        def instrument_name
+          "render_#{self.class.to_s.demodulize.underscore}.puffer_pages"
+        end
+
+        def render_method
+          Rails.application.config.puffer_pages.raise_errors ? 'render!' : 'render'
+        end
+      end
+    end
+  end
+end