comfortable_mexican_sofa 1.12.11 → 2.0.0

data/app/models/comfy/cms/page.rb

@@ -1,21 +1,22 @@
-# encoding: utf-8
-
 class Comfy::Cms::Page < ActiveRecord::Base
   self.table_name = 'comfy_cms_pages'
 
-  cms_acts_as_tree :counter_cache => :children_count
-  cms_is_categorized
-  cms_is_mirrored
-  cms_manageable
-  cms_has_revisions_for :blocks_attributes
+  include Comfy::Cms::WithFragments
+  include Comfy::Cms::WithCategories
+
+  cms_acts_as_tree counter_cache: :children_count
+  cms_has_revisions_for :fragments_attributes
 
-  # -- Relationships --------------------------------------------------------
+  # -- Relationships -----------------------------------------------------------
   belongs_to :site
-  belongs_to :layout
   belongs_to :target_page,
-    :class_name => 'Comfy::Cms::Page'
+    class_name: 'Comfy::Cms::Page',
+    optional:   true
 
-  # -- Callbacks ------------------------------------------------------------
+  has_many :translations,
+    dependent: :destroy
+
+  # -- Callbacks ---------------------------------------------------------------
   before_validation :assigns_label,
                     :assign_parent,
                     :escape_slug,
@@ -24,25 +25,22 @@ class Comfy::Cms::Page < ActiveRecord::Base
   after_save        :sync_child_full_paths!
   after_find        :unescape_slug_and_path
 
-  # -- Validations ----------------------------------------------------------
-  validates :site_id,
-    :presence   => true
+  # -- Validations -------------------------------------------------------------
   validates :label,
-    :presence   => true
+    presence:   true
   validates :slug,
-    :presence   => true,
-    :uniqueness => { :scope => :parent_id },
-    :unless     => lambda{ |p| p.site && (p.site.pages.count == 0 || p.site.pages.root == self) }
-  validates :layout,
-    :presence   => true
+    presence:   true,
+    uniqueness: {scope: :parent_id},
+    unless:     -> (p) {
+      p.site && (p.site.pages.count == 0 || p.site.pages.root == self)
+    }
   validate :validate_target_page
   validate :validate_format_of_unescaped_slug
 
-  # -- Scopes ---------------------------------------------------------------
-  default_scope -> { order('comfy_cms_pages.position') }
-  scope :published, -> { where(:is_published => true) }
+  # -- Scopes ------------------------------------------------------------------
+  scope :published, -> { where(is_published: true) }
 
-  # -- Class Methods --------------------------------------------------------
+  # -- Class Methods -----------------------------------------------------------
   # Tree-like structure for pages
   def self.options_for_select(site, page = nil, current_page = nil, depth = 0, exclude_self = true, spacer = '. . ')
     return [] if (current_page ||= site.pages.root) == page && exclude_self || !current_page
@@ -54,7 +52,7 @@ class Comfy::Cms::Page < ActiveRecord::Base
     return out.compact
   end
 
-  # -- Instance Methods -----------------------------------------------------
+  # -- Instance Methods --------------------------------------------------------
   # For previewing purposes sometimes we need to have full_path set. This
   # full path take care of the pages and its childs but not of the site path
   def full_path
@@ -63,17 +61,29 @@ class Comfy::Cms::Page < ActiveRecord::Base
 
   # Somewhat unique method of identifying a page that is not a full_path
   def identifier
-    self.parent_id.blank?? 'index' : self.full_path[1..-1].slugify
+    self.parent_id.blank?? 'index' : self.full_path[1..-1].parameterize
   end
 
   # Full url for a page
-  def url(relative = false)
-    public_cms_path = ComfortableMexicanSofa.config.public_cms_path || '/'
-    if relative
-      [public_cms_path, self.site.path, self.full_path].join('/').squeeze('/')
-    else
-      '//' + [self.site.hostname, public_cms_path, self.site.path, self.full_path].join('/').squeeze('/')
-    end
+  def url(relative: false)
+    [self.site.url(relative: relative), self.full_path].compact.join
+  end
+
+  # This method will mutate page object by transfering attributes from translation
+  # for a given locale.
+  def translate!(locale)
+    translation = self.translations.published.find_by!(locale: locale)
+    self.layout        = translation.layout
+    self.label         = translation.label
+    self.content_cache = translation.content_cache
+
+    # We can't just assign fragments as it's a relation and will write to DB
+    # This has odd side-effect of preserving page's fragments and just replacing
+    # them from the translation. Not an issue if all fragments match.
+    self.fragments_attributes = translation.fragments_attributes
+    self.readonly!
+
+    return self
   end
 
 protected
@@ -104,7 +114,9 @@ protected
     return unless self.target_page
     p = self
     while p.target_page do
-      return self.errors.add(:target_page_id, 'Invalid Redirect') if (p = p.target_page) == self
+      if (p = p.target_page) == self
+        return self.errors.add(:target_page_id, 'Invalid Redirect')
+      end
     end
   end
 
@@ -116,7 +128,7 @@ protected
 
   # Forcing re-saves for child pages so they can update full_paths
   def sync_child_full_paths!
-    return unless full_path_changed?
+    return unless self.full_path_previously_changed?
     children.each do |p|
       p.update_attribute(:full_path, p.send(:assign_full_path))
     end
@@ -132,5 +144,4 @@ protected
     self.slug       = CGI::unescape(self.slug)      unless self.slug.nil?
     self.full_path  = CGI::unescape(self.full_path) unless self.full_path.nil?
   end
-
 end

data/app/models/comfy/cms/revision.rb

@@ -1,12 +1,9 @@
 class Comfy::Cms::Revision < ActiveRecord::Base
   self.table_name = 'comfy_cms_revisions'
-  
+
   serialize :data
-  
+
   # -- Relationships --------------------------------------------------------
-  belongs_to :record, :polymorphic => true
-  
-  # -- Scopes ---------------------------------------------------------------
-  default_scope -> { order('created_at DESC') }
-  
-end
+  belongs_to :record, polymorphic: true
+
+end

data/app/models/comfy/cms/site.rb

@@ -1,8 +1,8 @@
 class Comfy::Cms::Site < ActiveRecord::Base
   self.table_name = 'comfy_cms_sites'
 
-  # -- Relationships --------------------------------------------------------
-  with_options :dependent => :destroy do |site|
+  # -- Relationships -----------------------------------------------------------
+  with_options dependent: :destroy do |site|
     site.has_many :layouts
     site.has_many :pages
     site.has_many :snippets
@@ -10,43 +10,38 @@ class Comfy::Cms::Site < ActiveRecord::Base
     site.has_many :categories
   end
 
-  # -- Callbacks ------------------------------------------------------------
+  # -- Callbacks ---------------------------------------------------------------
   before_validation :assign_identifier,
                     :assign_hostname,
-                    :assign_label
-  before_save :clean_path
-  after_save  :sync_mirrors
+                    :assign_label,
+                    :clean_path
 
-  # -- Validations ----------------------------------------------------------
+  # -- Validations -------------------------------------------------------------
   validates :identifier,
-    :presence   => true,
-    :uniqueness => true,
-    :format     => { :with => /\A\w[a-z0-9_-]*\z/i }
+    presence:   true,
+    uniqueness: true,
+    format:     {with: /\A\w[a-z0-9_-]*\z/i}
   validates :label,
-    :presence   => true
+    presence:   true
   validates :hostname,
-    :presence   => true,
-    :uniqueness => { :scope => :path },
-    :format     => { :with => /\A[\w\.\-]+(?:\:\d+)?\z/ }
+    presence:   true,
+    uniqueness: {scope: :path},
+    format:     {with: /\A[\w\.\-]+(?:\:\d+)?\z/}
 
-  # -- Scopes ---------------------------------------------------------------
-  scope :mirrored, -> { where(:is_mirrored => true) }
-
-  # -- Class Methods --------------------------------------------------------
+  # -- Class Methods -----------------------------------------------------------
   # returning the Comfy::Cms::Site instance based on host and path
   def self.find_site(host, path = nil)
     return Comfy::Cms::Site.first if Comfy::Cms::Site.count == 1
     cms_site = nil
 
+
     public_cms_path = ComfortableMexicanSofa.configuration.public_cms_path
-    if path && public_cms_path != "/"
-      path = path.sub(%r{\A#{public_cms_path}}, "")
-    end
+    path.gsub!(/\A#{public_cms_path}/, '') unless path.nil? || public_cms_path == '/'
 
-    Comfy::Cms::Site.where(:hostname => real_host_from_aliases(host)).each do |site|
+    Comfy::Cms::Site.where(hostname: real_host_from_aliases(host)).each do |site|
       if site.path.blank?
         cms_site = site
-      elsif "#{path.to_s.split('?')[0]}/" =~ %r{^/#{Regexp.escape(site.path.to_s)}/}
+      elsif "#{path.to_s.split('?')[0]}/".match /^\/#{Regexp.escape(site.path.to_s)}\//
         cms_site = site
         break
       end
@@ -54,17 +49,12 @@ class Comfy::Cms::Site < ActiveRecord::Base
     return cms_site
   end
 
-  # -- Instance Methods -----------------------------------------------------
-  def url
+  # -- Instance Methods --------------------------------------------------------
+  def url(relative: false)
     public_cms_path = ComfortableMexicanSofa.config.public_cms_path || '/'
-    '//' + [self.hostname, public_cms_path, self.path].join('/').squeeze('/')
-  end
-
-  # When removing entire site, let's not destroy content from other sites
-  # Since before_destroy doesn't really work, this does the trick
-  def destroy
-    self.update_attributes(:is_mirrored => false) if self.is_mirrored?
-    super
+    host = "//#{self.hostname}"
+    path = ['/', public_cms_path, self.path].compact.join('/').squeeze('/').chomp('/')
+    relative ? path.presence : [host, path].join
   end
 
 protected
@@ -79,7 +69,7 @@ protected
   end
 
   def assign_identifier
-    self.identifier = self.identifier.blank?? self.hostname.try(:slugify) : self.identifier
+    self.identifier = self.identifier.blank?? self.hostname.try(:parameterize) : self.identifier
   end
 
   def assign_hostname
@@ -94,21 +84,6 @@ protected
     self.path ||= ''
     self.path.squeeze!('/')
     self.path.gsub!(/\/$/, '')
+    self.path = nil if self.path.blank?
   end
-
-  # When site is marked as a mirror we need to sync its structure
-  # with other mirrors.
-  def sync_mirrors
-    return unless is_mirrored_changed? && is_mirrored?
-
-    [self, Comfy::Cms::Site.mirrored.where("id != #{id}").first].compact.each do |site|
-      site.layouts.reload
-      site.pages.reload
-      site.snippets.reload
-      (site.layouts.roots + site.layouts.roots.map(&:descendants)).flatten.map(&:sync_mirror)
-      (site.pages.roots + site.pages.roots.map(&:descendants)).flatten.map(&:sync_mirror)
-      site.snippets.map(&:sync_mirror)
-    end
-  end
-
-end
+end

data/app/models/comfy/cms/snippet.rb

@@ -1,45 +1,41 @@
 class Comfy::Cms::Snippet < ActiveRecord::Base
   self.table_name = 'comfy_cms_snippets'
-  
-  cms_is_categorized
-  cms_is_mirrored
+
+  include Comfy::Cms::WithCategories
+
   cms_has_revisions_for :content
-  
-  # -- Relationships --------------------------------------------------------
+
+  # -- Relationships -----------------------------------------------------------
   belongs_to :site
-  
-  # -- Callbacks ------------------------------------------------------------
+
+  # -- Callbacks ---------------------------------------------------------------
   before_validation :assign_label
   before_create :assign_position
   after_save    :clear_page_content_cache
   after_destroy :clear_page_content_cache
-  
-  # -- Validations ----------------------------------------------------------
-  validates :site_id,
-    :presence   => true
+
+  # -- Validations -------------------------------------------------------------
   validates :label,
-    :presence   => true
+    presence:   true
   validates :identifier,
-    :presence   => true,
-    :uniqueness => { :scope => :site_id },
-    :format     => { :with => /\A\w[a-z0-9_-]*\z/i }
-    
-  # -- Scopes ---------------------------------------------------------------
-  default_scope -> { order('comfy_cms_snippets.position') }
-  
+    presence:   true,
+    uniqueness: {scope: :site_id},
+    format:     {with: /\A\w[a-z0-9_-]*\z/i}
+
 protected
-  
+
   def assign_label
     self.label = self.label.blank?? self.identifier.try(:titleize) : self.label
   end
-  
+
+  # When snippet is changed or removed we need to blow away all page caches as
+  # we don't know where it was used.
   def clear_page_content_cache
-    Comfy::Cms::Page.where(:id => site.pages.pluck(:id)).update_all(:content_cache => nil)
+    Comfy::Cms::Page.where(id: site.pages.pluck(:id)).update_all(content_cache: nil)
   end
-  
+
   def assign_position
     max = self.site.snippets.maximum(:position)
     self.position = max ? max + 1 : 0
   end
-  
 end

data/app/models/comfy/cms/translation.rb

@@ -0,0 +1,37 @@
+class Comfy::Cms::Translation < ActiveRecord::Base
+  self.table_name = "comfy_cms_translations"
+
+  include Comfy::Cms::WithFragments
+
+  cms_has_revisions_for :fragments_attributes
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :page
+
+  # -- Callbacks ---------------------------------------------------------------
+  before_validation :assign_layout
+
+  # -- Scopes ------------------------------------------------------------------
+  scope :published, -> { where(is_published: true) }
+
+  # -- Validations -------------------------------------------------------------
+  validates :label,
+    presence:   true
+
+  validates :locale,
+    presence:   true,
+    uniqueness: {scope: :page_id}
+
+  validate :validate_locale
+
+private
+
+  def validate_locale
+    return unless self.page
+    errors.add(:locale) if self.locale == self.page.site.locale
+  end
+
+  def assign_layout
+    self.layout ||= self.page.layout if self.page.present?
+  end
+end

data/app/models/concerns/comfy/cms/with_categories.rb

@@ -0,0 +1,38 @@
+module Comfy::Cms::WithCategories
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :categorizations,
+      as:         :categorized,
+      class_name: "Comfy::Cms::Categorization",
+      dependent:  :destroy
+    has_many :categories,
+      through:    :categorizations,
+      class_name: "Comfy::Cms::Category"
+
+    attr_accessor :category_ids
+
+    after_save :sync_categories
+
+    scope :for_category, -> (*categories) {
+      if (categories = [categories].flatten.compact).present?
+        self.distinct.
+          joins(categorizations: :category).
+          where("comfy_cms_categories.label" => categories)
+      end
+    }
+  end
+
+  def sync_categories
+    (self.category_ids || {}).each do |category_id, flag|
+      case flag.to_i
+      when 1
+        if category = Comfy::Cms::Category.find_by_id(category_id)
+          category.categorizations.create(categorized: self)
+        end
+      when 0
+        self.categorizations.where(category_id: category_id).destroy_all
+      end
+    end
+  end
+end

data/app/models/concerns/comfy/cms/with_fragments.rb

@@ -0,0 +1,121 @@
+module Comfy::Cms::WithFragments
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :fragments_attributes_changed
+
+    belongs_to :layout,
+      class_name: 'Comfy::Cms::Layout'
+
+    has_many :fragments,
+      class_name: 'Comfy::Cms::Fragment',
+      as:         :record,
+      autosave:   true,
+      dependent:  :destroy
+
+    before_save :clear_content_cache
+
+    validates :layout,
+      presence: true
+  end
+
+  # Array of fragment hashes in the following format:
+  #   [
+  #     {identifier: "frag_a", format: "text", content: "fragment a content"},
+  #     {identifier: "frag_b", format: "file", files: [{file_a}, {file_b}]}
+  #   ]
+  # It also handles when frag hashes come in as a hash:
+  #   {
+  #     "0" => {identifer: "foo", content: "bar"},
+  #     "1" => {identifier: "bar", content: "foo"}
+  #   }
+  def fragments_attributes=(frag_hashes = [])
+    frag_hashes = frag_hashes.values if frag_hashes.is_a?(Hash)
+
+    frag_hashes.each do |frag_attrs|
+      unless frag_attrs.is_a?(HashWithIndifferentAccess)
+        frag_attrs.symbolize_keys!
+      end
+
+      identifier = frag_attrs.delete(:identifier)
+
+      fragment =
+        self.fragments.detect{|f| f.identifier == identifier} ||
+        self.fragments.build(identifier: identifier)
+
+      fragment.attributes = frag_attrs
+
+      # tracking dirty
+      self.fragments_attributes_changed ||= fragment.changed?
+    end
+  end
+
+  # Snapshop of page fragments data used primarily for saving revisions
+  def fragments_attributes(was = false)
+    self.fragments.collect do |frag|
+      attrs = {}
+      %i(identifier tag content datetime boolean).each do |column|
+        attrs[column] = frag.send(was ? "#{column}_was" : column)
+      end
+      # TODO: save files against revision (not on db though)
+      # attrs[:files] = frag.attachments.collect do |a|
+      #   {io: a.download, filename: a.filename.to_s, content_type: a.content_type}
+      # end
+      attrs
+    end
+  end
+
+  # Method to collect prevous state of blocks for revisions
+  def fragments_attributes_was
+    fragments_attributes(:previous_values)
+  end
+
+  # Grabbing nodes that we need to render form elements in the admin area
+  # Rejecting duplicates as we'd need to render only one form field. Don't declare
+  # duplicate tags on the layout. That's wierd (but still works).
+  def fragment_nodes
+    nodes
+      .select{|n| n.is_a?(ComfortableMexicanSofa::Content::Tag::Fragment)}
+      .uniq{|n| n.identifier}
+  end
+
+  # Rendered content of the page. We grab whatever layout is associated with the
+  # page and feed its content tokens to the renderer while passing this page as
+  # context.
+  def render(n = nodes)
+    renderer.render(n)
+  end
+
+  # If content_cache column is populated we don't need to call render for this
+  # page.
+  def content_cache
+    if (cache = read_attribute(:content_cache)).nil?
+      cache = self.render
+      update_column(:content_cache, cache) unless self.new_record?
+    end
+    cache
+  end
+
+  # Nuking content cache so it can be regenerated.
+  def clear_content_cache!
+    self.update_column(:content_cache, nil)
+  end
+
+  # Blanking cache on page saves so it can be regenerated on access
+  def clear_content_cache
+    write_attribute(:content_cache, nil)
+  end
+
+protected
+
+  def renderer
+    ComfortableMexicanSofa::Content::Renderer.new(self)
+  end
+
+  def nodes
+    return [] unless self.layout.present?
+
+    tokens = self.layout.content_tokens
+    renderer.nodes(tokens)
+  end
+end