taktsoft_liquid-rails 0.1.4

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

@@ -0,0 +1,37 @@
+module Liquid
+  module Rails
+    module AssetUrlFilter
+      delegate \
+                :asset_path,
+                :asset_url,
+
+                :audio_path,
+                :audio_url,
+
+                :font_path,
+                :font_url,
+
+                :image_path,
+                :image_url,
+
+                :javascript_path,
+                :javascript_url,
+
+                :stylesheet_path,
+                :stylesheet_url,
+
+                :video_path,
+                :video_url,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::AssetUrlFilter)

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

@@ -0,0 +1,19 @@
+module Liquid
+  module Rails
+    module DateFilter
+      delegate \
+                :distance_of_time_in_words,
+                :time_ago_in_words,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::DateFilter)

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

@@ -0,0 +1,30 @@
+module Liquid
+  module Rails
+    module GoogleStaticMapUrlFilter
+
+      # size:     '600x300'
+      #
+      # Available keys inside options
+      # center:   '40.714728,-73.998672'
+      # zoom:     13
+      # maptype:  'roadmap', 'satellite', 'terrain', or 'hybrid'
+      # markers:  an array of this 'color:blue|label:S|40.702147,-74.015794'
+      #           or string with semicolon
+      def google_static_map_url(size, options={})
+        markers = options.delete('markers')
+        markers = if markers
+          markers = markers.split(';') if markers.is_a?(String)
+          markers.map { |marker| { markers: marker }.to_query }
+        else
+          ''
+        end
+        options = options.merge('size' => size)
+        querystring = [options.to_query, markers].delete_if { |value| value.blank? }.join('&')
+
+        "https://maps.googleapis.com/maps/api/staticmap?#{querystring}"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::GoogleStaticMapUrlFilter)

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

@@ -0,0 +1,29 @@
+require 'json'
+
+module Liquid
+  module Rails
+    module MiscFilter
+      # Get the nth element of the passed in array
+      def index(array, position)
+        array.at(position) if array.respond_to?(:at)
+      end
+
+      def random(input)
+        rand(input.to_i)
+      end
+
+      def jsonify(object)
+        JSON.dump(object)
+      end
+
+      # If condition is true, the class_name is returned. Otherwise, it returns nil.
+      # class_name: css class name
+      # condition: boolean
+      def toggle_class_name(class_name, condition)
+        condition ? class_name : nil
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::MiscFilter)

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

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module NumberFilter
+      delegate \
+                :number_to_phone,
+                :number_to_currency,
+                :number_to_percentage,
+                :number_with_delimiter,
+                :number_with_precision,
+                :number_to_human_size,
+                :number_to_human,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::NumberFilter)

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

@@ -0,0 +1,59 @@
+module Liquid
+  module Rails
+    module PaginateFilter
+      def default_pagination(paginate)
+        html = []
+        html << %(<span class="prev"><a href="#{paginate['previous']['url']}" rel="prev">#{paginate['previous']['title']}</a></span>) if paginate['previous']
+
+        for part in paginate['parts']
+          if part['is_link']
+            html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+          elsif part['title'].to_i == paginate['current_page'].to_i
+            html << %(<span class="page current">#{part['title']}</span>)
+          else
+            html << %(<span class="deco">#{part['title']}</span>)
+          end
+        end
+
+        html << %(<span class="next"><a href="#{paginate['next']['url']}" rel="next">#{paginate['next']['title']}</a></span>) if paginate['next']
+        html.join(' ')
+      end
+
+      # Bootstrap pagination filter
+      #
+      # @param [ paginate ]
+      # @param [ size ]: .pagination-lg, .pagination-sm
+      def bootstrap_pagination(paginate, size='')
+        html = []
+        html << %{<nav><ul class="pagination #{size}">}
+
+        if paginate['previous']
+          html << %(<li><a href="#{paginate['previous']['url']}" aria-label="Previous"><span aria-hidden="true">#{paginate['previous']['title']}</span></a></li>)
+        else
+          html << %(<li class="disabled"><a href="#" aria-label="Previous"><span aria-hidden="true">&laquo; Previous</span></a></li>)
+        end
+
+        for part in paginate['parts']
+          if part['is_link']
+            html << %(<li><a href="#{part['url']}">#{part['title']}</a></li>)
+          elsif part['title'].to_i == paginate['current_page'].to_i
+            html << %(<li class="active"><span>#{part['title']}</span></li>)
+          else
+            html << %(<li class="disabled"><span>#{part['title']}</span></li>)
+          end
+        end
+
+        if paginate['next']
+          html << %(<li><a href="#{paginate['next']['url']}" aria-label="Next"><span aria-hidden="true">#{paginate['next']['title']}</span></a></li>)
+        else
+          html << %(<li class="disabled"><a href="#" aria-label="Next"><span aria-hidden="true">Next &raquo;</span></a></li>)
+        end
+
+        html << '</ul></nav>'
+        html.join(' ')
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::PaginateFilter)

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

@@ -0,0 +1,19 @@
+module Liquid
+  module Rails
+    module SanitizeFilter
+      delegate \
+                :strip_tags,
+                :strip_links,
+
+                to: :h
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::SanitizeFilter)

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

@@ -0,0 +1,46 @@
+module Liquid
+  module Rails
+    module TextFilter
+      delegate \
+                :highlight,
+                :excerpt,
+                :pluralize,
+                :word_wrap,
+                :simple_format,
+
+                to: :h
+
+      # right justify and padd a string
+      def rjust(input, integer, padstr = '')
+        input.to_s.rjust(integer, padstr)
+      end
+
+      # left justify and padd a string
+      def ljust(input, integer, padstr = '')
+        input.to_s.ljust(integer, padstr)
+      end
+
+      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
+
+      private
+
+        def h
+          @h ||= @context.registers[:view]
+        end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::TextFilter)

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

@@ -0,0 +1,14 @@
+module Liquid
+  module Rails
+    module TranslateFilter
+      def translate(key, options={})
+        options = { 'locale' => ::I18n.locale.to_s }.merge(options)
+
+        @context.registers[:view].translate(key.to_s, options.with_indifferent_access)
+      end
+      alias_method :t, :translate
+    end
+  end
+end
+
+Liquid::Template.register_filter Liquid::Rails::TranslateFilter

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

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module UrlFilter
+
+      def link_to(name, url, options={})
+        @context.registers[:view].link_to(name, url.to_s, options)
+      end
+
+      def link_to_unless_current(name, url, options={})
+        @context.registers[:view].link_to_unless_current(name, url.to_s, options)
+      end
+
+      def mail_to(email_address, name=nil, options={})
+        @context.registers[:view].mail_to(email_address, name, options)
+      end
+
+      def current_page?(path)
+        @context.registers[:view].current_page?(path.to_s)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Liquid::Rails::UrlFilter)

data/lib/liquid-rails/matchers.rb

@@ -0,0 +1,5 @@
+require 'liquid-rails/rspec/view_controller_context'
+require 'liquid-rails/rspec/drop_matchers'
+require 'liquid-rails/rspec/drop_example_group'
+require 'liquid-rails/rspec/tag_example_group'
+require 'liquid-rails/rspec/filter_example_group'

data/lib/liquid-rails/railtie.rb

@@ -0,0 +1,26 @@
+module Liquid
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.app_generators.template_engine :liquid
+
+      initializer 'liquid-rails.register_template_handler' do |app|
+        ActiveSupport.on_load(:action_view) do
+          ActionView::Template.register_template_handler(:liquid, Liquid::Rails::TemplateHandler)
+        end
+      end
+
+      initializer 'liquid-rails.include_partial' do |app|
+        template_path = ::Rails.root.join('app/views')
+        Liquid::Template.file_system = Liquid::Rails::FileSystem.new(template_path)
+      end
+
+      initializer 'liquid-rails.setup_drop' do |app|
+        [:active_record, :mongoid].each do |orm|
+          ActiveSupport.on_load orm do
+            Liquid::Rails.setup_drop self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Liquid
+  module Rails
+    module Rspec
+      module DropExampleGroup
+        extend ActiveSupport::Concern
+        include Liquid::Rails::Rspec::DropMatchers
+        include Liquid::Rails::Rspec::ViewControllerContext
+
+        included do
+          metadata[:type] = :drop
+
+          subject {
+            if described_class.ancestors.include?(Liquid::Rails::Drop)
+              begin
+                described_class.new(double)
+              rescue
+                described_class.new
+              end
+            else
+              described_class.new([])
+            end
+          }
+
+          before(:all)  { setup_view_and_controller }
+          before(:each) { subject.context = context }
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  if RSpec::Core::Version::STRING.starts_with?('3')
+    config.include Liquid::Rails::Rspec::DropExampleGroup, type: :drop, file_path: %r(spec/drops)
+  else
+    config.include Liquid::Rails::Rspec::DropExampleGroup, type: :drop, example_group: { file_path: %r{spec/drops} }
+  end
+end

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

@@ -0,0 +1,165 @@
+module Liquid
+  module Rails
+    module Rspec
+      module DropMatchers
+        def have_attribute(name)
+          AttributeMatcher.new(name)
+        end
+
+        def have_many(name)
+          AssociationMatcher.new(name, type: :has_many)
+        end
+
+        def belongs_to(name)
+          AssociationMatcher.new(name, type: :belongs_to)
+        end
+
+        def have_scope(name)
+          ScopeMatcher.new(name)
+        end
+
+        class AttributeMatcher
+          attr_reader :name, :actual
+
+          def initialize(name)
+            @name = name
+          end
+
+          def matches?(actual)
+            @actual = actual
+
+            attributes.include?(name)
+          end
+
+          def description
+            "have attribute #{name}"
+          end
+
+          def failure_message
+            %Q{expected #{actual.inspect} to define "#{name}" as attribute}
+          end
+
+          def failure_message_when_negated
+            %Q{expected #{actual.inspect} not to define "#{name}" as attribute}
+          end
+
+          private
+
+            def drop
+              if actual.is_a?(Class)
+                actual
+              else
+                actual.class
+              end
+            end
+
+            def attributes
+              drop._attributes
+            end
+        end
+
+        class AssociationMatcher
+          attr_reader :name, :actual, :options
+
+          def initialize(name, options)
+            @name    = name
+            @options = options
+          end
+
+          def matches?(actual)
+            @actual = actual
+
+            association = associations[name]
+            result = association.present? && association[:type] == options[:type]
+            result = result && association[:options][:scope] == options[:scope]           if options[:scope]
+            result = result && association[:options][:with] == options[:with]             if options[:with]
+            result = result && association[:options][:class_name] == options[:class_name] if options[:class_name]
+
+            result
+          end
+
+          def with(class_name)
+            @options[:with] = class_name
+            self
+          end
+
+          def scope(scope_name)
+            @options[:scope] = scope_name
+            self
+          end
+
+          def class_name(class_name)
+            @options[:class_name] = class_name
+            self
+          end
+
+          def description
+            "have association #{name}"
+          end
+
+          def failure_message
+            %Q{expected #{actual.inspect} to define "#{name}" as :#{options[:type]} association}
+          end
+
+          def failure_message_when_negated
+            %Q{expected #{actual.inspect} not to define "#{name}" as :#{options[:type]} association}
+          end
+
+          private
+
+            def drop
+              if actual.is_a?(Class)
+                actual
+              else
+                actual.class
+              end
+            end
+
+            def associations
+              drop._associations
+            end
+        end
+
+        class ScopeMatcher
+          attr_reader :name, :actual
+
+          def initialize(name)
+            @name = name
+          end
+
+          def matches?(actual)
+            @actual = actual
+
+            scopes.include?(name)
+          end
+
+          def description
+            "have scope #{name}"
+          end
+
+          def failure_message
+            %Q{expected #{actual.inspect} to define "#{name}" as scope}
+          end
+
+          def failure_message_when_negated
+            %Q{expected #{actual.inspect} not to define "#{name}" as scope}
+          end
+
+          private
+
+            def drop
+              if actual.is_a?(Class)
+                actual
+              else
+                actual.class
+              end
+            end
+
+            def scopes
+              drop._scopes
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Liquid
+  module Rails
+    module Rspec
+      module FilterExampleGroup
+        extend ActiveSupport::Concern
+        include Liquid::Rails::Rspec::ViewControllerContext
+
+        included do
+          metadata[:type] = :filter
+
+          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::FilterExampleGroup, type: :filter, file_path: %r(spec/filters)
+  else
+    config.include Liquid::Rails::Rspec::FilterExampleGroup, type: :filter, example_group: { file_path: %r{spec/filters} }
+  end
+end

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,63 @@
+module Liquid
+  module Rails
+    module Rspec
+      module ViewControllerContext
+        extend ActiveSupport::Concern
+
+        def setup_view_and_controller
+          @view                 = ActionView::Base.new
+          @controller           = ApplicationController.new
+          @request              = build_request_for_liquid
+          @response             = build_response_for_liquid
+          @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
+
+        private
+
+        def build_request_for_liquid
+          if ::Rails::VERSION::MAJOR < 5
+            ActionController::TestRequest.new({'PATH_INFO' => '/'})
+          else
+            ActionController::TestRequest.new({'PATH_INFO' => '/'}, {})
+          end
+        end
+
+        def build_response_for_liquid
+          if ::Rails::VERSION::MAJOR < 5
+            ActionController::TestResponse.new
+          else
+            ActionDispatch::TestResponse.new
+          end
+        end
+      end
+    end
+  end
+end