puffer_pages 0.1.1 → 0.5.0

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

@@ -0,0 +1,52 @@
+module PufferPages
+  module Backends
+    module Mixins
+      module Translatable
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def translatable *fields
+            if PufferPages.localize
+              translates *fields, fallbacks_for_empty_translations: true
+              translation_class.send(:include, ActiveUUID::UUID)
+
+              def self.globalize_migrator
+                @globalize_migrator ||= PufferPages::Globalize::Migrator.new(self)
+              end
+
+              fields.each do |field|
+                define_method "#{field}_translations" do
+                  result = translations.each_with_object(HashWithIndifferentAccess.new) do |translation, result|
+                    result[translation.locale] = translation.send(field)
+                  end
+                  globalize.stash.keys.each_with_object(result) do |locale, result|
+                    result[locale] = globalize.stash.read(locale, field) if globalize.stash.contains?(locale, field)
+                  end
+                end
+
+                define_method "#{field}_translations=" do |value|
+                  value.each do |(locale, value)|
+                    write_attribute(field, value, locale: locale)
+                  end
+                end
+              end
+
+              define_method :serializable_hash_with_translations do |options = nil|
+                options ||= {}
+                except = Array.wrap(options[:except])
+                options[:except] = except +
+                  self.class.translated_attribute_names.map(&:to_s)
+                methods = Array.wrap(options[:methods])
+                options[:methods] = methods +
+                  self.class.translated_attribute_names.map { |name| "#{name}_translations" }
+                serializable_hash_without_translations options
+              end
+
+              alias_method_chain :serializable_hash, :translations
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+class PufferPages::Backends::Origin < ActiveRecord::Base
+  self.abstract_class = true
+  self.table_name = :origins
+
+  attr_protected
+
+  validates_presence_of :name, :host, :token
+  validates_uniqueness_of :name
+
+  def path
+    read_attribute(:path).presence || PufferPages.export_path
+  end
+
+  def uri
+    parsed_host.merge URI::Generic.build(:path => path, :query => { :token => token }.to_query)
+  end
+
+  def import!
+    import_json import_data
+  end
+
+  def import_data
+    Net::HTTP.get(uri)
+  rescue
+    raise PufferPages::ImportFailed.new("Could not connect to `#{name}` (#{uri})")
+  end
+
+  def import_json json
+    data = json.is_a?(String) ? ActiveSupport::JSON.decode(json) : json
+    ActiveRecord::Base.transaction do
+      %w(layouts snippets pages).each do |table|
+        klass = "puffer_pages/#{table}".classify.constantize
+        klass.import_json data[table]
+      end
+    end
+  end
+
+  def self.export_json
+    %w(layouts snippets pages).each_with_object({}) do |table, result|
+      klass = "puffer_pages/#{table}".classify.constantize
+      result[table] = klass.export_json
+    end.as_json.to_json
+  end
+
+private
+
+  def parsed_host
+    URI.parse([scheme, real_host].join('://'))
+  end
+
+  def real_host
+    host.gsub(/\Ahttps?\:\/\//, '')
+  end
+
+  def scheme
+    match = host.match(/\A(https?)\:\/\//)
+    match ? match[1] : 'http'
+  end
+end

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

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+class PufferPages::Backends::Page < ActiveRecord::Base
+  include ActiveUUID::UUID
+  include PufferPages::Backends::Mixins::Renderable
+  include PufferPages::Backends::Mixins::Importable
+  include PufferPages::Backends::Mixins::Localable
+  self.abstract_class = true
+  self.table_name = :pages
+
+  attr_protected :location
+
+  def self.inherited base
+    base.acts_as_nested_set
+    super
+  end
+
+  scope :published, where(:status => 'published')
+
+  def self.statuses
+    %w(draft hidden published)
+  end
+
+  def self.controller_scope scope
+    where scope
+  end
+
+  def self.normalize_path path
+    path.to_s.split('/').delete_if(&:blank?).join('/').presence
+  end
+
+  def self.find_page location
+    location = normalize_path(location)
+    page = PufferPages.single_section_page_path ?
+      find_by_slug(location) : find_by_location(location)
+    raise ActiveRecord::RecordNotFound unless page
+    raise PufferPages::DraftPage.new("PufferPages can`t show page `#{page.location}` because it is draft") if page.draft?
+    page
+  end
+
+  def self.find_view_page location, options = {}
+    location = normalize_path(location)
+    depth = location.to_s.count('/').next
+    formats = options[:formats].presence || [:html]
+
+    page = if location.blank?
+      roots.first
+    else
+      formats.inject(nil) do |page, format|
+        page ||= begin
+          loc = if format == :html
+            where(['? like location', location])
+          else
+            where(['? like location', [location, format].join('.')]).where(['not ? like location', [location, format, ''].join('.')])
+          end
+          loc.where(['status not in (?)', 'draft']).where(:"#{depth_column_name}" => depth).order('lft desc').first
+        end
+      end
+    end
+
+    raise PufferPages::LayoutMissed.new(
+      "PufferPages can`t render page for `#{location}` with formats `#{formats.join('`, `')}` because layout page missed or draft"
+    ) unless page
+    page
+  end
+
+  def self.export_json
+    includes(:page_parts).order(:lft).as_json(
+      include: :page_parts, except: [:lft, :rgt, :depth, :location]
+    )
+  end
+
+  def self.import_destroy
+    roots.destroy_all
+  end
+
+  has_many_page_parts_options = {
+    order: "name = '#{PufferPages.primary_page_part_name}' desc, name",
+    dependent: :destroy,
+    class_name: '::PufferPages::PagePart',
+    validate: true,
+    inverse_of: :page
+  }
+  has_many_page_parts_options.merge!(include: :translations) if PufferPages.localize
+
+  has_many :page_parts, has_many_page_parts_options
+
+  accepts_nested_attributes_for :page_parts, :allow_destroy => true
+  belongs_to :layout, :primary_key => :name, :foreign_key => :layout_name, :class_name => 'PufferPages::Layout'
+
+  validates_presence_of :name
+  validates_uniqueness_of :slug,
+    :scope => (:parent_id unless PufferPages.single_section_page_path), :allow_nil => true
+  validates_inclusion_of :status, :in => statuses
+  validates_format_of :slug,
+    :with => /\A\s*\Z/, :message => :root_slug_format, :if => :root?
+  validates_format_of :slug,
+    :with => /\A([^\/]+)\Z/, :message => :slug_format, :unless => :root?
+  validate do |page|
+    page.errors.add(:layout_name, :blank) if page.inherited_layout_name.nil?
+  end
+
+  before_validation :defaultize_attributes
+  def defaultize_attributes
+    self.status ||= 'draft'
+    self.slug = slug.presence
+    self.location = [parent.try(:location), slug].compact.join('/').presence
+  end
+
+  def location
+    read_attribute(:location) || [parent.try(:location), slug].compact.join('/').presence
+  end
+
+  before_update :update_locations, :if => :location_changed?
+  def update_locations
+    self.class.update_all "location = replace(location, '#{location_was}', '#{location}')", ["location like ?", location_was + '%']
+  end
+
+  statuses.each do |status_name|
+    define_method "#{status_name}?" do status == status_name end
+  end
+
+  def status
+    ActiveSupport::StringInquirer.new(read_attribute(:status)) if status?
+  end
+
+  def segments
+    location.to_s.split ?/
+  end
+
+  def to_location
+    PufferPages.single_section_page_path ? slug : location
+  end
+
+  def format
+    File.extname(slug)[1..-1].to_s.to_sym.presence || :html
+  end
+
+  def ancestors_page_parts
+    self_and_ancestors_page_parts.where('pages.id != ?', id)
+  end
+
+  def self_and_ancestors_page_parts
+    PufferPages::PagePart
+      .where("#{q_left} <= ? AND #{q_right} >= ?", left, right)
+      .joins(:page).order('name, pages.lft desc')
+  end
+
+  def inherited_page_parts
+    @inherited_page_parts ||= self_and_ancestors_page_parts.group_by(&:name).map { |(_, group)| group.first }
+  end
+
+  def inherited_page_part name
+    inherited_page_parts.detect { |part| part.name == name }
+  end
+
+  def render *args
+    source, context = normalize_render_options *args
+    context = merge_context context, additional_render_options
+    source ||= inherited_layout
+
+    contextualize page_translations: page_translations do
+      if source
+        if source.respond_to?(:render)
+          instrument_render! context do
+            source.render context
+          end
+        else
+          render_template source, context
+        end
+      else
+        instrument_render! context do
+          inherited_page_parts.map do |part|
+            result = part.render context
+            part.main? ? result : "<% content_for :'#{part.name}' do %>#{result}<% end %>"
+          end.join
+        end
+      end
+    end
+  end
+
+  def locales_translations; locales; end
+  def locales_translations=(value); self.locales = value; end
+
+  def page_translations
+    self_and_ancestors.each_with_object({}) do |page, result|
+      result.deep_merge! page.locales.translations
+    end
+  end
+
+  def additional_render_options
+    { registers: { page: self }, drops: { page: self, self: self } }
+  end
+
+  def inherited_layout_page
+    @inherited_layout_page ||= layout_name? ? self : parent.try(:inherited_layout_page)
+  end
+
+  def inherited_layout_name
+    @inherited_layout_name ||= inherited_layout_page.try(:layout_name)
+  end
+
+  def current_layout
+    @current_layout ||= inherited_layout_page.try(:layout)
+  end
+
+  def inherited_layout
+    @inherited_layout ||= PufferPages::Layout.find_layout(current_layout.name) if current_layout
+  end
+
+  def layout_for_render
+    "layouts/#{inherited_layout_name}" unless inherited_layout
+  end
+
+  def content_type
+    Rack::Mime.mime_type(File.extname(slug.to_s), 'text/html')
+  end
+
+  def to_liquid
+    @to_liquid ||= ::PufferPages::Liquid::PageDrop.new(self)
+  end
+end

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

@@ -0,0 +1,71 @@
+class PufferPages::Backends::PagePart < 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 = :page_parts
+
+  attr_protected
+
+  default_scope ->{ includes :translations } if PufferPages.localize
+
+  validates_presence_of :name
+  validates_uniqueness_of :name, :scope => :page_id
+
+  belongs_to :page, :class_name => '::PufferPages::Page', :inverse_of => :page_parts
+
+  before_validation :defaultize_attributes
+  def defaultize_attributes
+    self.handler ||= 'html'
+  end
+
+  def main?
+    name == PufferPages.primary_page_part_name
+  end
+
+  def parent
+    ancestors.first
+  end
+
+  def ancestors
+    page.ancestors_page_parts.where(name: name)
+  end
+
+  def self_and_ancestors
+    page.self_and_ancestors_page_parts.where(name: name)
+  end
+
+  def render *args
+    _, context = normalize_render_options *args
+    render_template body, context, additional_render_options
+  end
+
+  def handle *args
+    _, context = normalize_render_options *args
+    PufferPages::Handlers.process handler || 'html', self, context
+  end
+
+  def additional_render_options
+    { environment: { processed: self } }
+  end
+
+  def i18n_scope
+    i18n_scope_for page.segments, :page_parts, name
+  end
+
+  def i18n_defaults
+    page.segments.inject([]) do |memo, element|
+      memo.push (memo.last || []).dup.push(element)
+    end.unshift([]).inject([]) do |memo, segments|
+      memo.unshift i18n_scope_for(segments)
+      memo.unshift i18n_scope_for(segments, :page_parts, name)
+    end
+  end
+
+private
+
+  def i18n_scope_for *segments
+    [:pages, *segments.flatten.map(&:to_sym)]
+  end
+end

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

@@ -0,0 +1,34 @@
+class PufferPages::Backends::Snippet < 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 = :snippets
+
+  attr_protected
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  def self.find_snippet(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
+    [:snippets, name.to_sym]
+  end
+
+  def i18n_defaults
+    []
+  end
+end

data/lib/puffer_pages/engine.rb

@@ -1,9 +1,20 @@
 module PufferPages
   class Engine < Rails::Engine
+    engine_name :puffer_pages
+
     config.autoload_paths << File.join(root, 'lib')
 
-    initializer 'puffer_pages.add_puffer_pages_route', :after => :add_builtin_route do |app|
-      app.routes_reloader.paths << File.join(root, 'config/puffer_routes.rb')
+    config.puffer_pages = ActiveSupport::OrderedOptions.new
+    config.puffer_pages.raise_errors = false
+
+    config.after_initialize do
+      if PufferPages.install_i18n_backend
+        I18n.backend = I18n::Backend::Chain.new(PufferPages.i18n_backend, I18n.backend)
+      end
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      ActionView::Base.send :include, PufferPages::Helpers
     end
   end
 end