liquid_cms 0.2.0

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/README.textile

@@ -0,0 +1,86 @@
+h1. Will Paginate Liquidized
+
+h2. About
+
+A small plugin allowing you to use pagination from "will_paginate":http://wiki.github.com/mislav/will_paginate inside your "Liquid":http://github.com/tobi/liquid/tree/master templates. This is a new version of the "older plugin":http://www.artweb-design.de/projects/ruby-on-rails-plugin-will_paginate-liquidized at artweb-design.  I've basically re-written parts of it to work with the very latest versions of Liquid and Will-Paginate (see below for the version information). I will try to keep this plugin up to date with ongoing changes in the Liquid and Will-Paginate projects.  Check the latest commit logs and this doc for more information.
+
+h2. Caveats
+
+Ongoing issues with this project include;
+
+* needs better tests, possibly switching to using RSpec
+* currently has only been tested within my own project - needs further testing
+
+h2. Setup / Using
+
+h3. Requirements
+
+What do you need?
+
+* "Rails":http://rubyonrails.org >= 2.2 
+* "Liquid":http://github.com/tobi/liquid/tree/master >= 2.0.0 (as a gem or plugin)
+* "Will-Paginate":http://wiki.github.com/mislav/will_paginate >= 2.3.8 (as a gem or plugin)
+
+h3. Installing
+
+<pre>script/plugin install git://github.com/hiddenloop/will_paginate-liquidized.git</pre>
+
+h2. Using
+
+In your controller you might have something like this;
+
+<pre>
+  class MoviesController < ApplicationController
+    # GET /movies
+    # GET /movies.xml
+    def index
+      @movies = Movie.all.paginate(:page => params[:page], :per_page => 10)
+      respond_to do |format|
+        format.html # index.html.erb
+        format.xml  { render :xml => @movies }
+      end
+    end
+  end
+</pre>
+
+In your view put something like this in movies/index.html.erb;
+
+<pre>
+  <%= Liquid::Template.parse("{{ movies | will_paginate_liquid }}").render({'movies' => @movies}, :registers => {:controller => @controller}) %>  
+</pre>
+
+*NOTE:* you must remember to pass the current controller in rendering (:registers). If anyone can think of a way around this let me know.
+
+You won't get any pagination links until you exceed 10 (per_page setting defined in controller action). You can also pass the following other optional arguments to the will_paginate_liquid method.
+
+<pre>
+  {{ movies | will_paginate_liquid : 'anchor', 'prev_label', 'next_label' }}
+  
+  anchor: apply a #anchor to all generated urls in the pagination
+  prev_label: label for the previous page button
+  next_label: label for the next page button
+</pre>
+
+
+h2. What does the code do?
+
+Registers a new filter tag for Liquid to access will_paginate using a custom LinkRenderer so it can reference the @controller from the current liquid context[:registers]. Uses ActionView::Helpers::UrlHelper, ActionView::Helpers::TagHelper for constructing the pagination links.
+
+h2. Credits
+
+Who's who?
+
+* Authored by "Matthew Hutchinson":http://matthewhutchinson.net
+* Modified from the original plugin at "Artweb Design":http://www.artweb-design.de/projects/ruby-on-rails-plugin-will_paginate-liquidized
+* "Will-Paginate":http://wiki.github.com/mislav/will_paginate by "mislav":http://wiki.github.com/mislav/
+* "Liquid":http://github.com/tobi/liquid/tree/master by "tobi":http://github.com/tobi
+
+h2. Get out clause
+
+Right now this script is provided without warranty, or support from the author.
+
+h2. Creative Commons License
+
+<a rel="license" href="http://creativecommons.org/licenses/by/2.0/uk/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by/2.0/uk/80x15.png" /></a>
+
+<span xmlns:dc="http://purl.org/dc/elements/1.1/" property="dc:title">Will Paginate Liquidized</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="http://github.com/hiddenloop/will_paginate-liquidized" property="cc:attributionName" rel="cc:attributionURL">Matthew Hutchinson</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by/2.0/uk/">Creative Commons Attribution 2.0 UK: England &amp; Wales License</a>.

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/init.rb

@@ -0,0 +1,2 @@
+# register the WillPaginate Liquid filter - fall through if class doesn't exist
+Liquid::Template.register_filter(WillPaginate::Liquidized::ViewHelpers) rescue nil

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/lib/will_paginate/liquidized.rb

@@ -0,0 +1,35 @@
+module WillPaginate::Liquidized
+  def self.included(base)
+    WillPaginate::Collection.class_eval do 
+      def to_liquid
+        WillPaginate::CollectionDrop.new self    
+      end
+
+      def collect(&block)    
+        dup.replace super.collect(&block)
+      end
+    end  
+  end
+  
+  class CollectionDrop < Liquid::Drop
+    attr_reader :source
+  
+    def initialize(source)
+      @source = source
+    end
+    
+    def [](*args)
+      return @source[*args]
+    end
+    
+    def method_missing(method, &block)
+     allow = [:current_page, :per_page, :total_entries, :offset, :total_pages, 
+              :previous_page, :next_page, :empty?, :length, :sort_by]
+     unless allow.include? method
+       super.method_missing method, &block
+     else
+        @source.send method, &block
+      end
+    end
+  end
+end

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/lib/will_paginate/liquidized/view_helpers.rb

@@ -0,0 +1,98 @@
+module WillPaginate::Liquidized   
+  module ViewHelpers
+    include WillPaginate::ViewHelpers
+    
+    #def will_paginate_liquid(collection, anchor = nil, prev_label = nil, next_label = nil)      
+    def paginate_links(collection, anchor = nil, prev_label = nil, next_label = nil)      
+      opts = {}
+      opts[:previous_label] = prev_label if prev_label
+      opts[:next_label]     = next_label if next_label      
+      opts[:params]         = {:anchor => anchor} if anchor
+      opts[:controller]     = @context.registers[:controller]
+      
+      with_renderer 'WillPaginate::Liquidized::LinkRenderer' do 
+        will_paginate *[collection, opts].compact
+      end
+    end
+    
+  protected
+    def with_renderer(renderer)
+      old_renderer, options[:renderer] = options[:renderer], renderer
+      result = yield
+      options[:renderer] = old_renderer
+      result
+    end
+    
+    def options
+      WillPaginate::ViewHelpers.pagination_options
+    end
+  end
+
+  class LinkRenderer < WillPaginate::LinkRenderer
+    
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::TagHelper 
+
+    def to_html
+      return "<p><strong style=\"color:red;\">(Will Paginate Liquidized) Error:</strong> you must pass a controller in Liquid render call; <br/>
+              e.g. Liquid::Template.parse(\"{{ movies | will_paginate_liquid }}\").render({'movies' => @movies}, :registers => {:controller => @controller})</p>" unless @options[:controller]
+      
+      links = @options[:page_links] ? windowed_links : []
+      # previous/next buttons added in to the links collection
+      links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:previous_label])
+      links.push    page_link_or_span(@collection.next_page,     'disabled next_page', @options[:next_label])
+      
+      html = links.join(@options[:separator])
+      html_attributes.delete(:controller)
+      @options[:container] ? content_tag(:div, html, html_attributes) : html
+    end
+    
+    def page_link(page, text, attributes = {})
+      link_to text, url_for_page(page), attributes
+    end
+
+    def page_span(page, text, attributes = {})
+      content_tag :span, text, attributes
+    end
+              
+    def url_for_page(page)
+      page_one = page == 1
+      unless @url_string and !page_one
+        @url_params = {}
+        @controller = @options[:controller]
+        # page links should preserve GET parameters
+        stringified_merge @url_params, @controller.params if @controller && @controller.request.get? && @controller.params
+        stringified_merge @url_params, @options[:params] if @options[:params]
+        
+        if complex = param_name.index(/[^\w-]/)
+          page_param = (defined?(CGIMethods) ? CGIMethods : ActionController::AbstractRequest).
+            parse_query_parameters("#{param_name}=#{page}")
+          
+          stringified_merge @url_params, page_param
+        else
+          @url_params[param_name] = page_one ? 1 : 2
+        end
+
+        url = @controller.url_for(@url_params)
+        url = "#{url}##{@options[:params][:anchor]}" if @options[:params] && @options[:params][:anchor]
+        return url if page_one
+        
+        if complex
+          @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, '\1@')
+          return url
+        else
+          @url_string = url
+          @url_params[param_name] = 3
+          @controller.url_for(@url_params).split(//).each_with_index do |char, i|
+            if char == '3' and url[i, 1] == '2'
+              @url_string[i] = '@'
+              break
+            end
+          end
+        end
+      end
+      # finally!
+      @url_string.sub '@', page.to_s
+    end
+  end  
+end        

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/spec/liquidized_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'WillPaginate::Liquidized' do
+  
+  before(:each) do
+    # setup
+  end
+
+  it "should return Collection Drop for collection to_liquid"
+  #do
+    #@collection.to_liquid.class.should eql(WillPaginate::Liquidized::CollectionDrop)
+  #end
+  
+  it "should allow access to collection drop methods"
+  # do
+  #   [:current_page, :per_page, :total_entries, :total_pages, :offset, 
+  #    :previous_page, :next_page, :empty?, :length ].each do |method|
+  #      assert_nothing_raised { @blogs.send method }
+  #   end
+  #   assert_nothing_raised { @blogs.sort_by do 1 end }
+  # end
+  
+  it "should allow array access to collection"
+  # do
+  #   assert_nothing_raised { assert_equal 1, @blogs[0] }  
+  # end
+  
+end

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'spec'
+require 'will_paginate'
+require 'will_paginate/view_helpers'
+require 'action_view'
+require 'liquid'
+
+require File.join(File.dirname(__FILE__), '/../lib/will_paginate/liquidized')
+require File.join(File.dirname(__FILE__), '/../lib/will_paginate/liquidized/view_helpers')
+

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/spec/view_helpers_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe WillPaginate::Liquidized::ViewHelpers do
+  
+  before(:each) do
+    # setup
+  end
+
+  it "should render pagination successfully from liquid template"
+  it "should respect will paginate options (anchor and link labels)"
+  
+end

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/will_paginate-liquidized/spec/will_paginate_liquidized_spec.rb

@@ -0,0 +1,37 @@
+describe 'Will Paginate Liquidized' do
+  
+  before(:each) do
+    # setup
+  end
+  
+  describe "liquidized collection drops" do
+    
+    it "should return Collection Drop for collection to_liquid"
+    #do
+      #@collection.to_liquid.class.should eql(WillPaginate::Liquidized::CollectionDrop)
+    #end
+    
+    it "should allow access to collection drop methods"
+    # do
+    #   [:current_page, :per_page, :total_entries, :total_pages, :offset, 
+    #    :previous_page, :next_page, :empty?, :length ].each do |method|
+    #      assert_nothing_raised { @blogs.send method }
+    #   end
+    #   assert_nothing_raised { @blogs.sort_by do 1 end }
+    # end
+    
+    it "should allow array access to collection"
+    # do
+    #   assert_nothing_raised { assert_equal 1, @blogs[0] }  
+    # end
+    
+  end
+  
+  describe "html pagination" do
+    
+    it "should render successfully from liquid template"
+    it "should respect will paginate options (anchor and link labels)"
+    
+  end
+  
+end

data/lib/liquid_cms.rb

@@ -0,0 +1,2 @@
+require 'liquid_cms/role_authentication'
+require 'liquid_cms/configuration'

data/lib/liquid_cms/configuration.rb

@@ -0,0 +1,32 @@
+require 'active_record/associations'
+require 'dispatcher'
+
+module Cms
+  autoload :Context, 'liquid_cms/context'
+  autoload :ContextAssociation, 'liquid_cms/context_association'
+  autoload :Association, 'association'
+
+  mattr_reader :context_class
+  def self.context_class=(klass)
+    @@context_class = klass
+    Dispatcher.to_prepare {
+      eval(klass.to_s).extend Cms::ContextAssociation
+
+      Cms::Page.belongs_to  :context, :class_name => klass.to_s
+      Cms::Asset.belongs_to :context, :class_name => klass.to_s
+    }
+  end
+  @@context_class = nil
+
+  def self.set_context(context, bind_to)
+    bind_to.instance_variable_set :@cms_context, context
+  end
+
+  def self.global_route(route_map)
+    route_map.connect '*url', :controller => 'cms/pages', :action => 'load'
+  end
+
+  def self.setup
+    yield self
+  end
+end

data/lib/liquid_cms/context.rb

@@ -0,0 +1,19 @@
+require 'liquid_cms/context_association'
+
+module Cms
+  class Context
+    attr_reader :object
+
+    def initialize(context = nil)
+      @object = context
+    end
+
+    def pages
+      @object ? @object.pages : Cms::Page.scoped(:extend => PageAssociationMethods)
+    end
+
+    def assets
+      @object ? @object.assets : Cms::Asset.scoped(nil)
+    end
+  end
+end

data/lib/liquid_cms/context_association.rb

@@ -0,0 +1,14 @@
+module Cms
+  module PageAssociationMethods
+    def root
+      first :conditions => {:root => true}
+    end
+  end
+
+  module ContextAssociation
+    def ContextAssociation.extended(other)
+      other.has_many :pages, :class_name => 'Cms::Page', :dependent => :destroy, :foreign_key => :context_id, :extend => PageAssociationMethods
+      other.has_many :assets, :class_name => 'Cms::Asset', :dependent => :destroy, :foreign_key => :context_id
+    end
+  end
+end

data/lib/liquid_cms/role_authentication.rb

@@ -0,0 +1,7 @@
+module Cms
+  module RoleAuthentication
+    def authenticate_user(role, action_options = {})
+      before_filter(action_options) {|controller| controller.authorize_role(role)}
+    end
+  end
+end

data/lib/liquid_cms/version.rb

@@ -0,0 +1,3 @@
+module Cms
+  VERSION = "0.2.0"
+end

data/liquid_cms.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/liquid_cms/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "liquid_cms"
+  s.version     = Cms::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Andrew Kaspick', 'Redline Software Inc.']
+  s.email       = ['andrew@redlinesoftware.com']
+  s.homepage    = "http://rubygems.org/gems/liquid_cms"
+  s.summary     = "A context aware Rails CMS engine using the Liquid template library."
+  s.description = "A context aware Rails CMS engine using the Liquid template library."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "liquid_cms"
+
+  s.add_dependency 'rails', '~> 2.3.5'
+  s.add_dependency 'paperclip', '~> 2.3.1'
+  s.add_dependency 'vestal_versions', '~> 1.0.1'
+  s.add_dependency 'simple_form', '~> 1.0.4'
+  s.add_dependency 'rubyzip', '~> 0.9.1'
+  s.add_dependency 'will_paginate', '~> 2.3.12'
+  s.add_dependency 'RedCloth'
+  s.add_dependency 'liquid', '~> 2.2.2'
+
+  s.add_development_dependency 'factory_girl', "~> 1.2.3"
+  s.add_development_dependency 'shoulda', "~> 2.10.3"
+
+  test_files = `git ls-files test/`.split("\n")
+  all_files  = `git ls-files`.split("\n")
+
+  s.files        = all_files - test_files
+  s.test_files   = test_files
+  s.executables  = all_files.map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/rails/init.rb

@@ -0,0 +1,46 @@
+require 'liquid_cms'
+require 'vestal_versions'
+require 'simple_form'
+require 'zip/zip'
+require 'will_paginate'
+require 'redcloth'
+
+config.to_prepare do
+  ApplicationController.helper(Cms::CommonHelper, Cms::AssetsHelper, Cms::ComponentsHelper, Cms::PagesHelper)
+end
+
+I18n.load_path += Dir[Rails.root.join('config', 'locales', 'cms', '*.{rb,yml}').to_s] 
+
+if defined?(Liquid)
+  # adds files to the load path
+  add_files_to_load_path = lambda {|dir|
+    path = File.expand_path(dir)
+    $LOAD_PATH << path
+    if ActiveSupport::Dependencies.respond_to?(:autoload_paths)
+      ActiveSupport::Dependencies.autoload_paths << path
+      ActiveSupport::Dependencies.autoload_once_paths.delete(path)
+    else
+      ActiveSupport::Dependencies.load_paths << path
+      ActiveSupport::Dependencies.load_once_paths.delete(path)
+    end
+    Dir[File.join(path, '*.rb')].each{|f| require f}
+  }
+
+  # add liquid files to load path
+  load_liquid_paths = lambda {|base|
+    add_files_to_load_path.call File.join(base, 'app', 'liquid')
+    %w{filters tags drops}.each do |dir|
+      add_files_to_load_path.call File.join(base, 'app', 'liquid', dir)
+    end
+  }
+
+  # load the cms paths first so that the main app can make use of existing classes
+  load_liquid_paths.call File.join(File.dirname(__FILE__), '..')
+  # load the main apps paths next
+  load_liquid_paths.call Rails.root.to_s
+end
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.human 'Cms::Page', 'Page'
+  inflect.human 'Cms::Asset', 'Asset'
+end