taktsoft_liquid-rails 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a5b2eea67d42cc7d46a644036e8f496c62da876
+  data.tar.gz: 40ba15806d2bdef4506e3201037c54d6207cb29c
+SHA512:
+  metadata.gz: a697171930d6419496a994b44369bba26ca3729c841b0e4f3ba1d35d1258fb61ca52b7ff1ce23ba684d7c7bb1a18f93bc1166e85ea867f1ebf5706c97476a737
+  data.tar.gz: f9b176b77314bdb5395ab274ed06f2042e694c903ddb24a86348b6a0dc56a1df22143c2f6ce2b3a58edf8234607e8f93bc159305188dfc587cb0f463a61be8c3

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: stxQNkczi4haKGRjKZvd7i8PAooQrahCX

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+spec/dummy/log/*
+gemfiles/*.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+liquid-rails

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.5

data/.travis.yml

@@ -0,0 +1,28 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+gemfile:
+  - gemfiles/rails_32.gemfile
+  - gemfiles/rails_40.gemfile
+  - gemfiles/rails_41.gemfile
+  - gemfiles/rails_42.gemfile
+  - gemfiles/rails_50.gemfile
+before_install:
+  - gem install bundler
+  - bundle --version
+matrix:
+  exclude:
+    - rvm: 2.2.5
+      gemfile: gemfiles/rails_32.gemfile
+    - rvm: 2.3.1
+      gemfile: gemfiles/rails_32.gemfile
+    - rvm: 2.0.0
+      gemfile: gemfiles/rails_50.gemfile
+    - rvm: 2.1.10
+      gemfile: gemfiles/rails_50.gemfile
+notifications:
+  email: false

data/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Overview
+
+## 0.1.4
+
+* Support for Rails 5.0
+
+## 0.1.3
+
+* ?!?
+
+## 0.1.2
+
+### New Features
+
+* Use google analytics universal (Chamnap Chhorn)
+
+* Render liquid template as html_safe by default (Dan Kubb)
+
+## 0.1.1
+
+### New Features
+
+* Add `bootstrap_pagination` filter. (Radin Reth)
+
+* Allow `translate` filter with interpolation. (Tomasz Stachewicz, Chamnap Chhorn)
+
+* Support `rails` 4.2 and `ruby` 2.2. (Chamnap Chhorn)
+
+* Support `scope` on collection drop. (Radin Reth)
+
+
+### Resolved Issues
+
+* Add `rel="prev"` and `rel="next"` to `default_pagination` filter. (Radin Reth)
+
+* Fix `content_for` and `yield` tag on `rails` 3.2. (Chamnap Chhorn)
+
+* \#4 Makes partial template work in namespaced controller. (Tomasz Stachewicz)
+
+* `truncate` filter now forwards to the standard filters. (Radin Reth)
+
+## 0.1.0
+
+* Initial Release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in liquid-rails.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,33 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  watch('spec/rails_helper.rb')                       { "spec" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chamnap Chhorn
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+[![Build Status](https://travis-ci.org/taktsoft/liquid-rails.svg?branch=master)](https://travis-ci.org/taktsoft/liquid-rails) [![Gem Version](https://badge.fury.io/rb/liquid-rails.svg)](http://badge.fury.io/rb/liquid-rails)
+
+# Liquid-Rails
+
+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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'taktsoft_liquid-rails', require: 'liquid-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install taktsoft_liquid-rails
+
+## Usage
+
+In order to render with layout, in your layout file `app/views/layouts/application.liquid`, put this:
+
+```html
+{{ content_for_layout }}
+```
+
+```html
+# It will render app/views/home/_partial.liquid when the current controller is `HomeController`.
+{% include 'partial' %}
+
+# It will render app/views/shared/_partial.liquid.
+{% include 'shared/partial' %}
+```
+
+### Template Rendering
+
+By default, **Liquid-Rails** makes all instance variables from controller available to liquid template. To limit only some instance variables, do this inside your controller:
+
+```ruby
+def liquid_assigns
+  { 'listing' => current_listing, 'content_for_header' => content_for_header, 'current_account' => current_account }
+end
+```
+
+By default, **Liquid-Rails** makes all your helper methods inside your rails app available to liquid template. To limit only some helpers, do this inside your controller:
+
+```ruby
+def liquid_filters
+  []
+end
+```
+
+You can render liquid templates from other template engines, eg. `erb`, `haml`, ...
+
+```ruby
+= render 'shared/partial.liquid'
+```
+
+### Filter
+
+> Filters are simple methods that modify the output of numbers, strings, variables and objects. They are placed within an output tag `{{` `}}` and are separated with a pipe character `|`.
+
+Currently, **Liquid-Rails** adds only the followings:
+
+1. [AssetTagFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/asset_tag_filter.rb)
+2. [AssetUrlFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/asset_url_filter.rb)
+3. [DateFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/date_filter.rb)
+4. [NumberFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/number_filter.rb)
+5. [SanitizeFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/sanitize_filter.rb)
+6. [TextFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/text_filter.rb)
+7. [TranslateFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/translate_filter.rb)
+8. [UrlFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/url_filter.rb)
+9. [MiscFilter](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/filters/misc_filter.rb)
+
+### Tag
+
+> Liquid tags are the programming logic that tells templates what to do. Tags are wrapped in: `{%` `%}`.
+
+Currently, **Liquid-Rails** adds only the followings:
+
+1. [csrf_meta_tags](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/tags/csrf_meta_tags.rb)
+2. [google_analytics_tag](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/tags/google_analytics_tag.rb)
+3. [javascript_tag](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/tags/javascript_tag.rb)
+4. [paginate](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/tags/paginate_tag.rb)
+4. [content_for](https://github.com/taktsoft/liquid-rails/blob/master/lib/liquid-rails/tags/content_for.rb)
+
+### Drop Class
+
+> Drops let you provide the user with custom functionality. They are very much like a standard Ruby class, but have all unused and potentially dangerous methods removed. From the user's perspective a drop acts very much like a Hash, though methods are accessed with dot-notation as well as element selection. A drop method cannot be invoked with arguments. Drops are called just-in-time, thus allowing you to lazily load objects.
+
+Given two models, a Post(title: string, body: text) and a Comment(name:string, body:text, post_id:integer), you will have two drops:
+
+```ruby
+class PostDrop < Liquid::Rails::Drop
+  attributes :id, :title, :body
+
+  has_many :comments
+end
+```
+
+and
+
+```ruby
+class CommentDrop < Liquid::Rails::Drop
+  attributes :id, :name, :body
+
+  belongs_to :post
+end
+```
+
+Check out more [examples](https://github.com/taktsoft/liquid-rails/blob/master/spec/fixtures/poro.rb).
+
+It works for any ORMs. The PORO should include `Liquid::Rails::Droppable`. That's all you need to do to have your POROs supported.
+
+### RSpec
+
+In spec_helper.rb, you'll need to require the matchers:
+
+```ruby
+require 'liquid-rails/matchers'
+```
+
+Example:
+
+```ruby
+describe PostDrop do
+  it { should have_attribute(:id) }
+  it { should have_attribute(:title) }
+  it { should have_attribute(:body) }
+  it { should have_many(:comments) }
+end
+```
+
+```ruby
+describe CommentDrop do
+  it { should have_attribute(:id) }
+  it { should have_attribute(:name) }
+  it { should have_attribute(:body) }
+  it { should belongs_to(:post) }
+end
+```
+
+## Contributors
+
+* [Radin Reth](https://github.com/radin-reth/)
+
+## Authors
+
+* [Chamnap Chhorn](https://github.com/chamnap)
+* [Taktsoft Developers](https://github.com/taktsoft)

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler/gem_tasks'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+namespace :spec do
+  %w(rails_50 rails_42 rails_41 rails_40 rails_32).each do |gemfile|
+    desc "Run Tests against #{gemfile}"
+    task gemfile do
+      sh "BUNDLE_GEMFILE='gemfiles/#{gemfile}.gemfile' bundle --quiet"
+      sh "BUNDLE_GEMFILE='gemfiles/#{gemfile}.gemfile' bundle exec rake spec"
+    end
+  end
+
+  desc "Run Tests against rails versions"
+  task :all do
+    %w(rails_50 rails_42 rails_41 rails_40 rails_32).each do |gemfile|
+      sh "BUNDLE_GEMFILE='gemfiles/#{gemfile}.gemfile' bundle --quiet"
+      sh "BUNDLE_GEMFILE='gemfiles/#{gemfile}.gemfile' bundle exec rake spec"
+    end
+  end
+end

data/gemfiles/rails_32.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 3.2.22'
+
+gem 'test-unit', '~> 3.0'
+gem 'mime-types', '< 3.0'
+gem 'listen', '< 3.1'
+
+gemspec path: '../'

data/gemfiles/rails_40.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 4.0.13'
+
+gem 'mime-types', '< 3.0'
+gem 'listen', '< 3.1'
+
+gemspec path: '../'

data/gemfiles/rails_41.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 4.1.16'
+
+gem 'mime-types', '< 3.0'
+gem 'listen', '< 3.1'
+
+gemspec path: '../'

data/gemfiles/rails_42.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 4.2.7'
+
+gem 'mime-types', '< 3.0'
+gem 'listen', '< 3.1'
+
+gemspec path: '../'

data/gemfiles/rails_50.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 5.0.0'
+
+gemspec path: '../'

data/lib/liquid-rails/drops/collection_drop.rb

@@ -0,0 +1,91 @@
+module Liquid
+  module Rails
+    class CollectionDrop < ::Liquid::Drop
+
+      class << self
+        attr_accessor :_scopes
+      end
+
+      def self.inherited(base)
+        base._scopes = []
+      end
+
+      def self.scope(*scope_names)
+        @_scopes.concat scope_names
+
+        scope_names.each do |scope_name|
+          define_method(scope_name) do
+            value = instance_variable_get("@_#{scope_name}")
+            return value if value
+
+            raise ArgumentError, "#{objects.class.name} doesn't define scope: #{scope_name}" unless objects.respond_to?(scope_name)
+            instance_variable_set("@_#{scope_name}", self.class.new(objects.send(scope_name)))
+          end
+        end
+      end
+
+      array_methods = Array.instance_methods - Object.instance_methods
+      delegate *array_methods, to: :dropped_collection
+      delegate :total_count, :total_pages, to: :objects
+
+      def initialize(objects, options={})
+        options.assert_valid_keys(:with, :scope)
+
+        @objects         = options[:scope].nil? ? objects : objects.send(options[:scope])
+        @drop_class_name = options[:with]
+      end
+
+      def page(number)
+        self.class.new(objects.page(number))
+      end
+
+      def per(number)
+        self.class.new(objects.per(number))
+      end
+
+      def dropped_collection
+        @dropped_collection ||= @objects.map { |item| drop_item(item) }
+      end
+
+      def kind_of?(klass)
+        dropped_collection.kind_of?(klass) || super
+      end
+      alias_method :is_a?, :kind_of?
+
+      ## :[] is invoked by parser before the actual. However, this method has the same name as array method.
+      ## Override this, so it will work for both cases.
+      ## {{ post_drop.comments[0] }}
+      ## {{ post_drop.<other_methods> }}
+      def [](method)
+        if method.is_a?(Integer)
+          dropped_collection.at(method)
+        else
+          public_send(method)
+        end
+      end
+
+      ## Need to override this. I don't understand too, otherwise it will return an array of drop objects.
+      ## Need to return self so that we can do chaining.
+      def to_liquid
+        self
+      end
+
+      def inspect
+        "#<#{self.class.name} of #{drop_class} for #{objects.inspect}>"
+      end
+
+      protected
+
+        attr_reader :objects
+
+        def drop_class
+          @drop_class ||= @drop_class_name.is_a?(String) ? @drop_class_name.safe_constantize : @drop_class_name
+        end
+
+        def drop_item(item)
+          liquid_drop_class = drop_class || item.drop_class
+          liquid_drop_class.new(item)
+        end
+    end
+  end
+end

data/lib/liquid-rails/drops/drop.rb

@@ -0,0 +1,114 @@
+module Liquid
+  module Rails
+    class Drop < ::Liquid::Drop
+
+      class << self
+        attr_accessor :_attributes
+        attr_accessor :_associations
+      end
+
+      def self.inherited(base)
+        base._attributes   = []
+        base._associations = {}
+      end
+
+      def self.attributes(*attrs)
+        @_attributes.concat attrs
+
+        attrs.each do |attr|
+          next if method_defined?(attr)
+
+          define_method(attr) do
+            object.send(attr) if object.respond_to?(attr, true)
+          end
+        end
+      end
+
+      # By default, `Product` maps to `ProductDrop`.
+      #             Array of products maps to `Liquid::Rails::CollectionDrop`.
+      def self.drop_class_for(resource)
+        if resource.respond_to?(:to_ary)
+          Liquid::Rails::CollectionDrop
+        else
+          if self == Liquid::Rails::Drop
+            resource.drop_class || Liquid::Rails::Drop
+          else
+            self
+          end
+        end
+      end
+
+      # Create a drop instance when it cannot be inferred.
+      def self.dropify(resource, options={})
+        drop_class = if options[:class_name]
+          options[:class_name].constantize
+        else
+          drop_class_for(resource)
+        end
+
+        drop_class.new(resource, options.except(:class_name))
+      end
+
+      def self.belongs_to(*attrs)
+        associate(:belongs_to, attrs)
+      end
+
+      def self.has_many(*attrs)
+        associate(:has_many, attrs)
+      end
+
+      def self.associate(type, attrs)
+        options = attrs.extract_options!
+        self._associations = _associations.dup
+
+        attrs.each do |attr|
+          next if method_defined?(attr)
+
+          define_method attr do
+            value = instance_variable_get("@_#{attr}")
+            return value if value
+
+            association = object.send(attr)
+            return nil if association.nil?
+
+            drop_instance = Liquid::Rails::Drop.dropify(association, options)
+            instance_variable_set("@_#{attr}", drop_instance)
+          end
+
+          self._associations[attr] = { type: type, options: options }
+        end
+      end
+
+      # Wraps an object in a new instance of the drop.
+      def initialize(object, options={})
+        @object = object
+      end
+
+      def attributes
+        @attributes ||= self.class._attributes.dup.each_with_object({}) do |name, hash|
+          hash[name.to_s] = send(name)
+        end
+      end
+
+      def as_json(options={})
+        attributes.as_json(options)
+      end
+
+      def to_json(options={})
+        as_json.to_json(options)
+      end
+
+      def before_method(method)
+        attributes[method.to_s]
+      end
+
+      def inspect
+        "#<#{self.class.name} @object: #{object.inspect} @attributes: #{attributes.inspect}>"
+      end
+
+      protected
+
+        attr_reader :object
+    end
+  end
+end

data/lib/liquid-rails/drops/droppable.rb

@@ -0,0 +1,22 @@
+module Liquid
+  module Rails
+    module Droppable
+      extend ActiveSupport::Concern
+
+      def to_liquid
+        drop_class.new(self)
+      end
+      alias_method :dropify, :to_liquid
+
+      def drop_class
+        self.class.drop_class
+      end
+
+      module ClassMethods
+        def drop_class
+          "#{self.name}Drop".safe_constantize
+        end
+      end
+    end
+  end
+end

data/lib/liquid-rails/file_system.rb

@@ -0,0 +1,13 @@
+require 'liquid/file_system'
+
+module Liquid
+  module Rails
+    class FileSystem < ::Liquid::LocalFileSystem
+      def read_template_file(template_path, context)
+        controller_path = context.registers[:controller].controller_path
+        template_path   = "#{controller_path}/#{template_path}" unless template_path.include?('/')
+        super
+      end
+    end
+  end
+end

data/lib/liquid-rails/filters/asset_tag_filter.rb

@@ -0,0 +1,25 @@
+module Liquid
+  module Rails
+    module AssetTagFilter
+      delegate \
+                :audio_tag,
+                :auto_discovery_link_tag,
+                :favicon_link_tag,
+                :image_alt,
+                :image_tag,
+                :javascript_include_tag,
+                :stylesheet_link_tag,
+                :video_tag,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::AssetTagFilter)