liquidizer 0.5.3 → 0.5.4

data/lib/liquidizer.rb

@@ -1,7 +1,8 @@
 require 'liquidizer/controller_extensions'
 require 'liquidizer/migration_extensions'
 require 'liquidizer/liquid_template'
-      
+require 'liquidizer/version'
+
 module Liquidizer
   # The path the default liquid templates are stored.
   mattr_accessor :template_paths

data/lib/liquidizer/controller_extensions.rb

@@ -37,7 +37,7 @@ module Liquidizer
           content = layout_template.render!(assigns.merge('content_for_layout' => content))
 
           render_without_liquid(options.merge(:text => content, :layout => false))
-        else    
+        else
           render_without_liquid(options, &block)
         end
       end
@@ -50,15 +50,15 @@ module Liquidizer
 
       unless name
         action = extract_action_for_render(options)
-        
+
         if action && liquify?(action)
-          name = liquid_template_name_for_action(action) 
+          name = liquid_template_name_for_action(action)
         end
       end
 
       name && find_and_parse_liquid_template(name)
     end
-    
+
     def liquify?(action)
       options = self.class.liquidizer_options
 
@@ -79,7 +79,7 @@ module Liquidizer
         nil
       end
     end
-    
+
     def liquify_layout?(options)
       if self.class.liquidizer_options[:layout]
         case options[:layout]
@@ -92,7 +92,7 @@ module Liquidizer
         false
       end
     end
-    
+
     def extract_action_for_render(options)
       if options.nil?
         action_name
@@ -105,12 +105,12 @@ module Liquidizer
       end
     end
 
-    UNLIQUIFIABLE_OPTIONS = [:partial, :file, :text, :xml, :json, :js, :inline]
+    UNLIQUIFIABLE_OPTIONS = [:partial, :file, :text, :xml, :json, :js, :inline, :nothing]
 
     def liquifiable_options?(options)
       (options.keys.map(&:to_sym) & UNLIQUIFIABLE_OPTIONS).empty?
     end
-    
+
     def find_and_parse_liquid_template(name)
       if template_record = find_liquid_template(name)
         template = Liquid::Template.parse(template_record.content)
@@ -147,7 +147,7 @@ module Liquidizer
     def assigns_for_liquify
       variable_names = instance_variable_names
       variable_names -= protected_instance_variables
-      
+
       variable_names.inject({}) do |memo, name|
         assign_name = name[/^@(.*)$/, 1]           # strip @
         next memo if assign_name.starts_with?('_') # skip "private" ivars

data/lib/liquidizer/version.rb

@@ -0,0 +1,3 @@
+module Liquidizer
+  VERSION = '0.5.4'
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 4
+  version: 0.5.4
 platform: ruby
 authors: 
 - "Adam Cig\xC3\xA1nek"
@@ -14,13 +14,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-01 00:00:00 +02:00
+date: 2010-12-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: liquid
+  name: actionpack
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: liquid
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -30,7 +58,7 @@ dependencies:
         - 0
         version: 2.0.0
   type: :runtime
-  version_requirements: *id001
+  version_requirements: *id003
 description: |
   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.
 
@@ -39,44 +67,23 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
-- .gitignore
-- README.rdoc
-- Rakefile
-- VERSION
-- 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/file_system.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/path_one/template_one.liquid
-- test/fixtures/path_two/template_one.liquid
-- test/fixtures/path_two/template_two.liquid
-- test/fixtures/posts/index.liquid
-- test/fixtures/posts/show.html.erb
-- test/fixtures/ratings/edit.html.erb
-- test/fixtures/spams/index.html.erb
-- test/liquid_template_test.rb
-- test/support_test.rb
-- test/test_helper.rb
+- lib/liquidizer/version.rb
+- lib/liquidizer.rb
 has_rdoc: true
 homepage: http://github.com/madadam/liquidizer
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -91,18 +98,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 7
+      version: 1.3.7
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Support for Ruby on Rails views powered by Liquid and loaded from database
-test_files: 
-- test/support_test.rb
-- test/liquid_template_test.rb
-- test/controller_extensions_test.rb
-- test/test_helper.rb
-- test/file_system_test.rb
+test_files: []
+

data/.gitignore

@@ -1 +0,0 @@
-pkg

data/README.rdoc

@@ -1,206 +0,0 @@
-= Liquidizer
-
-Liquidizer is a gem for Ruby on Rails that allows to render pages using templates stored in the
-database. It uses liquid (http://www.liquidmarkup.org/) templating system (thus the name),
-because it's easy to use, extend and it's safe to edit by users.
-
-One example of when you might want to use it is this: Let's say you want to have a blogging
-system where people can create their blogs about kittens, ninjas or vampires. Using this gem,
-you can allow them to edit the look and feel of their blog using just their browser. Every
-blog can have it's own set of templates.
-
-
-== Installation
-
-It's hosted on http://gemcutter.org. Add it to your source list if you don't have it already:
-
-    sudo gem source --add http://gemcutter.org
-
-Then install:
-
-    sudo gem install liquidizer
-
-And add this to your config/environment.rb:
-
-    config.gem 'liquidizer'
-
-== How to use
-
-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 PostsController < ApplicationController
-      # This will apply the templates to all actions in this controller.
-      liquify
-    end
-
-You can use the :only and :except options that work the same as for filters to limit the
-set of actions to liquify:
-
-    class PostsController < ApplicationController
-      liquify :only => [:show, :index]
-    end
-
-    class CommentsController < ApplicationController
-      liquify :except => :edit
-    end
-
-The +liquify+ macro is inherited, so if you want to apply liquid templates to all actions
-in all controller, put it into ApplicationController. You can fine-tune it in derived
-controllers, if you want:
-
-    class ApplicationController < ActionController::Base
-      liquify
-    end
-
-    class PostsController < ApplicationController
-      liquify :only => :show
-    end
-
-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
-      liquify :layout => false
-    end
-
-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
-this is completely up to you. For example, you can associate the templates with the Blog model
-(to follow the blog example) and have something like current_blog, which is loaded by the
-current subdomain.
-
-In any case, you need to provide a +current_liquid_templates+ method,
-which should return collection of liquid templates to use. This method should return something
-that responds at least to +find_by_name+ which returns an object that responds to +content+
-which returns a string containing the liquid template.
-
-The easies way to do this, is to have a +LiquidTemplate+ model and return a collections of
-those in the +current_liquid_templates+. Liquidizer provides one such model for you,
-but you will probably want to use your own. To make your life easier, there is a module
-Liquidizer::LiquidTemplate which you can include into your template model to extend it with
-some helpful methods (see the docs for more info):
-
-    class Blog < ActiveRecord::Base
-      has_many :liquid_templates
-    end
-
-    # The 
-    class LiquidTemplate < ActiveRecord::Base
-      include Liquidizer::LiquidTemplate
-      belongs_to :blog
-    end
-
-    class ApplicationController < ActionController::Base
-      private
-
-      def current_liquid_templates
-        current_blog.liquid_templates
-      end
-    end
-
-And that's it. You are now ready to kick asses!
-
-== Instance variables
-
-All instance variables that you assign in the controller are automatically available in the
-liquid templates. The variable will be automatically wrapped in a "drop", if necessary
-(please check the liquid docs for more details about what types can be passed directly to
-liquid templates and what are drops). For a class +Foo+, a +FooDrop+ will be used if it
-exists. If variable is not compatible with liquid and there is no corresponding drop class, it
-won't be passed to the template.
-
-Example: 
-
-A controller:
-
-    class PostsController < ActiveRecord::Base
-      liquify
-
-      def show
-        @post = current_blog.posts.find(params[:id])
-      end
-    end
-
-A drop:
-
-    class PostDrop < Liquid::Drop
-      def initialize(post)
-        @post = post
-      end
-
-      def title
-        filter_nasty_stuff(@post.title)
-      end
-    end
-
-Then you can do this in your liquid template:
-
-    <h1>{{ post.title }}</h1>
-
-    <!-- more stuff ... -->
-
-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.
-
-== Default templates
-
-The Liquidizer::LiquidTemplate module gives your model capability to fallback to a default
-template, if one is not found in the database. The default templates are stored in
-db/liquid_templates. You can configure this location by setting the Liquidizer.template_path:
-
-    Liqduidizer.template_path = Rails.root.join('app', 'views', 'liquid_templates')
-
-== TODO
-
-There are several possible improvements to this gem:
-
-- Extend it so it can handle different template systems in addition (unlikely, since I don't
-  need it and can't be bothered :) )
-
-- The Rails 3 has improved ActionView API and as far as I understand, abstracts away the
-  concept of template storage. Taking advantage of this could potentialy simplify this gem.
-  Also, support Rails 3 in general would be nice.
-
-- This does some nasty hacks into the ActionController::Base's render method. That method
-  originaly has quite liberal API, allowing to specify it's parameters in many ways. To make
-  this gem simple, some of those ways were sacrificed. Would be nice to support them too.
-
-Potentialy many more. In any case, it's open source project (MIT), so no fear, fork me and
-hack away!
-
-== Legal stuff
-
-Copyright (c) 2010 Adam Cigánek <adam.ciganek@gmail.com>. Released under the MIT License: www.opensource.org/licenses/mit-license.php

data/Rakefile

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'rake'
-require 'rake/testtask'
- 
-desc 'Default: run unit tests.'
-task :default => :test
- 
-desc 'Run unit tests.'
-Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-begin
-  require 'jeweler'
-
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name     = 'liquidizer'
-    gemspec.summary  = 'Support for Ruby on Rails views powered by Liquid and loaded from database'
-    gemspec.description = <<END
-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.
-END
-
-    gemspec.email    = 'adam.ciganek@gmail.com'
-    gemspec.homepage = 'http://github.com/madadam/liquidizer'
-    gemspec.authors  = ['Adam Cigánek']
-
-    gemspec.add_dependency 'liquid', '>= 2.0.0'
-  end
-
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end

data/VERSION

@@ -1 +0,0 @@
-0.5.3

data/app/models/liquid_template.rb

@@ -1,3 +0,0 @@
-class LiquidTemplate < ActiveRecord::Base
-  include Liquidizer::LiquidTemplate
-end

data/liquidizer.gemspec

@@ -1,75 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{liquidizer}
-  s.version = "0.5.3"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Adam Cigánek"]
-  s.date = %q{2010-06-01}
-  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}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "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/path_one/template_one.liquid",
-     "test/fixtures/path_two/template_one.liquid",
-     "test/fixtures/path_two/template_two.liquid",
-     "test/fixtures/posts/index.liquid",
-     "test/fixtures/posts/show.html.erb",
-     "test/fixtures/ratings/edit.html.erb",
-     "test/fixtures/spams/index.html.erb",
-     "test/liquid_template_test.rb",
-     "test/support_test.rb",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/madadam/liquidizer}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Support for Ruby on Rails views powered by Liquid and loaded from database}
-  s.test_files = [
-    "test/support_test.rb",
-     "test/liquid_template_test.rb",
-     "test/controller_extensions_test.rb",
-     "test/test_helper.rb",
-     "test/file_system_test.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<liquid>, [">= 2.0.0"])
-    else
-      s.add_dependency(%q<liquid>, [">= 2.0.0"])
-    end
-  else
-    s.add_dependency(%q<liquid>, [">= 2.0.0"])
-  end
-end
-

data/rails/init.rb

@@ -1 +0,0 @@
-require 'liquidizer'

data/test/controller_extensions_test.rb

@@ -1,315 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class BaseController < ActionController::Base
-  append_view_path File.dirname(__FILE__) + '/fixtures'
-
-  private
-
-  def current_liquid_templates
-    LiquidTemplate
-  end
-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
-    @post = Post.new(:title => 'Liquidizer is awesome!')
-  end
-
-  def update
-    render :action => 'edit'
-  end
-
-  def create
-    render :status => :created
-  end
-
-  def new
-    render :template => 'more_awesome_new'
-  end
-
-  def edit
-    render :layout => 'awesome_layout'
-  end
-end
-
-class CommentsController < BaseController
-  layout 'layout'
-  liquify :only => :show
-
-  def index
-  end
-
-  def show
-  end
-  
-  def new
-    render :partial => 'stuff'
-  end
-
-  def create
-    render :text => 'create'
-  end
-end
-
-class RatingsController < BaseController
-  liquify :layout => false
-
-  def show
-  end
-end
-
-class SpamsController < BaseController
-  layout 'layout'
-
-  def index
-  end
-end
-
-class Post
-  def initialize(attributes = {})
-    self.title = attributes[:title]
-  end
-
-  attr_accessor :title
-end
-
-class PostDrop < Liquid::Drop
-  def initialize(post)
-    @post = post
-  end
-
-  def title
-    "<em>#{@post.title}</em>"
-  end
-end
-
-module CoolDrops
-  class PostDrop < Liquid::Drop
-    def initialize(post)
-      @post = post
-    end
-
-    def title
-      "<strong>#{@post.title}</strong>"
-    end
-  end
-end
-
-class ControllerExtensionsTest < ActionController::TestCase
-  self.controller_class = nil
-
-  def setup
-    LiquidTemplate.destroy_all
-  end
-
-  def teardown
-    Liquidizer.drop_module = nil
-  end
-  
-  test 'renders with liquid template' do
-    setup_controller(PostsController)
-    
-    LiquidTemplate.create!(:name => 'posts/index', :content => "<p>This is liquid template</p>")
-
-    get :index
-    assert_select 'p', 'This is liquid template'
-  end
-
-  test 'passes instance variables to liquid template' do
-    setup_controller(PostsController)
-    
-    LiquidTemplate.create!(:name => 'posts/index', :content => "<h1>{{ title }}</h1>")
-
-    get :index
-    assert_select 'h1', /Hello blog!/
-  end
-
-  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/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)
-    
-    LiquidTemplate.create!(:name => 'posts/create', :content => "<p>create post</p>")
-
-    get :create
-    assert_response :created
-  end
-
-  test 'does not render with liquid template actions that were not liquified' do
-    setup_controller(CommentsController)
-
-    get :index
-    assert_select 'h1', 'This is not liquid template'
-  end
-
-  test 'does not render with liquid if liquify macro not called at all' do
-    setup_controller(SpamsController)
-
-    get :index
-    assert_select '#layout h1', 'This is not liquid template'
-  end
-
-  test 'renders liquid template with liquid layout' do
-    setup_controller(PostsController)
-
-    LiquidTemplate.create!(:name => 'posts/show', :content => '<p>This is liquid template</p>')
-    LiquidTemplate.create!(:name => 'layout',
-                           :content => '<div id="layout">{{ content_for_layout }}</div>')
-
-    get :show
-    assert_select '#layout p', 'This is liquid template'
-  end
-  
-  test 'renders solid template with liquid layout' do
-    setup_controller(PostsController)
-
-    LiquidTemplate.create!(:name => 'layout',
-                           :content => '<div id="layout">{{ content_for_layout }}</div>')
-
-    get :show
-    assert_select '#layout p', 'This is not liquid template'
-  end
-
-  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>')
-
-    LiquidTemplate.create!(
-      :name => 'posts/edit',
-      :content => '<p>Awesome liquid template</p>')
-
-    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>')
-
-    get :new
-    assert_select '#layout', false
-  end
-  
-  test 'does not apply liquid layout to render :text' do
-    setup_controller(CommentsController)
-    
-    LiquidTemplate.create!(:name => 'layout',
-                           :content => '<div id="layout">{{ content_for_layout }}</div>')
-
-    get :create
-    assert_select '#layout', false
-  end
-  
-  test 'applies liquid layout to render :template' do
-    setup_controller(PostsController)
-
-    LiquidTemplate.create!(:name => 'more_awesome_new', :content => "<p>more awesome new</p>")
-    LiquidTemplate.create!(:name => 'layout',
-                           :content => '<div id="layout">{{ content_for_layout }}</div>')
-
-    get :new
-    assert_select '#layout p', 'more awesome new'
-  end
-
-  test 'dropifies instance variables' do
-    setup_controller(PostsController)
-
-    LiquidTemplate.create!(:name => 'posts/show', :content => '<h1>{{ post.title }}</h1>')
-
-    get :show
-    assert_select 'h1 em', 'Liquidizer is awesome!'
-  end
-  
-  test 'dropifies instance variables using namespaced drop' do
-    setup_controller(PostsController)
-    Liquidizer.drop_module = CoolDrops
-
-    LiquidTemplate.create!(:name => 'posts/show', :content => '<h1>{{ post.title }}</h1>')
-
-    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
-
-  def setup_controller(controller_class)
-    self.class.prepare_controller_class(controller_class)
-  
-    # This is copied over from ActionController::TestCase.setup_controller_request_and_response
-    @controller = controller_class.new
-    @controller.request = @request
-    @controller.params = {}
-    @controller.send(:initialize_current_url)
-  end
-end

data/test/file_system_test.rb

@@ -1,18 +0,0 @@
-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/comments/_stuff.html.erb

@@ -1 +0,0 @@
-Stuff

data/test/fixtures/comments/index.html.erb

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

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

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

data/test/fixtures/path_one/template_one.liquid

@@ -1 +0,0 @@
-Default template one in path one

data/test/fixtures/path_two/template_one.liquid

@@ -1 +0,0 @@
-Default template one in path two

data/test/fixtures/path_two/template_two.liquid

@@ -1 +0,0 @@
-Default template two in path two

data/test/fixtures/posts/index.liquid

@@ -1,3 +0,0 @@
-<h1>Hello world</h1>
-
-<p>This is a liquid template.</p>

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

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

data/test/fixtures/ratings/edit.html.erb

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

data/test/fixtures/spams/index.html.erb

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

data/test/liquid_template_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class LiquidTemplateTest < ActiveSupport::TestCase
-  def setup
-    LiquidTemplate.delete_all
-    @old_template_paths = Liquidizer.template_paths
-  end
-
-  def teardown
-    Liquidizer.template_paths = @old_template_paths
-  end
-
-  test 'find_by_name finds template by name if it exists' do
-    one = LiquidTemplate.create!(:name => 'posts/index')
-    two = LiquidTemplate.create!(:name => 'posts/show')
-
-    assert_equal one, LiquidTemplate.find_by_name('posts/index')
-  end
-
-  test 'find_by_name fallbacks to default template' do
-    expected_content = File.read(File.dirname(__FILE__) + '/fixtures/posts/index.liquid')
-    found = LiquidTemplate.find_by_name('posts/index')
-
-    assert_equal expected_content, found.content
-  end
-
-  test 'find_by_name searches template in all template paths' do
-    Liquidizer.template_paths = [File.dirname(__FILE__) + '/fixtures/path_one',
-                                 File.dirname(__FILE__) + '/fixtures/path_two']
-
-    expected_one = File.read(File.dirname(__FILE__) + '/fixtures/path_one/template_one.liquid')
-    expected_two = File.read(File.dirname(__FILE__) + '/fixtures/path_two/template_two.liquid')
-
-    assert_equal expected_one, LiquidTemplate.find_by_name('template_one').content
-    assert_equal expected_two, LiquidTemplate.find_by_name('template_two').content
-  end
-
-  test 'find_by_name returns nil if not even default template exists' do
-    assert_nil LiquidTemplate.find_by_name('ninjas!')
-  end
-end

data/test/support_test.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-module Foo
-  class Bar
-  end
-
-  class Awesomeness
-  end
-end
-
-class Bar
-end
-
-class SupportTest < ActiveSupport::TestCase
-  test 'constant_defined? with non-namespaced constant' do
-    assert  Liquidizer::Support.constant_defined?('Bar')
-    assert !Liquidizer::Support.constant_defined?('Baz')
-  end
-  
-  test 'constant_defined? with namespaced constant' do
-    assert  Liquidizer::Support.constant_defined?('Foo::Bar')
-    assert !Liquidizer::Support.constant_defined?('Foo::Baz')
-  end
-end

data/test/test_helper.rb

@@ -1,24 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'action_controller'
-require 'active_record'
-require 'active_support/test_case'
-
-$: << File.dirname(__FILE__) + '/../lib'
-$: << File.dirname(__FILE__) + '/../app/models'
-
-require 'liquidizer'
-require 'liquid_template'
-
-Liquidizer.template_paths = [File.dirname(__FILE__) + '/fixtures']
-
-# Establish a temporary sqlite3 db for testing.
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-ActiveRecord::Base.logger # instantiate logger
-ActiveRecord::Schema.define(:version => 1) do
-  create_liquid_templates_table
-end
-
-ActionController::Routing::Routes.draw do |map|
-  map.connect ':controller/:action/:id'
-end