locomotivecms_solid 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@solid

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in solid.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Tigerlily, http://tigerlilyapps.com/
+
+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 @@
+# Solid
+
+Solid aim to provide a easier and nicer API to create custom Liquid tags and blocks
+
+## Installation
+
+Due to a name conflict the gem is called tigerlily-solid. So to use it:
+
+```
+gem 'tigerlily-solid', :require => 'solid'
+```
+
+## Build Status [![Build Status](https://secure.travis-ci.org/tigerlily/solid.png)](http://travis-ci.org/tigerlily/solid)
+
+## Tags
+
+To create a new tag, you just have to:
+
+  - Extend `Solid::Tag`
+  - Define a `display` method
+  - Give a `tag_name`
+
+```ruby
+class DummyTag < Solid::Tag
+
+  tag_name :dummy # register in Liquid under the name of `dummy`
+
+  def display
+    'dummy !!!'
+  end
+
+end
+```
+
+```html
+<p>{% dummy %}<p>
+```
+
+## Arguments
+
+This is the simpliest tag ever but, Solid tags can receive rich arguments:
+
+```ruby
+class TypeOfTag < Solid::Tag
+
+  tag_name :typeof
+
+  def display(*values)
+    ''.tap do |output|
+      values.each do |value|
+        output << "<p>Type of #{value} is #{value.class.name}</p>"
+      end
+    end
+  end
+
+end
+```
+
+```html
+{% capture myvar %}eggspam{% endcapture %}
+{% typeof "foo", 42, 4.2, myvar, myoption:"bar", otheroption:myvar %}
+<!-- produce -->
+<p>Type of "foo" is String</p>
+<p>Type of 42 is Integer</p>
+<p>Type of 4.2 is Float</p>
+<p>Type of "eggspam" is String</p>
+<p>Type of {:myoption=>"bar", :otheroption=>"eggspam"} is Hash</p>
+```
+
+## Context attributes
+
+If there is some "global variables" in your liquid context you can declare that
+your tag need to access it:
+
+```ruby
+class HelloTag < Solid::Tag
+
+  tag_name :hello
+
+  context_attribute :current_user
+
+  def display
+    "Hello #{current_user.name} !"
+  end
+
+end
+```
+
+```html
+<p>{% hello %}</p>
+<!-- produce -->
+<p>Hello Homer</p>
+```
+## Blocks
+
+Block are just tags with a body. They perform the same argument parsing.
+To render the block body from it's `display` method you just have to `yield`:
+
+```ruby
+class PBlock < Solid::Block
+
+  tag_name :p
+
+  def display(options)
+    "<p class='#{options[:class]}'>#{yield}</p>"
+  end
+
+end
+```
+
+```html
+{% p class:"content" %}
+  It works !
+{% endp %}
+<!-- produce -->
+<p class="content">It works !</p>
+```
+
+Of course you are free to yield once, multiple times or even never.
+
+## Conditional Blocks
+
+Conditional blocks are blocks with two bodies. If you yield `true` you will receive the main block
+and if you yield `false` you will receive the else block:
+
+```ruby
+class IfAuthorizedToTag < Solid::ConditionalBlock
+
+  tag_name :if_authorized_to
+
+  context_attribute :current_user
+
+  def display(permission)
+    yield(current_user.authorized_to?(permission))
+  end
+
+end
+```
+
+```html
+{% if_authorized_to "publish" %}
+  You are authorized !
+{% else %}
+  Get out !
+{% endif_authorized_to %}
+```
+
+## License
+
+Solid is released under the MIT license:
+
+http://www.opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/locomotivecms_solid.rb

@@ -0,0 +1,2 @@
+# Thanks to this file, the gem will be automatically loaded at startup.
+require 'solid'

data/lib/solid/arguments.rb

@@ -0,0 +1,28 @@
+require 'ripper'
+
+class Solid::Arguments
+  include Enumerable
+
+  def self.parse(string)
+    new("[#{string}]").parse!
+  end
+
+  attr_accessor :values
+
+  def initialize(string)
+    @string = string
+  end
+
+  def parse!
+    self.values = Solid::Parser.parse(@string)
+    self
+  end
+
+  def each(*args, &block)
+    values.each(*args, &block)
+  end
+
+  def interpolate(context)
+    values.evaluate(context)
+  end
+end

data/lib/solid/block.rb

@@ -0,0 +1,13 @@
+class Solid::Block < Liquid::Block
+
+  include Solid::Element
+
+  def render(context)
+    with_context(context) do
+      display(*arguments.interpolate(context)) do
+        super
+      end
+    end
+  end
+
+end

data/lib/solid/conditional_block.rb

@@ -0,0 +1,35 @@
+class Solid::ConditionalBlock < Liquid::Block
+  include Solid::Element
+
+  def initialize(tag_name, variable, tokens, context = {})
+    @blocks = []
+    push_block!
+    super
+  end
+
+  def render(context)
+    with_context(context) do
+      display(*arguments.interpolate(context)) do |condition_satisfied|
+        block = condition_satisfied ? @blocks.first : @blocks[1]
+        render_all(block, context) if block
+      end
+    end
+  end
+
+  def unknown_tag(tag, markup, tokens, context = {})
+    if tag == 'else'
+      push_block!
+    else
+      super
+    end
+  end
+
+  private
+
+  def push_block!
+    block = []
+    @blocks.push(block)
+    @nodelist = block
+  end
+
+end

data/lib/solid/context_error.rb

@@ -0,0 +1,2 @@
+class Solid::ContextError < Exception
+end

data/lib/solid/default_security_rules.rb

@@ -0,0 +1,24 @@
+Solid::MethodWhitelist
+	.allow(
+		BasicObject => [:!, :!=, :==],
+		Object => [:present?, :blank?, :in?, :to_json],
+		Kernel => [:nil?, :!~],
+		Module => [:==],
+		Enumerable => [:sort],
+		Comparable => [:<, :<=, :==, :>, :>=, :between?],
+    Numeric => [:blank?,
+      :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days, :week, :weeks,
+      :bytes, :kilobytes, :megabytes, :gigabytes, :terabytes, :petabytes, :exabytes],
+    Integer => [:multiple_of?, :month, :months, :year, :years, :to_json],
+	).deny(
+		Module => [:const_get, :const_set, :const_defined?, :freeze, :ancestors],
+		Class => [:new, :allocate, :superclass],
+	)
+
+if defined?(JSON::Ext::Generator::GeneratorMethods::Fixnum) &&
+   defined?(JSON::Ext::Generator::GeneratorMethods::Bignum)
+  Solid::MethodWhitelist.allow(
+    JSON::Ext::Generator::GeneratorMethods::Fixnum => [:to_json],
+    JSON::Ext::Generator::GeneratorMethods::Bignum => [:to_json],
+  )
+end

data/lib/solid/element.rb

@@ -0,0 +1,51 @@
+module Solid::Element
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, Solid::Iterable)
+  end
+
+  def initialize(tag_name, arguments_string, tokens, context = {})
+     super
+     @arguments = Solid::Arguments.parse(arguments_string)
+  end
+
+  def arguments
+    @arguments
+  end
+
+  def with_context(context)
+    previous_context = @current_context
+    @current_context = context
+    yield
+  ensure
+    @current_context = previous_context
+  end
+
+  def current_context
+    @current_context or raise Solid::ContextError.new("There is currently no context, do you forget to call render ?")
+  end
+
+  def display(*args)
+    raise NotImplementedError.new("Solid::Element implementations SHOULD define a #display method")
+  end
+
+  module ClassMethods
+
+    def tag_name(value=nil)
+      if value
+        @tag_name = value
+        Liquid::Template.register_tag(value.to_s, self)
+      end
+      @tag_name
+    end
+
+    def context_attribute(name)
+      define_method(name) do
+        Solid.unproxify(current_context[name.to_s])
+      end
+    end
+
+  end
+
+end

data/lib/solid/engine.rb

@@ -0,0 +1,4 @@
+module Solid
+  class Engine < Rails::Engine
+  end
+end

data/lib/solid/extensions.rb

@@ -0,0 +1,17 @@
+module LiquidSafe
+  def to_liquid
+    self
+  end
+end
+
+class Symbol
+  include LiquidSafe
+end
+
+class Regexp
+  include LiquidSafe
+end
+
+class Time
+  extend LiquidSafe
+end

data/lib/solid/iterable.rb

@@ -0,0 +1,18 @@
+module Solid
+  module Iterable
+    include Enumerable
+
+    def each(&block)
+      self.walk(&block)
+    end
+
+    protected
+    def walk(nodes=nil, &block)
+      (nodes || self.nodelist).each do |node|
+        yield node
+        walk(node.nodelist || [], &block) if node.respond_to?(:nodelist)
+      end
+    end
+
+  end
+end

data/lib/solid/liquid_extensions/assign_tag.rb

@@ -0,0 +1,21 @@
+module Solid
+  module LiquidExtensions
+    class AssignTag < Solid::Tag
+      extend TagHighjacker
+
+      tag_name :assign
+
+      def initialize(tag_name, assignment, tokens, context = {})
+        @assigned_variable, expression = assignment.split('=', 2)
+        @assigned_variable = @assigned_variable.strip
+        super(tag_name, expression, tokens, context)
+      end
+
+      def display(expression_result)
+        current_context.scopes.last[@assigned_variable] = expression_result
+        ''
+      end
+
+    end
+  end
+end

data/lib/solid/liquid_extensions/for_tag.rb

@@ -0,0 +1,102 @@
+module Solid
+  module LiquidExtensions
+
+    # This for block reimplementation is deliberately backward incompatible
+    # since all strange features supported by the original for loop like
+    # "reversed" or "limit: 20 offset: 40" are favourably replaced by pure ruby
+    # methods like `Array#reversed` or `Array#slice`
+    class ForTag < Solid::Block
+      extend TagHighjacker
+
+      tag_name :for
+
+      def initialize(tag_name, expression, tokens, context = {})
+        @variable_name, iterable_expression = expression.split(/\s+in\s+/, 2).map(&:strip)
+        super(tag_name, iterable_expression, tokens, context)
+      end
+
+      def display(collection)
+        forloop = loop_for(collection)
+        output = []
+        collection = [] unless collection.respond_to?(:each_with_index)
+        collection.each_with_index do |element, index|
+          current_context.stack do
+            current_context[@variable_name] = element.to_liquid
+            current_context['forloop'] = forloop
+            output << yield
+            forloop.inc!
+          end
+        end
+        output.join
+      end
+
+      protected
+      def loop_for(collection)
+        if paginated?(collection)
+          PaginatedForLoop.new(collection)
+        else
+          ForLoop.new(collection)
+        end
+      end
+
+      def paginated?(collection)
+        defined?(WillPaginate) and
+          (collection.singleton_class < WillPaginate::CollectionMethods or
+          collection.singleton_class < WillPaginate::Mongoid::CollectionMethods)
+      end
+
+    end
+
+    class ForLoop < Liquid::Drop
+
+      def initialize(collection)
+        @collection = collection
+        @index0 = 0
+      end
+
+      def index0
+        @index0
+      end
+
+      def index
+        index0 + 1
+      end
+
+      def rindex
+        length - index0
+      end
+
+      def rindex0
+        length - index0 - 1
+      end
+
+      def length
+        @collection.length
+      end
+
+      def first
+        index0 == 0
+      end
+
+      def last
+        index == length
+      end
+
+      def inc!
+         @index0 += 1
+      end
+
+    end
+
+    class PaginatedForLoop < ForLoop
+
+      def initialize(collection)
+        super
+        @index0 = collection.offset || 0
+      end
+
+    end
+
+  end
+end
+

data/lib/solid/liquid_extensions/if_tag.rb

@@ -0,0 +1,44 @@
+module Solid
+  module LiquidExtensions
+    class IfTag < Liquid::Block
+      include Solid::Element
+      extend TagHighjacker
+
+      tag_name :if
+
+      def initialize(tag_name, expression, tokens, context = {})
+        @blocks = []
+        push_block!(expression)
+        super
+      end
+
+      def render(context)
+        with_context(context) do
+          @blocks.each do |expression, blocks|
+            if expression.evaluate(context)
+              return render_all(blocks, context)
+            end
+          end
+        end
+        ''
+      end
+
+      def unknown_tag(tag, expression, tokens, context = {})
+        if tag == 'elsif'
+          push_block!(expression)
+        elsif tag == 'else'
+          push_block!('true')
+        end
+      end
+
+      protected
+
+      def push_block!(expression)
+        block = []
+        @blocks.push([Solid::Parser.parse(expression), block])
+        @nodelist = block
+      end
+
+    end
+  end
+end

data/lib/solid/liquid_extensions/unless_tag.rb

@@ -0,0 +1,13 @@
+module Solid
+  module LiquidExtensions
+    class UnlessTag < Solid::LiquidExtensions::IfTag
+
+      tag_name :unless
+
+      def initialize(tag_name, expression, tokens, context = {})
+        super(tag_name, "!(#{expression})", tokens, context)
+      end
+
+    end
+  end
+end

data/lib/solid/liquid_extensions/variable.rb

@@ -0,0 +1,34 @@
+module Solid
+  module LiquidExtensions
+    class Variable < ::Liquid::Variable
+      extend ClassHighjacker
+
+      def initialize(markup)
+        super
+        @expression = Solid::Parser.parse(@name)
+      end
+
+      def render(context)
+        return '' if @name.nil?
+        value = @expression.evaluate(context)
+        apply_filters_on(value, context)
+      end
+
+      protected
+
+      def apply_filters_on(value, context)
+        @filters.inject(value) do |output, filter|
+          filterargs = filter[1].to_a.collect do |a|
+            context[a]
+          end
+          begin
+            output = context.invoke(filter[0], output, *filterargs)
+          rescue FilterNotFound
+            raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
+          end
+        end
+      end
+
+    end
+  end
+end