wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/dialect/evaluation.rb

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

@@ -0,0 +1,50 @@
+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/dummy.rb

@@ -0,0 +1,32 @@
+require 'wlang'
+module WLang
+  #
+  # The _dummy_ dialect, which has no tag at all.
+  #
+  # This dialect can be used to parse tag blocks without further interpreting
+  # any wlang tag. This is needed to flush wlang output in certain situations
+  # as illustrated by the following template:
+  #
+  #     Hello ${who}! This is wlang, a templating language which comes with
+  #     special tags such as %{ ${who}, +{who}, *{authors}{...}, etc }
+  #
+  # The special tag %{ } might easily be implemented using the Dummy dialect:
+  #
+  #     require 'wlang/dummy'
+  #     class MyDialect < WLang::Dialect
+  #
+  #       def dollar(buf, fn)
+  #         buf << evaluate(fn)
+  #       end
+  #
+  #       def no_wlang(buf, fn)
+  #         render(fn)
+  #       end
+  #
+  #       tag '$', :dollar
+  #       tag '%', [WLang::Dummy], :no_wlang
+  #     end
+  #
+  class Dummy < Dialect
+  end # class Dummy
+end # module WLang

data/lib/wlang/html.rb

@@ -0,0 +1,106 @@
+require 'wlang'
+require 'wlang/dummy'
+module WLang
+  class Html < WLang::Dialect
+
+    module Helpers
+
+      def value_of(fn)
+        evaluate(render(fn).to_s.strip)
+      end
+      private :value_of
+
+      def to_html(val)
+        val = val.to_html if val.respond_to?(:to_html)
+        val = to_html(val.call) if val.is_a?(Proc)
+        val.to_s
+      end
+      private :to_html
+
+      def escape_html(val)
+        Temple::Utils.escape_html(val)
+      end
+      private :escape_html
+
+    end
+    include Helpers
+
+    module HighOrderFunctions
+
+      def bang(buf, fn)
+        val = value_of(fn).to_s
+        render(val, nil, buf)
+      end
+
+      def plus(buf, fn)
+        val = value_of(fn)
+        val = to_html(val) unless val.is_a?(Template)
+        render(val, nil, buf)
+      end
+
+      def dollar(buf, fn)
+        val = escape_html(plus("", fn))
+        render(val, nil, buf)
+      end
+
+      def ampersand(buf, fn)
+        val = escape_html(render(fn))
+        render(val, nil, buf)
+      end
+
+      def slash(buf, fn)
+      end
+
+      def modulo(buf, fn)
+        render(fn, nil, buf)
+      end
+
+      def question(buf, fn_if, fn_then, fn_else)
+        val = value_of(fn_if) ? fn_then : fn_else
+        render(val, nil, buf) if val
+      end
+
+      def caret(buf, fn_if, fn_then, fn_else)
+        val = value_of(fn_if) ? fn_else : fn_then
+        render(val, nil, buf) if val
+      end
+
+      def star(buf, coll_fn, elm_fn, between_fn)
+        collection = value_of(coll_fn)
+        collection.each_with_index do |elm,i|
+          render(between_fn, elm, buf) if between_fn and (i > 0)
+          render(elm_fn, elm, buf)
+        end
+      end
+
+      def greater(buf, fn)
+        val = value_of(fn)
+        val = Html.compile(val) unless Template === val
+        render(val, nil, buf)
+      end
+
+      def sharp(buf, who_fn, then_fn)
+        val = value_of(who_fn)
+        if val and not(val.respond_to?(:empty?) and val.empty?)
+          render(then_fn, val, buf)
+        end
+      end
+
+    end
+    include HighOrderFunctions
+
+    default_options :autospacing => true
+    tag '!', :bang
+    tag '+', :plus
+    tag '$', :dollar
+    tag '&', :ampersand
+    tag '/', :slash
+    tag '%', [WLang::Dummy], :modulo
+    tag '?', :question
+    tag '^', :caret
+    tag '*', :star
+    tag '>', :greater
+    tag '#', :sharp
+
+  end # class Html
+end # module WLang

data/lib/wlang/loader.rb

@@ -0,0 +1,6 @@
+require "citrus"
+require "temple"
+if RUBY_VERSION < "1.9"
+  require 'backports'
+  require "backports/basic_object" unless defined?(BasicObject)
+end

data/lib/wlang/mustang.rb

@@ -0,0 +1,90 @@
+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/lib/wlang/scope.rb

@@ -0,0 +1,57 @@
+module WLang
+  class Scope
+
+    attr_reader :subject
+    attr_reader :parent
+
+    def initialize(subject, parent)
+      @subject, @parent = subject, parent
+    end
+
+    def self.root
+      @root ||= RootScope.new
+    end
+
+    def self.coerce(arg, parent = root)
+      clazz = case arg
+      when Binding
+        BindingScope
+      when Scope
+        ProxyScope
+      else
+        ObjectScope
+      end
+      clazz.new(arg, parent)
+    end
+
+    def push(x)
+      Scope.coerce(x, self)
+    end
+
+    def pop
+      @parent
+    end
+
+    def with(x)
+      yield(self.push(x))
+    end
+
+    def evaluate(expr, *default)
+      unfound = lambda{ default.empty? ? throw(:fail) : default.first }
+      expr    = expr.to_s.strip
+      if expr.to_s.index('.').nil?
+        fetch(expr.to_sym, &unfound)
+      else
+        keys = expr.split('.').map(&:to_sym)
+        keys.inject(self){|scope,key|
+          Scope.coerce(scope.fetch(key, &unfound))
+        }.subject
+      end
+    end
+
+  end # class Scope
+end # module WLang
+require 'wlang/scope/root_scope'
+require 'wlang/scope/proxy_scope'
+require 'wlang/scope/object_scope'
+require 'wlang/scope/binding_scope'

data/lib/wlang/scope/binding_scope.rb

@@ -0,0 +1,18 @@
+module WLang
+  class Scope
+    class BindingScope < Scope
+
+      def fetch(k, &blk)
+        subject.eval(k.to_s)
+      rescue NameError
+        parent.fetch(k, &blk)
+      end
+
+      def inspect
+        "BindingScope(#{subject.inspect})"
+      end
+      alias :to_s :inspect
+
+    end # class ProxyScope
+  end # class Scope
+end # module WLang

data/lib/wlang/scope/object_scope.rb

@@ -0,0 +1,25 @@
+module WLang
+  class Scope
+    class ObjectScope < Scope
+
+      def fetch(k, &blk)
+        s = subject
+        return s if k == :self
+        if s.respond_to?(:has_key?)
+          return s[k] if s.has_key?(k)
+          return s[k.to_s] if s.has_key?(k.to_s)
+        end
+        return s.send(k) if s.respond_to?(k)
+        parent.fetch(k, &blk)
+      rescue NameError
+        parent.fetch(k, &blk)
+      end
+
+      def inspect
+        "ObjectScope(#{subject.inspect})"
+      end
+      alias :to_s :inspect
+
+    end # class ProxyScope
+  end # class Scope
+end # module WLang

data/lib/wlang/scope/proxy_scope.rb

@@ -0,0 +1,18 @@
+module WLang
+  class Scope
+    class ProxyScope < Scope
+
+      def fetch(key, &blk)
+        subject.fetch(key) do
+          parent.fetch(key, &blk)
+        end
+      end
+
+      def inspect
+        subject.inspect
+      end
+      alias :to_s :inspect
+
+    end # class ProxyScope
+  end # class Scope
+end # module WLang

data/lib/wlang/scope/root_scope.rb

@@ -0,0 +1,24 @@
+module WLang
+  class Scope
+    class RootScope < Scope
+
+      def initialize
+        super(nil,nil)
+      end
+
+      def pop
+        raise "Unable to pop from root scope"
+      end
+
+      def fetch(key)
+        block_given? ? yield : throw(:fail)
+      end
+
+      def inspect
+        "RootScope"
+      end
+      alias :to_s :inspect
+
+    end # class RootScope
+  end # class Scope
+end # module WLang