comfortable_mexican_sofa 1.12.11 → 2.0.0

data/lib/comfortable_mexican_sofa/seeds/page/importer.rb

@@ -0,0 +1,213 @@
+module ComfortableMexicanSofa::Seeds::Page
+  class Importer < ComfortableMexicanSofa::Seeds::Importer
+
+    # tracking target page linking. Since we might be linking to something that
+    # doesn't exist yet, we'll defer linking to the end of import
+    attr_accessor :target_pages
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMexicanSofa.config.seeds_path, from, "pages/")
+    end
+
+    def import!
+      import_page(File.join(self.path, "index/"), nil)
+
+      link_target_pages
+
+      # Remove pages not found in seeds
+      self.site.pages.where('id NOT IN (?)', self.seed_ids).destroy_all
+    end
+
+  private
+
+    # Recursive function that will be called for each child page (subfolder)
+    def import_page(path, parent)
+      slug = path.split("/").last
+
+      # setting page record
+      page = if parent.present?
+        self.site.pages.where(parent: parent, slug: slug).first_or_initialize
+      else
+        self.site.pages.root || self.site.pages.new(slug: slug)
+      end
+
+      content_path = File.join(path, "content.html")
+
+      # If file is newer than page record we'll process it
+      if fresh_seed?(page, content_path)
+
+        # reading file content in, resulting in a hash
+        fragments_hash  = parse_file_content(content_path)
+
+        # parsing attributes section
+        attributes_yaml = fragments_hash.delete("attributes")
+        attrs           = YAML.load(attributes_yaml)
+
+        # applying attributes
+        layout = self.site.layouts.find_by(identifier: attrs.delete("layout")) || parent.try(:layout)
+        category_ids    = category_names_to_ids(Comfy::Cms::Page, attrs.delete("categories"))
+        target_page     = attrs.delete("target_page")
+
+        page.attributes = attrs.merge(
+          layout: layout,
+          category_ids: category_ids
+        )
+
+        # applying fragments
+        old_frag_identifiers = page.fragments.pluck(:identifier)
+
+        new_frag_identifiers, fragments_attributes =
+          construct_fragments_attributes(fragments_hash, page, path)
+        page.fragments_attributes = fragments_attributes
+
+        if page.save
+          message = "[CMS SEEDS] Imported Page \t #{page.full_path}"
+          ComfortableMexicanSofa.logger.info(message)
+
+          # defering target page linking
+          if target_page.present?
+            self.target_pages ||= {}
+            self.target_pages[page.id] = target_page
+          end
+
+          # cleaning up old fragments
+          page.fragments.where(identifier: old_frag_identifiers - new_frag_identifiers).destroy_all
+
+        else
+          message = "[CMS SEEDS] Failed to import Page \n#{page.errors.inspect}"
+          ComfortableMexicanSofa.logger.warn(message)
+        end
+      end
+
+      import_translations(path, page)
+
+      # Tracking what page from seeds we're working with. So we can remove pages
+      # that are no longer in seeds
+      self.seed_ids << page.id
+
+      # importing child pages (if there are any)
+      Dir["#{path}*/"].each do |path|
+        import_page(path, page)
+      end
+    end
+
+    # Importing translations for given page. They look like `content.locale.html`
+    def import_translations(path, page)
+      old_translations = page.translations.pluck(:locale)
+      new_translations = []
+
+      Dir["#{path}content.*.html"].each do |file_path|
+        locale = File.basename(file_path).match(/content\.(\w+)\.html/)[1]
+        new_translations << locale
+
+        translation = page.translations.where(locale: locale).first_or_initialize
+
+        if fresh_seed?(translation, file_path)
+          # reading file content in, resulting in a hash
+          fragments_hash  = parse_file_content(file_path)
+
+          # parsing attributes section
+          attributes_yaml = fragments_hash.delete("attributes")
+          attrs           = YAML.load(attributes_yaml)
+
+          # applying attributes
+          layout = self.site.layouts.find_by(identifier: attrs.delete("layout")) || page.try(:layout)
+          translation.attributes = attrs.merge(
+            layout: layout
+          )
+
+          # applying fragments
+          old_frag_identifiers = translation.fragments.pluck(:identifier)
+
+          new_frag_identifiers, fragments_attributes =
+            construct_fragments_attributes(fragments_hash, translation, path)
+          translation.fragments_attributes = fragments_attributes
+
+          if translation.save
+            message = "[CMS SEEDS] Imported Translation \t #{locale}"
+            ComfortableMexicanSofa.logger.info(message)
+
+            # cleaning up old fragments
+            frags_to_remove = old_frag_identifiers - new_frag_identifiers
+            translation.fragments.where(identifier: frags_to_remove).destroy_all
+
+          else
+            message = "[CMS SEEDS] Failed to import Translation \n#{locale}"
+            ComfortableMexicanSofa.logger.warn(message)
+          end
+        end
+      end
+
+      # Cleaning up removed translations
+      translations_to_remove = old_translations - new_translations
+      page.translations.where(locale: translations_to_remove).destroy_all
+    end
+
+    # Constructing frag attributes hash that can be assigned to page or translation
+    # also returning list of frag identifiers so we can destroy old ones
+    def construct_fragments_attributes(hash, record, path)
+      frag_identifiers = []
+      frag_attributes = hash.collect do |frag_header, frag_content|
+        tag, identifier = frag_header.split
+        frag_hash = {
+          identifier: identifier,
+          tag:        tag
+        }
+
+        # tracking fragments that need removing later
+        frag_identifiers << identifier
+
+        # based on tag we need to cram content in proper place and proper format
+        case tag
+        when "date", "datetime"
+          frag_hash[:datetime] = frag_content
+        when "checkbox"
+          frag_hash[:boolean] = frag_content
+        when "file", "files"
+          files, file_ids_destroy = files_content(record, identifier, path, frag_content)
+          frag_hash[:files]            = files
+          frag_hash[:file_ids_destroy] = file_ids_destroy
+        else
+          frag_hash[:content] = frag_content
+        end
+
+        frag_hash
+      end
+
+      return [frag_identifiers, frag_attributes]
+    end
+
+    # Preparing fragment attachments. Returns hashes with file data for
+    # ActiveStorage and a list of ids of old attachements to destroy
+    def files_content(record, identifier, path, frag_content)
+      # preparing attachments
+      files = frag_content.split.collect do |filename|
+        file_handler = File.open(File.join(path, filename))
+        {
+          io:           file_handler,
+          filename:     filename,
+          content_type: MimeMagic.by_magic(file_handler)
+        }
+      end
+
+      # ensuring that old attachments get removed
+      ids_destroy = []
+      if frag = record.fragments.find_by(identifier: identifier)
+        ids_destroy = frag.attachments.pluck(:id)
+      end
+
+      [files, ids_destroy]
+    end
+
+    def link_target_pages
+      return unless self.target_pages.present?
+
+      self.target_pages.each do |page_id, target|
+        if target = self.site.pages.find_by(full_path: target)
+          @site.pages.find(page_id).update_column(:target_page_id, target.id)
+        end
+      end
+    end
+  end
+end

data/lib/comfortable_mexican_sofa/seeds/snippet/exporter.rb

@@ -0,0 +1,31 @@
+module ComfortableMexicanSofa::Seeds::Snippet
+  class Exporter < ComfortableMexicanSofa::Seeds::Exporter
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMexicanSofa.config.seeds_path, to, "snippets/")
+    end
+
+    def export!
+      prepare_folder!(self.path)
+
+      self.site.snippets.each do |snippet|
+        attrs = {
+          "label"       => snippet.label,
+          "categories"  => snippet.categories.map{|c| c.label},
+          "position"    => snippet.position
+        }.to_yaml
+
+        data = []
+        data << {header: "attributes", content: attrs}
+        data << {header: "content", content: snippet.content}
+
+        snippet_path = File.join(self.path, "#{snippet.identifier}.html")
+        write_file_content(snippet_path, data)
+
+        message = "[CMS SEEDS] Exported Snippet \t #{snippet.identifier}"
+        ComfortableMexicanSofa.logger.info(message)
+      end
+    end
+  end
+end

data/lib/comfortable_mexican_sofa/seeds/snippet/importer.rb

@@ -0,0 +1,48 @@
+module ComfortableMexicanSofa::Seeds::Snippet
+  class Importer < ComfortableMexicanSofa::Seeds::Importer
+
+    def initialize(from, to = from)
+      super
+      self.path = ::File.join(ComfortableMexicanSofa.config.seeds_path, from, "snippets/")
+    end
+
+    def import!
+      Dir.glob("#{self.path}/*.html").each do |path|
+        identifier = File.basename(path, ".html")
+
+        # reading file content in, resulting in a hash
+        content_hash = parse_file_content(path)
+
+        # parsing attributes section
+        attributes_yaml = content_hash.delete("attributes")
+        attrs           = YAML.load(attributes_yaml)
+
+        snippet = self.site.snippets.where(identifier: identifier).first_or_initialize
+
+        if fresh_seed?(snippet, path)
+          category_ids = category_names_to_ids(Comfy::Cms::Snippet, attrs.delete("categories"))
+
+          snippet.attributes = attrs.merge(
+            category_ids: category_ids,
+            content:      content_hash["content"]
+          )
+
+          if snippet.save
+            message = "[CMS SEEDS] Imported Snippet \t #{snippet.identifier}"
+            ComfortableMexicanSofa.logger.info(message)
+          else
+            message = "[CMS SEEDS] Failed to import Snippet \n#{snippet.errors.inspect}"
+            ComfortableMexicanSofa.logger.warn(message)
+          end
+        end
+
+        # Tracking what page from seeds we're working with. So we can remove pages
+        # that are no longer in seeds
+        self.seed_ids << snippet.id
+      end
+
+      # cleaning up
+      self.site.snippets.where("id NOT IN (?)", self.seed_ids).destroy_all
+    end
+  end
+end

data/lib/comfortable_mexican_sofa/version.rb

@@ -1,3 +1,3 @@
 module ComfortableMexicanSofa
-  VERSION = "1.12.11"
+  VERSION = "2.0.0"
 end

data/lib/comfortable_mexican_sofa/view_hooks.rb

@@ -29,5 +29,4 @@ module ComfortableMexicanSofa::ViewHooks
   def self.remove(name)
     self.hooks.delete(name)
   end
-
 end

data/lib/generators/comfy/cms/assets_generator.rb

@@ -5,7 +5,6 @@ module Comfy
         source_root File.expand_path(File.join(File.dirname(__FILE__), '../../../../app/assets'))
 
         def generate_assets
-          directory 'images/comfy/admin/cms',      'app/assets/images/comfy/admin/cms'
           directory 'javascripts/comfy/admin/cms', 'app/assets/javascripts/comfy/admin/cms'
           directory 'stylesheets/comfy/admin/cms', 'app/assets/stylesheets/comfy/admin/cms'
         end

data/lib/generators/comfy/cms/cms_generator.rb

@@ -26,15 +26,25 @@ module Comfy
           'config/initializers/comfortable_mexican_sofa.rb'
       end
 
+      def generate_railties_order
+        application <<-RUBY.strip_heredoc
+          # Ensuring that ActiveStorage routes are loaded before Comfy's globbing
+          # route. Without this file serving routes are inaccessible.
+          config.railties_order = [ActiveStorage::Engine, :main_app, :all]
+        RUBY
+      end
+
       def generate_routing
-        route_string  = "  comfy_route :cms_admin, :path => '/admin'\n\n"
-        route_string << "  # Make sure this routeset is defined last\n"
-        route_string << "  comfy_route :cms, :path => '/', :sitemap => false\n"
-        route route_string[2..-1]
+        route_string = <<-RUBY.strip_heredoc
+          comfy_route :cms_admin, path: "/admin"
+          # Ensure that this route is defined last
+          comfy_route :cms, path: "/"
+        RUBY
+        route route_string
       end
 
       def generate_cms_seeds
-        directory 'db/cms_fixtures', 'db/cms_fixtures'
+        directory 'db/cms_seeds', 'db/cms_seeds'
       end
 
       def generate_assets

data/lib/generators/comfy/scaffold/scaffold_generator.rb

@@ -4,42 +4,42 @@ require 'rails/generators/active_record'
 module Comfy
   module Generators
     class ScaffoldGenerator < Rails::Generators::NamedBase
-      
+
       include Rails::Generators::Migration
-      
-      no_tasks do 
+
+      no_tasks do
         attr_accessor :model_attrs
       end
-      
+
       source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
-      
-      argument :model_args, :type => :array, :default => [], :banner => 'attribute:type'
-      
+
+      argument :model_args, type: :array, default: [], banner: 'attribute:type'
+
       def initialize(*args, &block)
         super
         @model_attrs = []
         model_args.each do |arg|
           next unless arg.include?(':')
-          @model_attrs << Rails::Generators::GeneratedAttribute.new(*arg.split(':')) 
+          @model_attrs << Rails::Generators::GeneratedAttribute.new(*arg.split(':'))
         end
       end
-      
+
       def self.next_migration_number(dirname)
         ActiveRecord::Generators::Base.next_migration_number(dirname)
       end
-      
+
       def generate_model
         migration_template 'migration.rb', "db/migrate/create_#{file_name.pluralize}.rb"
         template 'model.rb', "app/models/#{file_name}.rb"
         template 'tests/model.rb', "test/models/#{file_name}_test.rb"
         template 'tests/fixture.yml', "test/fixtures/#{file_name.pluralize}.yml"
       end
-      
+
       def generate_controller
         template 'controller.rb', "app/controllers/admin/#{file_name.pluralize}_controller.rb"
         template 'tests/controller.rb', "test/controllers/admin/#{file_name.pluralize}_controller_test.rb"
       end
-      
+
       def generate_views
         template 'views/index.haml', "app/views/admin/#{file_name.pluralize}/index.html.haml"
         template 'views/show.haml', "app/views/admin/#{file_name.pluralize}/show.html.haml"
@@ -47,23 +47,29 @@ module Comfy
         template 'views/edit.haml', "app/views/admin/#{file_name.pluralize}/edit.html.haml"
         template 'views/_form.haml', "app/views/admin/#{file_name.pluralize}/_form.html.haml"
       end
-      
+
       def generate_route
-        route_string  = "  namespace :admin do\n"
-        route_string << "    resources :#{file_name.pluralize}\n"
-        route_string << "  end\n"
-        route route_string[2..-1]
+        route_string = <<-TEXT.strip_heredoc
+          namespace :admin do
+            resources :#{file_name.pluralize}
+          end
+
+        TEXT
+        route route_string
       end
-      
+
       def generate_navigation_link
         partial_path = 'app/views/comfy/admin/cms/partials/_navigation_inner.html.haml'
         unless File.exist?(File.join(destination_root, partial_path))
           create_file partial_path
         end
         append_file partial_path do
-          "\n%li= active_link_to '#{class_name.pluralize}', admin_#{file_name.pluralize}_path\n"
+          <<-HAML.strip_heredoc
+            %li.nav-item
+              = active_link_to '#{class_name.pluralize}', admin_#{file_name.pluralize}_path, class: 'nav-link'
+          HAML
         end
       end
     end
   end
-end
+end

data/lib/generators/comfy/scaffold/templates/{controller.rb → controller.rb.tt}

@@ -1,7 +1,7 @@
-class Admin::<%= class_name.pluralize %>Controller < Comfy::Admin::Cms::BaseController
+class Admin::<%= class_name.pluralize %>Controller < Comfy::Admin::BaseController
 
-  before_action :build_<%= file_name %>,  :only => [:new, :create]
-  before_action :load_<%= file_name %>,   :only => [:show, :edit, :update, :destroy]
+  before_action :build_<%= file_name %>,  only: [:new, :create]
+  before_action :load_<%= file_name %>,   only: [:show, :edit, :update, :destroy]
 
   def index
     @<%= file_name.pluralize %> = <%= class_name %>.page(params[:page])
@@ -22,25 +22,25 @@ class Admin::<%= class_name.pluralize %>Controller < Comfy::Admin::Cms::BaseCont
   def create
     @<%= file_name %>.save!
     flash[:success] = '<%= class_name.titleize %> created'
-    redirect_to :action => :show, :id => @<%= file_name %>
+    redirect_to action: :show, id: @<%= file_name %>
   rescue ActiveRecord::RecordInvalid
     flash.now[:danger] = 'Failed to create <%= class_name.titleize %>'
-    render :action => :new
+    render action: :new
   end
 
   def update
     @<%= file_name %>.update_attributes!(<%= file_name %>_params)
     flash[:success] = '<%= class_name.titleize %> updated'
-    redirect_to :action => :show, :id => @<%= file_name %>
+    redirect_to action: :show, id: @<%= file_name %>
   rescue ActiveRecord::RecordInvalid
     flash.now[:danger] = 'Failed to update <%= class_name.titleize %>'
-    render :action => :edit
+    render action: :edit
   end
 
   def destroy
     @<%= file_name %>.destroy
     flash[:success] = '<%= class_name.titleize %> deleted'
-    redirect_to :action => :index
+    redirect_to action: :index
   end
 
 protected
@@ -53,10 +53,10 @@ protected
     @<%= file_name %> = <%= class_name %>.find(params[:id])
   rescue ActiveRecord::RecordNotFound
     flash[:danger] = '<%= class_name.titleize %> not found'
-    redirect_to :action => :index
+    redirect_to action: :index
   end
 
   def <%= file_name %>_params
     params.fetch(:<%= file_name %>, {}).permit(<%= model_attrs.collect{|attr| ":#{attr.name}"}.join(', ') %>)
   end
-end
+end