alchemy_cms 4.0.6 → 4.1.0.beta

data/db/migrate/20180227224537_migrate_tags_to_gutentag.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class MigrateTagsToGutentag < ActiveRecord::Migration[5.0]
+  def up
+    return if table_exists?(:gutentag_tags)
+
+    remove_index :taggings, :taggable_id
+    remove_column :taggings, :tagger_id, :integer
+    remove_index :taggings, :taggable_type
+    remove_column :taggings, :tagger_type, :string
+    remove_index :taggings, column: [:taggable_id, :taggable_type, :context], name: 'index_taggings_on_taggable_id_and_taggable_type_and_context'
+    remove_column :taggings, :context, :string, limit: 128
+    if index_exists? :taggings, [:tag_id, :taggable_id, :taggable_type], unique: true, name: 'taggings_idx'
+      rename_index :taggings, 'taggings_idx', 'unique_taggings'
+    else
+      add_index :taggings, [:taggable_type, :taggable_id, :tag_id], unique: true, name: 'unique_taggings'
+    end
+    if index_exists? :taggings, [:taggable_id, :taggable_type], name: 'taggings_idy'
+      rename_index :taggings, 'taggings_idy', 'index_gutentag_taggings_on_taggable_id_and_taggable_type'
+    else
+      add_index :taggings, [:taggable_type, :taggable_id]
+    end
+    add_column :taggings, :updated_at, :datetime, precision: 6
+    change_column_null :taggings, :tag_id, false
+    change_column_null :taggings, :taggable_id, false
+    change_column_null :taggings, :taggable_type, false
+    change_column_null :taggings, :created_at, false, Time.current
+    change_column_null :taggings, :updated_at, false, Time.current
+    rename_table :taggings, :gutentag_taggings
+
+    change_column_null :tags, :name, false
+    add_index :tags, :taggings_count
+    rename_table :tags, :gutentag_tags
+
+    %i(alchemy_attachments alchemy_elements alchemy_pages alchemy_pictures).each do |table|
+      if column_exists? table, :cached_tag_list
+        remove_column table, :cached_tag_list
+      end
+    end
+  end
+end

data/lib/alchemy/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# encoding: utf-8
-
 module Alchemy
   class Config
     class << self

data/lib/alchemy/engine.rb

@@ -14,15 +14,11 @@ module Alchemy
       NonStupidDigestAssets.whitelist += [/^tinymce\//]
     end
 
-    # We need to reload each essence class in development mode on every request,
-    # so it can register itself as essence relation on Page and Element models
-    #
-    # @see lib/alchemy/essence.rb:71
-    config.to_prepare do
-      unless Rails.configuration.cache_classes
-        essences = File.join(File.dirname(__FILE__), '../../app/models/alchemy/essence_*.rb')
-        Dir.glob(essences).each { |essence| load(essence) }
-      end
+    # Gutentag downcases all tgas before save.
+    # We support having tags with uppercase characters.
+    # The Gutentag search is case insensitive.
+    initializer 'alchemy.gutentag_normalizer' do
+      Gutentag.normaliser = ->(value) { value.to_s }
     end
 
     config.after_initialize do

data/lib/alchemy/essence.rb

@@ -31,15 +31,15 @@ module Alchemy #:nodoc:
           ingredient_column: 'body'
         }.update(options)
 
-        class_eval <<-EOV
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           attr_writer :validation_errors
           include Alchemy::Essence::InstanceMethods
           stampable stamper_class_name: Alchemy.user_class_name
-          validate :validate_ingredient, :on => :update, :if => 'validations.any?'
+          validate :validate_ingredient, on: :update, if: -> { validations.any? }
 
-          has_one :content, :as => :essence, class_name: "Alchemy::Content"
-          has_one :element, :through => :content, class_name: "Alchemy::Element"
-          has_one :page,    :through => :element, class_name: "Alchemy::Page"
+          has_one :content, as: :essence, class_name: "Alchemy::Content"
+          has_one :element, through: :content, class_name: "Alchemy::Element"
+          has_one :page,    through: :element, class_name: "Alchemy::Page"
 
           scope :available,    -> { joins(:element).merge(Alchemy::Element.available) }
           scope :from_element, ->(name) { joins(:element).where(Element.table_name => { name: name }) }
@@ -65,7 +65,7 @@ module Alchemy #:nodoc:
           def preview_text_column
             '#{configuration[:preview_text_column] || configuration[:ingredient_column]}'
           end
-        EOV
+        RUBY
       end
 
       # Register the current class as has_many association on +Alchemy::Page+ and +Alchemy::Element+ models

data/lib/alchemy/filetypes.rb

@@ -16,7 +16,8 @@ module Alchemy
       "image/jpeg",
       "image/png",
       "image/svg+xml",
-      "image/tiff"
+      "image/tiff",
+      "image/x-psd"
     ]
 
     VCARD_FILE_TYPES = ["text/x-vcard", "application/vcard"]
@@ -30,5 +31,16 @@ module Alchemy
       "video/x-msvideo",
       "video/x-ms-wmv"
     ]
+
+    TEXT_FILE_TYPES = [
+      "application/rtf",
+      "text/plain"
+    ]
+
+    EXCEL_FILE_TYPES = [
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "application/vnd.ms-excel",
+      "text/csv"
+    ]
   end
 end

data/lib/alchemy/forms/builder.rb

@@ -21,9 +21,11 @@ module Alchemy
       # Renders a button tag wrapped in a div with 'submit' class.
       #
       def submit(label, options = {})
-        options = {class: 'submit'}.update(options[:wrapper_html] || {})
-        template.content_tag('div', options) do
-          template.content_tag('button', label, options[:input_html])
+        options = {
+          wrapper_html: {class: 'submit'}
+        }.update(options)
+        template.content_tag('div', options.delete(:wrapper_html)) do
+          template.content_tag('button', label, options.delete(:input_html))
         end
       end
     end

data/lib/alchemy/i18n.rb

@@ -18,6 +18,8 @@ module Alchemy
   end
 
   module I18n
+    LOCALE_FILE_PATTERN = /alchemy\.(\S{2,5})\.yml/
+
     class << self
       # Alchemy translation methods
       #
@@ -54,9 +56,9 @@ module Alchemy
 
       def available_locales
         @@available_locales ||= nil
-        @@available_locales || translation_files.collect do |f|
-          f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '').to_sym
-        end
+        @@available_locales || translation_files.collect { |f|
+          f.match(LOCALE_FILE_PATTERN)[1].to_sym
+        }.uniq.sort
       end
 
       def available_locales=(locales)
@@ -64,12 +66,12 @@ module Alchemy
         @@available_locales = nil if @@available_locales.empty?
       end
 
+      private
+
       def translation_files
-        Dir.glob(File.join(File.dirname(__FILE__), '../../config/locales/alchemy.*.yml'))
+        ::I18n.load_path.select { |path| path.match(LOCALE_FILE_PATTERN) }
       end
 
-      private
-
       def humanize_default_string!(msg, options)
         return if options[:default].present?
         options[:default] = msg.is_a?(Symbol) ? msg.to_s.humanize : msg

data/lib/alchemy/modules.rb

@@ -4,7 +4,7 @@ module Alchemy
   module Modules
     mattr_accessor :alchemy_modules
 
-    @@alchemy_modules = YAML.load_file(File.expand_path('../../../config/alchemy/modules.yml', __FILE__))
+    @@alchemy_modules = YAML.load_file(File.expand_path('../../config/alchemy/modules.yml', __dir__))
 
     def self.included(base)
       base.send :helper_method, :alchemy_modules, :module_definition_for

data/lib/alchemy/name_conversions.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# encoding: utf-8
-
 module Alchemy
   # Provides methods for converting names into urlnames and vice versa.
   #

data/lib/alchemy/page_layout.rb

@@ -138,7 +138,7 @@ module Alchemy
       # Returns true if one page already has the given layout
       #
       def page_with_layout_existing?(layout)
-        Page.where(page_layout: layout, language_id: @language_id).pluck(:id).any?
+        Alchemy::Page.where(page_layout: layout, language_id: @language_id).pluck(:id).any?
       end
 
       # Returns true if given layout is available for current site.
@@ -152,7 +152,8 @@ module Alchemy
       #     page_layouts: [default_intro]
       #
       def available_on_site?(layout)
-        Site.current.definition.blank? || Site.current.definition.fetch('page_layouts', []).include?(layout['name'])
+        Alchemy::Site.current.definition.blank? ||
+          Alchemy::Site.current.definition.fetch('page_layouts', []).include?(layout['name'])
       end
 
       # Reads the layout definitions from +config/alchemy/page_layouts.yml+.

data/lib/alchemy/paths.rb

@@ -4,7 +4,7 @@
 #
 # Alchemy has some defaults for admin path and admin constraints:
 #
-# +Alchemy.admin_path defaults to +'/admin'+
+# +Alchemy.admin_path defaults to +'admin'+
 # +Alchemy.admin_constraints defaults to +{}+
 #
 # Anyway, you can tell Alchemy about your routing configuration:
@@ -17,11 +17,11 @@
 #
 # == Example
 #
-# If you do not wish to use the default admin interface routing ('example.com/admin/')
-# and prefer e.g. 'hidden.example.com/backend/', those are the settings you need:
+# If you do not wish to use the default admin interface routing ('example.com/admin')
+# and prefer e.g. 'hidden.example.com/backend', those are the settings you need:
 #
 #     # config/initializers/alchemy.rb
-#     Alchemy.admin_path = '/backend'
+#     Alchemy.admin_path = 'backend'
 #     Alchemy.admin_constraints = {subdomain: 'hidden'}
 #
 module Alchemy
@@ -29,6 +29,6 @@ module Alchemy
 
   # Defaults
   #
-  @@admin_path = '/admin'
+  @@admin_path = 'admin'
   @@admin_constraints = {}
 end

data/lib/alchemy/resource.rb

@@ -95,7 +95,7 @@ module Alchemy
   # If you don't want to stick with these conventions you can separate model and controller by providing
   # a model class (for example used by Alchemy's Tags admin interface):
   #
-  #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, ActsAsTaggableOn::Tag)
+  #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, Gutentag::Tag)
   #
   class Resource
     attr_accessor :resource_relations, :model_associations
@@ -238,23 +238,23 @@ module Alchemy
 
     private
 
-    def searchable_attribute?(a)
-      SEARCHABLE_COLUMN_TYPES.include?(a[:type].to_sym) && !a.key?(:relation)
+    def searchable_attribute?(attribute)
+      SEARCHABLE_COLUMN_TYPES.include?(attribute[:type].to_sym) && !attribute.key?(:relation)
     end
 
-    def searchable_attribute_on_relation?(a)
-      a.key?(:relation) &&
-        SEARCHABLE_COLUMN_TYPES.include?(a[:relation][:attr_type].to_sym)
+    def searchable_attribute_on_relation?(attribute)
+      attribute.key?(:relation) &&
+        SEARCHABLE_COLUMN_TYPES.include?(attribute[:relation][:attr_type].to_sym)
     end
 
     def searchable_relation_attributes(attrs)
       attrs.select { |a| searchable_attribute_on_relation?(a) }.map { |a| searchable_relation_attribute(a) }
     end
 
-    def searchable_relation_attribute(a)
+    def searchable_relation_attribute(attribute)
       {
-        name: "#{a[:relation][:model_association].name}_#{a[:relation][:attr_method]}",
-        type: a[:relation][:attr_type]
+        name: "#{attribute[:relation][:model_association].name}_#{attribute[:relation][:attr_method]}",
+        type: attribute[:relation][:attr_type]
       }
     end
 

data/lib/alchemy/resources_helper.rb

@@ -68,17 +68,25 @@ module Alchemy
     # @param [Alchemy::Resource] resource
     # @param [Hash] attribute
     # @option options [Hash] :truncate (50) The length of the value returned.
+    # @option options [Hash] :datetime_format (alchemy.default) The format of timestamps.
+    # @option options [Hash] :time_format (alchemy.time) The format of time values.
     #
     # @return [String]
     #
     def render_attribute(resource, attribute, options = {})
+      attribute_value = resource.send(attribute[:name])
       if attribute[:relation]
         record = resource.send(attribute[:relation][:name])
         value = record.present? ? record.send(attribute[:relation][:attr_method]) : Alchemy.t(:not_found)
-      elsif attribute[:type] == :datetime
-        value = l(resource.send(attribute[:name]))
+      elsif attribute_value && (attribute[:type] == :datetime || attribute[:type] == :time)
+        localization_format = if attribute[:type] == :datetime
+          options[:datetime_format] || :'alchemy.default'
+        else
+          options[:time_format] || :'alchemy.time'
+        end
+        value = l(attribute_value, format: localization_format)
       else
-        value = resource.send(attribute[:name])
+        value = attribute_value
       end
 
       options.reverse_merge!(truncate: 50)
@@ -163,18 +171,6 @@ module Alchemy
       render partial: 'resource', collection: resources_instance_variable
     end
 
-    # Returns all the params necessary to get you back from where you where
-    # before: the Ransack query and the current page.
-    #
-    def current_location_params
-      {
-        q: params[:q],
-        page: params[:page],
-        tagged_with: params[:tagged_with],
-        filter: params[:filter]
-      }
-    end
-
     def resource_has_tags
       resource_model.respond_to?(:tag_counts) && resource_model.tag_counts.any?
     end

data/lib/alchemy/routing_constraints.rb

@@ -39,8 +39,8 @@ module Alchemy
     end
 
     # Handle invalid byte sequence in UTF-8 errors with 400 status.
-    def handle_invalid_byte_sequence(e)
-      if e.message =~ /invalid byte sequence/
+    def handle_invalid_byte_sequence(error)
+      if error.message =~ /invalid byte sequence/
         raise ActionController::BadRequest
       else
         raise

data/lib/alchemy/shell.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'thor/shell/color'
 
 module Alchemy

data/lib/alchemy/taggable.rb

@@ -0,0 +1,40 @@
+module Alchemy
+  # ActsAsTaggableOn to Gutentag interface compatibility module
+  # Include this module to add tagging support to your model.
+  module Taggable
+    def self.included(base)
+      Gutentag::ActiveRecord.call base
+      base.extend ClassMethods
+      base.send(:alias_method, :tag_list, :tag_names)
+    end
+
+    # Set a list of tags
+    # Pass a String with comma separated tag names or
+    # an Array of tag names
+    def tag_list=(tags)
+      case tags
+      when String
+        self.tag_names = tags.split(/,\s*/)
+      when Array
+        self.tag_names = tags
+      end
+    end
+
+    module ClassMethods
+      # Find all records matching all of the given tags.
+      # Separate multiple tags by comma.
+      def tagged_with(names)
+        if names.is_a? String
+          names = names.split(/,\s*/)
+        end
+        super(names: names, match: :all)
+      end
+
+      # Returns all unique tags
+      def tag_counts
+        Gutentag::Tag.distinct.joins(:taggings)
+          .where(gutentag_taggings: {taggable_type: name})
+      end
+    end
+  end
+end

data/lib/alchemy/tasks/tidy.rb

@@ -117,20 +117,12 @@ module Alchemy
         end
       end
 
-      def remove_duplicate_folded_pages
-        Alchemy::FoldedPage.select(:page_id, :user_id).group(:page_id, :user_id).having("count(*) > 1").each do |duplicate_page|
-          duplicate_page_ids = Alchemy::FoldedPage.where(duplicate_page.attributes.except("id")).pluck(:id)
-          duplicate_page_ids_except_oldest = duplicate_page_ids.reject { |i| i == duplicate_page_ids.min }
-          Alchemy::FoldedPage.where(id: duplicate_page_ids_except_oldest).delete_all
-        end
-      end
-
       private
 
       def destroy_orphaned_records(records, class_name)
         records.each do |record|
           log "Destroy orphaned #{class_name}: #{record.inspect}"
-          record.reload.try(:destroy)
+          record.destroy
         end
       end
     end

data/lib/alchemy/test_support/factories/content_factory.rb

@@ -7,5 +7,15 @@ FactoryBot.define do
     essence_type "Alchemy::EssenceText"
     association :essence, factory: :alchemy_essence_text
     association :element, factory: :alchemy_element
+
+    trait :essence_file do
+      essence_type "Alchemy::EssenceFile"
+      association :essence, factory: :alchemy_essence_file
+    end
+
+    trait :essence_picture do
+      essence_type "Alchemy::EssencePicture"
+      association :essence, factory: :alchemy_essence_picture
+    end
   end
 end