tigerlily-solid 0.2.0

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/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,138 @@
+# Solid
+
+Solid aim to provide a easier and nicer API to create custom Liquid tags and blocks
+
+## 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::ConditionalTag
+
+  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 %}
+```
+
+

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/app/assets/javascripts/ace/mode-solid.js

@@ -0,0 +1,203 @@
+define('ace/mode/solid_highlight_rules', function(require, exports, module) {
+
+var oop = require("../lib/oop");
+var HtmlHighlightRules = require("ace/mode/html_highlight_rules").HtmlHighlightRules;
+var TextHighlightRules = require("ace/mode/text_highlight_rules").TextHighlightRules;
+
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+var lang = require("../lib/lang");
+
+var SolidVariableHighlightRules = function() {
+    this.$rules = {
+      "start" : [
+          {
+             token : "variable.context",
+             regex : "[a-z_][a-zA-Z0-9_$]*\\b",
+             next  : 'filter',
+          }, {
+             token : "constant.language",
+             regex : "[a-zA-Z_][a-zA-Z0-9_$]*\\b",
+             next  : 'filter',
+          }, {
+             token : "string", // single line
+             regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+          }, {
+             token : "string", // single line
+             regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
+         }, {
+             token : "string", // backtick string
+             regex : "[`](?:(?:\\\\.)|(?:[^'\\\\]))*?[`]"
+         }
+      ],
+      'filter' : [
+          {
+            token : "keyword.operator",
+            regex : "\\|",
+            next  : 'filter'
+          }, {
+              token : "keyword.operator",
+              regex : "\:"
+          }, {
+            token : "support.function",
+            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
+          }, {
+            token : "string", // single line
+            regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+          }, {
+            token : "string", // single line
+            regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
+          }, {
+            token : "string", // backtick string
+            regex : "[`](?:(?:\\\\.)|(?:[^'\\\\]))*?[`]"
+          } 
+      ]
+    };
+};
+
+oop.inherits(SolidVariableHighlightRules, TextHighlightRules);
+
+exports.SolidVariableHighlightRules = SolidVariableHighlightRules;
+
+
+var SolidTagHighlightRules = function() {
+
+    var builtinConstants = lang.arrayToMap(
+        ("true|false|nil").split("|")
+    );
+    this.$rules = {
+        "start" : [
+            {
+               token : "support.function",
+               regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b",
+               next  : "literals"
+            }
+        ],
+        "literals" : [
+            {
+                token : "string.regexp",
+                regex : "[/](?:(?:\\[(?:\\\\]|[^\\]])+\\])|(?:\\\\/|[^\\]/]))*[/]\\w*\\s*(?=[).,;]|$)"
+            }, {
+                token : "string", // single line
+                regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+            }, {
+                token : "string", // single line
+                regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
+            }, {
+                token : "string", // backtick string
+                regex : "[`](?:(?:\\\\.)|(?:[^'\\\\]))*?[`]"
+            }, {
+                token : "text", // namespaces aren't symbols
+                regex : "::"
+            }, {
+                token : "constant.class", // class name
+                regex : "[A-Z](?:[a-zA-Z_]|\d)+"
+            }, {
+                token : "constant.symbol",
+                regex : "[a-zA-Z_][a-zA-Z0-9_]*\:"
+            }, {
+                token : "constant.symbol", // symbol
+                regex : "[:](?:[A-Za-z_]|[@$](?=[a-zA-Z0-9_]))[a-zA-Z0-9_]*[!=?]?"
+           }, {
+                token : "constant.numeric", // hex
+                regex : "0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_(?=[0-9a-fA-F]))*\\b"
+           },{
+                token : "constant.numeric", // float
+                regex : "[+-]?\\d(?:\\d|_(?=\\d))*(?:(?:\\.\\d(?:\\d|_(?=\\d))*)?(?:[eE][+-]?\\d+)?)?\\b"
+           }, {
+                token : "support.method",
+                regex : "\\.[a-z_$][a-zA-Z0-9_$]*[\\?\\!]?\\b"
+           }, {
+                token : "constant.language.boolean",
+                regex : "(?:true|false)\\b"
+           }, {
+                token : function(value) {
+                    if (builtinConstants.hasOwnProperty(value))
+                        return "constant.language";
+                    else
+                        return "variable.context";
+                },
+                regex : "[a-z_$][a-zA-Z0-9_$]*\\b"
+           }, {
+                token : "text",
+                regex : "\\s+"
+           }
+        ]
+    };
+};
+
+oop.inherits(SolidTagHighlightRules, TextHighlightRules);
+
+exports.SolidTagHighlightRules = SolidTagHighlightRules;
+
+var SolidHighlightRules = function() {
+  // TODO: make it work for scriptembed and cssembed
+  this.$rules = new HtmlHighlightRules().getRules();
+  this.$rules.start.unshift({
+    token: "keyword.operator",
+    regex: '{%',
+    next: 'solid-tag-start'
+  });
+
+  this.embedRules(SolidTagHighlightRules, "solid-tag-", [
+    {
+      token: ["keyword.operator", "string"],
+      regex: '(%})(")',
+      next: "tagembed-attribute-list"
+    }, {
+      token: "keyword.operator",
+      regex: '%}',
+      next: "start"
+    }
+  ]);
+
+  this.embedRules(SolidVariableHighlightRules, "solid-variable-", [
+    {
+       token: ["keyword.operator", "string"],
+       regex: '(}})(")',
+       next: "tagembed-attribute-list"
+    }, {
+       token: "keyword.operator",
+       regex: '}}',
+       next: "start"
+    }
+  ]);
+
+  this.$rules.start.unshift({
+    token: "keyword.operator",
+    regex: '{{',
+    next: 'solid-variable-start'
+  });
+
+  this.$rules['tagembed-attribute-list'].unshift({
+    token: ["string", "keyword.operator"],
+    regex: '(")({%)',
+    next: 'solid-tag-start'
+  });
+  this.$rules['tagembed-attribute-list'].unshift({
+    token: ["string", "keyword.operator"],
+    regex: '(")({{)',
+    next: 'solid-variable-start'
+  });
+
+}
+
+oop.inherits(SolidHighlightRules, HtmlHighlightRules);
+
+exports.SolidHighlightRules = SolidHighlightRules;
+});
+
+
+define('ace/mode/solid', function(require, exports, module) {
+
+var oop = require("../lib/oop");
+var TextMode = require("ace/mode/text").Mode;
+var Tokenizer = require("ace/tokenizer").Tokenizer;
+var SolidHighlightRules = require("ace/mode/solid_highlight_rules").SolidHighlightRules;
+
+var Mode = function() {
+    this.$tokenizer = new Tokenizer(new SolidHighlightRules().getRules());
+};
+oop.inherits(Mode, TextMode);
+
+exports.Mode = Mode;
+});

data/lib/solid.rb

@@ -0,0 +1,34 @@
+require 'liquid'
+
+module Solid
+  BASE_PATH = File.join(File.expand_path(File.dirname(__FILE__)), 'solid')
+
+  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 :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
+
+  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
+
+  end
+
+end

data/lib/solid/arguments.rb

@@ -0,0 +1,88 @@
+require 'parsr'
+
+class Solid::Arguments
+  include Enumerable
+
+  def self.parse(string)
+    new('[%s]' % string).parse!
+  end
+
+  attr_accessor :values
+
+  def initialize(string)
+    @string = string
+  end
+
+  def parse!
+    self.values = parser.parse(@string)
+    self
+  end
+
+  def each(*args, &block)
+    self.values.each(*args, &block)
+  end
+
+  def interpolate(context)
+    interpolate_one(self.values, context)
+  end
+
+  protected
+
+  def interpolate_one(value, context)
+    case value
+    when Solid::Arguments::ContextVariable
+      value.evaluate(context)
+    when Array
+      value.map{ |v| interpolate_one(v, context) }
+    when Hash
+      Hash[value.map{ |k, v| [interpolate_one(k, context), interpolate_one(v, context)] }]
+    else
+      value
+    end
+  end
+
+  def parser
+    unless defined?(@@parser)
+      rules = Parsr::Rules::All.dup
+      rules.insert(Parsr::Rules::All.index(Parsr::Rules::Constants) + 1, Solid::Arguments::ContextVariableRule)
+      @@parser = Parsr.new(*rules)
+    end
+    @@parser
+  end
+
+  class ContextVariable < Struct.new(:name)
+
+    def evaluate(context)
+      var, *methods = name.split('.')
+      object = context[var]
+      object = methods.inject(object) do |obj, method|
+        if obj.respond_to?(:public_send)
+          obj.public_send(method)
+        else # 1.8 fallback
+          obj.send(method) if obj.respond_to?(method, false)
+        end
+      end
+      
+      return Solid.unproxify(object)
+    end
+
+  end
+
+  module ContextVariableRule
+
+    PATTERN = /[a-zA-Z_][a-zA-Z\d_\.\!\?]*/
+
+    class << self
+
+      def match(scanner)
+        if scanner.scan(PATTERN)
+          variable = Solid::Arguments::ContextVariable.new(scanner.matched)
+          return Parsr::Token.new(variable)
+        end
+      end
+
+    end
+
+  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)
+    @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.last
+        render_all(block, context)
+      end
+    end
+  end
+
+  def unknown_tag(tag, markup, tokens)
+    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/element.rb

@@ -0,0 +1,56 @@
+module Solid::Element
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+    base.send(:include, Solid::Iterable)
+  end
+
+  module InstanceMethods
+
+    def initialize(tag_name, arguments_string, tokens)
+       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
+    
+  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/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/model_drop.rb

@@ -0,0 +1,118 @@
+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}
+            @scope = scope.public_send(:#{scope_name})
+          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)
+    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 *(Array.public_instance_methods - self.public_instance_methods), :to => :scope
+
+  protected
+
+  def limit_to(size)
+    @scope = scope.limit(size)
+  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/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))
+    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.0'
+end

data/solid.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "solid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tigerlily-solid"
+  s.version     = Solid::VERSION
+  s.authors     = ["Jean Boussier", "Yannick François"]
+  s.email       = ["jean.boussier@tigerlilyapps.com", "yannick@tigerlilyapps.com"]
+  s.homepage    = ""
+  s.summary     = %q{Helpers for easily creating custom Liquid tags and block}
+  #s.description = %q{TODO: Write a gem description}
+
+  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_runtime_dependency "liquid"
+  s.add_runtime_dependency "parsr", '0.0.4'
+end

data/spec/solid/arguments_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Solid::Arguments do
+
+  def parse(string, context={})
+    Solid::Arguments.parse(string).interpolate(context)
+  end
+
+  context 'with a single argument' do
+
+    context 'of type string' do
+
+      it 'can parse a simple string (between simple quotes)' do
+        parse("'foobar'").should be == ['foobar']
+      end
+
+      it 'can parse a simple string (between double quotes)' do
+        parse('"foobar"').should be == ['foobar']
+      end
+
+      it 'should not consider this string as a context var' do
+        parse('"foobar"', {'foobar' => 'plop'}).should_not == ['plop']
+      end
+
+      it 'should not be disturbed by a string containing a comma' do
+        parse(%{"foo,bar", 'egg,spam'}).should be == ['foo,bar', 'egg,spam']
+      end
+
+      it 'should not be disturbed by a string containing a simple quote' do
+        parse('"foo\'bar"').should be == ["foo'bar"]
+      end
+
+      it 'should not be disturbed by a string containing a double quote' do
+        parse("'foo\"bar'").should be == ['foo"bar']
+      end
+
+    end
+
+    context 'of type integer' do
+
+      it 'should works' do
+        parse('42').should be == [42]
+      end
+
+    end
+
+    context 'of type float' do
+
+      it 'should works' do
+        parse('4.2').should be == [4.2]
+      end
+
+    end
+
+    context 'of type boolean' do
+
+      it 'should works with `true`' do
+        parse('true').should be == [true]
+      end
+
+      it 'should works with `false`' do
+        parse('false').should be == [false]
+      end
+
+    end
+
+    context 'of type "context var"' do
+
+      it 'should works' do
+        parse('myvar', {'myvar' => 'myvalue'}).should be == ['myvalue']
+      end
+
+      it 'can call methods without arguments' do
+        parse('myvar.length', {'myvar' => ' myvalue '}).should be == [9]
+      end
+
+      it 'can evaluate context var deeply unclosed in collections' do
+        parse('[{1 => [{2 => myvar}]}]', {'myvar' => 'myvalue'}).first.should be == [{1 => [{2 => 'myvalue'}]}]
+      end
+
+      it 'can call methods chain without arguments' do
+        parse('myvar.strip.length', {'myvar' => ' myvalue '}).should be == [7]
+      end
+
+      it 'can call predicate methods' do
+        parse('myvar.empty?', {'myvar' => ' myvalue '}).should be == [false]
+      end
+
+      it 'should manage errors'
+
+    end
+
+    context 'of type "named parameter"' do
+
+      it 'should be able to parse a string' do
+        parse('foo:"bar"').should be == [{:foo => 'bar'}]
+      end
+
+      it 'should be able to parse an int' do
+        parse('foo:42').should be == [{:foo => 42}]
+      end
+
+      it 'should be able to parse a context var' do
+        parse('foo:bar', {'bar' => 'baz'}).should be == [{:foo => 'baz'}]
+      end
+
+      it "should not be disturbed by a comma into a named string" do
+        parse('foo:"bar,baz"').should be == [{:foo => 'bar,baz'}]
+      end
+
+    end
+
+  end
+
+  context 'with multiple arguments' do
+
+    it 'should return 3 arguments and an option hash' do
+      args = parse('1, "2", myvar, myopt:false', {'myvar' => 4.2})
+      args.should be == [1, '2', 4.2, {:myopt => false}]
+    end
+
+    it 'should be tolerent about whitespaces around commas and colons' do
+      args = parse("    1\t, '2'  ,myvar, myopt: false", {'myvar' => 4.2})
+      args.should be == [1, '2', 4.2, {:myopt => false}]
+    end
+
+  end
+
+end

data/spec/solid/block_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class DummyBlock < Solid::Block
+
+  def display(condition)
+    if condition
+      yield
+    else
+      'not_yielded'
+    end
+  end
+
+end
+
+describe Solid::Block do
+
+  it_behaves_like "a Solid element"
+
+  describe '#display' do
+
+    let(:tokens) { ["dummy", "{% enddummy %}", "outside"] }
+
+    subject{ DummyBlock.new('dummy', 'yield', tokens) }
+
+    it 'yielding should render the block content' do
+      subject.render('yield' => true).should be == 'dummy'
+    end
+
+    it 'should only render until the {% endblock %} tag' do
+      subject.render('yield' => true).should_not include('outside')
+    end
+
+    it 'should not render its content if it do not yield' do
+      subject.render('yield' => false).should_not include('dummy')
+    end
+
+  end
+
+end

data/spec/solid/conditional_block_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class IfPresent < Solid::ConditionalBlock
+
+  def display(string)
+    yield(!string.strip.empty?)
+  end
+
+end
+
+describe Solid::ConditionalBlock do
+
+  it_behaves_like "a Solid element"
+
+  describe '#display' do
+
+    let(:tokens) { ["present", "{% else %}", "blank", "{% endifpresent %}"] }
+
+    subject{ IfPresent.new('ifpresent', 'mystring', tokens) }
+
+    it 'yielding true should render the main block' do
+      context = Liquid::Context.new('mystring' => 'blah')
+      subject.render(context).should be == 'present'
+    end
+
+    it 'yielding false should render the `else` block' do
+      context = Liquid::Context.new('mystring' => '')
+      subject.render(context).should be == 'blank'
+    end
+
+  end
+
+end

data/spec/solid/element_examples.rb

@@ -0,0 +1,64 @@
+require 'solid'
+shared_examples "a Solid element" do
+
+  describe '.tag_name' do
+
+    it 'should register tag to Liquid with given name' do
+      Liquid::Template.should_receive(:register_tag).with('dummy', described_class)
+      described_class.tag_name 'dummy'
+    end
+
+    it 'should return previously given name' do
+      Liquid::Template.stub(:register_tag)
+      described_class.tag_name 'dummy'
+      described_class.tag_name.should be == 'dummy'
+    end
+
+  end
+
+  describe '.context_attribute' do
+
+    let(:element) do
+      described_class.context_attribute :current_user
+      element = described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+    end
+
+    it 'should define a custom accessor to the rendered context' do
+      element.stub(:current_context => {'current_user' => 'me'})
+      element.current_user.should be == 'me'
+    end
+
+    it 'should raise a Solid::ContextError if called outside render' do
+      expect{
+        element.current_user
+      }.to raise_error(Solid::ContextError)
+    end
+
+  end
+
+  describe '#arguments' do
+
+    it 'should instanciate a Solid::Arguments with his arguments_string' do
+      Solid::Arguments.should_receive(:parse).with('ARGUMENTS_STRING')
+      described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+    end
+
+    it 'should store his Solid:Arguments instance' do
+      element = described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+      element.arguments.should be_a(Solid::Arguments)
+    end
+
+  end
+
+  describe '#display' do
+
+    it 'should force developper to define it in child class' do
+      element = described_class.new('name', 'ARGUMENTS_STRING', ['{% endname %}'])
+      expect{
+        element.display
+      }.to raise_error(NotImplementedError)
+    end
+
+  end
+
+end

data/spec/solid/tag_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class DummyTag < Solid::Tag
+
+  def display(*args)
+    args.inspect
+  end
+
+end
+
+describe Solid::Tag do
+
+  it_behaves_like "a Solid element"
+
+  subject{ DummyTag.new('dummy', '1, "foo", myvar, myopts: false', 'token') }
+
+  it 'should works' do
+    subject.render('myvar' => 'bar').should be == '[1, "foo", "bar", {:myopts=>false}]'
+  end
+
+  it 'should send all parsed arguments do #display' do
+    subject.should_receive(:display).with(1, 'foo', 'bar', :myopts => false).and_return('result')
+    subject.render('myvar' => 'bar').should be == 'result'
+  end
+
+end

data/spec/solid/template_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Solid::Template do
+
+  let(:liquid) { %{first_string{% comment %}
+      {% if foo %}ifcontent{% endif %}
+      {% if foo %}ifsecondcontent{% endif %}
+    {% endcomment %}
+    {% unless foo %}unlesscontent{% endunless %}
+    
+  } }
+
+  let(:template) { Solid::Template.parse(liquid) }
+
+  specify { subject.should be_an(Enumerable) }
+
+  describe '#each' do
+
+    let(:yielded_nodes) do
+      [].tap do |nodes|
+        template.each{ |node| nodes << node }
+      end
+     end
+
+     let(:yielded_classes) { yielded_nodes.map(&:class) }
+
+    it 'should yield parent nodes before child nodes' do
+      yielded_classes.index(Liquid::Comment).should be < yielded_classes.index(Liquid::If)
+    end
+
+    it 'should yield first sibling first (No ! really ? ...)' do
+      yielded_classes.index(Liquid::Comment).should be < yielded_classes.index(Liquid::Unless)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'solid'))
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+Dir[File.join(File.dirname(__FILE__), '/**/*_examples.rb')].each{ |f| require f }

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: tigerlily-solid
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jean Boussier
+- Yannick François
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70127732609260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70127732609260
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: &70127732608840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70127732608840
+- !ruby/object:Gem::Dependency
+  name: parsr
+  requirement: &70127732608340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70127732608340
+description: 
+email:
+- jean.boussier@tigerlilyapps.com
+- yannick@tigerlilyapps.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/ace/mode-solid.js
+- lib/solid.rb
+- lib/solid/arguments.rb
+- lib/solid/block.rb
+- lib/solid/conditional_block.rb
+- lib/solid/context_error.rb
+- lib/solid/element.rb
+- lib/solid/engine.rb
+- lib/solid/iterable.rb
+- lib/solid/model_drop.rb
+- lib/solid/tag.rb
+- lib/solid/template.rb
+- lib/solid/version.rb
+- solid.gemspec
+- spec/solid/arguments_spec.rb
+- spec/solid/block_spec.rb
+- spec/solid/conditional_block_spec.rb
+- spec/solid/element_examples.rb
+- spec/solid/tag_spec.rb
+- spec/solid/template_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Helpers for easily creating custom Liquid tags and block
+test_files:
+- spec/solid/arguments_spec.rb
+- spec/solid/block_spec.rb
+- spec/solid/conditional_block_spec.rb
+- spec/solid/element_examples.rb
+- spec/solid/tag_spec.rb
+- spec/solid/template_spec.rb
+- spec/spec_helper.rb