wlang 0.8.5 → 0.9.1

data/lib/wlang/dialect.rb

@@ -3,8 +3,8 @@ require 'wlang/rule_set'
 module WLang
 
   #
-  # Implements the _dialect_ abstraction (see {README}[link://files/README.html]).
-  # A dialect instance is a aggregation of encoders and ruleset (through EncoderSet
+  # Implements the _dialect_ abstraction (see {README}[link://files/README.rdoc]).
+  # A dialect instance is an aggregation of encoders and ruleset (through EncoderSet
   # and RuleSet classes). A dialect is also a node in the dialect tree and has a 
   # qualified name through this tree. For example <tt>wlang/xhtml</tt> is the 
   # qualified name of a <tt>xhtml</tt> dialect which is a child dialect of 
@@ -14,6 +14,7 @@ module WLang
   # Language instead (see WLang::Dialect::DSL). 
   #
   # === For developers only
+  #
   # In order to avoid having users to install all required gems of all dialects
   # wlang implements a lazy load design pattern on the dialect tree, through the
   # WLang::Dialect::DSL and WLang::Dialect::Loader classes. The former only creates
@@ -26,7 +27,7 @@ module WLang
   # Standard dialect obtention methods (WLang#dialect as well as WLang::Dialect#dialect)
   # ensure that returned dialects are built. If you obtain dialects another way, 
   # be sure that they are built before using them (is_built? and build! are your 
-  # friends to achive that goal).      
+  # friends to achieve that goal).      
   #
   # Moreover, child dialects may require tools of their ancestors. The following 
   # invariant should always be respected: if a dialect is built, all its ancestors
@@ -47,6 +48,9 @@ module WLang
     # Parent dialect
     attr_reader :parent
     
+    # Sub dialects by name
+    attr_reader :dialects
+    
     #
     # Creates a dialect instance. _builder_ block is a chunk of code of the DSL
     # that will be executed twice: once at construction time to create sub dialects

data/lib/wlang/dialects/coderay_dialect.rb

@@ -13,7 +13,9 @@ module WLang
 
       # Default encoders  
       DEFAULT_ENCODERS = {"java" => :coderay, "ruby" => :coderay, "html" => :coderay, 
-                          "yaml" => :coderay}
+                          "yaml" => :coderay, "sql" => :coderay, "css" => :coderay,
+                          "javascript" => :coderay, "json" => :coderay, "php" => :coderay,
+                          "xml" => :coderay}
   
       # Upcase encoding
       def self.coderay(src, options);
@@ -21,10 +23,8 @@ module WLang
         encoder = $1.to_sym
         tokens = CodeRay.scan src, encoder
         highlighted = tokens.html({
-          :line_numbers => :inline, 
           :wrap => :div, 
-          :css => :style,
-          :style => :cygnus}
+          :css => :class}
         )
         return highlighted
       end

data/lib/wlang/dialects/plain_text_dialect.rb

@@ -5,20 +5,14 @@ module WLang
     module PlainText
 
       # Default encoders  
-      DEFAULT_ENCODERS = {"upcase" => :upcase, 
-                          "downcase" => :downcase, 
-                          "capitalize" => :capitalize,
-                          "camel-case" => :camel_case}
+      DEFAULT_ENCODERS = {"upcase"      => :upcase, 
+                          "downcase"    => :downcase, 
+                          "capitalize"  => :capitalize,
+                          "camel"       => :camel_case,
+                          "camel-case"  => :camel_case,
+                          "upper-camel" => :camel_case,
+                          "lower-camel" => :lower_camel_case}
   
-      # Accents to replace when camel-casing
-      #  ACCENTS = { ['á','à','â','ä','ã','Ã','Ä','Â','À'] => 'a',
-      #              ['é','è','ê','ë','Ë','É','È','Ê'] => 'e',
-      #              ['í','ì','î','ï','I','Î','Ì'] => 'i',
-      #              ['ó','ò','ô','ö','õ','Õ','Ö','Ô','Ò'] => 'o',
-      #              ['œ'] => 'oe',
-      #              ['ß'] => 'ss',
-      #              ['ú','ù','û','ü','U','Û','Ù'] => 'u'}
-                      
       # Upcase encoding
       def self.upcase(src, options); src.upcase; end
   
@@ -30,15 +24,15 @@ module WLang
   
       # Converts a string as CamelCase
       def self.camel_case(src, options)
-        #    ACCENTS.each do |ac,rep|
-        #      ac.each do |s|
-        #        src.gsub!(s, rep)
-        #      end
-        #    end
-        src.gsub!(/[^a-zA-Z ]/," ")
+        src.gsub!(/[^a-zA-Z\s]/," ")
         src = " " + src.split.join(" ")
         src.gsub!(/ (.)/) { $1.upcase }    
       end
+      
+      # Converts a string to lower camelCase
+      def self.lower_camel_case(src, options)
+        camel_case(src, options).gsub(/^([A-Z])/){ $1.downcase }
+      end
     
     end # module PlainText
     

data/lib/wlang/dialects/redcloth_dialect.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+module WLang
+  class EncoderSet
+    module RedClothEncoders
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"xhtml" => :xhtml_encoding}
+  
+      # RDoc encoding
+      def self.xhtml_encoding(src, options)
+        RedCloth.new(src).to_html
+      end
+  
+    end # RedClothEncoders
+  end # module EncoderSet
+end # module WLang

data/lib/wlang/dialects/ruby_dialect.rb

@@ -5,9 +5,14 @@ module WLang
     module Ruby
   
       # Default encoders  
-      DEFAULT_ENCODERS = {"single-quoting" => :single_quoting, 
+      DEFAULT_ENCODERS = {"main-encoding"  =>  :main_encoding,
+                          "single-quoting" => :single_quoting, 
                           "double-quoting" => :double_quoting, 
-                          "regex-escaping" => :regex_escaping}
+                          "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
@@ -17,6 +22,15 @@ module WLang
   
       # 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 Ruby  
   

data/lib/wlang/dialects/standard_dialects.rb

@@ -27,6 +27,18 @@ WLang::dialect("ruby", ".rb", ".ruby") do
   end
 end
 
+# sql dialect
+WLang::dialect("sql", ".sql") do
+  ruby_require "wlang/dialects/sql_dialect" do
+    encoders WLang::EncoderSet::SQL
+  end
+  dialect("sybase", '.sybsql') do
+    ruby_require "wlang/dialects/sql_dialect" do
+      encoders WLang::EncoderSet::SQL::Sybase
+    end
+  end
+end
+
 # ruby dialect
 WLang::dialect("xhtml", ".html", ".xhtml", ".htm") do
   ruby_require "cgi", "wlang/dialects/xhtml_dialect" do
@@ -46,6 +58,13 @@ WLang::dialect("rdoc") do
   end
 end
 
+# rdoc dialect
+WLang::dialect("redcloth") do
+  ruby_require "RedCloth", "wlang/dialects/redcloth_dialect" do
+    encoders WLang::EncoderSet::RedClothEncoders
+  end
+end
+
 # wlang dialects
 WLang::dialect("wlang") do
   
@@ -56,6 +75,7 @@ WLang::dialect("wlang") do
   # wlang/active-string dialect
   dialect("active-string") do
     rules WLang::RuleSet::Basic
+    rules WLang::RuleSet::Imperative
   end
   
   # wlang/uri dialect

data/lib/wlang/dialects/xhtml_dialect.rb

@@ -31,7 +31,30 @@ module WLang
     module XHtml
     
       # Default mapping between tag symbols and methods
-      DEFAULT_RULESET = {}
+      DEFAULT_RULESET = {'@' => :at}
+  
+      def self.at(parser, offset)
+        # parse the url
+        url, reached = parser.parse(offset, 'wlang/active-string')
+        url = WLang::encode(url, 'wlang/xhtml/double-quoting')
+        
+        # parse the label if there is one
+        label = nil
+        if parser.has_block?(reached)
+          label, reached = parser.parse_block(reached) 
+          label = WLang::encode(label, 'wlang/xhtml/entities-encoding')
+        end
+        
+        if label and url.respond_to?(:to_xhtml_link)
+          [url.to_xhtml_link(url, label), reached]
+        elsif url.respond_to?(:to_xhtml_href)
+          [url.to_xhtml_href(url), reached]
+        elsif label
+          ["<a href=\"#{url}\">#{label}</a>", reached]
+        else
+          [url, reached]
+        end
+      end
   
     end # module XHtml
     

data/lib/wlang/encoder.rb

@@ -56,7 +56,7 @@ module WLang
     # - options: encoding options through a Hash. Available options are documented 
     #   by encoders themselve. 
     #
-    def encode(src, options)
+    def encode(src, options = {})
       raise(NotImplementedError) unless @block
       @block.call(src, options)
     end

data/lib/wlang/encoder_set.rb

@@ -25,6 +25,11 @@ module WLang
       @encoders = {}
     end
   
+    # Yields the block with name, encoder pairs
+    def each
+      @encoders.each_pair{|name,encoder| yield(name, encoder)}
+    end
+    
     #
     # Adds an encoder under a specific name. Supported signatures are as follows:
     # - _name_ is a symbol: _encoder_ and _block_ are ignored and encoder is 

data/lib/wlang/errors.rb

@@ -1,16 +1,80 @@
 module WLang
   
   # Main error of all WLang errors.
-  class Error < StandardError; end
+  class Error < StandardError
+    
+    # The parser state whe this error has been raised
+    attr_accessor :parser_state
+    
+    # Optional cause (other lower level exception)
+    attr_accessor :cause
+    
+    # Creates an error instance with a given parser state
+    def initialize(msg = nil, parser_state = nil, cause = nil)
+      raise ArgumentError, "msg expected to be nil or a String" unless (msg.nil? or String===msg)
+      raise ArgumentError, "parser_state expected to be nil or a State"\
+        unless (parser_state.nil? or ::WLang::Parser::State===parser_state)
+      super(msg)
+      @parser_state = parser_state
+      @cause = cause
+    end
+    
+    # Returns a friendly wlang backtrace
+    def wlang_backtrace
+      parser_state ? parser_state.backtrace : ["no backtrace information, sorry"]
+    end
+    
+  end # class Error
+  
+  #
+  # Raised by hosted languages when something fails during 
+  # evaluation.
+  #
+  class EvalError < ::WLang::Error
+    
+    # The expression whose evaluation failed
+    attr_accessor :expression
+    
+    # Creates an error instance with an optional expression that
+    # failed
+    def initialize(msg = nil, parser_state = nil, expression = nil, cause = nil)
+      super(msg, parser_state, cause)
+      @expression = expression
+    end
+    
+    def to_s
+      "Evaluation of #{@expression} failed, #{@cause ? @cause.message : ''}"
+    end
+    
+  end # class EvalError
   
-  # Raise when something fails when evaluting through the parser context
-  class EvalError < StandardError; end
+  #
+  # Raised when a variable may not be found in the current 
+  # parser scope
+  #
+  class UndefinedVariableError < ::WLang::EvalError
+    
+    # Name of the variable that could not be found
+    attr_accessor :variable
+    
+    # Creates an error instance with an optional variable name
+    def initialize(msg = nil, parser_state = nil, expression = nil, variable = nil)
+      super(msg, parser_state, expression)
+      @variable = variable
+    end
+    
+    def to_s
+      "Unable to find variable #{@variable}"
+    end
+    
+  end # class UndefinedVariableError
   
   # Error raised by a WLang parser instanciation when an error occurs. 
-  class ParseError < StandardError;  
+  class ParseError < ::WLang::Error
     
+    # Where did the parsing failed
     attr_accessor :line, :column
     
-  end
+  end # class ParseError
   
-end # module WLang
+end # module WLang

data/lib/wlang/ext/hash_methodize.rb

@@ -0,0 +1,13 @@
+class Hash
+  
+  # Allows using hash.key as a synonym for hash[:key] and
+  # hash['key']
+  def method_missing(name, *args, &block)
+    if args.empty? and block.nil?
+      self[name] || self[name.to_s]
+    else
+      super(name, *args, &block)
+    end
+  end
+  
+end

data/lib/wlang/{ruby_extensions.rb → ext/string.rb}

@@ -4,19 +4,21 @@
 class String
 
   # Converts the string to a wlang template
-  def wlang_template(dialect="wlang/active-string", context=nil, block_symbols=:braces)
-    WLang::Template.new(self, dialect, context, block_symbols)
+  def wlang_template(dialect = "wlang/active-string", block_symbols = :braces)
+    WLang::template(self, dialect, block_symbols)
   end
   
   #
   # Instantiates the string as a wlang template using
   # a context object and a dialect.
   #
-  def wlang_instantiate(context=nil, dialect="wlang/active-string", block_symbols=:braces)
-    wlang_template(dialect, context, block_symbols).instantiate
+  def wlang_instantiate(context = nil, dialect = "wlang/active-string", block_symbols = :braces)
+    WLang::instantiate(self, context, dialect, block_symbols)
   end
   alias :wlang :wlang_instantiate
-    
+  
+  # Computes the column number for a given offset in 
+  # this string
   def __wlang_column_of(index)
     return 1 if index == 0
     newline_index = rindex("\n", index - 1)
@@ -27,6 +29,8 @@ class String
     end
   end
   
+  # Computes the line number for a given offset in 
+  # this string
   def __wlang_line_of(index)
     self[0...index].count("\n") + 1
   end

data/lib/wlang/hash_scope.rb

@@ -0,0 +1,89 @@
+require 'delegate'
+module WLang
+  #
+  # Implements a scoping mechanism on top of a ruby hash (accessible through pairing). 
+  # Such a scope mimics hashses for has_key?, [] and []= methods. A scope has an 
+  # accessible parent. Scopes form a tree, the root being accessible using its 
+  # natural accessor. Scope lookup (has_key? and []) uses the hierarchy to find
+  # accessible variables.
+  #
+  # Branching a scope allows installing new variables that hide variables with the 
+  # same name in the parent scope. Branching is made easy through the branch methods
+  # that accepts a block, passing the child as first argument:
+  #
+  #   scope = HashScope.new(:name => 'wlang')
+  #   puts scope[:name]    # prints 'wlang'
+  #   scope.branch(:name => 'other') do |child|
+  #     puts child[:name]  # prints 'other'
+  #   end
+  #   puts scope[:name]    # prints 'wlang'
+  #
+  # This branching mechanism is intended to be used to keep a current scope as instance
+  # variable of a using class:
+  # 
+  #   # We create an initial scope at construction
+  #   def initialize
+  #     @scope = HashScope.new
+  #   end
+  #
+  #   # Appends the current scope with new key/value pairs. Yields the block
+  #   # with the new scope and restore the original one after that.
+  #   def do_something_with_a_new_scope(hash = {})
+  #     @scope = @scope.branch(:name => 'other')
+  #       yield if block_given?
+  #     @scope = @scope.parent
+  #   end
+  #
+  class HashScope
+    
+    # The parent scope, or nil if no such parent
+    attr_reader :parent
+    
+    # The key/value pairing inside this scope
+    attr_reader :pairing
+    
+    # Creates a scope instance with a parent and initial 
+    # pairing through a Hash
+    def initialize(pairing = nil, parent = nil)
+      raise ArgumentError, "Hash expected for pairing #{pairing.class} received" unless (pairing.nil? or Hash===pairing)
+      @pairing = pairing || {}
+      @parent = parent
+    end
+        
+    # Returns the root scope
+    def root
+      @root ||= (parent ? parent.root : self)
+    end
+    
+    # Checks if a key exists in this scope, delegating to
+    # parent if not found and allowed
+    def has_key?(key, delegate = true)
+      pairing.has_key?(key) || (!delegate.nil? && !parent.nil? && parent.has_key?(key))
+    end
+    
+    # Returns the value associated to a key, delegating to parent
+    # if not found and allowed
+    def [](key, delegate = true)
+      pairing.has_key?(key) ? pairing[key] : (delegate && parent && parent[key])
+    end
+    
+    # Associates a key to a value inside this scope
+    def []=(key, value)
+      pairing[key] = value
+    end
+    
+    # Creates a new child scope and returns it. If a block is given,
+    # yields the block with the child scope
+    def branch(pairing = nil)
+      child = HashScope.new(pairing, self)
+      yield child if block_given?
+      child
+    end
+    
+    # Converts this scope to a full hash with all variables
+    def to_h
+      parent ? parent.to_h.merge(pairing) : pairing.dup
+    end
+    
+  end # class HashScope
+end # module WLang