liquidizer 0.1.0 → 0.4.2

data/README.rdoc

@@ -29,28 +29,20 @@ And add this to your config/environment.rb:
 First you have to specify which actions of which controllers should be liquified (rendered
 with loadable liquid templates). To do that, use the +liquify+ controller macro:
 
-    class PostController < ApplicationController
+    class PostsController < ApplicationController
       # This will apply the templates to all actions in this controller.
       liquify
     end
 
-If you want to liquify only some actions, but leave the others to be rendered using standard
-Rails means, do this:
+You can use the :only and :except options that work the same as for filters to limit the
+set of actions to liquify:
 
-    class PostController < ApplicationController
-      # Liquify only :show and :index.
-      liquify :show, :index
+    class PostsController < ApplicationController
+      liquify :only => [:show, :index]
     end
 
-By default, Liquidizer will infer liquid template names from the controller and action name
-in the same way Rails does. So action index in controller PostsController will have
-template called "posts/index". Namespaced controllers work too: index in Blog::PostsController
-will have template "blog/posts/index". This, however, can be overriden:
-
-
-    class PostController < ApplicationController
-      # This will liquify only show, but will use template called "awesome_show_template"
-      liquify :show, :as => 'awesome_show_template'
+    class CommentsController < ApplicationController
+      liquify :except => :edit
     end
 
 The +liquify+ macro is inherited, so if you want to apply liquid templates to all actions
@@ -62,18 +54,26 @@ controllers, if you want:
     end
 
     class PostsController < ApplicationController
-      liquify :show,  :as => 'kickass_show'
-      liquify :index, :as => 'hardcore_index'
+      liquify :only => :show
     end
 
-To liquify also layouts, use the +liquify_layout+ macro:
+The layout is also liquified by default. You can disable it using the :layout => false options.
+Note that this will disable layout rendering with liquid, not layout rendering in general.
 
     class ApplicationController < ActionController::Base
-      # This will use layout called "layout"
-      liquify_layout
+      liquify :layout => false
+    end
 
-      # This will use layout called "awesome_kickass_layout"
-      liquify_layout :as => "awesome_kickass_layout"
+The Liqidizer uses the same naming convention for templates as Rails. So for the 
+Blog::PostsController's action :index, the looked up template will be "blog/posts/index". If
+you want to override it, do it the standard Rails way:
+
+    class PostsController < ApplicationController
+      liquify
+
+      def index
+        render :template => 'more_awesome_index_template'
+      end
     end
 
 The last step is to tell Liquidizer where to load the liquid templates from. The way to implement
@@ -153,6 +153,25 @@ Then you can do this in your liquid template:
 
 And the post.title will call PostDrop#title, filtering all nasty stuff.
 
+If the instance variable is an array (also association collection, active record scope or
+this kind of stuff), all it's elements will be dropified too:
+
+    class PostsController < ActiveRecord::Base
+      liquify
+
+      def index
+        @posts = current_blog.posts
+      end
+    end
+
+Then in your liquid tempalte:
+
+  {% for post in posts %}
+  <h2>{{ post.title }}</h2>
+  
+  <!-- more stuff -->
+  {% endfor %}
+
 The way how variables are wrapped with drops can be completelly customized by overriding the
 +dropify+ method.
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.4.2

data/lib/liquidizer/controller_extensions.rb

@@ -1,5 +1,6 @@
 require 'liquid'
 require 'liquidizer/support'
+require 'liquidizer/file_system'
 
 module Liquidizer
   module ControllerExtensions
@@ -8,16 +9,18 @@ module Liquidizer
         extend ClassMethods
         alias_method_chain :render, :liquid
 
-        class_inheritable_accessor :liquify_actions
-        class_inheritable_hash     :liquid_template_names_for_actions
-        class_inheritable_accessor :liquid_template_name_for_layout
+        class_inheritable_hash :liquidizer_options
+        self.liquidizer_options ||= {}
+
+        before_filter :set_liquid_file_system
       end
     end
 
-    def render_with_liquid(options = {}, &block)
-      if action_template = liquid_template_for_action(options)
+    def render_with_liquid(options = nil, &block)
+      if view_template = liquid_template_for_view(options)
+        options ||= {}
         assigns = assigns_for_liquify
-        content = action_template.render!(assigns)
+        content = view_template.render!(assigns)
 
         if layout_template = liquid_template_for_layout(options)
           content = layout_template.render!(assigns.merge('content_for_layout' => content))
@@ -28,6 +31,7 @@ module Liquidizer
       else
         if layout_template = liquid_template_for_layout(options)
           assigns = assigns_for_liquify
+          options ||= {}
 
           content = render_to_string(options.merge(:layout => false))
           content = layout_template.render!(assigns.merge('content_for_layout' => content))
@@ -41,38 +45,47 @@ module Liquidizer
 
     private
 
-    def liquid_template_for_action(options)
-      action = extract_action_for_render(options)
-      
-      if action && liquify?(action)
-        name = liquid_template_name_for_action(action)
-        find_and_parse_liquid_template(name)
-      else
-        nil
+    def liquid_template_for_view(options)
+      name = options && options[:template]
+
+      unless name
+        action = extract_action_for_render(options)
+        
+        if action && liquify?(action)
+          name = liquid_template_name_for_action(action) 
+        end
       end
+
+      name && find_and_parse_liquid_template(name)
     end
     
     def liquify?(action)
-      self.class.liquify_actions == :all ||
-      self.class.liquify_actions &&
-      self.class.liquify_actions.include?(action.to_sym)
+      options = self.class.liquidizer_options
+
+      return false unless options[:actions]
+      return false if options[:only] && !Array.wrap(options[:only]).include?(action.to_sym)
+      return false if options[:except] && Array.wrap(options[:except]).include?(action.to_sym)
+
+      true
     end
 
     def liquid_template_for_layout(options)
       if liquify_layout?(options)
-        find_and_parse_liquid_template(self.class.liquid_template_name_for_layout)
+        name = liquid_template_name_for_layout(options)
+        name && find_and_parse_liquid_template(name)
       else
         nil
       end
     end
     
     def liquify_layout?(options)
-      if options[:layout] == true ||
-         options[:layout].nil? && liquifiable_options?(options)
-        self.class.liquid_template_name_for_layout.present?
-      else
-        false
-      end
+      options ||= {}
+
+      return false unless self.class.liquidizer_options[:layout]
+      return true  if     options[:layout].nil? && liquifiable_options?(options)
+      return true  if     options[:layout] == true
+
+      false
     end
     
     def extract_action_for_render(options)
@@ -84,7 +97,7 @@ module Liquidizer
         action_name
       else
         nil
-      end 
+      end
     end
 
     UNLIQUIFIABLE_OPTIONS = [:partial, :template, :file, :text, :xml, :json, :js, :inline]
@@ -105,11 +118,15 @@ module Liquidizer
     end
 
     def liquid_template_name_for_action(action)
-      liquid_template_names_for_actions[action.to_sym] || infer_liquid_template_name(action)
+      "#{controller_path}/#{action}"
     end
 
-    def infer_liquid_template_name(action)
-      "#{controller_path}/#{action}"
+    def liquid_template_name_for_layout(options)
+      case layout = self.class.read_inheritable_attribute(:layout)
+        when Symbol then __send__(layout)
+        when Proc   then layout.call(self)
+        else layout
+      end
     end
 
     def find_liquid_template(name)
@@ -130,8 +147,7 @@ module Liquidizer
         assign_name = name[/^@(.*)$/, 1]           # strip @
         next memo if assign_name.starts_with?('_') # skip "private" ivars
 
-        value = instance_variable_get(name)
-        value = dropify(value) unless value.respond_to?(:to_liquid)
+        value = dropify(instance_variable_get(name))
 
         memo[assign_name] = value if value
         memo
@@ -142,8 +158,16 @@ module Liquidizer
     #
     #   Foo::Bar -> Foo::BarDrop
     def dropify(value)
-      drop_class = infer_drop_class(value)
-      drop_class && drop_class.new(value)
+      if value.respond_to?(:to_liquid)
+        if value.is_a?(Array)
+          value.map { |element| dropify(element) }
+        else
+          value
+        end
+      else
+        drop_class = infer_drop_class(value)
+        drop_class && drop_class.new(value)
+      end
     end
 
     def infer_drop_class(value)
@@ -153,62 +177,29 @@ module Liquidizer
       Support.constant_defined?(name) ? name.constantize : nil
     end
 
+    def set_liquid_file_system
+      Liquid::Template.file_system = FileSystem.new { current_liquid_templates }
+    end
+
     module ClassMethods
-      # Define actions to liquify (render with liquid templates).
+      # Enables liquid rendering.
       #
       # == Examples
       #
       #     # liquify all actions
       #     liquify
       #
-      #     # also liquify all actions
-      #     liquify :all
-      #
       #     # liquify only show and index
-      #     liquify :show, :index  
-      #
-      #     # liquify only edit, but use template called awesome_edit
-      #     liquify :edit, :as => 'awesome_edit'
-      #
-      # Unless you specify template name with the :as options, the name will be
-      # inferend from controller and action names thusly:
-      #
-      # controller Blog, action :index        - blogs/index
-      # controller Blog, action :show         - blogs/show
-      # controller Blog, action :edit         - blogs/edit
-      #
-      # controller Blog::Post, action :index  - blog/posts/index
-      # controller Blog::Post, action :show   - blog/posts/show
-      # controller Blog::Post, action :edit   - blog/posts/edit
-      #
-      # You've got the idea.
-      #
-      def liquify(*actions)
-        options = actions.extract_options!
-        actions = actions.map(&:to_sym)
-
-        self.liquify_actions = actions.empty? ? :all : actions
-        self.liquid_template_names_for_actions = {}
-
-        if options[:as]
-          actions.each do |action|
-            self.liquid_template_names_for_actions[action] = options[:as]
-          end        
-        end
-      end
-
-      # Liquify the layout.
-      #
-      # == Examples
+      #     liquify :only => [:show, :index]
       #
-      #     # Uses layout template "layout"
-      #     liquify_layout
+      #     # liquify all except show and index
+      #     liquify :except => [:show, :index]
       #
-      #     # Uses layout template "wicked_layout"
-      #     liquify_layout :as => 'wicked_layout'
+      #     # liquify all, but do not liquify layout
+      #     liquify :layout => false
       #
-      def liquify_layout(options = {})
-        self.liquid_template_name_for_layout = options[:as] || 'layout'
+      def liquify(options = {})
+        self.liquidizer_options = options.reverse_merge(:actions => true, :layout => true)
       end
     end
   end

data/lib/liquidizer/file_system.rb

@@ -0,0 +1,13 @@
+module Liquidizer
+  # File system for liquid that loads the templates from the database
+  class FileSystem
+    def initialize(&block)
+      @source = block
+    end
+
+    def read_template_file(template_path)
+      record = @source.call.find_by_name(template_path)
+      record && record.content
+    end
+  end
+end

data/lib/liquidizer/liquid_template.rb

@@ -6,10 +6,10 @@ module Liquidizer
 
     module ClassMethods
       def find_by_name(name)
-        first(:conditions => {:name => name}) || load_default(name)
+        first(:conditions => {:name => name}) || find_default_by_name(name)
       end
 
-      def load_default(name)
+      def find_default_by_name(name)
         file_name = File.join(Liquidizer.template_path, name) + '.liquid'
 
         if File.exist?(file_name)

data/lib/liquidizer/support.rb

@@ -2,16 +2,9 @@ module Liquidizer
   module Support
     # This is like Object.const_defined?, but works with namespaced constants (Foo::Bar::Baz).
     def self.constant_defined?(name)
-      base = Object
-      name.split('::').each do |name|
-        if base.const_defined?(name)
-          base = base.const_get(name)
-        else
-          return false
-        end
-      end
-
-      true
+      name.constantize && true
+    rescue NameError
+      false
     end
   end
 end

data/liquidizer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{liquidizer}
-  s.version = "0.1.0"
+  s.version = "0.4.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Cig\303\241nek"]
-  s.date = %q{2010-03-04}
+  s.date = %q{2010-03-09}
   s.description = %q{WIth this gem, you can render your Ruby on Rails views with liquid templates that are loaded from database. This way, the look and feel of your site can be safely configured by it's users.
 }
   s.email = %q{adam.ciganek@gmail.com}
@@ -24,15 +24,19 @@ Gem::Specification.new do |s|
      "app/models/liquid_template.rb",
      "lib/liquidizer.rb",
      "lib/liquidizer/controller_extensions.rb",
+     "lib/liquidizer/file_system.rb",
      "lib/liquidizer/liquid_template.rb",
      "lib/liquidizer/migration_extensions.rb",
      "lib/liquidizer/support.rb",
      "liquidizer.gemspec",
      "rails/init.rb",
      "test/controller_extensions_test.rb",
+     "test/file_system_test.rb",
+     "test/fixtures/comments/_stuff.html.erb",
      "test/fixtures/comments/index.html.erb",
+     "test/fixtures/layouts/layout.html.erb",
      "test/fixtures/posts/index.liquid",
-     "test/fixtures/ratings/_stuff.html.erb",
+     "test/fixtures/posts/show.html.erb",
      "test/fixtures/ratings/edit.html.erb",
      "test/fixtures/spams/index.html.erb",
      "test/liquid_template_test.rb",
@@ -48,7 +52,8 @@ Gem::Specification.new do |s|
     "test/support_test.rb",
      "test/liquid_template_test.rb",
      "test/controller_extensions_test.rb",
-     "test/test_helper.rb"
+     "test/test_helper.rb",
+     "test/file_system_test.rb"
   ]
 
   if s.respond_to? :specification_version then

data/test/controller_extensions_test.rb

@@ -11,10 +11,12 @@ class BaseController < ActionController::Base
 end
 
 class PostsController < BaseController
+  layout 'layout'
   liquify
 
   def index
     @title = 'Hello blog!' 
+    @posts = [Post.new(:title => 'First post'), Post.new(:title => 'Second post')]
   end
 
   def show
@@ -28,32 +30,26 @@ class PostsController < BaseController
   def create
     render :status => :created
   end
-end
-
-class CommentsController < BaseController
-  liquify :show
-  liquify :edit, :as => 'funky_comments_edit'
 
-  def index
-  end
-
-  def show
+  def new
+    render :template => 'more_awesome_new'
   end
 
   def edit
+    render :layout => 'awesome_layout'
   end
 end
 
-class RatingsController < BaseController
-  liquify :show
-  liquify_layout
+class CommentsController < BaseController
+  layout 'layout'
+  liquify :only => :show
 
-  def show
+  def index
   end
 
-  def edit
+  def show
   end
-
+  
   def new
     render :partial => 'stuff'
   end
@@ -63,7 +59,16 @@ class RatingsController < BaseController
   end
 end
 
+class RatingsController < BaseController
+  liquify :layout => false
+
+  def show
+  end
+end
+
 class SpamsController < BaseController
+  layout 'layout'
+
   def index
   end
 end
@@ -130,13 +135,23 @@ class ControllerExtensionsTest < ActionController::TestCase
   test 'renders with liquid template when explicit action specified' do
     setup_controller(PostsController)
 
-    LiquidTemplate.create!(:name => 'posts/edit',   :content => "<p>edit post</p>")
+    LiquidTemplate.create!(:name => 'posts/edit', :content => "<p>edit post</p>")
     LiquidTemplate.create!(:name => 'posts/update', :content => "<p>update post</p>")
 
     get :update
     assert_select 'p', 'edit post'
   end
   
+  test 'renders with liquid template when explicit template specified' do
+    setup_controller(PostsController)
+
+    LiquidTemplate.create!(:name => 'more_awesome_new', :content => "<p>more awesome new</p>")
+    LiquidTemplate.create!(:name => 'posts/new', :content => "<p>less awesome new</p>")
+
+    get :new
+    assert_select 'p', 'more awesome new'
+  end
+  
   test 'preserves additional render options' do
     setup_controller(PostsController)
     
@@ -157,23 +172,13 @@ class ControllerExtensionsTest < ActionController::TestCase
     setup_controller(SpamsController)
 
     get :index
-    assert_select 'h1', 'This is not liquid template'
-  end
-
-  test 'renders with liquid template with custom name' do
-    setup_controller(CommentsController)
-
-    LiquidTemplate.create!(:name => 'comments/edit', :content => "<p>default edit</p>")
-    LiquidTemplate.create!(:name => 'funky_comments_edit', :content => "<p>funky edit</p>")
-
-    get :edit
-    assert_select 'p', 'funky edit'
+    assert_select '#layout h1', 'This is not liquid template'
   end
 
   test 'renders liquid template with liquid layout' do
-    setup_controller(RatingsController)
+    setup_controller(PostsController)
 
-    LiquidTemplate.create!(:name => 'ratings/show', :content => '<p>This is liquid template</p>')
+    LiquidTemplate.create!(:name => 'posts/show', :content => '<p>This is liquid template</p>')
     LiquidTemplate.create!(:name => 'layout',
                            :content => '<div id="layout">{{ content_for_layout }}</div>')
 
@@ -182,17 +187,45 @@ class ControllerExtensionsTest < ActionController::TestCase
   end
   
   test 'renders solid template with liquid layout' do
-    setup_controller(RatingsController)
+    setup_controller(PostsController)
 
     LiquidTemplate.create!(:name => 'layout',
                            :content => '<div id="layout">{{ content_for_layout }}</div>')
 
-    get :edit
+    get :show
     assert_select '#layout p', 'This is not liquid template'
   end
 
-  test 'does not apply liquid layout to render :partial' do
+  # TODO: make this pass
+  # test 'renders with overriden liquid layout' do
+  #   setup_controller(PostsController)
+
+  #   LiquidTemplate.create!(
+  #     :name => 'awesome_layout',
+  #     :content => '<div id="awesome_layout">{{ content_for_layout }}</div>')
+
+  #   LiquidTemplate.create!(
+  #     :name => 'layout',
+  #     :content => '<div id="layout">{{ content_for_layout }}</div>')
+
+  #   get :edit
+  #   assert_select '#awesome_layout p'
+  # end
+  
+  test 'does not render liquid layout if disabled' do
     setup_controller(RatingsController)
+
+    LiquidTemplate.create!(:name => 'ratings/show', :content => '<p>This is liquid template</p>')
+    LiquidTemplate.create!(:name => 'layout',
+                           :content => '<div id="layout">{{ content_for_layout }}</div>')
+
+    get :show
+    assert_select 'p', 'This is liquid template'
+    assert_select '#layout', false
+  end
+  
+  test 'does not apply liquid layout to render :partial' do
+    setup_controller(CommentsController)
     
     LiquidTemplate.create!(:name => 'layout',
                            :content => '<div id="layout">{{ content_for_layout }}</div>')
@@ -202,7 +235,7 @@ class ControllerExtensionsTest < ActionController::TestCase
   end
   
   test 'does not apply liquid layout to render :text' do
-    setup_controller(RatingsController)
+    setup_controller(CommentsController)
     
     LiquidTemplate.create!(:name => 'layout',
                            :content => '<div id="layout">{{ content_for_layout }}</div>')
@@ -229,6 +262,30 @@ class ControllerExtensionsTest < ActionController::TestCase
     get :show
     assert_select 'h1 strong', 'Liquidizer is awesome!'
   end
+  
+  test 'dropifies array elements' do
+    setup_controller(PostsController)
+
+    LiquidTemplate.create!(:name => 'posts/index',
+                           :content => '{% for post in posts %} {{ post.title }} {% endfor %}')
+
+    get :index
+    assert_select 'em', 'First post'
+    assert_select 'em', 'Second post'
+  end
+
+  test 'renders partials' do
+    setup_controller(PostsController)
+
+    LiquidTemplate.create!(:name => 'posts/show',
+                           :content => '<p>This is a template</p> {% include "cool_partial" %}')
+    LiquidTemplate.create!(:name => 'cool_partial',
+                           :content => '<p>This is a partial</p>')
+
+    get :show
+    assert_select 'p', 'This is a template'
+    assert_select 'p', 'This is a partial' 
+  end
 
   private
 

data/test/file_system_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'liquidizer/file_system'
+
+class FileSystemTest < ActiveSupport::TestCase
+  def setup
+    LiquidTemplate.destroy_all
+  end
+
+  test 'reads templates from the database' do
+    LiquidTemplate.create!(:name => 'posts/index', :content => 'These are posts')
+    LiquidTemplate.create!(:name => 'comments/show', :content => 'This is a comment')
+
+    file_system = Liquidizer::FileSystem.new { LiquidTemplate }
+
+    assert_equal 'These are posts', file_system.read_template_file('posts/index')
+    assert_equal 'This is a comment', file_system.read_template_file('comments/show')
+  end
+end

data/test/fixtures/layouts/layout.html.erb

@@ -0,0 +1 @@
+<div id="layout"><%= yield %></div>

data/test/fixtures/posts/show.html.erb

@@ -0,0 +1 @@
+<p>This is not liquid template</p>

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 0
-  version: 0.1.0
+  - 4
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - "Adam Cig\xC3\xA1nek"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 +01:00
+date: 2010-03-09 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,15 +49,19 @@ files:
 - app/models/liquid_template.rb
 - lib/liquidizer.rb
 - lib/liquidizer/controller_extensions.rb
+- lib/liquidizer/file_system.rb
 - lib/liquidizer/liquid_template.rb
 - lib/liquidizer/migration_extensions.rb
 - lib/liquidizer/support.rb
 - liquidizer.gemspec
 - rails/init.rb
 - test/controller_extensions_test.rb
+- test/file_system_test.rb
+- test/fixtures/comments/_stuff.html.erb
 - test/fixtures/comments/index.html.erb
+- test/fixtures/layouts/layout.html.erb
 - test/fixtures/posts/index.liquid
-- test/fixtures/ratings/_stuff.html.erb
+- test/fixtures/posts/show.html.erb
 - test/fixtures/ratings/edit.html.erb
 - test/fixtures/spams/index.html.erb
 - test/liquid_template_test.rb
@@ -98,3 +102,4 @@ test_files:
 - test/liquid_template_test.rb
 - test/controller_extensions_test.rb
 - test/test_helper.rb
+- test/file_system_test.rb