locomotivecms-solid 0.2.2

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.rb

@@ -0,0 +1,87 @@
+module Solid
+
+  class << self
+
+    def extend_liquid!
+      LiquidExtensions.load!
+    end
+
+  end
+
+  module LiquidExtensions
+
+    module ClassHighjacker
+
+      def load!
+        original_class = Liquid.send(:remove_const, demodulized_name)
+        original_classes[demodulized_name] = original_class unless original_classes.has_key?(demodulized_name) # avoid loosing reference to original class
+        Liquid.const_set(demodulized_name, self)
+      end
+
+      def unload!
+        if original_class = original_classes[demodulized_name]
+          Liquid.send(:remove_const, demodulized_name)
+          Liquid.const_set(demodulized_name, original_class)
+        end
+      end
+
+      def demodulized_name
+        @demodulized_name ||= self.name.split('::').last
+      end
+
+      protected
+      def original_classes
+        @@original_classes ||= {}
+      end
+
+    end
+
+    module TagHighjacker
+
+      def load!
+        original_tag = Liquid::Template.tags[tag_name.to_s]
+        original_tags[tag_name] = original_tag unless original_tags.has_key?(tag_name) # avoid loosing reference to original class
+        Liquid::Template.register_tag(tag_name, self)
+      end
+
+      def unload!
+        Liquid::Template.register_tag(tag_name, original_tags[tag_name])
+      end
+
+      def tag_name(name=nil)
+        @tag_name = name unless name.nil?
+        @tag_name
+      end
+
+      protected
+      def original_tags
+        @@original_tags ||= {}
+      end
+
+    end
+
+    BASE_PATH = File.join(File.expand_path(File.dirname(__FILE__)), 'liquid_extensions')
+
+    # FIXME: Keep the original ForTag from being modified.
+    %w(if_tag unless_tag assign_tag variable).each do |mod|
+      require File.join(BASE_PATH, mod)
+    end
+
+    # FIXME: Keep the original ForTag from being modified.
+    ALL = [IfTag, UnlessTag, AssignTag, Variable]
+
+    class << self
+
+      def load!
+        ALL.each(&:load!)
+      end
+
+      def unload!
+        ALL.each(&:unload!)
+      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, options={})
+        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

data/lib/solid/method_whitelist.rb

@@ -0,0 +1,56 @@
+module Solid
+  module MethodWhitelist
+    extend self
+
+    METHODS_WHITELIST = {}
+    METHODS_BLACKLIST = {}
+
+    class << self
+
+      def allow(rules)
+        rules.each do |owner, method_names|
+          list = METHODS_WHITELIST[owner] ||= Set.new
+          [method_names].flatten.each do |method_name|
+            list.add(method_name.to_sym)
+          end
+        end
+        self
+      end
+
+      def deny(rules)
+        rules.each do |owner, method_names|
+          list = METHODS_BLACKLIST[owner] ||= Set.new
+          [method_names].flatten.each do |method_name|
+            list.add(method_name.to_sym)
+          end
+        end
+        self
+      end
+
+    end
+
+    def safely_respond_to?(object, method)
+      return false unless object.respond_to?(method, false)
+      method = object.method(method)
+      (!inherited?(object, method) || whitelisted?(method)) && !blacklisted?(method)
+    end
+    module_function :safely_respond_to?
+
+    private
+
+    def whitelisted?(method)
+      METHODS_WHITELIST.has_key?(method.owner) && METHODS_WHITELIST[method.owner].include?(method.name)
+    end
+
+    def blacklisted?(method)
+      METHODS_BLACKLIST.has_key?(method.owner) && METHODS_BLACKLIST[method.owner].include?(method.name)
+    end
+
+    def inherited?(object, method)
+      method.owner != object.class && !object.methods(false).include?(method.name)
+    end
+
+  end
+end
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'default_security_rules')

data/lib/solid/model_drop.rb

@@ -0,0 +1,119 @@
+class Solid::ModelDrop < Liquid::Drop
+
+  module ModelExtension
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def to_drop
+        "#{self.name}Drop".constantize.new(current_scope || self)
+      end
+
+    end
+
+  end
+
+  class_attribute :dynamic_methods
+
+  class << self
+
+    def model(model_name=nil)
+      if model_name
+        @model_name = model_name
+      else
+        @model_name ||= self.name.gsub(/Drop$/, '')
+      end
+    end
+
+    def model_class
+      @model_class ||= self.model.to_s.camelize.constantize
+    end
+
+    def immutable_method(method_name)
+      self.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+        def #{method_name}_with_immutation(*args, &block)
+          self.dup.tap do |clone|
+            clone.#{method_name}_without_immutation(*args, &block)
+          end
+        end
+      END_EVAL
+      self.alias_method_chain method_name, :immutation
+    end
+
+    def respond(options={})
+      raise ArgumentError.new(":to option should be a Regexp") unless options[:to].is_a?(Regexp)
+      raise ArgumentError.new(":with option is mandatory") unless options[:with].present?
+      self.dynamic_methods ||= []
+      self.dynamic_methods += [[options[:to], options[:with]]]
+    end
+
+    def allow_scopes(*scopes)
+      @allowed_scopes = scopes
+      scopes.each do |scope_name|
+        self.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+          def #{scope_name}(*args)
+            @scope = scope.public_send(:#{scope_name}, *args)
+          end
+        END_EVAL
+        self.immutable_method(scope_name)
+      end
+    end
+
+  end
+
+  delegate :model_class, :to => 'self.class'
+  
+  respond :to => /limited_to_(\d+)/, :with => :limit_to
+
+  def initialize(base_scope=nil, context=nil)
+    @scope = base_scope
+    @context ||= context
+  end
+
+  def all
+    self
+  end
+
+  def each(&block)
+    scope.each(&block)
+  end
+
+  def before_method(method_name, *args)
+    self.class.dynamic_methods.each do |pattern, method|
+      if match_data = pattern.match(method_name)
+        return self.send(method, *match_data[1..-1])
+      end
+    end
+    raise NoMethodError.new("undefined method `#{method_name}' for #{self.inspect}")
+  end
+
+  delegate :to_a, to: :each
+  delegate *(Array.public_instance_methods - self.public_instance_methods), to: :to_a
+
+  protected
+
+  def limit_to(size)
+    @scope = scope.limit(size.to_i)
+  end
+  immutable_method :limit_to
+
+  def scope
+    @scope ||= default_scope
+  end
+
+  def default_scope
+    model_class
+  end
+
+  def context
+    @context
+  end
+
+  private
+  
+  if Rails.env.test? # Just for cleaner and simpler specs
+    def method_missing(name, *args, &block)
+      before_method(name.to_s)
+    end
+  end
+end