locomotivecms-solid 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c7a10871a1bd686fd52392900ae05429a57efa5
+  data.tar.gz: 18d617cded1dc8a1abd28548be9c40aee0343e86
+SHA512:
+  metadata.gz: fb7ffdbd7aeb5a8755ce513be15d39f02a3f0196eb70ed69c853098845feac19b82409656fd7c354210ce26a234015d4f06c13c9ac8feaad7f17f806e35279ec
+  data.tar.gz: a9cb451974d001e7ebe5a34872dab917090481f1f8b79011a263e24883987d0ec9142278f8375f45bcf578ec60851999076fdee66ceb0987b9b1814fe97c2b6c

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in solid.gemspec
+gemspec
+
+# gem 'locomotivecms-liquid', path: '/Users/didier/Documents/LocomotiveCMS/gems/liquid'

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.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/lib/solid/arguments.rb

@@ -0,0 +1,26 @@
+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