lc_alchemy_cms 3.2.0

data/lib/alchemy/errors.rb

@@ -0,0 +1,82 @@
+# Custom error classes.
+#
+module Alchemy
+
+  class CellDefinitionError < StandardError
+    # Raised if no cell definition can be found.
+  end
+
+  class ContentDefinitionError < StandardError
+    # Raised if no content definition can be found.
+  end
+
+  class DefaultLanguageNotFoundError < StandardError
+    # Raised if no default language can be found.
+    def message
+      "No default language found! Please run the `bin/rake db:seed` task."
+    end
+  end
+
+  class DefaultLanguageNotDeletable < StandardError
+    # Raised if one tries to delete the default language.
+    def message
+      "Default language is not deletable!"
+    end
+  end
+
+  class ElementDefinitionError < StandardError
+    # Raised if element definition can not be found.
+    def initialize(attributes)
+      @name = attributes[:name]
+    end
+
+    def message
+      "Element definition for #{@name} not found. Please check your elements.yml"
+    end
+  end
+
+  class EssenceMissingError < StandardError
+    # Raised if a content misses its essence.
+    def message
+      "Essence not found"
+    end
+  end
+
+  class MissingImageFileError < StandardError
+    # Raised if calling +image_file+ on a Picture object returns nil.
+  end
+
+  class NotMountedError < StandardError
+    # Raised if Alchemy is not properly mounted in the apps routes file.
+    def message
+      "Alchemy mount point not found! Please run `bin/rake alchemy:mount'"
+    end
+  end
+
+  class PictureInUseError < StandardError
+    # Raised if the picture is still in use and can not be deleted.
+  end
+
+  class TinymceError < StandardError; end
+
+  class UpdateServiceUnavailable < StandardError
+    # Raised it no succesful connection to GitHub was possible
+    def message
+      "The update service is temporarily unavailable!"
+    end
+  end
+
+  class MissingActiveRecordAssociation < StandardError
+    # Raised if a alchemy_resource_relation is defined without proper ActiveRecord association
+    def message
+      "You need to define proper ActiveRecord associations, if you want to use alchemy_resource_relations."
+    end
+  end
+
+  class NoCurrentUserFoundError < StandardError
+    # Raised if no current_user is found to authorize against.
+    def message
+      "You need to provide a current_user method in your ApplicationController that returns the current authenticated user."
+    end
+  end
+end

data/lib/alchemy/essence.rb

@@ -0,0 +1,232 @@
+require 'active_record'
+
+module Alchemy #:nodoc:
+  module Essence #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Delivers various methods we need for Essences in Alchemy.
+    #
+    # To turn a model into an essence call acts_as_essence inside your model and you will get:
+    #   * validations
+    #   * several getters (ie: page, element, content, ingredient, preview_text)
+    #
+    module ClassMethods
+
+      # Turn any active record model into an essence by calling this class method
+      #
+      # @option options [String || Symbol] ingredient_column ('body')
+      #   specifies the column name you use for storing the content in the database (default: +body+)
+      # @option options [String || Symbol] validate_column (ingredient_column)
+      #   The column the the validations run against.
+      # @option options [String || Symbol] preview_text_column (ingredient_column)
+      #   Specify the column for the preview_text method.
+      #
+      def acts_as_essence(options={})
+        register_as_essence_association!
+
+        configuration = {
+          ingredient_column: 'body'
+        }.update(options)
+
+        class_eval <<-EOV
+          attr_writer :validation_errors
+          include Alchemy::Essence::InstanceMethods
+          stampable stamper_class_name: Alchemy.user_class_name
+          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"
+
+          scope :available,    -> { joins(:element).merge(Alchemy::Element.available) }
+          scope :from_element, ->(name) { joins(:element).where(Element.table_name => { name: name }) }
+
+          delegate :restricted?, to: :page,    allow_nil: true
+          delegate :trashed?,    to: :element, allow_nil: true
+          delegate :public?,     to: :element, allow_nil: true
+
+          after_update :touch_content
+
+          def acts_as_essence_class
+            #{self.name}
+          end
+
+          def ingredient_column
+            '#{configuration[:ingredient_column]}'
+          end
+
+          def validation_column
+            '#{configuration[:validate_column] || configuration[:ingredient_column]}'
+          end
+
+          def preview_text_column
+            '#{configuration[:preview_text_column] || configuration[:ingredient_column]}'
+          end
+        EOV
+      end
+
+      # Register the current class as has_many association on +Alchemy::Page+ and +Alchemy::Element+ models
+      def register_as_essence_association!
+        klass_name = self.model_name.to_s
+        arguments = [:has_many, klass_name.demodulize.tableize.to_sym, through: :contents,
+          source: :essence, source_type: klass_name]
+        %w(Page Element).each { |k| "Alchemy::#{k}".constantize.send(*arguments) }
+      end
+    end
+
+    module InstanceMethods
+
+      # Essence Validations:
+      #
+      # Essence validations can be set inside the config/elements.yml file.
+      #
+      # Supported validations are:
+      #
+      # * presence
+      # * uniqueness
+      # * format
+      #
+      # format needs to come with a regex or a predefined matcher string as its value.
+      # There are already predefined format matchers listed in the config/alchemy/config.yml file.
+      # It is also possible to add own format matchers there.
+      #
+      # Example of format matchers in config/alchemy/config.yml:
+      #
+      # format_matchers:
+      #   email: !ruby/regexp '/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/'
+      #   url:   !ruby/regexp '/\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix'
+      #   ssl:   !ruby/regexp '/https:\/\/[\S]+/'
+      #
+      # Example of an element definition with essence validations:
+      #
+      #   - name: person
+      #     contents:
+      #     - name: name
+      #       type: EssenceText
+      #       validate: [presence]
+      #     - name: email
+      #       type: EssenceText
+      #       validate: [format: 'email']
+      #     - name: homepage
+      #       type: EssenceText
+      #       validate: [format: !ruby/regexp '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$']
+      #
+      # Example of an element definition with chained validations.
+      #
+      #   - name: person
+      #     contents:
+      #     - name: name
+      #       type: EssenceText
+      #       validate: [presence, uniqueness, format: 'name']
+      #
+      def validate_ingredient
+        validations.each do |validation|
+          if validation.respond_to?(:keys)
+            validation.map do |key, value|
+              self.send("validate_#{key}", value)
+            end
+          else
+            self.send("validate_#{validation}")
+          end
+        end
+      end
+
+      def validations
+        @validations ||= description.present? ? description['validate'] || [] : []
+      end
+
+      def validation_errors
+        @validation_errors ||= []
+      end
+
+      def validate_presence(validate = true)
+        if validate && ingredient.blank?
+          errors.add(ingredient_column, :blank)
+          validation_errors << :blank
+        end
+      end
+
+      def validate_uniqueness(validate = true)
+        return if !validate || !public?
+        if duplicates.any?
+          errors.add(ingredient_column, :taken)
+          validation_errors << :taken
+        end
+      end
+
+      def validate_format(format)
+        matcher = Config.get('format_matchers')[format] || format
+        if ingredient.to_s.match(Regexp.new(matcher)).nil?
+          errors.add(ingredient_column, :invalid)
+          validation_errors << :invalid
+        end
+      end
+
+      def duplicates
+        acts_as_essence_class
+          .available
+          .from_element(element.name)
+          .where("#{ingredient_column}" => ingredient)
+          .where.not(id: self.id)
+      end
+
+      # Returns the value stored from the database column that is configured as ingredient column.
+      def ingredient
+        if self.respond_to?(ingredient_column)
+          self.send(ingredient_column)
+        end
+      end
+
+      # Returns the value stored from the database column that is configured as ingredient column.
+      def ingredient=(value)
+        if self.respond_to?(ingredient_setter_method)
+          self.send(ingredient_setter_method, value)
+        end
+      end
+
+      # Returns the setter method for ingredient column
+      def ingredient_setter_method
+        ingredient_column.to_s + '='
+      end
+
+      # Essence description from config/elements.yml
+      def description
+        return {} if element.nil? or element.content_descriptions.nil?
+        element.content_descriptions.detect { |c| c['name'] == self.content.name } || {}
+      end
+
+      # Touch content. Called after update.
+      def touch_content
+        return nil if content.nil?
+        content.touch
+      end
+
+      # Returns the first x (default 30) characters of ingredient for the Element#preview_text method.
+      #
+      def preview_text(maxlength = 30)
+        self.send(preview_text_column).to_s[0..maxlength-1]
+      end
+
+      def open_link_in_new_window?
+        respond_to?(:link_target) && link_target == 'blank'
+      end
+
+      def partial_name
+        self.class.name.split('::').last.underscore
+      end
+
+      def acts_as_essence?
+        acts_as_essence_class.present?
+      end
+
+      def to_partial_path
+        "alchemy/essences/#{partial_name}_view"
+      end
+
+    end
+
+  end
+end
+ActiveRecord::Base.class_eval { include Alchemy::Essence } if defined?(Alchemy::Essence)

data/lib/alchemy/filetypes.rb

@@ -0,0 +1,33 @@
+module Alchemy
+  module Filetypes
+
+    ARCHIVE_FILE_TYPES = ["application/zip", "application/x-rar"]
+
+    AUDIO_FILE_TYPES = [
+      "audio/mpeg",
+      "audio/mp4",
+      "audio/wav",
+      "audio/x-wav"
+    ]
+
+    IMAGE_FILE_TYPES = [
+      "image/gif",
+      "image/jpeg",
+      "image/png",
+      "image/tiff"
+    ]
+
+    VCARD_FILE_TYPES = ["text/x-vcard", "application/vcard"]
+
+    VIDEO_FILE_TYPES = [
+      "application/x-flash-video",
+      "video/x-flv",
+      "video/mp4",
+      "video/mpeg",
+      "video/quicktime",
+      "video/x-msvideo",
+      "video/x-ms-wmv"
+    ]
+
+  end
+end

data/lib/alchemy/forms/builder.rb

@@ -0,0 +1,23 @@
+module Alchemy
+  module Forms
+    class Builder < SimpleForm::FormBuilder
+
+      # Renders a simple_form input, but uses input alchemy_wrapper
+      #
+      def input(attribute_name, options = {}, &block)
+        options[:wrapper] = :alchemy
+        super
+      end
+
+      # 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])
+        end
+      end
+
+    end
+  end
+end

data/lib/alchemy/hints.rb

@@ -0,0 +1,57 @@
+module Alchemy
+  module Hints
+
+    # Returns a hint
+    #
+    # To add a hint to a content pass +hint: true+ to the element definition in its element.yml
+    #
+    # Then the hint itself is placed in the locale yml files.
+    #
+    # Alternativly you can pass the hint itself to the hint key.
+    #
+    # == Locale Example:
+    #
+    #   # elements.yml
+    #   - name: headline
+    #     contents:
+    #     - name: headline
+    #       type: EssenceText
+    #       hint: true
+    #
+    #   # config/locales/de.yml
+    #     de:
+    #       content_hints:
+    #         headline: Lorem ipsum
+    #
+    # == Hint Key Example:
+    #
+    #   - name: headline
+    #     contents:
+    #     - name: headline
+    #       type: EssenceText
+    #       hint: Lorem ipsum
+    #
+    # @return String
+    #
+    def hint
+      hint = definition['hint']
+      if hint == true
+        I18n.t(name, scope: hint_translation_scope)
+      else
+        hint
+      end
+    end
+
+    # Returns true if the element has a hint
+    def has_hint?
+      hint.present?
+    end
+
+    private
+
+    def hint_translation_scope
+      "#{self.class.model_name.to_s.demodulize.downcase}_hints"
+    end
+
+  end
+end

data/lib/alchemy/i18n.rb

@@ -0,0 +1,70 @@
+module Alchemy
+  module I18n
+
+    # Alchemy translation methods
+    #
+    # Instead of having to translate strings and defining a default value:
+    #
+    #     Alchemy::I18n.t("Hello World!", :default => 'Hello World!')
+    #
+    # We define this method to define the value only once:
+    #
+    #     Alchemy::I18n.t("Hello World!")
+    #
+    # Note that interpolation still works:
+    #
+    #     Alchemy::I18n.t("Hello %{world}!", :world => @world)
+    #
+    # It offers a shortcut method and view helper called _t
+    #
+    # === Notes
+    #
+    # All translations are scoped into the +alchemy+ namespace.
+    # Even scopes are scoped into the +alchemy+ namespace.
+    #
+    # So a call for _t('hello', :scope => :world) has to be translated like this:
+    #
+    #   de:
+    #     alchemy:
+    #       world:
+    #         hello: Hallo
+    #
+    def self.t(msg, *args)
+      options = args.extract_options!
+      humanize_default_string!(msg, options)
+      scope = ['alchemy']
+      case options[:scope].class.name
+      when "Array"
+        scope += options[:scope]
+      when "String"
+        scope << options[:scope]
+      when "Symbol"
+        scope << options[:scope] unless options[:scope] == :alchemy
+      end
+      ::I18n.t(msg, options.merge(:scope => scope))
+    end
+
+    def self.available_locales
+      @@available_locales ||= nil
+      @@available_locales || translation_files.collect { |f| f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '').to_sym }
+    end
+
+    def self.available_locales=(locales)
+      @@available_locales = Array(locales).map { |locale| locale.to_sym }
+      @@available_locales = nil if @@available_locales.empty?
+    end
+
+    def self.translation_files
+      Dir.glob(File.join(File.dirname(__FILE__), '../../config/locales/alchemy.*.yml'))
+    end
+
+  private
+
+    def self.humanize_default_string!(msg, options)
+      if options[:default].blank?
+        options[:default] = msg.is_a?(Symbol) ? msg.to_s.humanize : msg
+      end
+    end
+
+  end
+end