liquid4-rails5 0.1.5

data/lib/liquid-rails/rspec/tag_example_group.rb

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module Rspec
+      module TagExampleGroup
+        extend ActiveSupport::Concern
+        include Liquid::Rails::Rspec::ViewControllerContext
+
+        included do
+          metadata[:type] = :tag
+
+          before(:all) { setup_view_and_controller }
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  if RSpec::Core::Version::STRING.starts_with?('3')
+    config.include Liquid::Rails::Rspec::TagExampleGroup, type: :tag, file_path: %r(spec/tags)
+  else
+    config.include Liquid::Rails::Rspec::TagExampleGroup, type: :tag, example_group: { file_path: %r{spec/tags} }
+  end
+end

data/lib/liquid-rails/rspec/view_controller_context.rb

@@ -0,0 +1,45 @@
+module Liquid
+  module Rails
+    module Rspec
+      module ViewControllerContext
+        extend ActiveSupport::Concern
+
+        def setup_view_and_controller
+          @view                 = ActionView::Base.new
+          @controller           = ApplicationController.new
+          @request              = ActionController::TestRequest.new('PATH_INFO' => '/')
+          @response             = ActionController::TestResponse.new
+          @response.request     = @request
+          @controller.request   = @request
+          @controller.response  = @response
+          @controller.params    = {}
+          @view.assign_controller(@controller)
+          @view.class.send(:include, @controller._helpers)
+          @view.class.send(:include, ::Rails.application.routes.url_helpers)
+        end
+
+        def view
+          @view
+        end
+
+        def controller
+          @controller
+        end
+
+        def context(assigns={})
+          @context ||= ::Liquid::Context.new(assigns, {}, { helper: @view, view: @view, controller: @controller })
+        end
+
+        def expect_template_result(template, expected, assigns={})
+          # make assigns available inside context
+          assigns.each do |key, value|
+            context[key] = value
+          end
+
+          actual = Liquid::Template.parse(template).render!(context)
+          expect(actual.to_s.strip).to eq(expected.to_s.strip)
+        end
+      end
+    end
+  end
+end

data/lib/liquid-rails/tags/content_for_tag.rb

@@ -0,0 +1,77 @@
+# It works similar to Rails #content_for.
+# Calling #content_for stores a block of markup in an identifier for later use.
+# In order to access this stored content in other templates or the layout, you would pass the identifier as an argument to content_for.
+#
+# Usage:
+#
+# {% content_for not_authorized %}
+#   alert('You are not authorized to do that!');
+# {% endcontent_for %}
+#
+# You can then use content_for :not_authorized anywhere in your templates.
+# {% if current_user.nil? %}
+#   {% yield not_authorized %}
+# {% endif %}
+
+module Liquid
+  module Rails
+    class ContentForTag < ::Liquid::Block
+      Syntax = /(#{::Liquid::QuotedFragment}+)\s*(flush\s*(true|false))?/
+
+      def initialize(tag_name, markup, context)
+        super
+
+        if markup =~ Syntax
+          @flush = $3
+          @identifier = $1.gsub('\'', '')
+        else
+          raise SyntaxError.new("Syntax Error - Valid syntax: {% content_for [name] %}")
+        end
+      end
+
+      def render(context)
+        @context = context
+        content  = super.html_safe
+
+        if ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR == 2
+          if @flush == 'true'
+            @context.registers[:view].view_flow.set(@identifier, content) if content
+          else
+            @context.registers[:view].view_flow.append(@identifier, content) if content
+          end
+        else
+          options = @flush == 'true' ? { flush: true } : {}
+          @context.registers[:view].content_for(@identifier, content, options)
+        end
+        ''
+      end
+    end
+  end
+end
+
+module Liquid
+  module Rails
+    class YieldTag < ::Liquid::Tag
+      Syntax = /(#{::Liquid::QuotedFragment}+)/
+
+      def initialize(tag_name, markup, context)
+        super
+
+        if markup =~ Syntax
+          @identifier = $1.gsub('\'', '')
+        else
+          raise SyntaxError.new("Syntax Error - Valid syntax: {% yield [name] %}")
+        end
+      end
+
+      def render(context)
+        @context = context
+
+        @context.registers[:view].content_for(@identifier).try(:html_safe)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('content_for', Liquid::Rails::ContentForTag)
+Liquid::Template.register_tag('yield', Liquid::Rails::YieldTag)

data/lib/liquid-rails/tags/csrf_meta_tags.rb

@@ -0,0 +1,11 @@
+module Liquid
+  module Rails
+    class CsrfMetaTags < ::Liquid::Tag
+      def render(context)
+        context.registers[:view].csrf_meta_tags
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('csrf_meta_tags', Liquid::Rails::CsrfMetaTags)

data/lib/liquid-rails/tags/google_analytics_tag.rb

@@ -0,0 +1,40 @@
+# Returns a Google Analytics tag.
+#
+# Usage:
+#
+# {% google_analytics_tag 'UA-XXXXX-X' %}
+
+module Liquid
+  module Rails
+    class GoogleAnalyticsTag < ::Liquid::Tag
+      Syntax = /(#{::Liquid::QuotedFragment}+)?/
+
+      def initialize(tag_name, markup, tokens)
+        if markup =~ Syntax
+          @account_id = $1.gsub('\'', '')
+        else
+          raise ::Liquid::SyntaxError.new("Syntax Error in 'google_analytics_tag' - Valid syntax: google_analytics_tag <account_id>")
+        end
+
+        super
+      end
+
+      def render(context)
+        %{
+        <script type="text/javascript">
+
+          (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+          })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+          ga('create', '#{@account_id}', 'auto');
+          ga('send', 'pageview');
+
+        </script>
+        }
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('google_analytics_tag', Liquid::Rails::GoogleAnalyticsTag)

data/lib/liquid-rails/tags/javascript_tag.rb

@@ -0,0 +1,22 @@
+# Returns a JavaScript tag with the content inside.
+#
+# Usage:
+#
+# {% javascript_tag %}
+#   alert('Hello Liquid Rails!');
+# {% endjavascript_tag %}
+
+module Liquid
+  module Rails
+    class JavascriptTag < ::Liquid::Block
+      include ActionView::Helpers::JavaScriptHelper
+      include ActionView::Helpers::TagHelper
+
+      def render(context)
+        javascript_tag(super, type: 'text/javascript')
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('javascript_tag', Liquid::Rails::JavascriptTag)

data/lib/liquid-rails/tags/paginate_tag.rb

@@ -0,0 +1,118 @@
+# Paginate a collection
+#
+# Usage:
+#
+# {% paginate listing.photos by 5 %}
+#   {% for photo in paginate.collection %}
+#     {{ photo.caption }}
+#   {% endfor %}
+#  {% endpaginate %}
+#
+module Liquid
+  module Rails
+    class PaginateTag < ::Liquid::Block
+      Syntax = /(#{::Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+
+      def initialize(tag_name, markup, context)
+        super
+
+        if markup =~ Syntax
+          @collection_name = $1
+          @page_size = if $2
+            $3.to_i
+          else
+            25
+          end
+
+          @attributes = { 'window_size' => 3 }
+          markup.scan(Liquid::TagAttributes) do |key, value|
+            @attributes[key] = value
+          end
+        else
+          raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
+        end
+      end
+
+      def render(context)
+        @context = context
+
+        context.stack do
+          collection = @context[@collection_name].presence || @context.environments[0][@collection_name]
+          raise ::Liquid::ArgumentError.new("Cannot paginate collection '#{@collection_name}'. Not found.") if collection.nil?
+
+          if collection.is_a? Array
+            paginated_collection = Kaminari.paginate_array(collection.to_a).page(current_page).per(@page_size)
+          elsif collection.respond_to?(:page)
+            paginated_collection = collection.page(current_page).per(@page_size)
+          end
+
+          page_count = paginated_collection.total_pages
+          pagination = {}
+          pagination['collection']      = paginated_collection
+          pagination['current_offset']  = (current_page-1) * @page_size
+          pagination['current_page']    = current_page
+          pagination['page_size']       = @page_size
+          pagination['pages']           = page_count
+          pagination['items']           = paginated_collection.total_count
+          pagination['previous']        = link('&laquo; Previous'.html_safe, current_page-1 ) unless 1 >= current_page
+          pagination['next']            = link('Next &raquo;'.html_safe, current_page+1 )     unless page_count < current_page+1
+          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)
+              elsif page == page_count - 1
+                pagination['parts'] << link(page, page)
+              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)
+              end
+
+              hellip_break = false
+            end
+          end
+          context['paginate'] = pagination
+
+          super
+        end
+      end
+
+      private
+
+        def current_page
+          _current_page = @context.registers[:controller].params[:page]
+          _current_page.nil? ? 1 : _current_page.to_i
+        end
+
+        def current_url
+          current_url = @context.registers[:controller].request.fullpath.gsub(/page=[0-9]+&?/, '')
+          current_url = current_url.slice(0..-2) if current_url.last == '?' || current_url.last == '&'
+          current_url
+        end
+
+        def window_size
+          @attributes['window_size']
+        end
+
+        def no_link(title)
+          { 'title' => title, 'is_link' => false, 'hellip_break' => (title == '&hellip;') }
+        end
+
+        def link(title, page)
+          _current_url = %(#{current_url}#{current_url.include?('?') ? '&' : '?'}page=#{page})
+          { 'title' => title, 'url' => _current_url, 'is_link' => true }
+        end
+    end
+  end
+end
+
+Liquid::Template.register_tag('paginate', Liquid::Rails::PaginateTag)

data/lib/liquid-rails/template_handler.rb

@@ -0,0 +1,44 @@
+module Liquid
+  module Rails
+    class TemplateHandler
+
+      def self.call(template)
+        "Liquid::Rails::TemplateHandler.new(self).render(#{template.source.inspect}, local_assigns)"
+      end
+
+      def initialize(view)
+        @view       = view
+        @controller = @view.controller
+        @helper     = ActionController::Base.helpers
+      end
+
+      def render(template, local_assigns={})
+        @view.controller.headers['Content-Type'] ||= 'text/html; charset=utf-8'
+
+        assigns = if @controller.respond_to?(:liquid_assigns, true)
+          @controller.send(:liquid_assigns)
+        else
+          @view.assigns
+        end
+        assigns['content_for_layout'] = @view.content_for(:layout) if @view.content_for?(:layout)
+        assigns.merge!(local_assigns.stringify_keys)
+
+        liquid = Liquid::Template.parse(template)
+        render_method = (::Rails.env.development? || ::Rails.env.test?) ? :render! : :render
+        liquid.send(render_method, assigns, filters: filters, registers: { view: @view, controller: @controller, helper: @helper }).html_safe
+      end
+
+      def filters
+        if @controller.respond_to?(:liquid_filters, true)
+          @controller.send(:liquid_filters)
+        else
+          [@controller._helpers]
+        end
+      end
+
+      def compilable?
+        false
+      end
+    end
+  end
+end

data/lib/liquid-rails/version.rb

@@ -0,0 +1,5 @@
+module Liquid
+  module Rails
+    VERSION = '0.1.5'
+  end
+end

data/lib/liquid-rails.rb

@@ -0,0 +1,24 @@
+require 'liquid-rails/version'
+require 'liquid'
+require 'liquid-rails/liquid_monkey_patch'
+require 'kaminari'
+require 'active_support/concern'
+
+module Liquid
+  module Rails
+    autoload :TemplateHandler,  'liquid-rails/template_handler'
+    autoload :FileSystem,       'liquid-rails/file_system'
+
+    autoload :Drop,             'liquid-rails/drops/drop'
+    autoload :CollectionDrop,   'liquid-rails/drops/collection_drop'
+
+    def self.setup_drop(base)
+      base.class_eval do
+        include Liquid::Rails::Droppable
+      end
+    end
+  end
+end
+
+require 'liquid-rails/railtie' if defined?(Rails)
+Dir[File.dirname(__FILE__) + '/liquid-rails/{filters,tags,drops}/*.rb'].each { |f| require f }

data/liquid-rails.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'liquid-rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'liquid4-rails5'
+  spec.version       = Liquid::Rails::VERSION
+  spec.authors       = ['Viktor Fonic']
+  spec.email         = ['viktor.fonic@gmail.com']
+  spec.summary       = %q{Renders liquid templates with layout and partial support}
+  spec.description   = %q{It allows you to render .liquid templates with layout and partial support. It also provides filters, tags, drops class to be used inside your liquid template.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+  spec.required_ruby_version     = '>= 2.0.0'
+  spec.required_rubygems_version = '>= 1.8.11'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rails',    '>= 3.2'
+  spec.add_dependency 'liquid',   '>= 3.0.0'
+  spec.add_dependency 'kaminari', '>= 0.16.1'
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

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

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/controllers/foospace/bar_controller.rb

@@ -0,0 +1,5 @@
+class Foospace::BarController < ApplicationController
+  def index_partial
+    render layout: false
+  end
+end

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

@@ -0,0 +1,28 @@
+class HomeController < ApplicationController
+  before_filter :set_book
+
+  def index
+    render layout: false
+  end
+
+  def index_with_layout
+  end
+
+  def index_partial
+  end
+
+  def index_partial_with_full_path
+  end
+
+  def index_with_filter
+  end
+
+  def erb_with_html_liquid_partial
+  end
+
+  private
+
+    def set_book
+      @book = { 'name' => 'Liquid on Rails' }
+    end
+end

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

@@ -0,0 +1,16 @@
+class PagesController < ApplicationController
+  before_filter :set_book
+
+  def index_witout_filter
+  end
+
+  private
+
+    def liquid_filters
+      []
+    end
+
+    def set_book
+      @book = { 'name' => 'Liquid on Rails' }
+    end
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,5 @@
+module ApplicationHelper
+  def truncate_it(input, length)
+    input[0..length] + '...'
+  end
+end

data/spec/dummy/app/views/foospace/bar/_partial.liquid

@@ -0,0 +1 @@
+Bar Partial

data/spec/dummy/app/views/foospace/bar/index_partial.liquid

@@ -0,0 +1,3 @@
+Foospace::BarController
+
+{% include 'partial' %}

data/spec/dummy/app/views/home/_html_liquid_partial.liquid

@@ -0,0 +1 @@
+<p>Partial Content</p>

data/spec/dummy/app/views/home/_partial.liquid

@@ -0,0 +1 @@
+Home Partial

data/spec/dummy/app/views/home/erb_with_html_liquid_partial.erb

@@ -0,0 +1 @@
+<%= render 'html_liquid_partial' %>

data/spec/dummy/app/views/home/index.liquid

@@ -0,0 +1 @@
+{{ book.name }}

data/spec/dummy/app/views/home/index_partial.liquid

@@ -0,0 +1,4 @@
+{{ book.name }}
+
+{% include 'partial' %}
+{% include 'shared/partial' %}

data/spec/dummy/app/views/home/index_partial_with_full_path.liquid

@@ -0,0 +1,4 @@
+{{ book.name }}
+
+{% include 'home/partial' %}
+{% include 'shared/partial' %}

data/spec/dummy/app/views/home/index_with_filter.liquid

@@ -0,0 +1,2 @@
+{{ book.name }}
+{{ 'This is a long section of text' | truncate_it: 3 }}

data/spec/dummy/app/views/home/index_with_layout.liquid

@@ -0,0 +1 @@
+{{ book.name }}

data/spec/dummy/app/views/layouts/application.liquid

@@ -0,0 +1,2 @@
+Application Layout
+{{ content_for_layout }}

data/spec/dummy/app/views/pages/index_without_filter.liquid

@@ -0,0 +1,2 @@
+{{ book.name }}
+{{ 'This is a long section of text' | truncate_it:3 }}

data/spec/dummy/app/views/shared/_partial.liquid

@@ -0,0 +1 @@
+Shared Partial

data/spec/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run