comfortable_mexican_sofa 1.12.11 → 2.0.0

data/lib/comfortable_mexican_sofa/extensions/acts_as_tree.rb

@@ -1,43 +1,44 @@
 module ComfortableMexicanSofa::ActsAsTree
-  
+
   def self.included(base)
     base.extend(ClassMethods)
   end
-  
+
   module ClassMethods
     def cms_acts_as_tree(options = {})
       configuration = {
-        :foreign_key    => 'parent_id', 
-        :order          => nil, 
-        :counter_cache  => nil,
-        :dependent      => :destroy,
-        :touch          => false }
+        foreign_key:    'parent_id',
+        order:          nil,
+        counter_cache:  nil,
+        dependent:      :destroy,
+        touch:          false }
       configuration.update(options) if options.is_a?(Hash)
-      
+
       belongs_to :parent,
-        :class_name     => name, 
-        :foreign_key    => configuration[:foreign_key],
-        :counter_cache  => configuration[:counter_cache],
-        :touch          => configuration[:touch]
-        
+        optional:       true,
+        class_name:     name,
+        foreign_key:    configuration[:foreign_key],
+        counter_cache:  configuration[:counter_cache],
+        touch:          configuration[:touch]
+
       has_many :children,
         -> { order(configuration[:order])},
-        :class_name     => name, 
-        :foreign_key    => configuration[:foreign_key],
-        :dependent      => configuration[:dependent]
-        
+        class_name:   name,
+        foreign_key:  configuration[:foreign_key],
+        dependent:    configuration[:dependent]
+
       class_eval <<-EOV
         include ComfortableMexicanSofa::ActsAsTree::InstanceMethods
-        
+
         scope :roots, -> {
           where("#{configuration[:foreign_key]} IS NULL").
           order(#{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
         }
-        
+
         def self.root
           roots.first
         end
-        
+
         validates_each "#{configuration[:foreign_key]}" do |record, attr, value|
           if value
             if record.id == value
@@ -48,10 +49,10 @@ module ComfortableMexicanSofa::ActsAsTree
           end
         end
       EOV
-      
+
     end
   end
-  
+
   module InstanceMethods
     # Returns list of ancestors, starting from parent until root.
     #
@@ -61,7 +62,7 @@ module ComfortableMexicanSofa::ActsAsTree
       nodes << node = node.parent while node.parent
       nodes
     end
-    
+
     # Returns all children and children of children
     def descendants
       nodes = []
@@ -71,39 +72,41 @@ module ComfortableMexicanSofa::ActsAsTree
       end
       nodes.flatten
     end
-    
+
     # Returns the root node of the tree.
     def root
       node = self
       node = node.parent while node.parent
       node
     end
-    
+
     # Checks if this node is a root
     def root?
       !self.parent_id
     end
-    
+
     # Returns all siblings of the current node.
     #
     #   subchild1.siblings # => [subchild2]
     def siblings
       self_and_siblings - [self]
     end
-    
+
     # Returns all siblings and a reference to the current node.
     #
     #   subchild1.self_and_siblings # => [subchild1, subchild2]
     def self_and_siblings
       parent ? parent.children : self.class.roots
     end
-    
+
     # BUG: https://github.com/rails/rails/issues/14369
     def parent_id=(id)
       self.parent = self.class.find_by(:id => id)
     end
-    
+
   end
 end
 
-ActiveRecord::Base.send :include, ComfortableMexicanSofa::ActsAsTree
+ActiveSupport.on_load :active_record do
+  include ComfortableMexicanSofa::ActsAsTree
+end

data/lib/comfortable_mexican_sofa/extensions/has_revisions.rb

@@ -1,37 +1,37 @@
 module ComfortableMexicanSofa::HasRevisions
-  
+
   def self.included(base)
     base.send :extend, ClassMethods
   end
-  
+
   module ClassMethods
-    
+
     def cms_has_revisions_for(*fields)
-      
+
       include ComfortableMexicanSofa::HasRevisions::InstanceMethods
-      
+
       attr_accessor :revision_data
-      
+
       has_many :revisions,
-        :as         => :record,
-        :dependent  => :destroy,
-        :class_name => 'Comfy::Cms::Revision'
-      
+        as:         :record,
+        dependent:  :destroy,
+        class_name: 'Comfy::Cms::Revision'
+
       before_save :prepare_revision
       after_save  :create_revision
-      
+
       define_method(:revision_fields) do
         fields.collect(&:to_s)
       end
     end
   end
-  
+
   module InstanceMethods
-    
+
     # Preparing revision data. A bit of a special thing to grab page blocks
     def prepare_revision
       return if self.new_record?
-      if (self.respond_to?(:blocks_attributes_changed) && self.blocks_attributes_changed) || 
+      if (self.respond_to?(:fragments_attributes_changed) && self.fragments_attributes_changed) ||
         !(self.changed & revision_fields).empty?
         self.revision_data = revision_fields.inject({}) do |c, field|
           c[field] = self.send("#{field}_was")
@@ -39,22 +39,24 @@ module ComfortableMexicanSofa::HasRevisions
         end
       end
     end
-    
+
     # Revision is created only if relevant data changed
     def create_revision
       return unless self.revision_data
-      
+
+      limit = ComfortableMexicanSofa.config.revisions_limit.to_i
+
       # creating revision
-      if ComfortableMexicanSofa.config.revisions_limit.to_i != 0
-        self.revisions.create!(:data => self.revision_data)
+      if limit != 0
+        self.revisions.create!(data: self.revision_data)
       end
-      
+
       # blowing away old revisions
-      ids = [0] + self.revisions.limit(ComfortableMexicanSofa.config.revisions_limit.to_i).collect(&:id)
+      ids = [0] + self.revisions.order(created_at: :desc).limit(limit).pluck(:id)
       self.revisions.where('id NOT IN (?)', ids).destroy_all
     end
-    
-    # Assigning whatever is found in revision data and attemptint to save the object
+
+    # Assigning whatever is found in revision data and attempting to save the object
     def restore_from_revision(revision)
       return unless revision.record == self
       self.update_attributes!(revision.data)
@@ -62,4 +64,6 @@ module ComfortableMexicanSofa::HasRevisions
   end
 end
 
-ActiveRecord::Base.send :include, ComfortableMexicanSofa::HasRevisions
+ActiveSupport.on_load :active_record do
+  include ComfortableMexicanSofa::HasRevisions
+end

data/lib/comfortable_mexican_sofa/form_builder.rb

@@ -1,117 +1,45 @@
 class ComfortableMexicanSofa::FormBuilder < BootstrapForm::FormBuilder
 
-  def field_name_for(tag)
-    tag.blockable.class.name.demodulize.underscore.gsub(/\//,'_')
+  def default_label_col
+    "col-sm-2 text-md-right"
   end
 
-  # -- Tag Field Fields -----------------------------------------------------
-  def default_tag_field(tag, index, method = :text_field_tag, options = {})
+  def field(record, tag, index)
+    object_name = record.class.to_s.demodulize.underscore
 
-    label       = tag.blockable.class.human_attribute_name(tag.identifier.to_s)
-    css_class   = tag.class.to_s.demodulize.underscore
-    content     = ''
-    fieldname   = field_name_for(tag)
-    case method
-    when :file_field_tag
-      input_params = {:id => nil}
-      name = "#{fieldname}[blocks_attributes][#{index}][content]"
+    tag.form_field(object_name, @template, index) do |tag_input|
 
-      if options.delete(:multiple)
-        input_params.merge!(:multiple => true)
-        name << '[]'
-      end
-
-      content << @template.send(method, name, input_params)
-      content << @template.render(:partial => 'comfy/admin/cms/files/page_form', :object => tag.block)
-    else
-      options[:class] = ' form-control'
-      content << @template.send(method, "#{fieldname}[blocks_attributes][#{index}][content]", tag.content, options)
-    end
-    content << @template.hidden_field_tag("#{fieldname}[blocks_attributes][#{index}][identifier]", tag.identifier, :id => nil)
-
-    form_group :label => {:text => label} do 
-      content.html_safe
-    end
-  end
-
-  def field_date_time(tag, index)
-    default_tag_field(tag, index, :text_field_tag, :data => {'cms-datetime' => true})
-  end
-
-  def field_integer(tag, index)
-    default_tag_field(tag, index, :number_field_tag)
-  end
-
-  def field_string(tag, index)
-    default_tag_field(tag, index)
-  end
-
-  def field_text(tag, index)
-    default_tag_field(tag, index, :text_area_tag, :data => {'cms-cm-mode' => 'text/html'})
-  end
-
-  def field_rich_text(tag, index)
-    default_tag_field(tag, index, :text_area_tag, :data => {'cms-rich-text' => true})
-  end
-
-  def field_boolean(tag, index)
-    fieldname = field_name_for(tag)
-    content = @template.hidden_field_tag("#{fieldname}[blocks_attributes][#{index}][content]", '', :id => nil)
-    content << @template.check_box_tag("#{fieldname}[blocks_attributes][#{index}][content]", '1', tag.content.present?, :id => nil)
-    content << @template.hidden_field_tag("#{fieldname}[blocks_attributes][#{index}][identifier]", tag.identifier, :id => nil)
-    form_group :label => {:text => (tag.blockable.class.human_attribute_name(tag.identifier.to_s) || tag.identifier.titleize + "?")} do 
-      content
-    end
-  end
-
-  def page_date_time(tag, index)
-    default_tag_field(tag, index, :text_field_tag, :data => {'cms-datetime' => true})
-  end
-
-  def page_integer(tag, index)
-    default_tag_field(tag, index, :number_field_tag)
-  end
-
-  def page_string(tag, index)
-    default_tag_field(tag, index)
-  end
-
-  def page_text(tag, index)
-    default_tag_field(tag, index, :text_area_tag, :data => {'cms-cm-mode' => 'text/html'})
-  end
+      name = "#{object_name}[fragments_attributes][#{index}][identifier]"
+      identifer_input = @template.hidden_field_tag(name, tag.identifier, id: nil)
 
-  def page_rich_text(tag, index)
-    default_tag_field(tag, index, :text_area_tag, :data => {'cms-rich-text' => true})
-  end
-
-  def page_file(tag, index)
-    default_tag_field(tag, index, :file_field_tag)
-  end
-
-  def page_files(tag, index)
-    default_tag_field(tag, index, :file_field_tag, :multiple => true)
-  end
+      name  = "#{object_name}[fragments_attributes][#{index}][tag]"
+      value = tag.class.to_s.demodulize.underscore
+      tag_name_input = @template.hidden_field_tag(name, value, id: nil)
 
-  def page_markdown(tag, index)
-    default_tag_field(tag, index, :text_area_tag, :data => {'cms-cm-mode' => 'text/x-markdown'})
-  end
-
-  def collection(tag, index)
-    options = [["---- Select #{tag.collection_class.titleize} ----", nil]] +
-      tag.collection_objects.collect do |m|
-        [m.send(tag.collection_title), m.send(tag.collection_identifier)]
+      label = I18n.t("comfy.cms.content.tag.#{tag.identifier}", default: tag.identifier.titleize)
+      renderable = tag.respond_to?(:renderable) ? tag.renderable : true
+      form_group label: {text: label, class: "renderable-#{renderable}"} do
+        [identifer_input, tag_name_input, tag_input].join.html_safe
       end
-
-    fieldname = field_name_for(tag)
-    content = @template.select_tag(
-      "#{fieldname}[blocks_attributes][#{index}][content]",
-      @template.options_for_select(options, :selected => tag.content),
-      :id => nil
-    )
-    content << @template.hidden_field_tag("#{fieldname}[blocks_attributes][#{index}][identifier]", tag.identifier, :id => nil)
-    form_group :label => {:text => tag.identifier.titleize}, :class => tag.class.to_s.demodulize.underscore do
-      content
     end
   end
 
+  # Wrapper for form action that is sticking to the bottom of the viewport
+  def form_actions(&block)
+    <<-HTML.strip_heredoc.html_safe
+      <div class="form-actions bg-light">
+        <div class="row">
+          <div class="col-lg-2"></div>
+          <div class="col-lg-8">
+            <div class="row">
+              <div class="col-sm-2"></div>
+              <div class="col-sm-10">
+                #{capture(&block)}
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    HTML
+  end
 end

data/lib/comfortable_mexican_sofa/render_methods.rb

@@ -4,27 +4,27 @@ module ComfortableMexicanSofa::RenderMethods
 
     # If application controller doesn't have template associated with it
     # CMS will attempt to find one. This is so you don't have to explicitly
-    # call render :cms_page => '/something'
+    # call render cms_page: '/something'
     base.rescue_from 'ActionView::MissingTemplate' do |e|
       begin
-        render :cms_page => request.path
+        render cms_page: request.path
       rescue ComfortableMexicanSofa::MissingPage, ComfortableMexicanSofa::MissingSite
         raise e
       end
     end
 
     # Now you can render cms_page simply by calling:
-    #   render :cms_page => '/path/to/page'
+    #   render cms_page: '/path/to/page'
     # This way application controllers can use CMS content while populating
     # instance variables that can be used in partials (that are included by
     # by the cms page and/or layout)
     #
     # Or how about not worrying about setting up CMS pages and rendering
     # application view using a CMS layout?
-    #   render :cms_layout => 'layout_slug', :cms_blocks => {
-    #     :block_label_a => 'content text',
-    #     :block_label_b => { :template => 'path/to/template' },
-    #     :block_label_c => { :partial  => 'path/to/partial' }
+    #   render cms_layout: 'layout_slug', cms_fragments: {
+    #     fragment_identifier_a: 'content text',
+    #     fragment_identifier_b: {template: 'path/to/template' },
+    #     fragment_identifier_c: {partial:  'path/to/partial' }
     #   }
     #
     # This way you are populating page block content and rendering
@@ -32,7 +32,7 @@ module ComfortableMexicanSofa::RenderMethods
     #
     # Site is loaded automatically based on the request. However you can force
     # it by passing :cms_site parameter with site's slug. For example:
-    #   render :cms_page => '/path/to/page', :cms_site => 'default'
+    #   render cms_page: '/path/to/page', cms_site: 'default'
     #
     def render(options = {}, locals = {}, &block)
 
@@ -67,12 +67,12 @@ module ComfortableMexicanSofa::RenderMethods
       end
 
       @cms_layout = @cms_page.layout
-      if (cms_blocks = options.delete(:cms_blocks)).present?
-        cms_blocks.each do |identifier, value|
-          content = value.is_a?(Hash) ? render_to_string(value.merge(:layout => false)) : value.to_s
-          page_block  = @cms_page.blocks.detect{|b| b.identifier == identifier.to_s} ||
-                        @cms_page.blocks.build(:identifier => identifier.to_s)
-          page_block.content = content
+      if (cms_fragments = options.delete(:cms_fragments)).present?
+        cms_fragments.each do |identifier, value|
+          content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+          page_fragment = @cms_page.fragments.detect{|f| f.identifier == identifier.to_s} ||
+                          @cms_page.fragments.build(identifier: identifier.to_s)
+          page_fragment.content = content
         end
       end
       cms_app_layout = @cms_layout.app_layout
@@ -89,19 +89,22 @@ module ComfortableMexicanSofa::RenderMethods
       end
 
       cms_app_layout = @cms_layout.app_layout
-      cms_page = @cms_site.pages.build(:layout => @cms_layout)
-      cms_blocks = options.delete(:cms_blocks) || { :content => render_to_string({ :layout => false }.merge(options)) }
-      cms_blocks.each do |identifier, value|
-        content = value.is_a?(Hash) ? render_to_string(value.merge(:layout => false)) : value.to_s
-        cms_page.blocks.build(:identifier => identifier.to_s, :content => content)
+      cms_page = @cms_site.pages.build(layout: @cms_layout)
+      cms_fragments = options.delete(:cms_fragments) ||
+        {content: render_to_string({layout: false}.merge(options))}
+
+      cms_fragments.each do |identifier, value|
+        content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+        cms_page.fragments.build(identifier: identifier.to_s, content: content)
       end
       options[:layout] ||= cms_app_layout.blank?? nil : cms_app_layout
       options[:inline] = cms_page.render
 
       render(options, locals, &block)
     end
-
   end
 end
 
-ActionController::Base.send :include, ComfortableMexicanSofa::RenderMethods
+ActiveSupport.on_load :action_controller_base do
+  include ComfortableMexicanSofa::RenderMethods
+end