manageable_content 0.0.1 → 0.1.1

data/CHANGELOG.rdoc

@@ -0,0 +1,10 @@
+== 0.1.1
+
+* README instructions
+
+== 0.1.0
+
+* ManageableContent::Controllers::Dsl
+* ManageableContent::Manager
+* ManageableContent::Page
+* ManageableContent::PageContent

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011 YOURNAME
+Copyright 2011 Fabio Kreusch
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,6 +1,94 @@
-= ManageableContent
+= ManageableContent http://travis-ci.org/fabiokr/manageable_content.png
 
-This project rocks and uses MIT-LICENSE.
+Manageable Content is a Rails 3.1 Engine that provides a simple framework for content management. It works by providing a Page instance for each of your configured controllers, so that each controller can have it's own contents that will be available to the views. You can also have shared contents.
 
-TODO Explain how to setup and use
-TODO Talk about multiple locale configuration
+== Contributing
+
+This engine is a work in progress and open for contributions! Please don't forget to add tests if you plan on contributing.
+
+== Installation
+
+This gem is compatible with Rails 3.1. To install it, add the following to your Gemfile:
+
+   gem 'manageable_content'
+   
+After that, run the 'bundle' command to install the gem.
+
+The next step is to import the engine migrations to your application. Just run this:
+
+   bundle exec rake manageable_content_engine:install:migrations
+   
+Then migrate your database with the usual command:
+
+   bundle exec rake db:migrate
+
+The last step is to include the Dsl in where you want to make the ManageableContent engine available. For example, you might want to add the following code to your ApplicationController:
+
+   include ManageableContent::Controllers::Dsl
+   
+== Getting Started
+
+ManageableContent supports two types of contents: a controller content, and a layout content.
+A controller content is a content that each controller will have by its own. For example, you might want to have a 'body' content, in which each controller will have a different value for it.
+A layout content is a content that will be shared between controllers. For example, you might want to have a 'footer' content that will be shared accross all of your controllers.
+
+=== Controller contents
+
+Supposing that you have a controller named ContactController and you want it to have its own 'body' content. You will need to add this to the controller code:
+
+   manageable_content_for :body
+   
+After that, run the following rake task:
+
+   bundle exec rake manageable_content:generate
+   
+This rake task will check your controllers configurations and will generate the corresponding pages for each controller with their contents. This should be run everytime a new controller or page content is added. This rake task just calls the ManageableContent::Manager.generate! method. You might want to add some kind of hook so that when you deploy your application the generator will run.
+
+You might also want to have an administration interface to edit you pages contents. Currently, this engine does not provide that, but you can check an admin example here: https://github.com/fabiokr/manageable_content_example_app/
+
+Now, to use this in your views, you have to use the manageable_content_for helper:
+
+  manageable_content_for :body
+
+This will print the content 'body' for the current controller, if it exists. This will print the content with html_safe.
+
+If you need a content that all your controllers will have (for example, a 'title' content), you can add the configuration to your parent controller and all controllers that inherit from it will also have that content. For example, you could add this to your ApplicationController:
+
+   manageable_content_for :title
+
+=== Layout contents
+
+Supposing that your application will have a 'footer' content that should be the same in all of your controllers, you would add this to your ApplicationController:
+
+   manageable_layout_content_for :footer
+
+In the views, to print it you need to use the manageable_layout_content_for helper:
+
+   manageable_layout_content_for :footer
+
+==== Different layouts
+
+In the previous example, the 'footer' content is available under the 'application' page. By default, manageable_layout_content_for uses the current controller default layout, which in the ApplicationController case is 'application'.
+If you need to add a content to a different layout, you could use this:
+
+   manageable_layout_content_for :footer, :layout => 'my_custom_layout'
+
+=== I18n
+
+If you need different contents for multiple locales, you can generate multiple pages for each available locale. You just need to set the available locales for ManageableContent, and then when you run the generator task it will generate contents for all available locales. To do that, just add an initializer with this content:
+
+   ManageableContent::Engine.config.locales = [:en, :pt]
+
+In your views, the helper calls will remain the same. The helpers use I18n.locale to get the current locale and than will use the content available for that locale.
+
+== Contributors
+
+https://github.com/fabiokr/manageable_content/contributors
+
+== Maintainers
+
+* Fabio Kreusch (https://github.com/fabiokr)
+
+== License
+
+MIT License. Copyright 2011 Fabio Kreusch http://www.kreusch.com.br

data/Rakefile

@@ -17,6 +17,8 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.title    = 'ManageableContent'
   rdoc.options << '--line-numbers'
   rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('CHANGELOG.rdoc')
+  rdoc.rdoc_files.include('app/**/*.rb')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 

data/app/models/manageable_content/page_content.rb

@@ -4,7 +4,7 @@ class ManageableContent::PageContent < ActiveRecord::Base
   attr_accessible :content
 
   validates :page_id, :presence => true
-  validates :key, :presence => true
+  validates :key,     :presence => true
 
-  default_scope order('key ASC')
+  default_scope order('short DESC, key ASC')
 end

data/db/migrate/20110814003912_create_manageable_content_page_contents.rb

@@ -3,6 +3,7 @@ class CreateManageableContentPageContents < ActiveRecord::Migration
     create_table :manageable_content_page_contents do |t|
       t.references :page
       t.string :key
+      t.boolean :short, :default => false
       t.text :content
 
       t.timestamps

data/lib/manageable_content/controllers/dsl.rb

@@ -8,7 +8,7 @@ module ManageableContent
 
       included do
         class_attribute :manageable_content_keys
-        self.manageable_content_keys = []
+        self.manageable_content_keys = {}
 
         helper_method :manageable_layout_content_for
         helper_method :manageable_content_for
@@ -31,13 +31,19 @@ module ManageableContent
         #
         #   manageable_layout_content_for :footer_message, :footer_copyright, :layout => 'application'
         #
+        # You can also set a content type for the given keys. By default they are :text content types.
+        # Available types are :text for long contents and :string for short contents.
+        #
+        #   manageable_layout_content_for :footer_copyright, :type => :string
+        #
         def manageable_layout_content_for(*keys)
           options = keys.last.is_a?(Hash) ? keys.pop : {}
-          layout = options[:layout] || self.controller_path
+          layout  = options[:layout] || self.controller_path
+          type    = options[:type]   || :text
 
           unless keys.empty?
             Dsl.manageable_layout_content_keys[layout] = 
-              ((Dsl.manageable_layout_content_keys[layout] || []) + keys).uniq
+              ((Dsl.manageable_layout_content_keys[layout] || {}).merge(keys_for_type(type, keys)))
           end
         end
 
@@ -53,9 +59,26 @@ module ManageableContent
         #
         #   manageable_content_for :title
         #
+        # You can also set a content type for the given keys. By default they are :text content types.
+        # Available types are :text for long contents and :string for short contents.
+        #
+        #   manageable_content_for :title, :type => :string
+        #
         def manageable_content_for(*keys)
+          options = keys.last.is_a?(Hash) ? keys.pop : {}
+          type    = options[:type] || :text
+
           unless keys.empty?
-            self.manageable_content_keys = (self.manageable_content_keys + keys).uniq
+            self.manageable_content_keys = (self.manageable_content_keys.merge(keys_for_type(type, keys)))
+          end
+        end
+
+        private
+
+        def keys_for_type(type, keys)
+          keys.inject({}) do |config, key|
+            config[key] = type
+            config
           end
         end
       end

data/lib/manageable_content/manager.rb

@@ -72,15 +72,17 @@ module ManageableContent
     # This can be useful to check if a PageContent is still relevant
     # based on the current configurations.
     #
+    # This will return a list of page keys with it's corresponding content type (:string or :text).
+    #
     def self.eligible_contents(key)
-      layout_content_keys = Controllers::Dsl.manageable_layout_content_keys[key] || []
+      layout_content_keys = Controllers::Dsl.manageable_layout_content_keys[key] || {}
       content_keys        = begin
         "#{key.camelize}Controller".constantize.manageable_content_keys
       rescue NameError
         []
       end
 
-      (layout_content_keys + content_keys).uniq
+      layout_content_keys.merge(content_keys)
     end
 
     protected
@@ -89,7 +91,7 @@ module ManageableContent
       #
       def self.generate_page!(key, locale, content_keys)
         Rails.logger.info "Generating ManageableContent::Page for key '#{key}', 
-          locale '#{locale}' and keys [#{content_keys.join(',')}]"
+          locale '#{locale}' and keys [#{content_keys.keys.join(',')}]"
 
         Page.transaction do
           page = Manager.page(key, locale).first || Page.new
@@ -100,11 +102,10 @@ module ManageableContent
             page.save!
           end
 
-          content_keys.each do |content_key|
-            if page.page_content(content_key).nil?
-              page_content     = page.page_contents.build
-              page_content.key = content_key
-            end
+          content_keys.each do |content_key, content_type|
+            page_content       = page.page_content(content_key) || page.page_contents.build
+            page_content.key   = content_key
+            page_content.short = content_type == :string
           end
 
           page.save!

data/lib/manageable_content/version.rb

@@ -1,3 +1,3 @@
 module ManageableContent
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/spec/dummy/app/controllers/application_controller.rb

@@ -3,6 +3,9 @@ class ApplicationController < ActionController::Base
 
   protect_from_forgery
 
-  manageable_layout_content_for :footer_copyright, :footer_contact
-  manageable_content_for :title, :keywords
+  manageable_layout_content_for :footer_contact,   :type => :string
+  manageable_layout_content_for :footer_copyright, :type => :text
+
+  manageable_content_for :title,    :type => :string
+  manageable_content_for :keywords, :type => :text
 end

data/spec/dummy/db/schema.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
@@ -15,6 +16,7 @@ ActiveRecord::Schema.define(:version => 20110814003912) do
   create_table "manageable_content_page_contents", :force => true do |t|
     t.integer  "page_id"
     t.string   "key"
+    t.boolean  "short",      :default => false
     t.text     "content"
     t.datetime "created_at"
     t.datetime "updated_at"

data/spec/dummy/log/development.log

@@ -1725,3 +1725,45 @@ Sprockets::FileNotFound: couldn't find file 'jquery'
   (in /home/fabio/dev/manageable_content/spec/dummy/app/assets/javascripts/application.js:7)
 Served asset /application.js - 500 Internal Server Error
 
+   (0.1ms)  select sqlite_version(*)
+   (122.1ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (121.1ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateManageableContentPages (20110814002730)
+   (0.8ms)  CREATE TABLE "manageable_content_pages" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "key" varchar(255), "locale" varchar(255), "created_at" datetime, "updated_at" datetime) 
+   (0.1ms)  PRAGMA index_list("manageable_content_pages")
+   (0.5ms)  CREATE UNIQUE INDEX "index_manageable_content_pages_on_key_and_locale" ON "manageable_content_pages" ("key", "locale")
+   (0.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20110814002730')
+Migrating to CreateManageableContentPageContents (20110814003912)
+   (0.5ms)  CREATE TABLE "manageable_content_page_contents" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "page_id" integer, "key" varchar(255), "type" varchar(255) DEFAULT 'text', "content" text, "created_at" datetime, "updated_at" datetime) 
+   (0.1ms)  PRAGMA index_list("manageable_content_page_contents")
+   (0.3ms)  CREATE UNIQUE INDEX "index_manageable_content_page_contents_on_page_id_and_key" ON "manageable_content_page_contents" ("page_id", "key")
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20110814003912')
+   (0.4ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  PRAGMA index_list("manageable_content_page_contents")
+   (0.1ms)  PRAGMA index_info('index_manageable_content_page_contents_on_page_id_and_key')
+   (0.0ms)  PRAGMA index_list("manageable_content_pages")
+   (0.1ms)  PRAGMA index_info('index_manageable_content_pages_on_key_and_locale')
+   (0.1ms)  select sqlite_version(*)
+   (207.7ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (104.2ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateManageableContentPages (20110814002730)
+   (0.6ms)  CREATE TABLE "manageable_content_pages" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "key" varchar(255), "locale" varchar(255), "created_at" datetime, "updated_at" datetime) 
+   (0.1ms)  PRAGMA index_list("manageable_content_pages")
+   (0.3ms)  CREATE UNIQUE INDEX "index_manageable_content_pages_on_key_and_locale" ON "manageable_content_pages" ("key", "locale")
+   (0.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20110814002730')
+Migrating to CreateManageableContentPageContents (20110814003912)
+   (0.9ms)  CREATE TABLE "manageable_content_page_contents" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "page_id" integer, "key" varchar(255), "short" boolean DEFAULT 'f', "content" text, "created_at" datetime, "updated_at" datetime) 
+   (0.1ms)  PRAGMA index_list("manageable_content_page_contents")
+   (0.4ms)  CREATE UNIQUE INDEX "index_manageable_content_page_contents_on_page_id_and_key" ON "manageable_content_page_contents" ("page_id", "key")
+   (0.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20110814003912')
+   (0.5ms)  select sqlite_version(*)
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  PRAGMA index_list("manageable_content_page_contents")
+   (0.1ms)  PRAGMA index_info('index_manageable_content_page_contents_on_page_id_and_key')
+   (0.1ms)  PRAGMA index_list("manageable_content_pages")
+   (0.1ms)  PRAGMA index_info('index_manageable_content_pages_on_key_and_locale')