pages_core 3.4.2

data/lib/pages_core/paginates.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+module PagesCore
+  # The Paginates module adds syntactic sugar to a collection for
+  # handling pagination.  The module doesn't do any pagination on it's
+  # own, the logic should be handled by the finders.
+  #
+  # Example:
+  #   @users = User.limit(20).offset(20)
+  #   PagesCore::Paginates.paginate(
+  #     @users,
+  #     current_page: 2,
+  #     pages: 5,
+  #     per_page: 20
+  #   )
+  #
+  # Now, in the view, you could do:
+  #
+  #   <%= link_to_unless(
+  #         @pages.first_page?, "Previous", {page: @users.previous_page})  %>
+  #   <% @users.pages.each do |p| %>
+  #     <%= link_to_unless p == @users.current_page, p, {page: p} %>
+  #   <% end %>
+  #   <%= link_to_unless @pages.last_page? "Next", {page: @users.next_page}  %>
+  module Paginates
+    attr_accessor :paginated, :current_page, :pages, :per_page, :offset
+
+    class << self
+      # Applies pagination to any collection.
+      def paginate(collection, options = {})
+        options = default_options.merge(options)
+        class << collection
+          include PagesCore::Paginates
+        end
+        collection.current_page = options[:current_page]
+        collection.pages        = options[:pages]
+        collection.per_page     = options[:per_page]
+        collection.offset       = options[:offset]
+        collection.paginated    = options[:per_page] ? true : false
+      end
+
+      def default_options
+        {
+          current_page: 1,
+          pages: 1,
+          per_page: nil,
+          offset: 0
+        }
+      end
+    end
+
+    # Returns true if collection is paginated
+    def paginated?
+      (@paginated) ? true : false
+    end
+
+    # Returns next page, or nil if at last page.
+    def next_page
+      (@current_page < @pages) ? (@current_page + 1) : nil
+    end
+
+    # Returns true/false depending on if there's a next page
+    def next_page?
+      (next_page) ? true : false
+    end
+
+    # Returns previous page, or nil if at first page.
+    def previous_page
+      (@current_page > 1) ? (@current_page - 1) : nil
+    end
+
+    # Returns true/false depending on if there's a previous page
+    def previous_page?
+      (previous_page) ? true : false
+    end
+
+    # Number of pages
+    def last_page
+      @pages.to_i
+    end
+
+    # Returns true if at the last page
+    def last_page?
+      (@page == @pages) ? true : false
+    end
+
+    # First page
+    def first_page
+      1
+    end
+
+    # Returns true if at the first page
+    def first_page?
+      (@page == 1) ? true : false
+    end
+
+    # All pages as an array
+    def pages
+      (first_page..last_page).to_a
+    end
+  end
+end

data/lib/pages_core/plugin.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+# module PagesGallery
+#  class Plugin < PagesCore::Plugin
+#    paths['db/migrate'] = 'template/db/migrate'
+#  end
+# end
+
+module PagesCore
+  class Plugin
+    class << self
+      attr_accessor :called_from, :paths
+
+      def inherited(plugin)
+        plugin.paths ||= {
+          "db/migrate"                    => "db/migrate",
+          "config/removed_migrations.yml" => "config/removed_migrations.yml"
+        }
+        plugin.called_from = begin
+          # Remove the line number from backtraces making sure we
+          # don't leave anything behind
+          call_stack = caller.map { |p| p.sub(/:\d+.*/, "") }
+          File.dirname(
+            call_stack.detect do |p|
+              p !~ %r{railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack}
+            end
+          )
+        end
+      end
+
+      def admin_menu_item(label, path, group = :custom, options = {})
+        PagesCore::AdminMenuItem.register(label, path, group, options)
+      end
+
+      def plugins
+        @plugins ||= ::PagesCore::Plugin.subclasses.map do |class_name|
+          class_name.to_s.split("::").inject(Object) do |klass, m|
+            klass.const_get(m)
+          end
+        end
+      end
+
+      def migrations
+        plugins.map { |p| p.new.migrations }.flatten.compact
+      end
+
+      def removed_migrations
+        plugins.map { |p| p.new.removed_migrations }.flatten.compact
+      end
+
+      def existing_removed_migrations
+        removed_migrations
+          .select { |m| File.exist?(Rails.root.join("db", "migrate", m)) }
+      end
+
+      def existing_migrations
+        migrations
+          .map { |m| Rails.root.join("db", "migrate", m.basename) }
+          .select { |m| File.exist?(m) }
+      end
+
+      def remove_old_migrations!
+        (existing_removed_migrations + existing_migrations).each do |migration|
+          File.unlink Rails.root.join("db", "migrate", migration)
+        end
+      end
+    end
+
+    def root
+      @root ||= find_root_with_subfolder("app")
+    end
+
+    def paths
+      self.class.paths
+    end
+
+    def migrations_path
+      root.join(paths["db/migrate"])
+    end
+
+    def removed_migrations_path
+      root.join(paths["config/removed_migrations.yml"])
+    end
+
+    def migrations?
+      File.exist?(migrations_path) && File.directory?(migrations_path)
+    end
+
+    def migrations
+      Dir.entries(migrations_path)
+        .select { |f| f =~ /\.rb$/ }
+        .map { |f| migrations_path.join(f) }
+    end
+
+    def removed_migrations
+      return unless File.exist?(removed_migrations_path)
+      YAML.load_file(removed_migrations_path)
+    end
+
+    protected
+
+    def find_root_with_subfolder(subfolder)
+      root_path = self.class.called_from
+
+      while root_path && File.directory?(root_path) &&
+          !File.exist?("#{root_path}/#{subfolder}")
+        parent = File.dirname(root_path)
+        root_path = parent != root_path && parent
+      end
+
+      unless File.exist?("#{root_path}/#{subfolder}")
+        fail "Could not find root path for #{self}"
+      end
+
+      Pathname.new(root_path).realpath
+    end
+  end
+end

data/lib/pages_core/templates/block_configuration.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    # Configuration for the blocks on an individual template
+    class BlockConfiguration
+      attr_reader :name, :title, :description, :optional, :enforced
+      def small?
+        (@size == :small) ? true : false
+      end
+
+      def large?
+        (small?) ? false : true
+      end
+    end
+  end
+end

data/lib/pages_core/templates/configuration.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    class Configuration < PagesCore::Templates::ConfigurationHandler
+      handle :default do |instance, name, *args|
+        if name == :blocks
+          blocks_proxy = instance.blocks
+          args.first.call(blocks_proxy) if args.first.is_a?(Proc)
+          blocks_proxy
+        else
+          instance.configure_template(:_defaults, name, *args)
+        end
+      end
+
+      def valid_template_options
+        [
+          :template, :image, :images, :files, :text_filter, :blocks,
+          :enabled_blocks, :sub_template, :comments, :comments_allowed, :tags
+        ]
+      end
+
+      def configure_block(tpl_name, block_name, title = false, options = {})
+        block_name = block_name.to_sym
+        title ||= block_name.to_s.humanize
+        options[:title] = title
+        if tpl_name == :_defaults
+          set([:default, :blocks, block_name], options)
+        else
+          set([:templates, tpl_name, :blocks, block_name], options)
+        end
+      end
+
+      def configure_template(template_name, setting, value, options = {})
+        template_name = template_name.to_sym
+        setting = setting.to_sym
+        if valid_template_options.include?(setting)
+          value = true  if value == :enabled
+          value = false if value == :disabled
+          template_config = {
+            setting => {
+              value:   value,
+              options: options
+            }
+          }
+          if template_name == :_defaults
+            set([:default], template_config)
+          else
+            set([:templates, template_name], template_config)
+          end
+        else
+          fail "Invalid template configuration value: #{setting.inspect}"
+        end
+      end
+
+      def blocks(template_name = :_defaults, &block)
+        proxy(block) do |name, *args|
+          configure_block(template_name, name, *args)
+        end
+      end
+
+      def templates(*tpl_args, &block)
+        template_names = tpl_args.flatten.map(&:to_sym)
+        proxy(block) do |name, *args|
+          if name == :blocks
+            proxy(args.first.is_a?(Proc) ? args.first : nil) do |n2, *a2|
+              template_names.each do |template_name|
+                configure_block(template_name, n2, *a2)
+              end
+            end
+          else
+            template_names.each do |template_name|
+              configure_template(template_name, name, *args)
+            end
+          end
+        end
+      end
+      alias_method :template, :templates
+    end
+  end
+end

data/lib/pages_core/templates/configuration_handler.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    class ConfigurationHandler
+      class << self
+        def handle_blocks
+          @handle_blocks ||= {}
+        end
+
+        def handle(method_name, &handle_block)
+          @handle_blocks ||= {}
+          @handle_blocks[method_name] = handle_block
+        end
+      end
+
+      attr_reader :configuration
+
+      def initialize
+        @configuration = {}
+      end
+
+      def method_missing(method_name, *args, &block)
+        if self.class.handle_blocks.keys.include?(method_name)
+          proxy = PagesCore::Templates::ConfigurationProxy.new(
+            self.class.handle_blocks[method_name],
+            self
+          )
+          block.call(proxy) if block
+          proxy
+        else
+          super
+        end
+      end
+
+      def proxy(proxy_block = nil, &callback)
+        proxy_object = PagesCore::Templates::ConfigurationProxy.new(callback)
+        proxy_block.call(proxy_object) if proxy_block
+        proxy_object
+      end
+
+      def set(stack, value)
+        @configuration ||= {}
+        value = true  if value == :enabled
+        value = false if value == :disabled
+        stack = [stack] unless stack.is_a?(Enumerable)
+        partial_hash = stack.reverse.inject(value) do |hash, key|
+          Hash[key => hash]
+        end
+        @configuration = @configuration.deep_merge(partial_hash)
+        value
+      end
+
+      def get(*path)
+        @configuration ||= {}
+        path.inject(@configuration) do |value, key|
+          (value && value.is_a?(Hash) && value.key?(key)) ? value[key] : nil
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/templates/configuration_proxy.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    class ConfigurationProxy
+      def initialize(callback, parent = nil)
+        @callback = callback
+        @parent = parent
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @parent
+          if block_given?
+            @callback.call(@parent, method_name, block)
+          else
+            @callback.call(@parent, method_name, *args)
+          end
+        else
+          if block_given?
+            @callback.call(method_name, block)
+          else
+            @callback.call(method_name, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/templates/controller_actions.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    module ControllerActions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def template_actions
+          @template_actions ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def template(*names, &block)
+          Array(names).each do |name|
+            name = name.to_s unless name == :all
+            template_actions[name] << block
+          end
+        end
+
+        def template_actions_for(name)
+          template_actions[:all] + template_actions[name.to_s]
+        end
+      end
+
+      def run_template_actions_for(template, *args)
+        self.class.template_actions_for(template).each do |proc|
+          instance_exec(*args, &proc)
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/templates/template_configuration.rb

@@ -0,0 +1,198 @@
+# encoding: utf-8
+
+module PagesCore
+  module Templates
+    class TemplateConfiguration
+      attr_reader :template_name
+
+      class << self
+        def all_blocks
+          new(:index).all_blocks
+        end
+      end
+
+      def initialize(template_name)
+        @template_name = template_name.to_sym
+      end
+
+      def config
+        PagesCore::Templates.configuration
+      end
+
+      def value(*path)
+        path = [path, :value].flatten
+        value = config.get(*[:default, path].flatten)
+        template_value = config.get(*[:templates, @template_name, path].flatten)
+        value = template_value unless template_value.nil?
+        value
+      end
+
+      def options(*path)
+        path = [path, :options].flatten
+        (config.get(*[:default, path].flatten) || {})
+          .deep_merge(
+            config.get(*[:templates, @template_name, path].flatten) || {}
+          )
+      end
+
+      def block(block_name)
+        default_block_options(block_name)
+          .deep_merge(config.get(*[:default, :blocks, block_name]) || {})
+          .deep_merge(
+            config.get(*[:templates, @template_name, :blocks, block_name]) || {}
+          )
+      end
+
+      def enabled_blocks
+        blocks = value(:enabled_blocks)
+        blocks = [:name] + blocks unless blocks.include?(:name)
+        if block_given?
+          blocks.each { |block_name| yield block_name, block(block_name) }
+        end
+        blocks
+      end
+
+      def metadata_blocks
+        blocks = PagesCore::Templates.metadata_block_names
+        if block_given?
+          blocks.each { |block_name| yield block_name, block(block_name) }
+        end
+        blocks
+      end
+
+      # Returns a list of all configured blocks
+      def all_blocks
+        (
+          all_templates.map { |t| configured_block_names(t) } +
+            all_templates.map { |t| enabled_block_names(t) }
+        ).flatten.compact.uniq
+      end
+
+      private
+
+      def configured_block_names(template)
+        Array(config.get(:default, :blocks).try(&:keys)) +
+          Array(config.get(:templates, template, :blocks).try(&:keys))
+      end
+
+      def enabled_block_names(template)
+        Array(config.get(:default, :enabled_blocks, :value)) +
+          Array(config.get(:templates, template, :enabled_blocks, :value))
+      end
+
+      def default_block_options(block_name)
+        {
+          title:    block_name.to_s.humanize,
+          optional: true,
+          size:     :small
+        }
+      end
+
+      def all_templates
+        Array(config.get(:templates).try(&:keys))
+      end
+    end
+
+    class << self
+      def configure(options = {}, &_block)
+        if options[:reset] == :defaults
+          load_default_configuration
+        elsif options[:reset] == true
+          @configuration = PagesCore::Templates::Configuration.new
+        end
+        yield configuration if block_given?
+      end
+
+      def load_default_configuration
+        @configuration = PagesCore::Templates::Configuration.new
+
+        # Default template options
+        config.default do |default|
+          default.template :autodetect, root: "index"
+          default.image :enabled, linkable: false
+          default.comments :disabled
+          default.comments_allowed :enabled
+          default.files :disabled
+          default.images :disabled
+          default.text_filter :textile
+          default.enabled_blocks [:headline, :excerpt, :body]
+          default.tags :disabled
+          default_block_configuration(default)
+        end
+      end
+
+      def configuration
+        load_default_configuration unless defined? @configuration
+        @configuration
+      end
+      alias_method :config, :configuration
+
+      def metadata_block_names
+        [
+          :meta_title,
+          :meta_description,
+          :open_graph_title,
+          :open_graph_description
+        ]
+      end
+
+      private
+
+      def default_block_configuration(default)
+        default.blocks do |block|
+          block.name(
+            "Name",
+            size: :field,
+            description: "This is the name of the page, and it will also " \
+              "be the name of the link to this page.",
+            class: "page_title"
+          )
+          block.body(
+            "Body",
+            size: :large
+          )
+          block.headline(
+            "Headline",
+            description: "Optional, use if the headline should differ from " \
+              "the page name.",
+            size: :field
+          )
+          block.excerpt(
+            "Standfirst",
+            description: "An introductory paragraph before the start " \
+              "of the body."
+          )
+          block.boxout(
+            "Boxout",
+            description: "Part of the page, usually background info or " \
+              "facts related to the article."
+          )
+          block.meta_title(
+            "Title",
+            size: :field,
+            description: "Document title. Will fall back to the page name " \
+              "if empty. Recommended length: Up to 56 characters."
+          )
+          block.meta_description(
+            "Description",
+            size: :small,
+            description: "Description for search engines. Will fall back to " \
+              "Standfirst if empty. Recommended length: Up to 156 characters."
+          )
+          block.open_graph_title(
+            "Open Graph Title",
+            size: :field,
+            description: "Page title for Facebook sharing. Will fall back to " \
+              "the document title."
+          )
+          block.open_graph_description(
+            "Open Graph Description",
+            size: :small,
+            description: "Description for Facebook sharing. Will fall back " \
+              "to Description or Standfirst if empty."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/templates.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+load "pages_core/templates/block_configuration.rb"
+load "pages_core/templates/configuration_proxy.rb"
+load "pages_core/templates/configuration_handler.rb"
+load "pages_core/templates/configuration.rb"
+load "pages_core/templates/controller_actions.rb"
+load "pages_core/templates/template_configuration.rb"
+
+module PagesCore
+  module Templates
+    class << self
+      def names
+        @names ||= find_all_templates
+      end
+
+      private
+
+      def template_paths
+        [
+          PagesCore.plugin_root.join("app", "views", "pages", "templates"),
+          Rails.root.join("app", "views", "pages", "templates")
+        ]
+      end
+
+      def template_files
+        template_paths
+          .select { |dir| File.exist?(dir) }
+          .flat_map { |dir| template_files_in_dir(dir) }
+          .uniq
+          .compact
+          .sort
+          .map { |f| f.gsub(/\.[\w\.]+$/, "") }
+      end
+
+      def template_files_in_dir(dir)
+        Dir.entries(dir).select { |f| template_file?(f, dir) }
+      end
+
+      def template_file?(file, dir)
+        File.file?(File.join(dir, file)) && !file.match(/^_/)
+      end
+
+      def find_all_templates
+        if template_files.include?("index")
+          ["index"] + (template_files - ["index"])
+        else
+          template_files
+        end
+      end
+    end
+  end
+end

data/lib/pages_core/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module PagesCore
+  VERSION = "3.4.2" unless PagesCore.const_defined?("VERSION")
+end