pages_core 3.4.2

data/lib/pages_core/configuration/base.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module PagesCore
+  module Configuration
+    class Base
+      class InvalidConfigurationKey < StandardError; end
+
+      def self.settings
+        @settings ||= {}
+      end
+
+      def self.setting(key, type, default = nil)
+        settings[key] = OpenStruct.new(type: type, default: default)
+
+        define_method key do |*args|
+          if args.length > 0
+            set(key, *args)
+          else
+            get(key)
+          end
+        end
+
+        define_method "#{key}=" do |value|
+          set(key, value)
+        end
+
+        define_method "#{key}?" do
+          get(key) ? true : false
+        end
+      end
+
+      def get(key)
+        fail InvalidConfigurationKey unless setting?(key)
+        if configuration.key?(key)
+          configuration[key]
+        else
+          self.class.settings[key].default
+        end
+      end
+
+      def set(key, value)
+        fail InvalidConfigurationKey unless setting?(key)
+        value = parse_value(key, value)
+        unless valid_type?(key, value)
+          fail(
+            ArgumentError,
+            "expected #{self.class.settings[key].type}, got #{value.class}"
+          )
+        end
+        configuration[key] = value
+      end
+
+      protected
+
+      def configuration
+        @configuration ||= {}
+      end
+
+      def setting?(key)
+        self.class.settings.key?(key)
+      end
+
+      def type_for(key)
+        self.class.settings[key].type
+      end
+
+      def valid_type?(key, value)
+        return true if value.nil?
+        if type_for(key) == :boolean
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        else
+          value.is_a?(type_for(key).to_s.camelize.constantize)
+        end
+      end
+
+      def parse_value(key, value)
+        if type_for(key) == :boolean
+          value = true  if value == :enabled
+          value = false if value == :disabled
+        end
+        value
+      end
+    end
+  end
+end

data/lib/pages_core/configuration/pages.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module PagesCore
+  module Configuration
+    class Pages < Base
+      setting :site_name,             :string,  "Pages Site"
+      setting :default_sender,        :string
+      setting :localizations,         :boolean, false
+      setting :locales,               :hash
+      setting :text_filter,           :symbol, :textile
+      setting :page_cache,            :boolean, true
+      setting :domain_based_cache,    :boolean, false
+      setting :rss_fulltext,          :boolean, true
+      setting :image_fallback_url,    :string
+      setting :default_author,        :string
+      setting :comment_notifications, :array,   []
+      setting :close_comments_after,  :integer
+      setting :comment_honeypot,      :boolean, false
+      setting :recaptcha,             :boolean, false
+      setting :pages_path_scope,      :string
+    end
+  end
+end

data/lib/pages_core/configuration.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+load "pages_core/configuration/base.rb"
+load "pages_core/configuration/pages.rb"
+
+module PagesCore
+  module Configuration
+  end
+end

data/lib/pages_core/engine.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module PagesCore
+  class Engine < Rails::Engine
+    initializer :active_job do |_config|
+      ActiveJob::Base.queue_adapter = :delayed_job
+    end
+
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+
+    # Enable asset precompilation
+    initializer :assets do |_config|
+      Rails.application.config.assets.precompile += %w(
+        pages/admin.js
+        pages/admin.css
+        pages/admin/print.css
+        pages/errors.css
+      )
+    end
+  end
+end

data/lib/pages_core/extensions/hash_extensions.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module PagesCore
+  module Extensions
+    module HashExtensions
+      def deep_merge(hash)
+        target = dup
+
+        hash.keys.each do |key|
+          if hash[key].is_a?(Hash) && self[key].is_a?(Hash)
+            target[key] = target[key].deep_merge(hash[key])
+            next
+          end
+
+          target[key] = hash[key]
+        end
+
+        target
+      end
+    end
+  end
+end
+Hash.send(:include, PagesCore::Extensions::HashExtensions)

data/lib/pages_core/extensions/string_extensions.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module PagesCore
+  module Extensions
+    module StringExtensions
+      def to_html_with(append, options = {})
+        to_html(options.merge(append: append))
+      end
+
+      def to_html(options = {})
+        PagesCore::HtmlFormatter.to_html(self, options)
+      end
+    end
+  end
+end
+
+String.send(:include, PagesCore::Extensions::StringExtensions)

data/lib/pages_core/extensions.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+load "pages_core/extensions/hash_extensions.rb"
+load "pages_core/extensions/string_extensions.rb"

data/lib/pages_core/localizable/active_record_extension.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    # = Localizable::ActiveRecordExtension
+    #
+    # Extends ActiveRecord::Base with the localizable setup method.
+    #
+    module ActiveRecordExtension
+      # Extends the model with Localizable features.
+      # It takes an optional block as argument, which yields an instance of
+      # Localizable::Configuration.
+      #
+      # Example:
+      #
+      #  class Page < ActiveRecord::Base
+      #    localizable do
+      #      attribute :name
+      #      attribute :body
+      #    end
+      #  end
+      #
+      def localizable(&block)
+        unless self.is_a?(Localizable::ClassMethods)
+          send :extend,  Localizable::ClassMethods
+          send :include, Localizable::InstanceMethods
+          has_many(
+            :localizations,
+            as: :localizable,
+            dependent: :destroy,
+            autosave: true
+          )
+          before_save :cleanup_localizations!
+        end
+        localizable_configuration.instance_eval(&block) if block_given?
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, PagesCore::Localizable::ActiveRecordExtension)

data/lib/pages_core/localizable/class_methods.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    # = Localizable::ClassMethods
+    #
+    # Class methods for all Localizable models.
+    #
+    module ClassMethods
+      # Returns a scope where all records will be set to the given locale.
+      #
+      def in_locale(locale)
+        all
+          .extending(Localizable::ScopeExtension)
+          .localize(locale)
+          .includes(:localizations)
+      end
+
+      # Returns a scope with only records matching the given locale.
+      #
+      #  Page.localized('en').first.locale # => 'en'
+      #
+      def localized(locale)
+        in_locale(locale)
+          .where("localizations.locale = ?", locale)
+          .references(:localizations)
+      end
+
+      def localized_attributes
+        localizable_configuration.attributes.keys
+      end
+
+      # Accessor for the configuration.
+      def localizable_configuration
+        @localizable_configuration ||= inherited_localizable_configuration
+      end
+
+      private
+
+      def inherited_localizable_configuration
+        if superclass.respond_to?(:localizable_configuration)
+          Localizable::Configuration.new(
+            superclass.localizable_configuration.attributes.dup
+          )
+        else
+          Localizable::Configuration.new
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/localizable/configuration.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    class Configuration
+      def initialize(attributes = nil)
+        @attributes = attributes
+      end
+
+      def attribute(attribute_name, options = {})
+        attribute_table[attribute_name.to_sym] = options
+      end
+
+      def attributes
+        attribute_table.merge(dictionary_attributes)
+      end
+
+      def dictionary(dict)
+        dictionaries << dict
+      end
+
+      def attribute?(attribute)
+        attributes.keys.include?(attribute)
+      end
+
+      private
+
+      def dictionaries
+        @dictionaries ||= []
+      end
+
+      def dictionary_attributes
+        dictionaries.map(&:call).inject({}) do |attrs, list|
+          attrs.merge(hashify(list))
+        end
+      end
+
+      def hashify(list)
+        return list if list.is_a?(Hash)
+        list.each_with_object({}) do |e, a|
+          a[e] = {}
+        end
+      end
+
+      def attribute_table
+        @attributes ||= {}
+      end
+    end
+  end
+end

data/lib/pages_core/localizable/instance_methods.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    # = Localizable::InstanceMethods
+    #
+    # This is the public API for all localizable models.
+    # See Localizable for usage examples.
+    #
+    module InstanceMethods
+      # Returns all locales saved for this page.
+      #
+      def locales
+        localizer.locales
+      end
+
+      # Getter for locale
+      #
+      #  page.locale # => 'en'
+      #
+      def locale
+        localizer.locale
+      end
+
+      # Setter for locale
+      #
+      #  page.locale = 'no' # => 'no'
+      #
+      def locale=(locale)
+        @localizer = Localizer.new(self)
+        localizer.locale = locale
+      end
+
+      # Returns true if this page has a locale set
+      #
+      def locale?
+        localizer.locale?
+      end
+
+      # Returns a copy of the model with a different locale.
+      #
+      #  localized = page.localize('en')
+      #
+      # localize also takes a block as an argument, which returns the
+      # result of the block.
+      #
+      #  page.localize('nb') do |p|
+      #    p.locale # => 'nb'
+      #  end
+      #  page.locale # => 'en'
+      #
+      def localize(locale)
+        clone = self.clone.localize!(locale)
+        (block_given?) ? (yield clone) : clone
+      end
+
+      # In-place variant of #localize.
+      #
+      #  page.localize!('en')
+      #
+      # This is functionally equivalent to setting locale=,
+      # but returns the model instead of the locale and is chainable.
+      #
+      def localize!(locale)
+        @localizer = Localizer.new(self)
+        localizer.locale = locale
+        self
+      end
+
+      # assign_attributes from ActiveRecord is overridden to catch locale before
+      # any other attributes are written. This enables the following construct:
+      #
+      #  Page.create(name: 'My Page', locale: 'en')
+      #
+      def assign_attributes(new_attributes)
+        if new_attributes.is_a?(Hash)
+          attributes = new_attributes.stringify_keys
+          self.locale = attributes["language"] if attributes.key?("language")
+          self.locale = attributes["locale"]   if attributes.key?("locale")
+        end
+        super
+      end
+
+      # A localized model responds to :foo, :foo= and :foo?
+      #
+      def respond_to?(method_name, *args)
+        requested_attribute, _ = method_name.to_s.match(/(.*?)([\?=]?)$/)[1..2]
+        localizer.attribute?(requested_attribute.to_sym) ? true : super
+      end
+
+      alias_method :translate,  :localize
+      alias_method :translate!, :localize!
+      alias_method :working_language,  :locale
+      alias_method :working_language=, :locale=
+
+      protected
+
+      # Getter for the model's Localizer.
+      #
+      def localizer
+        @localizer ||= Localizer.new(self)
+      end
+
+      # Callback for cleaning up empty localizations.
+      # This is performed automatically when the model is saved.
+      #
+      def cleanup_localizations!
+        localizer.cleanup_localizations!
+      end
+
+      def method_missing(method_name, *args)
+        attr = method_to_attr(method_name)
+        super unless localizer.attribute?(attr)
+
+        case method_name.to_s
+        when /\?$/
+          localizer.value_for?(attr)
+        when /=$/
+          localizer.set(attr, args.first)
+        else
+          localizer.get(attr).to_s
+        end
+      end
+
+      def method_to_attr(method_name)
+        method_name.to_s.match(/(.*?)([\?=]?)$/)[1].to_sym
+      end
+    end
+  end
+end

data/lib/pages_core/localizable/localizer.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    class Localizer
+      attr_accessor :locale
+      def initialize(model)
+        @model         = model
+        @configuration = model.class.localizable_configuration
+      end
+
+      def attribute?(attribute)
+        @configuration.attribute?(attribute)
+      end
+
+      def locales
+        @model.localizations.map(&:locale).uniq
+      end
+
+      def locale?
+        locale ? true : false
+      end
+
+      def get(attribute, options = {})
+        get_options = { locale: locale }.merge(options)
+
+        find_localizations(
+          attribute.to_s,
+          get_options[:locale].to_s
+        ).try(&:first) ||
+          @model.localizations.new(
+            locale: get_options[:locale].to_s,
+            name: attribute.to_s
+          )
+      end
+
+      def set(attribute, value, options = {})
+        set_options = { locale: locale }.merge(options)
+        if value.is_a?(Hash)
+          value.each do |loc, val|
+            set(attribute, val, locale: loc)
+          end
+        else
+          unless set_options[:locale]
+            fail(
+              ArgumentError,
+              "Tried to set :#{attribute}, but no locale has been set"
+            )
+          end
+          get(attribute, locale: set_options[:locale]).value = value
+        end
+        value
+      end
+
+      def value_for?(attribute)
+        get(attribute).value?
+      end
+
+      def cleanup_localizations!
+        @model.localizations = @model.localizations.select(&:value?)
+      end
+
+      private
+
+      def find_localizations(name, locale)
+        @model.localizations.select do |l|
+          l.name == name && l.locale == locale
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/localizable/scope_extension.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module PagesCore
+  module Localizable
+    # = Localizable::ScopeExtension
+    #
+    # Injected into the Relation when Model.localized is called.
+    #
+    module ScopeExtension
+      attr_accessor :locale
+
+      def localize(locale)
+        @locale = locale
+        self
+      end
+
+      def to_a
+        super.map { |record| record.localize(@locale) }
+      end
+    end
+  end
+end

data/lib/pages_core/localizable.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+load "pages_core/localizable/active_record_extension.rb"
+load "pages_core/localizable/class_methods.rb"
+load "pages_core/localizable/configuration.rb"
+load "pages_core/localizable/instance_methods.rb"
+load "pages_core/localizable/localizer.rb"
+load "pages_core/localizable/scope_extension.rb"
+
+module PagesCore
+  # = Localizable
+  #
+  # Localizable allows any model to have localized attributes.
+  #
+  # == Configuring the model
+  #
+  #  class Page < ActiveRecord::Base
+  #    localizable do
+  #      attribute :name
+  #      attribute :body
+  #    end
+  #  end
+  #
+  # == Usage
+  #
+  #  page = Page.create(name: 'Hello', locale: 'en')
+  #  page.name?     # => true
+  #  page.name.to_s # => 'Hello'
+  #
+  # The localized attributes always return an instance of Localization.
+  #
+  # To get a localized version of a page, call .localize on it:
+  #
+  #  page = Page.first.localize('en')
+  #
+  # .localize also takes a block argument:
+  #
+  #  page.localize('nb') do |p|
+  #    p.locale # => 'nb'
+  #  end
+  #  page.locale # => 'en'
+  #
+  # Multiple locales can be updated at the same time:
+  #
+  #  page.name = {'en' => 'Hello', 'nb' => 'Hallo'}
+  #
+  module Localizable
+  end
+end

data/lib/pages_core/pages_plugin.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module PagesCore
+  class PagesPlugin < Plugin
+    paths["db/migrate"] = "db/migrate"
+
+    admin_menu_item "News",  proc { news_admin_pages_path(@locale) }, :pages,
+                    if:      proc { Page.news_pages.any? },
+                    current: proc { @page && @page.parent.try(&:news_page?) }
+
+    admin_menu_item "Pages", proc { admin_pages_path(@locale) }, :pages
+    admin_menu_item "Users", proc { admin_users_path }, :account
+  end
+end