lc_alchemy_cms 3.2.0

data/lib/alchemy/kaminari/scoped_pagination_url_helper.rb

@@ -0,0 +1,13 @@
+# A Kaminari patch for scoping the urls.
+Kaminari::Helpers::Tag.class_eval do
+
+  def page_url_for(page)
+    params = @params.merge(@param_name => (page <= 1 ? nil : page))
+    if @options[:scope]
+      @options[:scope].url_for params
+    else
+      @template.url_for params
+    end
+  end
+
+end

data/lib/alchemy/locale.rb

@@ -0,0 +1,65 @@
+module Alchemy
+  module Locale
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_translation
+    end
+
+    private
+
+    # Sets Alchemy's GUI translation.
+    #
+    # Uses the most preferred locale or falls back to the default locale if none of the preferred is available.
+    #
+    # It respects the default translation from your +config/application.rb+ +default_locale+ config option.
+    #
+    def set_translation
+      if locale_change_needed?
+        locale = available_locale || ::I18n.default_locale
+      else
+        locale = session[:alchemy_locale]
+      end
+      ::I18n.locale = session[:alchemy_locale] = locale
+    end
+
+    # Checks if we need to change to locale or not.
+    def locale_change_needed?
+      params[:locale].present? || session[:alchemy_locale].blank?
+    end
+
+    # Returns either the most preferred locale that is within the list of available locales or nil
+    #
+    # The availability of the locales is checked in the exact order of either
+    #
+    #  * the passed parameter: +params[:locale]+
+    #  * the user's locale
+    #  * the locale of the browser
+    #
+    def available_locale
+      locales = [params[:locale], locale_from_user, locale_from_browser].compact
+      locales.detect { |locale| ::I18n.available_locales.include?(locale.to_sym) }
+    end
+
+    # Try to get the locale from user settings.
+    def locale_from_user
+      return if !current_alchemy_user
+      if user_has_preferred_language?
+        current_alchemy_user.language
+      end
+    end
+
+    # Checks if the +current_alchemy_user+ has a preferred language set or not.
+    def user_has_preferred_language?
+      return if !current_alchemy_user
+      current_alchemy_user.respond_to?(:language) &&
+        current_alchemy_user.language.present?
+    end
+
+    # Try to get the locale from browser headers.
+    def locale_from_browser
+      request.env['HTTP_ACCEPT_LANGUAGE'].try(:scan, /\A[a-z]{2}/).try(:first)
+    end
+
+  end
+end

data/lib/alchemy/logger.rb

@@ -0,0 +1,15 @@
+module Alchemy
+  module Logger
+
+    # Logs a debug message to the Rails standard logger and adds some nicer formatting
+    def self.warn(message, caller_string)
+      Rails.logger.debug %(\n++++ WARNING: #{message}\nCalled from: #{caller_string}\n)
+      return nil
+    end
+
+    def log_warning(message)
+      Alchemy::Logger.warn(message, caller.first)
+    end
+
+  end
+end

data/lib/alchemy/middleware/rescue_old_cookies.rb

@@ -0,0 +1,27 @@
+module Alchemy
+  module Middleware
+    class RescueOldCookies
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        begin
+          @app.call(env)
+        rescue NameError => error
+          if error.to_s =~ /uninitialized constant Alchemy::Clipboard/
+            message = "<h2>You have an old style Alchemy clipboard in your session!</h2>"
+            message += "<h3>Please remove your cookies and try again.</h3>"
+            Rails.logger.error(error)
+            return [
+              500, { "Content-Type" => "text/html" },
+              [message]
+            ]
+          else
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/modules.rb

@@ -0,0 +1,75 @@
+module Alchemy
+  module Modules
+    mattr_accessor :alchemy_modules
+
+    @@alchemy_modules = YAML.load_file(File.expand_path('../../../config/alchemy/modules.yml', __FILE__))
+
+    def self.included(base)
+      base.send :helper_method, :alchemy_modules, :module_definition_for
+    end
+
+    # Register a Alchemy module.
+    #
+    # A module is a Hash that must have at least a name and a navigation key
+    # that has a controller and action name.
+    #
+    # == Example:
+    #
+    #     name: 'module',
+    #     navigation: {
+    #       controller: 'admin/controller_name',
+    #       action: 'index'
+    #     }
+    #
+    def self.register_module(module_definition)
+      @@alchemy_modules << module_definition.stringify_keys
+    end
+
+    # Get the module definition for given module name
+    #
+    # You can also pass a hash of an module definition.
+    # It then tries to find the module defintion from controller name and action name
+    #
+    def module_definition_for(name)
+      case name
+      when String
+        alchemy_modules.detect { |p| p['name'] == name }
+      when Hash
+        alchemy_modules.detect do |alchemy_module|
+          definition_from_subnavi(alchemy_module, name.symbolize_keys)
+        end
+      else
+        raise ArgumentError, "Could not find module definition for #{name}"
+      end
+    end
+
+    private
+
+    def alchemy_module_navigation(alchemy_module)
+      alchemy_module.stringify_keys!
+      alchemy_module.fetch('navigation', {}).stringify_keys
+    end
+
+    def definition_from_subnavi(alchemy_module, name)
+      module_navi = alchemy_module_navigation(alchemy_module)
+      subnavi = module_navi['sub_navigation']
+      return if subnavi.nil?
+      subnavi.map(&:stringify_keys).detect do |subnavi|
+        controller_matches?(subnavi, name) && action_matches?(subnavi, name)
+      end
+    end
+
+    def controller_matches?(subnavi, name)
+      remove_slash(subnavi['controller']) == remove_slash(name[:controller])
+    end
+
+    def action_matches?(subnavi, name)
+      subnavi['action'] == name[:action]
+    end
+
+    def remove_slash(name)
+      name.gsub(/^\//, '')
+    end
+
+  end
+end

data/lib/alchemy/mount_point.rb

@@ -0,0 +1,47 @@
+require 'rails'
+
+module Alchemy
+
+  # Utilities for Alchemy's mount point in the host rails app.
+  #
+  class MountPoint
+    MOUNT_POINT_REGEXP = /mount\sAlchemy::Engine\s=>\s['|"](\/\w*)['|"]/
+
+    class << self
+
+      # Returns the path of Alchemy's mount point in current rails app.
+      #
+      # @param [Boolean] remove_leading_slash_if_blank
+      #   Pass false to not return a leading slash on empty mount point.
+      #
+      def get(remove_leading_slash_if_blank = true)
+        if path == "/" && remove_leading_slash_if_blank
+          path.gsub(/\A\/\z/, '')
+        else
+          path
+        end
+      end
+
+      # Returns the mount point path from the Rails app routes.
+      #
+      def path
+        match = File.read(routes_file_path).match(MOUNT_POINT_REGEXP)
+        if match.nil?
+          raise NotMountedError
+        else
+          match[1]
+        end
+      end
+
+      private
+
+      def routes_file_path
+        if Rails.root
+          Rails.root.join('config/routes.rb')
+        else
+          'config/routes.rb'
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/name_conversions.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Alchemy
+  # Provides methods for converting names into urlnames and vice versa.
+  #
+  module NameConversions
+
+    # Converts a given name into url save and readable urlanme.
+    # Uses rails parameterize, but converts german umlauts before.
+    #
+    # @returns String
+    def convert_to_urlname(name)
+      name
+        .gsub(/[äÄ]/, 'ae')
+        .gsub(/[üÜ]/, 'ue')
+        .gsub(/[öÖ]/, 'oe')
+        .gsub(/[ß]/, 'ss')
+        .parameterize
+    end
+
+    # Converts a filename and suffix into a human readable name.
+    #
+    def convert_to_humanized_name(name, suffix)
+      name.gsub(/\.#{::Regexp.quote(suffix)}$/i, '').gsub(/_/, ' ').strip
+    end
+
+  end
+end

data/lib/alchemy/on_page_layout.rb

@@ -0,0 +1,58 @@
+module Alchemy
+
+  # = Adds before filter to pages show action
+  #
+  # Use this mixin to add the +on_page_layout+ class method
+  # into your +ApplicationController+.
+  #
+  # Pass a block or method name in which you have the +@page+ object and can do
+  # everything as if you where in a normal controller action.
+  #
+  # Pass a +Alchemy::PageLayout+ name or +:all+ to
+  # call this callback only on specific pages or all pages.
+  #
+  # == Example:
+  #
+  #     class ApplicationController < ActionController::Base
+  #       extend Alchemy::OnPageLayout
+  #
+  #       on_page_layout :all do
+  #         @my_stuff = Stuff.all
+  #       end
+  #
+  #       on_page_layout :contact, :do_something
+  #
+  #       private
+  #
+  #       def do_something
+  #         @contacts = Contact.all
+  #         if @page.tag_list.include?('something')
+  #           do_something
+  #         end
+  #       end
+  #     end
+  #
+  module OnPageLayout
+
+    def on_page_layout(page_layout, callback = nil)
+      Alchemy::PagesController.class_eval do
+
+        append_before_action only: :show, if: -> { call_page_layout_callback_for?(page_layout) } do
+          if block_given?
+            instance_eval(&Proc.new)
+          elsif callback
+            self.send(callback)
+          else
+            raise "You need to either pass a block or method name as callback for `on_page_layout`"
+          end
+        end
+
+        private
+
+        def call_page_layout_callback_for?(page_layout)
+          page_layout.to_sym == :all || @page.page_layout.to_sym == page_layout.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/page_layout.rb

@@ -0,0 +1,183 @@
+module Alchemy
+  class PageLayout
+    class << self
+
+      # Returns all page layouts.
+      #
+      # They are defined in +config/alchemy/page_layout.yml+ file.
+      #
+      def all
+        @definitions ||= read_layouts_file
+      end
+
+      # Add additional page layout definitions to collection.
+      #
+      # Useful for extending the page layouts from an Alchemy module.
+      #
+      # === Usage Example
+      #
+      #   Call +Alchemy::PageLayout.add(your_layout_definition)+ in your engine.rb file.
+      #
+      # @param [Array || Hash]
+      #   You can pass a single layout definition as Hash, or a collection of page layouts as Array.
+      #
+      def add(page_layout)
+        all
+        if page_layout.is_a?(Array)
+          @definitions += page_layout
+        elsif page_layout.is_a?(Hash)
+          @definitions << page_layout
+        else
+          raise TypeError
+        end
+      end
+
+      # Returns one page layout description by given name.
+      #
+      def get(name)
+        return {} if name.blank?
+        all.detect { |a| a['name'].downcase == name.downcase }
+      end
+
+      def get_all_by_attributes(attributes)
+        return [] if attributes.blank?
+        if attributes.class.name == 'Hash'
+          layouts = []
+          attributes.stringify_keys.each do |key, value|
+            result = all.select { |a| a[key].to_s.downcase == value.to_s.downcase if a.has_key?(key) }
+            layouts += result unless result.empty?
+          end
+          return layouts
+        else
+          return []
+        end
+      end
+
+      # Returns page layouts ready for Rails' select form helper.
+      #
+      def layouts_for_select(language_id, only_layoutpages = false)
+        @map_array = [[I18n.t('Please choose'), '']]
+        mapped_layouts_for_select(selectable_layouts(language_id, only_layoutpages))
+      end
+
+      # Returns page layouts including given layout ready for Rails' select form helper.
+      #
+      def layouts_with_own_for_select(page_layout_name, language_id, only_layoutpages = false)
+        layouts = selectable_layouts(language_id, only_layoutpages)
+        if layouts.detect { |l| l['name'] == page_layout_name }.nil?
+          @map_array = [[human_layout_name(page_layout_name), page_layout_name]]
+        else
+          @map_array = []
+        end
+        mapped_layouts_for_select(layouts)
+      end
+
+      # Returns all layouts that can be used for creating a new page.
+      #
+      # It removes all layouts from available layouts that are unique and already taken and that are marked as hide.
+      #
+      # @param [Fixnum]
+      #   language_id of current used Language.
+      # @param [Boolean] (false)
+      #   Pass true to only select layouts for global/layout pages.
+      #
+      def selectable_layouts(language_id, only_layoutpages = false)
+        @language_id = language_id
+        all.select { |layout|
+          if only_layoutpages
+            layout['layoutpage'] && layout_available?(layout)
+          else
+            !layout['layoutpage'] && layout_available?(layout)
+          end
+        }
+      end
+
+      # Returns all names of elements defined in given page layout.
+      #
+      def element_names_for(page_layout)
+        if layout_description = get(page_layout)
+          layout_description.fetch('elements', [])
+        else
+          Rails.logger.warn "\n+++ Warning: No Layout Description for #{page_layout} found! in page_layouts.yml\n"
+          return []
+        end
+      end
+
+      # Translates name for given layout
+      #
+      # === Translation example
+      #
+      #   de:
+      #     alchemy:
+      #       page_layout_names:
+      #         products_overview: Produktübersicht
+      #
+      # @param [String]
+      #   The layout name
+      #
+      def human_layout_name(layout)
+        I18n.t(layout, scope: 'page_layout_names', default: layout.to_s.humanize)
+      end
+
+    private
+
+      # Returns true if the given layout is unique and not already taken or it should be hidden.
+      #
+      def layout_available?(layout)
+        !layout['hide'] && !already_taken?(layout) && available_on_site?(layout)
+      end
+
+      # Returns true if this layout is unique and already taken by another page.
+      #
+      def already_taken?(layout)
+        layout['unique'] && page_with_layout_existing?(layout['name'])
+      end
+
+      # 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?
+      end
+
+      # Returns true if given layout is available for current site.
+      #
+      # If no site layouts are defined it always returns true.
+      #
+      # == Example
+      #
+      #   # config/alchemy/site_layouts.yml
+      #   - name: default_site
+      #     page_layouts: [default_intro]
+      #
+      def available_on_site?(layout)
+        Site.current.layout_definition.blank? || Site.current.layout_definition.fetch('page_layouts', []).include?(layout['name'])
+      end
+
+      # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
+      #
+      def read_layouts_file
+        if File.exists?(layouts_file_path)
+          YAML.load(ERB.new(File.read(layouts_file_path)).result) || []
+        else
+          raise LoadError, "Could not find page_layouts.yml file! Please run `rails generate alchemy:scaffold`"
+        end
+      end
+
+      # Returns the page_layouts.yml file path
+      #
+      def layouts_file_path
+        Rails.root.join 'config/alchemy/page_layouts.yml'
+      end
+
+      # Maps given layouts for Rails select form helper.
+      #
+      def mapped_layouts_for_select(layouts)
+        layouts.each do |layout|
+          @map_array << [human_layout_name(layout['name']), layout["name"]]
+        end
+        @map_array
+      end
+
+    end
+  end
+end