liquid-rails 0.1.0

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,159 @@
+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][: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 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,44 @@
+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
+          @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)
+        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 eq(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# 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
+          @identifier = $1.to_s
+          @flush = $3
+        else
+          raise SyntaxError.new("Syntax Error - Valid syntax: {% content_for [name] %}")
+        end
+      end
+
+      def render(context)
+        @context = context
+
+        options = @flush == 'true' ? { flush: true } : {}
+        @context.registers[:view].content_for(@identifier, super.html_safe, options)
+        ''
+      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
+        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,43 @@
+# 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">
+
+          var _gaq = _gaq || [];
+          _gaq.push(['_setAccount', '#{@account_id}']);
+          _gaq.push(['_trackPageview']);
+
+          (function() {
+            var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+            ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+            var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+          })();
+
+        </script>
+        }
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('google_analytics_tag', Liquid::Rails::GoogleAnalyticsTag)