wlang 0.9.2 → 0.10.0

data/doc/specification/specification.yml

@@ -1,6 +1,6 @@
 ---
 title: WLang
-version: 0.9.1
+version: 0.10.0
 sections:
   - identifier: about
     name: About
@@ -105,6 +105,8 @@ rulesets:
       - ["wlang/active-string", "Hello %{wlang/dummy}{!{name}}",       "Hello !{name}"]
       - ["wlang/dummy",         "Hello %{wlang/dummy}{!{name}}",       "Hello %{wlang/dummy}{!{name}}"]
       - ["wlang/active-string", "Hello ^{plain-text/upcase}{${name}}", "Hello O'NEIL"]
+      - ["wlang/ruby",          "puts +{name}",                        "puts \"O'Neil\""]
+      - ["wlang/ruby",          "puts +{authors}",                     "puts [\"blambeau\", \"llambeau\", \"ancailliau\"]"]
     rules:
       # !{wlang/hosted}
       - name:      "execution"
@@ -254,15 +256,15 @@ rulesets:
       scope is provided by the Context ruleset. All are variants of 'saving previous instantiations' in 
       scope variables...
     examples:
-      - ["wlang/*", '={name as n}{Hello +{n}}',                      "Hello O'Neil"]
-      - ["wlang/*", '={name as n}Hello +{n}',                        "Hello O'Neil"]
-      - ["wlang/*", '#={name}{blambeau}{Hello +{name}} and +{name}', "Hello blambeau and O'Neil"]
-      - ["wlang/*", '#={name}{blambeau}Hello +{name} and +{name}',   "Hello blambeau and blambeau"]
-      - ["wlang/*", '={author as name}{Hello +{name}} and +{name}', "Hello blambeau and O'Neil"]
-      - ["wlang/*", '={author as name}Hello +{name} and +{name}',   "Hello blambeau and blambeau"]
-      - ["wlang/*", '%={wlang/dummy as hello}{Hello +{name}}{+{hello}}', "Hello +{name}"]
-      - ["wlang/*", '^={plain-text/upcase as name}{+{author}}{Hello +{name}} and +{name}', "Hello BLAMBEAU and O'Neil"]
-      - ["wlang/*", '^={plain-text/upcase as name}{+{author}}Hello +{name} and +{name}', "Hello BLAMBEAU and BLAMBEAU"]
+      - ["wlang/*", '={name as n}{Hello !{n}}',                      "Hello O'Neil"]
+      - ["wlang/*", '={name as n}Hello !{n}',                        "Hello O'Neil"]
+      - ["wlang/*", '#={name}{blambeau}{Hello !{name}} and !{name}', "Hello blambeau and O'Neil"]
+      - ["wlang/*", '#={name}{blambeau}Hello !{name} and !{name}',   "Hello blambeau and blambeau"]
+      - ["wlang/*", '={author as name}{Hello !{name}} and !{name}',  "Hello blambeau and O'Neil"]
+      - ["wlang/*", '={author as name}Hello !{name} and !{name}',    "Hello blambeau and blambeau"]
+      - ["wlang/*", '%={wlang/dummy as hello}{Hello !{name}}{!{hello}}', "Hello !{name}"]
+      - ["wlang/*", '^={plain-text/upcase as name}{!{author}}{Hello !{name}} and !{name}', "Hello BLAMBEAU and O'Neil"]
+      - ["wlang/*", '^={plain-text/upcase as name}{!{author}}Hello !{name} and !{name}', "Hello BLAMBEAU and BLAMBEAU"]
       
     rules: 
       # ={wlang/hosted as x}{...}

data/lib/wlang.rb

@@ -20,7 +20,7 @@ require 'wlang/intelligent_buffer'
 module WLang
   
   # Current version of WLang
-  VERSION = "0.9.2".freeze
+  VERSION = "0.10.0".freeze
 
   ######################################################################## About files and extensions
   
@@ -58,7 +58,7 @@ module WLang
 
   # Checks that _name_ is a valid qualified dialect name or raises an ArgumentError
   def self.check_qualified_dialect_name(name)
-    raise ArgumentError, "Invalid dialect qualified name #{name} (/^[-a-z]+([\/][-a-z]+)*$/ expected)", caller\
+    raise ArgumentError, "Invalid dialect qualified name '#{name}' (/^[-a-z]+([\/][-a-z]+)*$/ expected)", caller\
       unless QUALIFIED_DIALECT_NAME_REGEXP =~ name
   end
 

data/lib/wlang/dialects/coderay_dialect.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'coderay'
 module WLang
   class EncoderSet

data/lib/wlang/dialects/hosted_dialect.rb

@@ -0,0 +1,50 @@
+module WLang
+  class EncoderSet
+    
+    # Encoders for ruby
+    module Hosted
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"main-encoding"  => :main_encoding,
+                          "single-quoting" => :single_quoting, 
+                          "double-quoting" => :double_quoting, 
+                          "regex-escaping" => :regex_escaping,
+                          "method-case"    => :method_case}
+  
+      # No-op encoding here
+      def self.main_encoding(src, options); src; end
+  
+      # Single-quoting encoding
+      def self.single_quoting(src, options); src.gsub(/([^\\])'/,%q{\1\\\'}); end
+  
+      # Double-quoting encoding
+      def self.double_quoting(src, options); src.gsub('"','\"'); end
+  
+      # Regexp-escaping encoding
+      def self.regex_escaping(src, options); Regexp.escape(src); end
+      
+      # Converts any source to a typical ruby method name
+      def self.method_case(src, options)
+        src.strip.gsub(/[^a-zA-Z0-9\s]/," ").
+                  gsub(/([A-Z])/){ " " + $1.downcase}.
+                  strip.
+                  gsub(/^([^a-z])/){ "_" + $1 }.
+                  gsub(/\s+/){"_"}
+      end
+      
+  
+    end # module Hosted
+  
+  end
+  class RuleSet
+
+    # Defines rulset of the wlang/ruby dialect
+    module Hosted
+    
+        # Default mapping between tag symbols and methods
+        DEFAULT_RULESET = {}
+      
+    end # module Hosted
+    
+  end # class RuleSet
+end # module WLang

data/lib/wlang/dialects/plain_text_dialect.rb

@@ -47,7 +47,7 @@ module WLang
   
       # Upcase rule as <tt>+{wlang/hosted}</tt>
       def self.upcase(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         value = parser.evaluate(expression)
         value = value.nil? ? "" : value.to_s
         result = WLang::EncoderSet::PlainText.upcase(value)
@@ -56,7 +56,7 @@ module WLang
   
       # Downcase rule as <tt>-{wlang/hosted}</tt>
       def self.downcase(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         value = parser.evaluate(expression)
         value = value.nil? ? "" : value.to_s
         result = EncoderSet::PlainText.downcase(value)

data/lib/wlang/dialects/ruby_dialect.rb

@@ -5,11 +5,12 @@ module WLang
     module Ruby
   
       # Default encoders  
-      DEFAULT_ENCODERS = {"main-encoding"  =>  :main_encoding,
+      DEFAULT_ENCODERS = {"main-encoding"  => :main_encoding,
                           "single-quoting" => :single_quoting, 
                           "double-quoting" => :double_quoting, 
                           "regex-escaping" => :regex_escaping,
-                          "method-case"    => :method_case}
+                          "method-case"    => :method_case,
+                          "literal"        => :to_literal}
   
       # No-op encoding here
       def self.main_encoding(src, options); src; end
@@ -31,6 +32,66 @@ module WLang
                   gsub(/^([^a-z])/){ "_" + $1 }.
                   gsub(/\s+/){"_"}
       end
+      
+      # Ruby classes for which value.inspect will work for returning
+      # a valid literal
+      SAFE_LITERAL_CLASSES = {}
+      [NilClass, TrueClass, FalseClass,
+       Fixnum, Bignum,
+       Float, 
+       String,
+       Symbol,
+       Class, 
+       Module,
+       Regexp].each{|c| SAFE_LITERAL_CLASSES[c] = true}
+       
+      #
+      # Converts _value_ to a ruby literal and returns it.
+      #
+      # Behavior of the algorithm when th value cannot be recognized depends
+      # on the :fallback option:
+      #   * when set to :fail, it raises a NoSuchLiteralError
+      #   * when set to :inspect, it returns <code>value.inspect</code>
+      #   * when set to :marshal it uses <code>Marshal::dump(value)</code>
+      #   * when set to :json it uses <code>JSON::generate(value)</code>
+      #
+      def self.to_literal(value, options = {:fallback => :fail})
+        if value.respond_to?(:to_ruby_literal)
+          value.to_ruby_literal
+        elsif value.respond_to?(:to_ruby)
+          value.to_ruby
+        elsif value == (1.0/0)
+          return '(1.0/0)'
+        elsif value == -(1.0/0)
+          return '(-1.0/0)'
+        elsif SAFE_LITERAL_CLASSES.key?(value.class)
+          value.inspect
+        elsif value.kind_of?(Array)
+          "[" + value.collect{|v| to_literal(v, options)}.join(', ') + "]"
+        elsif value.kind_of?(Hash)
+          "{" + value.collect{|pair| "#{to_literal(pair[0], options)} => #{to_literal(pair[1], options)}"}.join(', ') + "}"
+        elsif value.kind_of?(Date)
+          "Date::parse(#{value.to_s.inspect})"
+        elsif value.kind_of?(Time)
+          "Time::parse(#{value.inspect.inspect})"
+        else
+          case options[:fallback]
+            when :to_s
+              value.to_s
+            when :inspect
+              value.inspect
+            when :marshal
+              "Marshal::load(#{Marshal::dump(value).inspect})"
+            when :json
+              require 'json'
+              JSON::generate(value)
+            when :fail, nil
+              raise WLang::Error, "Unable to convert #{value.inspect} to a ruby literal"
+            else
+              raise ArgumentError, "Invalid fallback option #{options[:fallback]}"
+          end
+        end
+      end
   
     end # module Ruby  
   
@@ -41,9 +102,17 @@ module WLang
     module Ruby
     
         # Default mapping between tag symbols and methods
-        DEFAULT_RULESET = {}
+        DEFAULT_RULESET = {'+' => :inclusion}
     
+        # Rule implementation of <tt>+{wlang/ruby}</tt>.
+        def self.inclusion(parser, offset)
+          expression, reached = parser.parse(offset, "wlang/hosted")
+          value = parser.evaluate(expression)
+          result = WLang::EncoderSet::Ruby.to_literal(value)
+          [result, reached]
+        end
+  
     end # module Ruby
     
-  end
-end
+  end # class RuleSet
+end # module WLang

data/lib/wlang/dialects/standard_dialects.rb

@@ -27,6 +27,13 @@ WLang::dialect("ruby", ".rb", ".ruby") do
   end
 end
 
+# yaml dialect
+WLang::dialect("yaml", ".yaml", ".yml") do
+  ruby_require "wlang/dialects/yaml_dialect" do
+    encoders WLang::EncoderSet::YAML
+  end
+end
+
 # sql dialect
 WLang::dialect("sql", ".sql") do
   ruby_require "wlang/dialects/sql_dialect" do
@@ -72,12 +79,32 @@ WLang::dialect("wlang") do
   dialect("dummy") do
   end
   
+  # wlang/ruby dialect
+  dialect("hosted") do
+    ruby_require "wlang/dialects/hosted_dialect" do
+      encoders WLang::EncoderSet::Hosted
+      rules    WLang::RuleSet::Basic
+      rules    WLang::RuleSet::Encoding
+      rules    WLang::RuleSet::Imperative
+      rules    WLang::RuleSet::Context
+      rules    WLang::RuleSet::Hosted
+    end
+  end
+  
   # wlang/active-string dialect
   dialect("active-string") do
     rules WLang::RuleSet::Basic
     rules WLang::RuleSet::Imperative
   end
   
+  # wlang/active-text dialect
+  dialect("active-text") do
+    rules WLang::RuleSet::Basic
+    rules WLang::RuleSet::Imperative
+    rules WLang::RuleSet::Buffering
+    rules WLang::RuleSet::Context
+  end
+  
   # wlang/uri dialect
   dialect("uri") do
     rules WLang::RuleSet::Basic
@@ -90,11 +117,25 @@ WLang::dialect("wlang") do
       rules WLang::RuleSet::Basic
       rules WLang::RuleSet::Encoding
       rules WLang::RuleSet::Imperative
+      rules WLang::RuleSet::Buffering
       rules WLang::RuleSet::Context
       rules WLang::RuleSet::Ruby
     end
   end
   
+  # wlang/ruby dialect
+  dialect("yaml", ".wyaml", ".wyml") do
+    ruby_require "wlang/dialects/yaml_dialect" do
+      encoders WLang::EncoderSet::YAML
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Encoding
+      rules WLang::RuleSet::Imperative
+      rules WLang::RuleSet::Buffering
+      rules WLang::RuleSet::Context
+      rules WLang::RuleSet::YAML
+    end
+  end
+  
   # wlang/ruby dialect
   dialect("xhtml", ".wtpl", ".whtml") do
     ruby_require "cgi", "wlang/dialects/xhtml_dialect" do

data/lib/wlang/dialects/yaml_dialect.rb

@@ -0,0 +1,30 @@
+require "yaml"
+module WLang
+  class EncoderSet
+    module YAML
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {}
+  
+    end # module YAML
+  end
+  class RuleSet
+    module YAML
+    
+        # Default mapping between tag symbols and methods
+        DEFAULT_RULESET = {'+' => :inclusion}
+    
+        # Rule implementation of <tt>+{wlang/ruby}</tt>.
+        def self.inclusion(parser, offset)
+          expression, reached = parser.parse(offset, "wlang/hosted")
+          value = parser.evaluate(expression)
+          col = parser.buffer.__wlang_column_of(parser.buffer.length)
+          result = value.to_yaml.
+                         gsub(/^\s*---\s*|\n$/,"").
+                         __wlang_realign(col-1, true)
+          [result, reached]
+        end
+  
+    end # module YAML
+  end # class RuleSet
+end # module WLang

data/lib/wlang/encoder.rb

@@ -37,10 +37,6 @@ module WLang
     # same arguments. 
     #
     def initialize(&block)
-      unless block.nil?
-        raise(ArgumentError, "Expected a rule block of arity 2")\
-          unless block.arity==2
-      end
       @block = block
     end
   

data/lib/wlang/ext/string.rb

@@ -34,6 +34,11 @@ class String
   def __wlang_line_of(index)
     self[0...index].count("\n") + 1
   end
-
+  
+  def __wlang_realign(offset, strip_first = false)
+    s = gsub(/^/, ' ' * offset)
+    strip_first ? s.gsub(/\A\s*/, "") : s
+  end
+  
 end
-
+       

data/lib/wlang/parser.rb

@@ -315,7 +315,7 @@ module WLang
     end
     
     # Protected methods are...
-    protected :hosted, :offset, :source_text, :buffer, :dialect
+    protected :hosted, :offset, :source_text, :dialect
     
   end # class Parser
 end # module WLang

data/lib/wlang/rulesets/basic_ruleset.rb

@@ -19,7 +19,7 @@ module WLang
   
       # Rule implementation of <tt>!{wlang/ruby}</tt>.
       def self.execution(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         value = parser.evaluate(expression)
         result = value.nil? ? "" : value.to_s
         [result, reached]

data/lib/wlang/rulesets/context_ruleset.rb

@@ -18,7 +18,7 @@ module WLang
 
       # Rule implementation of <tt>={wlang/hosted as x}{...}</tt>
       def self.assignment(parser, offset)
-        expr, reached = parser.parse(offset, "wlang/ruby")
+        expr, reached = parser.parse(offset, "wlang/hosted")
     
         # decode expression
         decoded = U.decode_expr_as(expr)
@@ -62,7 +62,7 @@ module WLang
     
       # Rule implementation of <tt>%={wlang/active-string as x}{...}{...}</tt>
       def self.modulo_assignment(parser, offset)
-        dialect_as, reached = parser.parse(offset, "wlang/ruby")
+        dialect_as, reached = parser.parse(offset, "wlang/hosted")
 
         # decode expression
         decoded = U.decode_qdialect_as(dialect_as)
@@ -84,7 +84,7 @@ module WLang
     
       # Rule implementation of <tt>^={wlang/active-string as x}{...}{...}</tt>
       def self.encoding_assignment(parser, offset)
-        encoding_as, reached = parser.parse(offset, "wlang/ruby")
+        encoding_as, reached = parser.parse(offset, "wlang/hosted")
 
         # decode expression
         decoded = U.decode_qencoder_as(encoding_as)

data/lib/wlang/rulesets/encoding_ruleset.rb

@@ -45,7 +45,7 @@ module WLang
   
       # Injection as <tt>${wlang/ruby}</tt>
       def self.injection(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         result = parser.evaluate(expression)
         encoded = parser.encode(result.to_s, "main-encoding")
         [encoded, reached]
@@ -53,7 +53,7 @@ module WLang
   
       # Single-quoted as <tt>'{wlang/ruby}</tt>
       def self.single_quoted(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         result = parser.evaluate(expression)
         encoded = parser.encode(result.to_s, "single-quoting")
         ["'" << encoded, reached]
@@ -61,7 +61,7 @@ module WLang
   
       # Double-quoted as <tt>"{wlang/ruby}</tt>
       def self.double_quoted(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         result = parser.evaluate(expression)
         encoded = parser.encode(result.to_s, "double-quoting")
         ['"' << encoded, reached]

data/lib/wlang/rulesets/imperative_ruleset.rb

@@ -27,7 +27,7 @@ module WLang
       # otherwise instantiates #3 if present.
       #
       def self.conditional(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
         value = parser.evaluate(expression)
         if value
           then_block, reached = parser.parse_block(reached)
@@ -64,7 +64,7 @@ module WLang
       # name x in the scope). If #3 is present, it is instantiated between elements.
       #
       def self.enumeration(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/ruby")
+        expression, reached = parser.parse(offset, "wlang/hosted")
     
         # decode 'wlang/hosted using each as x' expression
         hash = U.expr(:expr,