locomotivecms_solid 0.2.1

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/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

data/lib/solid/parser.rb

@@ -0,0 +1,265 @@
+require 'set'
+require 'ripper'
+
+class Solid::Parser
+
+  class ContextVariable < Struct.new(:name)
+    def evaluate(context)
+      Solid.to_liquid(context[name], context)
+    end
+  end
+
+  class Literal < Struct.new(:value)
+    def evaluate(context)
+      Solid.to_liquid(value, context)
+    end
+  end
+
+  class LiteralArray < Literal
+    def evaluate(context)
+      value.map{ |v| v.evaluate(context) }
+    end
+  end
+
+  class LiteralRange < Struct.new(:start_value, :end_value, :exclusive)
+    def evaluate(context)
+      Range.new(start_value.evaluate(context), end_value.evaluate(context), exclusive)
+    end
+  end
+
+  class LiteralHash < Literal
+    def evaluate(context)
+      Hash[value.map{ |k, v| [k.evaluate(context), v.evaluate(context)] }]
+    end
+  end
+
+  class MethodCall < Struct.new(:receiver, :name, :arguments)
+    include Solid::MethodWhitelist
+    BUILTIN_HANDLERS = {
+      :'&&' => ->(left, right) { left && right },
+      :'||' => ->(left, right) { left || right }
+    }
+
+    def evaluate(context)
+      Solid.to_liquid(pluck(receiver.evaluate(context), name, *arguments.map {|arg| arg.evaluate(context) }), context)
+    end
+
+    protected
+
+    def pluck(object, method, *args)
+      if BUILTIN_HANDLERS.has_key?(method)
+        BUILTIN_HANDLERS[method].call(object, *args)
+      elsif safely_respond_to?(object, method)
+        object.public_send(method, *args)
+      elsif object.respond_to?(:[]) && args.empty?
+        object[method]
+      elsif object.respond_to?(:before_method)
+        object.before_method(method, *args)
+      end
+    end
+
+  end
+
+  class << self
+
+    def parse(string)
+      new(string).parse
+    end
+
+  end
+
+  def initialize(string)
+    @string = string
+    @sexp = nil
+  end
+
+  def parse
+    @sexp = Ripper.sexp(@string)
+    dive_in or raise 'Ripper changed?'
+    parse_one(@sexp)
+  end
+
+  # Looks for a structure like
+  # [:program, [[:array, [#stuff#]]]] or
+  # [:program, [[:array, nil]]]
+  def dive_in
+    @sexp = @sexp[1]
+    @sexp = @sexp.first
+  end
+
+  def parse_one(argument)
+    type = argument.shift
+    handler = "handle_#{type.to_s.sub('@', '')}"
+    raise Solid::SyntaxError, "unknown Ripper type: #{type.inspect}" unless respond_to?(handler)
+    public_send handler, *argument
+  end
+
+  # # spam
+  # [:@ident, "spam", [1, 33]] or
+  # # true
+  # [:@kw, "true", [1, 23]]
+  def handle_var_ref(var_ref)
+    parse_one(var_ref)
+  end
+
+  # # foo: 42
+  # [[:assoc_new, [:@label, "foo:", [1, 1]], [:@int, "42", [1, 5]]]]
+  def handle_bare_assoc_hash(assoc_hash)
+    LiteralHash.new assoc_hash.map {|(_, *key_value)| key_value.map(&method(:parse_one)) }
+  end
+
+  # # {foo: 42}
+  # [:assoclist_from_args, [[:assoc_new, [:@label, "foo:", [1, 2]], [:@int, "42", [1, 7]]]]]
+  def handle_hash(hash)
+    handle_bare_assoc_hash(hash.last)
+  end
+
+  # # myvar.length
+  #
+  # [:var_ref, [:@ident, "myvar", [1, 1]]]
+  # :"."
+  # [:@ident, "length", [1, 7]]
+  def handle_call(receiver_sexp, method_call, method_sexp)
+    receiver = parse_one(receiver_sexp)
+    method = method_sexp[1]
+    MethodCall.new receiver, method, []
+  end
+
+  # # myvar
+  #
+  # since 1.9.3
+  # [:vcall, [:@ident, "myvar", [1, 0]]]
+  def handle_vcall(expression)
+    parse_one(expression)
+  end
+
+  # # myvar.split(',', 2)
+  #
+  # [:call, [:var_ref, [:@ident, "myvar", [1, 1]]], :".", [:@ident, "split", [1, 7]]]
+  # [:arg_paren, [:args_add_block, [
+  #     [:string_literal, [:string_content, [:@tstring_content, ",", [1, 14]]]],
+  #     [:@int, "2", [1, 18]]
+  #   ], false]]
+  def handle_method_add_arg(call_sexp, args_sexp)
+    method_call = parse_one(call_sexp)
+    method_call.arguments = method_call_args(args_sexp)
+    method_call
+  end
+
+  # # args list: (',', 2)
+  # [:arg_paren, [:args_add_block, [
+  #     [:string_literal, [:string_content, [:@tstring_content, ",", [1, 14]]]],
+  #     [:@int, "2", [1, 18]]
+  #   ], false]]
+  #
+  # 1 args list: ()
+  # [:arg_paren, nil]
+  def method_call_args(args_sexp)
+    return [] if args_sexp[1].nil?
+    args_sexp = args_sexp.last[1]
+    args_sexp.map(&method(:parse_one))
+  end
+
+  # # !true
+  # [:!, [:var_ref, [:@kw, "true", [1, 1]]]]
+  def handle_unary(operator, operand)
+    MethodCall.new(parse_one(operand), operator, [])
+  end
+
+  # # 1 + 2
+  # [:@int, "1", [1, 0]], :*, [:@int, "2", [1, 4]]
+  def handle_binary(left_operand, operator, right_operand)
+    receiver = parse_one(left_operand)
+    MethodCall.new(receiver, operator, [parse_one(right_operand)])
+  end
+
+  # # [1]
+  # [[:@int, "1", [1, 1]]
+  def handle_array(array)
+    LiteralArray.new((array || []).map(&method(:parse_one)))
+  end
+
+  # # (1)
+  # [[:@int, "42", [1, 2]]]
+  def handle_paren(content)
+    parse_one(content.first)
+  end
+
+  # # 1..10
+  # [[:@int, "1", [1, 0]], [:@int, "10", [1, 4]]]
+  def handle_dot2(start_value, end_value)
+    LiteralRange.new(parse_one(start_value), parse_one(end_value), false)
+  end
+
+  # # 1...10
+  # [[:@int, "1", [1, 0]], [:@int, "10", [1, 4]]]
+  def handle_dot3(start_value, end_value)
+    LiteralRange.new(parse_one(start_value), parse_one(end_value), true)
+  end
+
+  # # 'mystring'
+  # [:string_content, [:@tstring_content, "mystring", [1, 14]]]
+  # TODO: handle string interpolation
+  def handle_string_literal(string_content)
+    Literal.new(parse_one(string_content))
+  end
+
+  def handle_string_content(*parts)
+    parts.map(&method(:parse_one)).join
+  end
+
+  # [:@tstring_content, "mystring", [1, 14]]
+  def handle_tstring_content(string_content, lineno_column)
+    string_content
+  end
+
+  # # /bb|[^b]{2}/
+  # [[:@tstring_content, "bb|[^b]{2}", [1, 2]]].first.first
+  # TODO: handle regexp interpolation
+  def handle_regexp_literal(regexp_literal, lineno_column)
+    Literal.new Regexp.new(regexp_literal.first[1])
+  end
+
+  KEYWORDS = {
+    'true' => Literal.new(true),
+    'false' => Literal.new(false),
+    'nil' => Literal.new(nil),
+  }
+  # # true
+  # "true", [1, 33]
+  def handle_kw(keyword, lineno_column)
+    raise Solid::SyntaxError, 'unknown Ripper sexp' unless KEYWORDS.has_key? keyword
+    KEYWORDS[keyword]
+  end
+
+  # # spam
+  # "spam", [1, 23]
+  def handle_ident(identifier, lineno_column)
+    ContextVariable.new identifier
+  end
+
+  # # Spam
+  # "Spam", [1, 23]
+  def handle_const(constant, lineno_column)
+    ContextVariable.new constant
+  end
+
+  # # 42
+  # "42", [1, 2]
+  def handle_int(int, lineno_column)
+    Literal.new int.to_i
+  end
+
+  # # 4.2
+  # "4.2", [1, 2]
+  def handle_float(float, lineno_column)
+    Literal.new float.to_f
+  end
+
+  # # foo:
+  # "foo:", [1, 2]
+  def handle_label(label, lineno_column)
+    Literal.new label[0..-2].to_sym
+  end
+
+end

data/lib/solid/tag.rb

@@ -0,0 +1,11 @@
+class Solid::Tag < Liquid::Tag
+
+  include Solid::Element
+
+  def render(context)
+    with_context(context) do
+      display(*arguments.interpolate(context).map(&Solid.method(:unproxify)))
+    end
+  end
+
+end

data/lib/solid/template.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+
+class Solid::Template < Liquid::Template
+  extend Forwardable
+  include Solid::Iterable
+
+  class << self
+
+    def parse(source)
+      template = Solid::Template.new
+      template.parse(source)
+      template
+    end
+
+  end
+
+  def_delegators :root, :nodelist
+
+  # Avoid issues with ActiveSupport::Cache which freeze all objects passed to it like an ass
+  # And anyway once frozen Liquid::Templates are unable to render anything
+  def freeze
+  end
+
+end

data/lib/solid/version.rb

@@ -0,0 +1,3 @@
+module Solid
+  VERSION = '0.2.1'
+end

data/lib/solid.rb

@@ -0,0 +1,48 @@
+require 'liquid'
+
+module Solid
+  BASE_PATH = File.join(File.expand_path(File.dirname(__FILE__)), 'solid')
+
+  require File.join(BASE_PATH, 'extensions')
+
+  autoload :Argument,         File.join(BASE_PATH, 'argument')
+  autoload :Arguments,        File.join(BASE_PATH, 'arguments')
+  autoload :Block,            File.join(BASE_PATH, 'block')
+  autoload :ConditionalBlock, File.join(BASE_PATH, 'conditional_block')
+  autoload :ContextError,     File.join(BASE_PATH, 'context_error')
+  autoload :Element,          File.join(BASE_PATH, 'element')
+  autoload :Iterable,         File.join(BASE_PATH, 'iterable')
+  autoload :MethodWhitelist,  File.join(BASE_PATH, 'method_whitelist')
+  autoload :Parser,           File.join(BASE_PATH, 'parser')
+  autoload :Tag,              File.join(BASE_PATH, 'tag')
+  autoload :Template,         File.join(BASE_PATH, 'template')
+  autoload :VERSION,          File.join(BASE_PATH, 'version')
+
+  if defined?(Rails) # Rails only features
+    autoload :ModelDrop,      File.join(BASE_PATH, 'model_drop')
+    require File.join(BASE_PATH, 'engine')
+  end
+
+  require File.join(BASE_PATH, 'liquid_extensions')
+
+  class << self
+
+    def unproxify(object)
+      class_name = object.class.name
+      if class_name && class_name.end_with?('::LiquidDropClass')
+        return object.instance_variable_get('@object')
+      end
+      object
+    end
+
+    def to_liquid(object, context)
+      object = object.to_liquid
+      object.context = context if object.respond_to?(:context=)
+      object
+    end
+
+  end
+
+  SyntaxError = Class.new(Liquid::SyntaxError)
+
+end

data/locomotivecms_solid.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "solid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "locomotivecms_solid"
+  s.version     = Solid::VERSION
+  s.authors     = ["Jean Boussier", "Yannick François", "Didier Lafforgue"]
+  s.email       = ["jean.boussier@tigerlilyapps.com", "yannick@tigerlilyapps.com", "didier.lafforgue@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Helpers for easily creating custom Liquid tags and block}
+  s.description = %q{The Solid gem from the TigerLily team but modified to work with LocomotiveCMS}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "i18n"
+  s.add_development_dependency "activesupport", "~> 3"
+  s.add_runtime_dependency "locomotive_liquid", '~> 2.4.2'
+end