wlang 2.0.0.beta → 2.0.0

data/lib/wlang/dialect/evaluation.rb

@@ -1,30 +0,0 @@
-module WLang
-  class Dialect
-    module Evaluation
-
-      def scope
-        @scope ||= Scope.root
-      end
-
-      def with_scope(x)
-        @scope = scope.push(x)
-        res    = yield
-        @scope = scope.pop
-        res
-      end
-
-      def evaluate(expr, *default)
-        case expr
-        when Symbol, String
-          catch(:fail) do
-            return scope.evaluate(expr, *default)
-          end
-          raise NameError, "Unable to find `#{expr}`"
-        else
-          evaluate(render(expr), *default)
-        end
-      end
-
-    end # module Evaluation
-  end # class Dialect
-end # module WLang

data/lib/wlang/dialect/tags.rb

@@ -1,50 +0,0 @@
-module WLang
-  class Dialect
-    module Tags
-
-      module ClassMethods
-
-        protected
-
-        def tag(symbols, dialects = nil, method = nil, &block)
-          if block
-            tag(symbols, dialects, block)
-          else
-            dialects, method = nil, dialects if method.nil?
-            define_tag_method(symbols, dialects, method)
-          end
-        end
-
-      end
-
-      module InstanceMethods
-
-        protected
-
-        def render(fn, scope = nil, buffer = "")
-          if scope.nil?
-            case fn
-            when String
-              buffer << fn
-            when Proc
-              fn.call(self, buffer)
-            when Template
-              fn.call(@scope, buffer)
-            else
-              raise ArgumentError, "Unable to render `#{fn}`"
-            end
-          else
-            with_scope(scope){ render(fn, nil, buffer) }
-          end
-        end
-
-      end
-
-      def self.included(mod)
-        mod.instance_eval{ include(InstanceMethods) }
-        mod.extend(ClassMethods)
-      end
-
-    end # module Tags
-  end # class Dialect
-end # module WLang

data/lib/wlang/mustang.rb

@@ -1,90 +0,0 @@
-require 'wlang'
-require 'wlang/dummy'
-module WLang
-  #
-  # A WLang dialect mimicing the excellent Mustache.
-  #
-  # This dialect installs the following high-order functions:
-  #
-  # * `${...}` mimics mustache's `{{ ... }}` that is, it evaluates the variable and
-  #    returns the HTML-escaped string
-  # * `+{...}` mimics mustache's `{{{ ... }}}` that is, it evaluates the variable and
-  #   returns its string representation (through `to_s`)
-  # * `#{..1..}{..2..}` mimics mustache's `{{#..1..}}..2..{{/..1..}}`. For false and nil,
-  #   it returns nil. For scopes and ranges, it instantiates the second block in the scope
-  #   of each element in turn and returns the concatenation of instantiation results. For
-  #   a Proc, it calls it, passing a rendering continuation as first argument. Every other
-  #   object is used as a new scope in which the second block is instantiated.
-  # * `^{..1..}{..2..}` mimics mustache's `{{^..1..}}..2..{{/..1..}}`, instantiating the
-  #   second only if the evaluation of the first yields false, nil, an empty list or an
-  #   unbound variable.
-  # * `>{...}` mimics mustache's `{{>...}}`, instantiating the partial denoted by the
-  #    evaluated expression.
-  # * `!{...}` mimics mustache's `{{!...}}`, taking the block content as a comment
-  #   therefore skipping it.
-  #
-  class Mustang < WLang::Dialect
-
-    module HighOrderFunctions
-
-      def plus(buf, fn)
-        if x = evaluate(fn)
-          buf << x.to_s
-        end
-      end
-
-      def escape(buf, fn)
-        buf << Temple::Utils.escape_html(evaluate(fn))
-      end
-
-      def section(buf, fn1, fn2)
-        case x = evaluate(fn1)
-        when FalseClass, NilClass
-          nil
-        when Array, Range
-          x.each{|item|
-            render(fn2, item, buf)
-          }
-        when Proc
-          buf << x.call(lambda{ render(fn2) })
-        else
-          render(fn2, x, buf)
-        end
-      end
-
-      def inverted(buf, fn1, fn2)
-        case x = evaluate(fn1)
-        when FalseClass, NilClass
-          render(fn2, scope, buf)
-        when Array
-          render(fn2, scope, buf) if x.empty?
-        end
-      end
-
-      def comment(buf, fn)
-      end
-
-      def partial(buf, fn)
-        if x = Mustang.compile(evaluate(fn))
-          render(x, scope, buf)
-        end
-      end
-
-    end
-    include HighOrderFunctions
-
-    def evaluate(expr)
-      super
-    rescue
-      nil
-    end
-
-    tag '+', :plus
-    tag '$', :escape
-    tag '#', :section
-    tag '^', :inverted
-    tag '>', :partial
-    tag '!', [WLang::Dummy], :comment
-
-  end # class Mustang
-end # module WLang

data/spec/integration/test_mustang.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-require 'wlang/mustang'
-module WLang
-  describe Mustang do
-
-    def m(tpl, scope = {}, buffer = "")
-      Mustang.render(tpl, scope, buffer)
-    end
-
-    context '+{...} mimicing {{{ ... }}}' do
-      it "renders nothing on nil" do
-        m('Hello +{who}', :who => nil).should eq("Hello ")
-      end
-      it "renders nothing on unknown" do
-        m('Hello +{who}', {}).should eq("Hello ")
-      end
-      it "renders the variable if known" do
-        m('Hello +{who}', :who => "World").should eq("Hello World")
-      end
-      it "calls to_s on such variable" do
-        m('Hello +{who}', :who => 12).should eq("Hello 12")
-      end
-      it "does not escape html" do
-        m('Hello +{who}', :who => "<script>").should eq("Hello <script>")
-      end
-    end
-
-    context "${...} mimicing {{ ... }}" do
-      it "renders nothing on nil" do
-        m('Hello ${who}', :who => nil).should eq("Hello ")
-      end
-      it "renders nothing on unknown" do
-        m('Hello ${who}', {}).should eq("Hello ")
-      end
-      it "renders the variable if known" do
-        m('Hello ${who}', :who => "World").should eq("Hello World")
-      end
-      it "calls to_s on such variable" do
-        m('Hello ${who}', :who => 12).should eq("Hello 12")
-      end
-      it "does escape html" do
-        m('Hello ${who}', :who => "<script>").should eq("Hello &lt;script&gt;")
-      end
-    end
-
-    context '#{..1..}{..2..} mimicing {{#..1..}}..2..{{/..1..}} ' do
-      it 'skips the section on false' do
-        m('Hello #{present}{World}', :present => false).should eq("Hello ")
-      end
-      it 'skips the section on nil' do
-        m('Hello #{present}{World}', :present => nil).should eq("Hello ")
-      end
-      it 'skips the section on missing' do
-        m('Hello #{present}{World}').should eq("Hello ")
-      end
-      it 'skips the section on empty lists' do
-        m('Hello #{present}{World}', :present => []).should eq("Hello ")
-      end
-      it 'iterates on non-empty lists' do
-        repo = [{:name => "resque"},{:name => "hub"},{:name => "rip"}]
-        m('Hello #{repo}{<b>${name}</b>}', :repo => repo).should eq("Hello <b>resque</b><b>hub</b><b>rip</b>")
-      end
-      it 'iterates on ranges' do
-        m('Hello #{range}{.}', :range => 1..10).should eq("Hello ..........")
-      end
-      it 'passes the block to a lambda' do
-        wrapped = lambda{|fn| "<b>#{fn.call}</b>"}
-        scope   = {:wrapped => wrapped, :name => "World"}
-        m('#{wrapped}{Hello ${name}}', scope).should eq("<b>Hello World</b>")
-      end
-      it 'use a Hash a a new scope' do
-        m('Hello #{person}{${name}}', :person => {:name => "World"}).should eq("Hello World")
-      end
-      it 'use a Struct a a new scope' do
-        person = Struct.new(:name).new("World")
-        m('Hello #{person}{${name}}', :person => person).should eq("Hello World")
-      end
-      it 'outputs frequently when iterating' do
-        m('#{range}{.}', {:range => 1..10}, []).should eq(Array.new(10, '.'))
-      end
-    end
-
-    context "^{..1..}{..2..} mimicing {{^..1..}}..2..{{/..1..}}" do
-      it 'renders the section on false' do
-        m('Hello ^{missing}{World}', :missing => false).should eq("Hello World")
-      end
-      it 'renders the section on nil' do
-        m('Hello ^{missing}{World}', :missing => nil).should eq("Hello World")
-      end
-      it 'renders the section on missing' do
-        m('Hello ^{missing}{World}').should eq("Hello World")
-      end
-      it 'renders the section on empty lists' do
-        m('Hello ^{missing}{World}', :missing => []).should eq("Hello World")
-      end
-      it 'does not iterate lists' do
-        repo = [{:name => "resque"},{:name => "hub"},{:name => "rip"}]
-        m('Hello ^{repo}{<b>${name}</b>}', :repo => repo).should eq("Hello ")
-      end
-    end
-
-    context "!{...} mimicing {{!...}}" do
-      it 'skips the section altogether' do
-        m('Hello !{this is a comment} world').should eq("Hello  world")
-      end
-    end
-
-    context '>{...} mimicing {{>...}}' do
-      it 'renders the partial' do
-        scope = {:who => "<b>${name}</b>", :name => "World"}
-        m("Hello >{who}", scope).should eq("Hello <b>World</b>")
-      end
-      it 'supports a pre-compiled partial' do
-        scope = {:who => Mustang.compile("<b>${name}</b>"), :name => "World"}
-        m("Hello >{who}", scope).should eq("Hello <b>World</b>")
-      end
-    end
-
-  end # describe Mustang
-end # module WLang

data/spec/unit/dialect/test_dispatching.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module WLang
-  describe Dialect::Dispatching do
-    include Dialect::Dispatching::ClassMethods
-
-    describe 'tag_dispatching_name' do
-      it "works with a single char" do
-        tag_dispatching_name("$").should eq(:_tag_36)
-      end
-      it "works with a multiple chars" do
-        tag_dispatching_name("!$").should eq(:_tag_33_36)
-      end
-      it "works with an array" do
-        tag_dispatching_name(['!', '$']).should eq(:_tag_33_36)
-      end
-    end
-
-  end # describe Dialect
-end # module WLang

data/spec/unit/dialect/test_tags.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module WLang
-  describe Dialect::Tags do
-
-    describe 'tag' do
-      include Dialect::Tags::ClassMethods
-
-      def define_tag_method(*args)
-        args
-      end
-
-      it "works with a symbol" do
-        tag("$", :dollar).should eq(["$", nil, :dollar])
-      end
-
-      it "works with a single proc" do
-        proc = lambda{|buf,fn| }
-        tag("$", &proc).should eq(["$", nil, proc])
-      end
-
-      it "allows specifying dialects with a symbol" do
-        tag("$", [Foo], :dollar).should eq(["$", [Foo], :dollar])
-      end
-
-      it "allows specifying dialects with a proc" do
-        proc = lambda{|buf,fn| }
-        tag("$", [Foo], &proc).should eq(["$", [Foo], proc])
-      end
-    end
-
-  end # describe Dialect
-end # module WLang