locomotive_cms 0.0.1

data/lib/locomotive/liquid/filters/date.rb

@@ -0,0 +1,30 @@
+module Locomotive  
+  module Liquid    
+    module Filters  
+      module Date
+    
+        def localized_date(input, *args)
+          format, locale = args[0], args[1] rescue 'en'
+      
+          date = input.is_a?(String) ? Time.parse(input) : input
+      
+          if format.to_s.empty?
+            return input.to_s
+          end
+      
+          date = input.is_a?(String) ? Time.parse(input) : input
+      
+          if date.respond_to?(:strftime)
+            I18n.locale = locale
+            I18n.l date, :format => format
+          else
+            input
+          end
+        end
+    
+      end
+  
+      ::Liquid::Template.register_filter(Date)      
+    end    
+  end  
+end

data/lib/locomotive/liquid/filters/html.rb

@@ -0,0 +1,114 @@
+module Locomotive
+  module Liquid  
+    module Filters  
+      module Html
+    
+        # Write the link to a stylesheet resource
+        # input: url of the css file
+        def stylesheet_tag(input)
+          return '' if input.nil?
+          input = "#{input}.css" unless input.ends_with?('.css')
+          %{<link href="#{input}" media="screen" rel="stylesheet" type="text/css" />}
+        end
+    
+        # Write the link to javascript resource
+        # input: url of the javascript file
+        def javascript_tag(input)
+          return '' if input.nil?
+          input = "#{input}.js" unless input.ends_with?('.js')
+           %{<script src="#{input}" type="text/javascript"></script>}
+        end
+    
+    
+        # Write an image tag
+        # input: url of the image OR asset drop
+        def image_tag(input, *args)
+          image_options = inline_options(args_to_options(args))
+          "<img src=\"#{File.join('/', get_path_from_asset(input))}\" #{image_options}/>"
+        end
+        
+        # Embed a flash movie into a page
+        # input: url of the flash movie OR asset drop
+        # width: width (in pixel or in %) of the embedded movie
+        # height: height (in pixel or in %) of the embedded movie
+        def flash_tag(input, *args)
+          path = get_path_from_asset(input)
+          embed_options = inline_options(args_to_options(args))
+          %{
+            <object #{embed_options}>
+              <param name="movie" value="#{path}" />
+              <embed src="#{path}" #{embed_options}/>
+              </embed>
+            </object>
+          }.gsub(/ >/, '>').strip
+        end
+
+        # Render the navigation for a paginated collection
+        def default_pagination(paginate, *args)
+          return '' if paginate['parts'].empty?
+      
+          options = args_to_options(args)
+      
+          previous_link = (if paginate['previous'].blank?
+            "<span class=\"disabled prev_page\">#{I18n.t('pagination.previous')}</span>"
+          else
+            "<a href=\"#{paginate['previous']['url']}\" class=\"prev_page\">#{I18n.t('pagination.previous')}</a>"
+          end)
+      
+          links = ""
+          paginate['parts'].each do |part|
+            links << (if part['is_link']
+              "<a href=\"#{part['url']}\">#{part['title']}</a>"
+            elsif part['hellip_break']
+              "<span class=\"gap\">#{part['title']}</span>"
+            else
+              "<span class=\"current\">#{part['title']}</span>"
+            end)
+          end
+      
+          next_link = (if paginate['next'].blank?
+            "<span class=\"disabled next_page\">#{I18n.t('pagination.next')}</span>"
+          else
+            "<a href=\"#{paginate['next']['url']}\" class=\"next_page\">#{I18n.t('pagination.next')}</a>"
+          end)
+      
+          %{<div class="pagination #{options[:css]}">
+              #{previous_link}
+              #{links}
+              #{next_link}
+            </div>}
+        end
+    
+        protected
+    
+        # Convert an array of properties ('key:value') into a hash
+        # Ex: ['width:50', 'height:100'] => { :width => '50', :height => '100' }
+        def args_to_options(*args)
+          options = {}
+          args.flatten.each do |a|
+            if (a =~ /^(.*):(.*)$/)
+              options[$1.to_sym] = $2
+            end
+          end
+          options
+        end
+    
+        # Write options (Hash) into a string according to the following pattern:
+        # <key1>="<value1>", <key2>="<value2", ...etc
+        def inline_options(options = {})
+          return '' if options.empty?
+          (options.stringify_keys.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ') << ' '
+        end
+    
+        # Get the path to be used in html tags such as image_tag, flash_tag, ...etc
+        # input: url (String) OR asset drop
+        def get_path_from_asset(input)
+          input.respond_to?(:url) ? input.url : input
+        end
+      end
+    
+      ::Liquid::Template.register_filter(Html)
+      
+    end  
+  end
+end

data/lib/locomotive/liquid/filters/misc.rb

@@ -0,0 +1,30 @@
+module Locomotive
+  module Liquid
+    module Filters  
+      module Misc
+    
+        def underscore(input)
+          input.to_s.gsub(' ', '_').gsub('/', '_').underscore
+        end
+    
+        def dasherize(input)
+          input.to_s.gsub(' ', '-').gsub('/', '-').dasherize
+        end
+    
+        def concat(input, *args)
+          result = input.to_s
+          args.flatten.each { |a| result << a.to_s }
+          result
+        end
+    
+        def modulo(word, index, modulo)
+          (index.to_i + 1) % modulo == 0 ? word : '' 
+        end
+    
+      end
+        
+      ::Liquid::Template.register_filter(Misc)
+      
+    end    
+  end
+end

data/lib/locomotive/liquid/liquify_template.rb

@@ -0,0 +1,57 @@
+module Locomotive  
+  module Liquid      
+    module LiquifyTemplate
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Store the parsed version of a liquid template into a column in order to increase performance
+      # See http://cjohansen.no/en/rails/liquid_email_templates_in_rails 
+      #
+      # class Page
+      #   liquify_template :body
+      # end
+      #
+      # page = Page.new :body => '...some liquid tags'
+      # page.template # Liquid::Template
+      # 
+      #
+      module ClassMethods
+
+        def liquify_template(source = :value)
+          field :serialized_template, :type => Binary
+          before_validate :store_template
+          
+          class_eval <<-EOV
+            def liquify_template_source
+              self.send(:#{source.to_s})
+            end
+          EOV
+          
+          include InstanceMethods
+        end
+
+      end
+      
+      module InstanceMethods
+        
+        def template
+          Marshal.load(read_attribute(:serialized_template).to_s) rescue nil
+        end
+                
+        protected
+        
+        def store_template
+          begin
+            template = ::Liquid::Template.parse(self.liquify_template_source)
+            self.serialized_template = BSON::Binary.new(Marshal.dump(template))
+          rescue ::Liquid::SyntaxError => error
+            self.errors.add :template, :liquid_syntax_error
+          end
+        end
+        
+      end      
+    end          
+  end  
+end

data/lib/locomotive/liquid/tags/blueprint.rb

@@ -0,0 +1,21 @@
+module Locomotive
+  module Liquid    
+    module Tags    
+      class Blueprint < ::Liquid::Tag
+      
+        def render(context)
+          %{
+            <link href="/stylesheets/admin/blueprint/screen.css" media="screen, projection" rel="stylesheet" type="text/css" />
+          	<link href="/stylesheets/admin/blueprint/print.css" media="print" rel="stylesheet" type="text/css" />
+          	<!--[if IE]>
+          		<link href="/stylesheets/admin/blueprint/ie.css" media="screen, projection" rel="stylesheet" type="text/css" />
+          	<![endif]-->
+          }
+        end
+      
+      end
+  
+      ::Liquid::Template.register_tag('blueprint_stylesheets', Blueprint)      
+    end  
+  end  
+end

data/lib/locomotive/liquid/tags/jquery.rb

@@ -0,0 +1,17 @@
+module Liquid  
+  module Locomotive  
+    module Tags    
+      class Jquery < ::Liquid::Tag
+
+        def render(context)
+          %{
+            <script src="/javascripts/jquery.js" type="text/javascript"></script>
+            <script src="/javascripts/jquery.ui.js" type="text/javascript"></script>
+          }
+        end
+      end
+  
+      ::Liquid::Template.register_tag('jQuery', Jquery)    
+    end  
+  end  
+end

data/lib/locomotive/liquid/tags/paginate.rb

@@ -0,0 +1,100 @@
+module Locomotive
+  
+  module Liquid
+
+      module Tags
+
+      # Paginate a collection
+      #
+      # Usage:
+      #
+      # {% paginate contents.projects by 5 %}
+      #   {% for project in paginate.collection %}
+      #     {{ project.name }}
+      #   {% endfor %}
+      #  {% endpaginate %}
+      #
+      
+      class Paginate < ::Liquid::Block
+  
+        Syntax = /(#{::Liquid::Expression}+)\s+by\s+([0-9]+)/
+  
+        def initialize(tag_name, markup, tokens)
+          if markup =~ Syntax
+            @collection_name = $1
+            @per_page = $2.to_i
+          else
+            raise SyntaxError.new("Syntax Error in 'paginate' - Valid syntax: paginate [collection] by [number]")
+          end
+    
+          super
+        end
+  
+        def render(context)
+          context.stack do
+            collection = context[@collection_name]
+      
+            raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection.nil?
+      
+            pagination = collection.paginate({
+              :page       => context['current_page'],
+              :per_page   => @per_page }).stringify_keys!
+      
+            page_count, current_page = pagination['total_pages'], pagination['current_page']
+      
+            path = context['page'].path rescue '/' 
+      
+            pagination['previous'] = link(I18n.t('pagination.previous'), current_page - 1, path) if pagination['previous_page']
+            pagination['next'] = link(I18n.t('pagination.next'), current_page + 1, path) if pagination['next_page']
+            pagination['parts'] = []
+
+            hellip_break = false
+
+            if page_count > 1
+              1.upto(page_count) do |page|
+                if current_page == page
+                  pagination['parts'] << no_link(page)
+                elsif page == 1
+                  pagination['parts'] << link(page, page, path)
+                elsif page == page_count - 1
+                  pagination['parts'] << link(page, page, path)
+                elsif page <= current_page - window_size or page >= current_page + window_size
+                  next if hellip_break
+                  pagination['parts'] << no_link('&hellip;')
+                  hellip_break = true
+                  next
+                else
+                  pagination['parts'] << link(page, page, path)
+                end
+
+                hellip_break = false
+              end
+            end        
+      
+            context['paginate'] = pagination
+      
+            render_all(@nodelist, context)
+          end
+        end
+  
+        private  
+  
+        def window_size
+          3
+        end
+  
+        def no_link(title)
+          { 'title' => title, 'is_link' => false, 'hellip_break' => title == '&hellip;' }
+        end
+
+        def link(title, page, path)
+          { 'title' => title, 'url' => path + "?page=#{page}", 'is_link' => true}
+        end
+      end
+
+      ::Liquid::Template.register_tag('paginate', Paginate)
+    end
+    
+  end
+  
+end

data/lib/locomotive/liquid/tags/snippet.rb

@@ -0,0 +1,42 @@
+module Locomotive
+  
+  module Liquid
+    
+    module Tags
+      
+      class Snippet < ::Liquid::Include
+    
+        def render(context)
+          site = context.registers[:site]
+      
+          partial = ::Liquid::Template.file_system.read_template_file(site, context[@template_name])
+      
+          variable = context[@variable_name || @template_name[1..-2]]
+      
+          context.stack do
+            @attributes.each do |key, value|
+              context[key] = context[value]
+            end
+
+            output = (if variable.is_a?(Array)          
+              variable.collect do |variable|            
+                context[@template_name[1..-2]] = variable
+                partial.render(context)
+              end
+            else
+              context[@template_name[1..-2]] = variable
+              partial.render(context)
+            end)
+        
+            output
+          end
+        end
+      end
+
+      ::Liquid::Template.register_tag('include', Snippet)  
+    
+    end
+  
+  end
+
+end

data/lib/locomotive/liquid/tags/with_scope.rb

@@ -0,0 +1,39 @@
+module Locomotive
+  module Liquid
+    module Tags
+      class WithScope < ::Liquid::Block
+    
+        def initialize(tag_name, markup, tokens)
+          @attributes = {}
+          markup.scan(::Liquid::TagAttributes) do |key, value|
+            @attributes[key] = value
+          end       
+          super
+        end
+  
+        def render(context)
+          context.stack do
+            context['with_scope'] = decode(@attributes)
+            render_all(@nodelist, context)
+          end
+        end
+    
+        private
+    
+        def decode(attributes)
+          attributes.each_pair do |key, value|
+            attributes[key] = (case value
+            when /true|false/ then value == 'true'
+            when /[0-9]+/ then value.to_i
+            when /'(\S+)'/ then $1
+            else
+              value
+            end)
+          end
+        end
+      end
+  
+      ::Liquid::Template.register_tag('with_scope', WithScope)    
+    end  
+  end  
+end