wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/command.rb

@@ -0,0 +1,94 @@
+require 'wlang'
+require 'quickl'
+module WLang
+  #
+  # wlang -- templating engine
+  #
+  # SYNOPSIS
+  #   Usage: wlang [options] TEMPLATE
+  #
+  # OPTIONS:
+  # #{summarized_options}
+  #
+  # DESCRIPTION
+  #   This command invokes the wlang templating engine on TEMPLATE
+  #   and flushes the rendering result on standard output.
+  #
+  class Command < Quickl::Command(__FILE__, __LINE__)
+
+    options do |opt|
+      @output = nil
+      opt.on('--output=FILE', 'Render output in FILE') do |file|
+        @output = file
+      end
+      @yaml_front_matter = true
+      opt.on("--[no-]yaml-front-matter",
+             "Enable/disable YAML front mater (defaults to true)") do |val|
+        @yaml_front_matter = val
+      end
+      @ast = false
+      opt.on('--ast', "Debugs the AST") do
+        @ast = true
+      end
+      @compiling_options = {}
+      opt.on('--[no-]auto-spacing') do |val|
+        @compiling_options[:autospacing] = val
+      end
+      opt.on_tail("--help", "Show help") do
+        raise Quickl::Help
+      end
+      opt.on_tail("--version", "Show version") do
+        raise Quickl::Exit, "#{Quickl.program_name} #{WLang::VERSION} (c) 2009-2012, Bernard Lambeau"
+      end
+    end
+
+    def execute(argv)
+      install(argv)
+
+      compiler = @dialect.compiler(@compiling_options)
+      if @ast
+        require 'awesome_print'
+        ap compiler.ast(@template)
+      end
+
+      with_output do |output|
+        compiler.compile(@template).render(@context, output)
+      end
+    end
+
+    private
+
+    def install(argv)
+      raise Quickl::Help unless argv.size == 1
+
+      # template file
+      unless File.file?(@tpl_file = argv.first)
+        raise Quickl::Exit, "No such template #{tpl_file}"
+      end
+
+      # dialect
+      require 'wlang/html'
+      @dialect       = WLang::Html
+
+      # template and context
+      @template      = File.read(@tpl_file)
+      @context       = {}
+
+      if @yaml_front_matter and
+         @template =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        require 'yaml'
+        @context.merge! YAML::load($1)
+        @template = $'
+      end
+    end
+
+    def with_output(&proc)
+      if @output
+        File.open(@output, 'w', &proc)
+      else
+        proc.call($stdout)
+      end
+    end
+
+  end # class Command
+end # module WLang

data/lib/wlang/compiler.rb

@@ -0,0 +1,78 @@
+require 'wlang/compiler/parser'
+require 'wlang/compiler/filter'
+require 'wlang/compiler/dialect_enforcer'
+require 'wlang/compiler/strconcat_flattener'
+require 'wlang/compiler/proc_call_removal'
+require 'wlang/compiler/autospacing'
+require 'wlang/compiler/to_ruby_abstraction'
+require 'wlang/compiler/static_merger'
+require 'wlang/compiler/to_ruby_code'
+module WLang
+  #
+  # Provides the wlang compiler which works on the following AST abstractions:
+  #
+  # - :template,  the root element      [:template, [:fn, ...]]
+  # - :fn,        a concrete function   [:fn, code]
+  # - :wlang,     a high-order function [:wlang, symbols, [:fn, ..], [:fn, ...], ...]
+  # - :strconcat, concatenation         [:strconcat, [...], [...], [...]]
+  # - :modulo,    modulation            [:modulo, dialect, [:fn, ...]]
+  # - :static,    constant text         [:static, "..."]
+  #
+  class Compiler
+
+    attr_reader :dialect
+
+    def initialize(dialect)
+      @dialect = dialect
+    end
+
+    def options
+      dialect.options
+    end
+
+    def compile(source)
+      case source
+      when Template
+        source
+      when Proc
+        Template.new(@dialect, source)
+      else
+        code = to_ruby_code(source)
+        proc = eval(code, TOPLEVEL_BINDING)
+        Template.new(@dialect, proc)
+      end
+    end
+
+    def to_ruby_code(source)
+      engine.call(source)
+    end
+
+    def ast(source)
+      parser.new.call(source)
+    end
+
+    def parser
+      Class.new(Temple::Engine).tap{|c|
+        c.use Parser
+        c.use DialectEnforcer, :dialect => @dialect
+        c.use Autospacing if options[:autospacing]
+        c.use StrconcatFlattener
+        c.use StaticMerger
+      }
+    end
+
+    def engine(gencode = true)
+      Class.new(Temple::Engine).tap{|c|
+        c.use Parser
+        c.use DialectEnforcer, :dialect => @dialect
+        c.use Autospacing if options[:autospacing]
+        c.use StrconcatFlattener
+        c.use StaticMerger
+        c.use ProcCallRemoval
+        c.use ToRubyAbstraction
+        c.use ToRubyCode if gencode
+      }.new
+    end
+
+  end # class Compiler
+end # module WLang

data/lib/wlang/compiler/autospacing.rb

@@ -0,0 +1,60 @@
+module WLang
+  class Compiler
+    class Autospacing < Filter
+
+      def on_strconcat(*exps)
+        optimized = []
+        exps.each_with_index do |exp,i|
+          optimized[i] = call(exp)
+          if exp.first == :wlang and multiline?(exp) and i != 0
+            optimized[i-1] = RightStrip.new.call(optimized[i-1])
+          end
+        end
+        [:strconcat] + optimized
+      end
+
+      def on_wlang(symbols, *fns)
+        fns.inject [:wlang, symbols] do |rw,fn|
+          fn = Unindent.new.call(fn)
+          fn = RightStrip.new.call(fn)
+          rw << call(fn)
+        end
+      end
+
+      private
+
+      def multiline?(who)
+        case who.first
+        when :static
+          who.last =~ /\n/
+        when :wlang, :modulo
+          who[2..-1].any?{|s| s && multiline?(s)}
+        else
+          who[1..-1].any?{|s| s && multiline?(s)}
+        end
+      end
+
+      class RightStrip < Filter
+
+        def on_strconcat(*exps)
+          exps[-1] = call(exps[-1])
+          [:strconcat] + exps
+        end
+
+        def on_static(text)
+          [:static, text.gsub(/\s+\Z/m, '')]
+        end
+
+      end # class RightStrip
+
+      class Unindent < Filter
+
+        def on_static(text)
+          [:static, text.gsub(/^  /m, '')]
+        end
+
+      end # class Unindent
+
+    end # class Autospacing
+  end # class Compiler
+end # module WLang

data/lib/wlang/compiler/dialect_enforcer.rb

@@ -0,0 +1,91 @@
+module WLang
+  class Compiler
+    class DialectEnforcer < Filter
+
+      def dialect; options[:dialect]; end
+
+      def on_wlang(symbols, *fns)
+        extra, meth = find_dispatching_method(symbols, :unbound_method)
+        if meth
+          argsize, arity = fns.size, meth.arity - 1
+          if extra.size > 0
+            rewrite_extra_symbols(extra, symbols[extra.length..-1], fns)
+          elsif argsize > arity
+            rewrite_trailing_fns(symbols, fns[0...arity], fns[arity..-1])
+          elsif argsize < arity
+            rewrite_missing_fns(symbols, fns, arity - argsize)
+          else
+            enforce_sub_dialects(symbols, fns)
+          end
+        else
+          rewrite_unknown_tag(symbols, fns)
+        end
+      end
+
+      private
+
+      def enforce_sub_dialects(symbols, fns)
+        ds = dialect.dialects_for(symbols) || []
+        fns.zip(ds).inject [:wlang, symbols] do |rw, (fn, d)|
+          if d
+            enforcer = DialectEnforcer.new(:dialect => d.factor)
+            rw << [:modulo, d, enforcer.call(fn)]
+          else
+            rw << call(fn)
+          end
+        end
+      end
+
+      def rewrite_missing_fns(symbols, fns, count)
+        count.times do
+          fns << [:arg, nil]
+        end
+        call([:wlang, symbols] + fns)
+      end
+
+      def rewrite_trailing_fns(symbols, fns, trailing)
+        wlanged = call([:wlang, symbols] + fns)
+        trailing.inject [:strconcat, wlanged] do |rw,fn|
+          rw << [:static, '{']
+          rw << call(fn.last)
+          rw << [:static, '}']
+        end
+      end
+
+      def rewrite_extra_symbols(extra, symbols, fns)
+        wlang = fns.inject [:wlang, symbols] do |rw,fn|
+          rw << fn
+        end
+        [:strconcat, [:static, extra], call(wlang)]
+      end
+
+      def rewrite_unknown_tag(symbols, fns)
+        start, stop = dialect.braces
+        from = [:strconcat, [:static, symbols]]
+        fns.inject(from) do |rw, fn|
+          rw << [:static, start]
+          rw << call(fn.last)
+          rw << [:static, stop]
+        end
+      end
+
+      def find_dispatching_method(symbols, kind = :name)
+        extra, symbols, found = [], symbols.chars.to_a, nil
+        dialect.tap do |d|
+          begin
+            meth = Dialect.tag_dispatching_name(symbols)
+            if d.respond_to?(meth)
+              found = d.class.instance_method(meth)
+              break
+            else
+              extra << symbols.shift
+            end
+          end until symbols.empty?
+        end
+        found = found.name.to_sym if found && kind == :name
+        [extra.join, found]
+      end
+
+    end # class DialectEnforcer
+  end # class Compiler
+end # module WLang

data/lib/wlang/compiler/filter.rb

@@ -0,0 +1,32 @@
+module WLang
+  class Compiler
+    class Filter < Temple::Filter
+
+      module ClassMethods
+
+        def recurse_on(*kinds)
+          kinds.each do |kind|
+            define_method(:"on_#{kind}") do |*args|
+              recurse(kind, *args)
+            end
+          end
+        end
+
+      end
+      extend ClassMethods
+
+      module InstanceMethods
+
+        def recurse(kind, *args)
+          args.inject [kind] do |rw,arg|
+            rw << (arg.is_a?(Array) ? call(arg) : arg)
+          end
+        end
+
+      end
+      include InstanceMethods
+
+      recurse_on :template, :fn, :wlang, :strconcat, :modulo, :static
+    end # class Filter
+  end # class Compiler
+end # module WLang

data/lib/wlang/compiler/grammar.citrus

@@ -0,0 +1,67 @@
+grammar WLang::Grammar
+  
+  rule template
+    (strconcat !.){
+      [:template, [:fn, strconcat.value]]
+    }
+  end
+  
+  rule strconcat
+    (non_static | static)* {
+      if matches.size == 1
+        matches.first.value
+      else
+        [:strconcat] + matches.map(&:value)
+      end
+    }
+  end
+  
+  rule static
+    (!stop_char .)+ { 
+      [:static, to_s] 
+    }
+  end
+  
+  rule non_static
+    block | wlang
+  end
+  
+  rule block
+    (fn_start strconcat fn_stop){
+      [:static, to_s]
+    }
+  end
+  
+  rule wlang
+    (symbols functions){
+      [:wlang, symbols.to_s] + functions.value
+    }
+  end
+  
+  rule functions
+    function+ { matches.map{|fn| [:fn, fn.value]} }
+  end
+  
+  rule function
+    (fn_start strconcat fn_stop){
+      strconcat.value
+    }
+  end
+  
+  rule stop_char
+    fn_start | fn_stop | (symbols fn_start)
+  end
+  
+  rule symbols
+    /[!\^%"\$&'\*\+\?@~\#,\-\.\/:;=<>\|_]+/
+  end
+  
+  rule fn_start
+    '{'
+  end
+  
+  rule fn_stop
+    '}'
+  end
+  
+end

data/lib/wlang/compiler/parser.rb

@@ -0,0 +1,26 @@
+module WLang
+  Citrus.load(File.expand_path('../grammar', __FILE__))
+  class Parser
+
+    def initialize(options = {})
+    end
+
+    def call(input)
+      return input if input.is_a?(Array)
+      parser.parse(parsing_source(input)).value
+    end
+
+    private
+
+    def parser
+      WLang::Grammar
+    end
+
+    def parsing_source(input)
+      input = File.read(input.to_path) if input.respond_to?(:to_path)
+      input = input.to_str if input.respond_to?(:to_str)
+      input
+    end
+
+  end # class Engine
+end # module WLang