ecm_cms2 1.0.0

data/lib/ecm/cms/active_admin/ecm_cms_partials.rb

@@ -0,0 +1,53 @@
+ActiveAdmin.register Ecm::Cms::Partial do
+  permit_params(:basename,
+                :body,
+                :ecm_cms_folder_id,
+                :format,
+                :handler,
+                :layout,
+                :locale,
+                :pathname) if Rails.version >= '4.0.0'
+  # Menu
+  menu :parent => Proc.new { I18n.t('ecm.cms.active_admin.menu') }.call
+
+  form do |f|
+    f.inputs do
+      f.input :body
+    end
+
+    f.inputs do
+      f.input :pathname
+      f.input :basename
+      f.input :locale, :as => :select, :collection => I18n.available_locales.map(&:to_s)
+      f.input :format, :as => :select, :collection => Mime::SET.symbols.map(&:to_s)
+      f.input :handler, :as => :select, :collection => ActionView::Template::Handlers.extensions.map(&:to_s)
+    end
+
+    f.actions
+  end
+
+  index do
+    selectable_column
+    column :pathname
+    column :filename
+    column :created_at
+    column :updated_at
+    ActiveAdmin::VERSION[0] < '1' ? default_actions : actions
+  end
+
+  show do
+    panel Ecm::Cms::Partial.human_attribute_name(:body) do
+      pre { ecm_cms_partial.body }
+    end
+  end
+
+  sidebar Ecm::Cms::Partial.human_attribute_name(:details), :only => :show do
+    attributes_table_for ecm_cms_partial do
+      row :pathname
+      row :filename
+      row :created_at
+      row :updated_at
+    end
+  end # sidebar
+end
+

data/lib/ecm/cms/active_admin/ecm_cms_templates.rb

@@ -0,0 +1,55 @@
+ActiveAdmin.register Ecm::Cms::Template do
+  permit_params(:basename,
+                :body,
+                :ecm_cms_folder_id,
+                :format,
+                :handler,
+                :layout,
+                :locale,
+                :pathname) if Rails.version >= '4.0.0'
+                  
+  # Menu
+  menu :parent => Proc.new { I18n.t('ecm.cms.active_admin.menu') }.call
+
+  form do |f|
+    f.inputs do
+      f.input :body
+    end
+
+    f.inputs do
+      f.input :pathname
+      f.input :basename
+      f.input :locale, :as => :select, :collection => I18n.available_locales.map(&:to_s)
+      f.input :format, :as => :select, :collection => Mime::SET.symbols.map(&:to_s)
+      f.input :handler, :as => :select, :collection => ActionView::Template::Handlers.extensions.map(&:to_s)
+    end
+
+    f.actions
+  end
+
+  index do
+    selectable_column
+    column :pathname
+    column :filename
+    column :created_at
+    column :updated_at
+    ActiveAdmin::VERSION[0] < '1' ? default_actions : actions
+  end
+
+  show do
+    panel Ecm::Cms::Template.human_attribute_name(:body) do
+      pre { ecm_cms_template.body }
+    end
+  end
+
+  sidebar Ecm::Cms::Template.human_attribute_name(:details), :only => :show do
+    attributes_table_for ecm_cms_template do
+      # row :folder
+      row :pathname
+      row :filename
+      row :created_at
+      row :updated_at
+    end
+  end # sidebar
+end
+

data/lib/ecm/cms/configuration.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/hash_with_indifferent_access'
+
+module Ecm
+  module Cms
+    module Configuration
+      def configure
+        yield self
+      end
+
+      mattr_accessor :base_controller do
+        'ApplicationController'
+      end
+
+      mattr_accessor :default_handlers do
+        HashWithIndifferentAccess.new()
+      end
+
+      mattr_accessor :site_title do
+        ''
+      end
+
+      mattr_accessor :navigation_item_properties do
+        []
+      end
+
+      def default_handlers=(default_handlers)
+        @@default_handlers = HashWithIndifferentAccess.new(default_handlers)
+      end
+    end
+  end
+end

data/lib/ecm/cms/controller_extensions/page_resolver.rb

@@ -0,0 +1,13 @@
+module Ecm
+  module Cms
+    module ControllerExtensions
+      module PageResolver
+        def self.included(base)
+          # add the page resolver
+          base.prepend_view_path ::Ecm::Cms::PageResolver.instance unless base.view_paths.include?(::Ecm::Cms::PageResolver.instance)
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/controller_extensions/partial_resolver.rb

@@ -0,0 +1,13 @@
+module Ecm
+  module Cms
+    module ControllerExtensions
+      module PartialResolver
+        def self.included(base)
+          # add the partial resolver
+          base.prepend_view_path ::Ecm::Cms::PartialResolver.instance unless base.view_paths.include?(::Ecm::Cms::PartialResolver.instance)
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/controller_extensions/template_resolver.rb

@@ -0,0 +1,13 @@
+module Ecm
+  module Cms
+    module ControllerExtensions
+      module TemplateResolver
+        def self.included(base)
+          # add the template resolver
+          base.prepend_view_path ::Ecm::Cms::TemplateResolver.instance unless base.view_paths.include?(::Ecm::Cms::TemplateResolver.instance)
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/database_resolver.rb

@@ -0,0 +1,101 @@
+module Ecm
+  module Cms
+    module DatabaseResolver
+      # Include hook for class methods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # class methods go here
+      module ClassMethods
+      end
+
+      # instance methods go here
+      def find_templates(name, prefix, partial, details)
+        return [] unless resolve(partial)
+
+        conditions = {
+          :pathname    => assert_slashs(prefix.to_s),
+          :basename    => normalize_basename(name),
+          :locale      => normalize_array(details[:locale]).first,
+          :format      => normalize_array(details[:formats]).first,
+          :handler     => normalize_array(details[:handlers])
+        }
+
+        format = conditions.delete(:format)
+        locale = conditions.delete(:locale)
+        
+        query  = self.template_class.constantize.where(conditions)
+
+        # 2) Check for templates with the given format or format is nil
+        query = query.where(["format = ? OR format = ''", format])
+
+        # 3) Ensure templates with format come first
+        query = query.order("format DESC")
+
+        # 4) Check for templates with the given locale or locale is nil
+        query = query.where(["locale = ? OR locale = ''", locale])
+
+        # 5) Ensure templates with locale come first
+        query = query.order("locale DESC")
+
+        # 6) Now trigger the query passing on conditions to initialization
+        query.map do |record|
+          initialize_template(record, details)
+        end
+      end
+
+      # Initialize an ActionView::Template object based on the record found.
+      def initialize_template(record, details)
+        source     = build_source(record)
+        identifier = "#{record.class} - #{record.id} - #{record.pathname}#{record.basename}"
+        handler    = ::ActionView::Template.registered_template_handler(record.handler)
+
+        # 5) Check for the record.format, if none is given, try the template
+        # handler format and fallback to the one given on conditions
+        format   = record.format && Mime[record.format]
+        format ||= handler.default_format if handler.respond_to?(:default_format)
+        format ||= details[:formats]
+
+        details = {
+          :format => format,
+          :updated_at => record.updated_at,
+          :virtual_path => "#{record.pathname}#{record.basename}"
+        }
+
+        details[:layout] = record.layout if record.respond_to?(:layout) && record.layout.present?
+
+        ::ActionView::Template.new(source, identifier, handler, details)
+      end
+
+      def assert_slashs(prefix)
+        output = prefix.dup
+        output << '/' unless output.end_with?('/')
+        output = '/' << output unless output.start_with?('/')
+        return output
+      end
+
+      # Normalize arrays by converting all symbols to strings.
+      def normalize_array(array)
+        array.map(&:to_s)
+      end
+
+      def build_source
+        raise "call to abstract method #build_source"
+      end
+
+      def normalize_basename(basename)
+        raise "call to abstract method #normalize_basename"
+      end
+
+      def resolve(partial_flag)
+        raise "call to abstract method #resolve"
+      end
+
+      def template_class
+        raise "call to abstract method #template_class"
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/database_template.rb

@@ -0,0 +1,61 @@
+module Ecm
+  module Cms
+    module DatabaseTemplate
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        # associations
+        base.belongs_to :ecm_cms_folder,
+                        :class_name => 'Ecm::Cms::Folder',
+                        :foreign_key => 'ecm_cms_folder_id'
+
+        # callbacks
+        base.after_initialize :set_defaults
+        base.before_validation :assert_trailing_slash_on_pathname
+        base.after_save :clear_resolver_cache
+
+        # validations
+        base.validates :basename, :presence => true,
+                                  :uniqueness =>  { :scope => [ :pathname, :locale, :format, :handler ] }
+        base.validates :handler, :inclusion => ActionView::Template::Handlers.extensions.map(&:to_s)
+        base.validates :locale, :inclusion => I18n.available_locales.map(&:to_s),
+                                :allow_nil => true,
+                                :allow_blank => true
+        base.validates :format, :inclusion => Mime::SET.symbols.map(&:to_s),
+                                :allow_nil => true,
+                                :allow_blank => true
+        base.validates :pathname, :presence => true
+      end
+
+      module ClassMethods
+      end
+
+      def filename
+        filename = basename.dup
+        filename << ".#{locale}" if locale.present?
+        filename << ".#{format}" if format.present?
+        filename << ".#{handler}" if handler.present?
+        filename
+      end
+
+      private
+
+      def assert_trailing_slash_on_pathname
+        self.pathname = '/' and return if self.pathname.blank?
+        self.pathname << '/' unless self.pathname.end_with?('/')
+      end
+
+      def clear_resolver_cache
+        Ecm::Cms::PageResolver.instance.clear_cache
+      end
+
+      def set_defaults
+        if self.new_record?
+          self.locale  ||= I18n.default_locale.to_s
+          self.handler ||= Ecm::Cms::Configuration.default_handlers[:page].to_s
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/engine.rb

@@ -0,0 +1,28 @@
+module Ecm
+  module Cms
+    class Engine < ::Rails::Engine
+      config.app_generators do |c|
+        c.test_framework :rspec, :fixture => true,
+                                 :fixture_replacement => nil
+
+        c.integration_tool :rspec
+        c.performance_tool :rspec
+      end
+
+      # active admin
+      initializer :ecm_cms_engine do
+        ::ActiveAdmin.setup do |config|
+          config.load_paths += Dir[File.dirname(__FILE__) + '/active_admin']
+          config.register_stylesheet 'ecm_cms.css'
+          config.register_javascript 'ecm_cms.js'
+        end
+      end if defined?(::ActiveAdmin)
+
+      initializer "ecm_cms.asset_pipeline" do |app|
+        app.config.assets.precompile << 'ecm_cms.js'
+        app.config.assets.precompile << 'ecm_cms.css'
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/importers/navigation.rb

@@ -0,0 +1,30 @@
+module Ecm
+  module Cms
+    module Importers
+      class Navigation
+        def initialize(yaml, option = {})
+          @navigations = nil
+          @yaml = YAML.load(yaml)
+        end
+
+        def build_navigations
+          navigations = []
+          @yaml.each do |navigation_data|
+            navigation = Ecm::Cms::Navigation.new(navigation_data)
+            navigations << navigation
+          end if @yaml.respond_to?(:each)
+          navigations
+        end
+
+        def navigations
+          @navigations ||= build_navigations
+        end
+
+        def yaml
+          @yaml
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/importers/navigation_item.rb

@@ -0,0 +1,64 @@
+module Ecm
+  module Cms
+    module Importers
+      class NavigationItem
+        def initialize(yaml, option = {})
+          @navigation_items = nil
+          @yaml = YAML.load(yaml)
+        end
+
+        def navigation_items
+          @navigation_items ||= create_navigation_items
+        end
+
+        private
+
+        def create_navigation_items
+          built_navigation_items = []
+          @yaml.each do |navigation_locale, navigation|     
+            navigation.each do |navigation_name, navigation_items_attributes|
+              n = find_or_create_navigation(navigation_locale, navigation_name)
+              built_navigation_items << create_navigation_items_for_navigation(n, navigation_items_attributes)
+            end if navigation_locale.respond_to?(:each)
+          end if @yaml.respond_to?(:each)
+          built_navigation_items.flatten
+        end
+
+        def create_navigation_items_for_navigation(navigation, navigation_items_attributes)
+          built_navigation_items = []
+          navigation_items_attributes.each do |navigation_item_attributes|
+            ni = create_navigation_item(navigation_item_attributes, navigation)
+            built_navigation_items << ni
+          end
+          return built_navigation_items
+        end
+
+        def create_navigation_item(navigation_item_attributes, navigation)
+          subitems = navigation_item_attributes.delete('subitems')
+
+          ni = Ecm::Cms::NavigationItem.new(navigation_item_attributes)
+          ni.ecm_cms_navigation = navigation
+          ni.save!
+
+          subitems.each do |subitem_attributes|
+            subitem_attributes['parent'] = ni
+            create_navigation_item(subitem_attributes, navigation)
+          end if subitems.respond_to?(:each)
+
+          ni
+        end
+
+        def find_or_create_navigation(navigation_locale, navigation_name)
+          navigation = Ecm::Cms::Navigation.where(:locale => navigation_locale, :name => navigation_name).first
+          navigation = Ecm::Cms::Navigation.create!(:locale => navigation_locale, :name => navigation_name) if navigation.nil?
+          navigation
+        end
+
+        def yaml
+          @yaml
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/importers/page.rb

@@ -0,0 +1,41 @@
+module Ecm
+  module Cms
+    module Importers
+      class Page
+        def initialize(yaml, option = {})
+          @pages = nil
+          @yaml = YAML.load(yaml)
+        end
+
+        def build_pages
+          pages = []
+          @yaml.each do |page_data|
+            navigation_items = extract_navigation_items(page_data.delete('navigation_items'))
+            page = Ecm::Cms::Page.new(page_data)
+            page.ecm_cms_navigation_item_ids = navigation_items.map(&:id)
+            pages << page
+          end if @yaml.respond_to?(:each)
+          pages
+        end
+
+        def extract_navigation_items(navigation_item_data)
+          navigation_items = []
+          navigation_item_data.each do |nid|
+            navigation = Ecm::Cms::Navigation.where(:locale => nid['navigation_locale'], :name => nid['navigation_name']).first
+            navigation_items << navigation.ecm_cms_navigation_items.where(:name => nid['name']).first if navigation.respond_to?(:ecm_cms_navigation_items)
+          end
+          navigation_items
+        end
+
+        def pages
+          @pages ||= build_pages
+        end
+
+        def yaml
+          @yaml
+        end
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/resolvers/ecm/cms/page_resolver.rb

@@ -0,0 +1,45 @@
+require 'ecm/cms/database_resolver'
+
+module Ecm
+  module Cms
+    class PageResolver < ::ActionView::Resolver
+      require 'singleton'
+      include Singleton
+
+      # add shared behaviour for database backed templates
+      include Ecm::Cms::DatabaseResolver
+
+      def build_source(record)
+        output = ''
+        record.ecm_cms_page_content_blocks.each do |content_block|
+          # rendered_body = RedCloth.new(begin;content_block.body;end).to_html.html_safe
+          rendered_body = RedCloth.new(content_block.body).to_html
+          output << "<% content_for :#{content_block.content_box_name} do %>#{rendered_body}<% end %>"
+        end
+
+        content_for_title = "<% content_for :title do %>#{record.title}<% end %>"
+        content_for_meta_description = "<% content_for :meta_description do %>#{record.meta_description}<% end %>"
+        output << content_for_title << content_for_meta_description
+        
+        unless record.body.nil?
+          output << record.body
+        end
+
+        return output
+      end
+
+      def normalize_basename(basename)
+        basename
+      end
+
+      def resolve(partial_flag)
+        !partial_flag
+      end
+
+      def template_class
+        'Ecm::Cms::Page'
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/resolvers/ecm/cms/partial_resolver.rb

@@ -0,0 +1,30 @@
+require 'ecm/cms/database_resolver'
+
+module Ecm
+  module Cms
+    class PartialResolver < ::ActionView::Resolver
+      require 'singleton'
+      include Singleton
+
+      # add shared behaviour for database backed templates
+      include Ecm::Cms::DatabaseResolver
+
+      def template_class
+        'Ecm::Cms::Partial'
+      end
+
+      def build_source(record)
+        record.body
+      end
+
+      def normalize_basename(basename)
+        '_' << basename
+      end
+
+      def resolve(partial_flag)
+        partial_flag
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/resolvers/ecm/cms/template_resolver.rb

@@ -0,0 +1,30 @@
+require 'ecm/cms/database_resolver'
+
+module Ecm
+  module Cms
+    class TemplateResolver < ::ActionView::Resolver
+      require 'singleton'
+      include Singleton
+
+      # add shared behaviour for database backed templates
+      include Ecm::Cms::DatabaseResolver
+
+      def build_source(record)
+        record.body
+      end
+
+      def normalize_basename(basename)
+        basename
+      end
+
+      def resolve(partial_flag)
+        !partial_flag
+      end
+
+      def template_class
+        'Ecm::Cms::Template'
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/routing.rb

@@ -0,0 +1,13 @@
+module Ecm
+  module Cms
+    class Routing
+      def self.routes(router, options = {})
+        options.reverse_merge!({})
+
+        router.get "/*page", :to => "ecm/cms/page#respond", :as => :page
+        router.get '/' => "ecm/cms/page#respond", :page => 'home' #, :as => :root
+      end
+    end
+  end
+end
+

data/lib/ecm/cms/version.rb

@@ -0,0 +1,5 @@
+module Ecm
+  module Cms
+    VERSION = "1.0.0"
+  end
+end

data/lib/ecm_cms2.rb

@@ -0,0 +1,36 @@
+require 'ecm/cms/action_view/template/handlers/textile'
+require 'ecm/cms/action_view/template_patch'
+require 'ecm/cms/action_view/template_renderer_patch'
+
+require 'awesome_nested_set'
+require 'redcloth'
+require 'simple-navigation'
+require 'simple-navigation-bootstrap'
+require 'active_admin-awesome_nested_set'
+
+require 'ecm/cms/engine'
+require 'ecm/cms/configuration'
+require 'ecm/cms/routing'
+
+require 'ecm/cms/database_template'
+
+require 'ecm/cms/resolvers/ecm/cms/page_resolver'
+require 'ecm/cms/resolvers/ecm/cms/template_resolver'
+require 'ecm/cms/resolvers/ecm/cms/partial_resolver'
+
+require 'ecm/cms/controller_extensions/page_resolver'
+require 'ecm/cms/controller_extensions/partial_resolver'
+require 'ecm/cms/controller_extensions/template_resolver'
+
+::ActionView::Template.register_template_handler :textile, ::ActionView::Template::Handlers::Textile.new
+
+module Ecm
+  module Cms
+    extend Configuration
+
+    def self.table_name_prefix
+      'ecm_cms_'
+    end
+  end
+end
+