wlang 0.8.5 → 0.9.1

data/lib/wlang/parser_state.rb

@@ -0,0 +1,94 @@
+module WLang
+  class Parser
+    # 
+    # Encapsulates all state information of a WLang parser
+    #
+    class State
+      
+      # The attached parser
+      attr_accessor :parser
+      
+      # The parent state
+      attr_accessor :parent
+      
+      # The current hosted language
+      attr_accessor :hosted
+      
+      # The current template
+      attr_accessor :template
+      
+      # The current dialect
+      attr_accessor :dialect
+      
+      # The current offset in template's source code
+      attr_accessor :offset
+      
+      # The current scope
+      attr_accessor :scope
+      
+      # The current output buffer
+      attr_accessor :buffer
+      
+      # Creates a new state instance for a given parser and optional
+      # parent.
+      def initialize(parser, parent = nil)
+        @parser, @parent = parser, parent
+      end
+      
+      # Checks internals
+      def check
+        raise "WLang::Parser::State fatal: invalid parser #{parser}" unless ::WLang::Parser===parser
+        raise "WLang::Parser::State fatal: invalid hosted #{hosted}" unless ::WLang::HostedLanguage===hosted
+        raise "WLang::Parser::State fatal: missing template #{template}" unless ::WLang::Template===template
+        raise "WLang::Parser::State fatal: missing dialect #{dialect}" unless ::WLang::Dialect===dialect
+        raise "WLang::Parser::State fatal: missing offset #{offset}" unless Integer===offset
+        raise "WLang::Parser::State fatal: missing scope #{scope}" unless ::WLang::HashScope===scope
+        raise "WLang::Parser::State fatal: missing buffer #{buffer}" unless buffer.respond_to?(:<<)
+        self
+      end
+      
+      #
+      # Branches this state.
+      #
+      # Branching allows creating a child parser state of this one. Options are:
+      # - :hosted     => a new hosted language
+      # - :template   => a new template
+      # - :dialect    => a new dialect
+      # - :offset     => a new offset in the template
+      # - :shared     => :all, :root or :none (which scoping should be shared)
+      # - :scope      => a Hash of new pairing to push on the new scope
+      # - :buffer     => a new output buffer to use
+      #
+      def branch(opts = {})
+        child = State.new(parser, self)
+        child.hosted    = opts[:hosted]    || hosted
+        child.template  = opts[:template]  || template
+        child.dialect   = opts[:dialect]   || child.template.dialect
+        child.offset    = opts[:offset]    || offset 
+        child.buffer    = opts[:buffer]    || child.dialect.factor_buffer
+        child.scope     = case opts[:shared]
+          when :all, NilClass
+            scope.branch(opts[:scope])
+          when :root
+            scope.root.branch(opts[:scope])
+          when :none
+            ::WLang::HashScope.new(opts[:scope])
+          else
+            raise ArgumentError, "Invalid ParserState.branch option :shared #{opts[:shared]}" 
+        end
+        child.check
+      end
+      
+      # Returns a friendly location for this parser state
+      def where
+        template ? template.where(offset) : "Source template tree"
+      end
+      
+      # Returns a friendly wlang backtrace as an array
+      def backtrace
+        parent ? parent.backtrace.unshift(where) : [where]
+      end
+      
+    end # class State
+  end # class Parser
+end # module WLang

data/lib/wlang/rule_set.rb

@@ -18,10 +18,22 @@ module WLang
   # == Detailed API
   class RuleSet
 
+    # Which modules are reused
+    attr_reader :reuse
+
     #
     # Creates an new dialect rule set.
     #    
-    def initialize() @rules, @pattern = {}, nil; end
+    def initialize() 
+      @rules = {}
+      @reuse = []
+      @patterns = Hash.new{|h, k| h[k] = build_pattern(k)} 
+    end
+
+    # Yields the block with name, rule pairs
+    def each
+      @rules.each_pair{|name,rule| yield(name, rule)}
+    end
 
     #  
     # Adds a tag matching rule to this rule set. _tag_ must be a String with the
@@ -38,7 +50,7 @@ module WLang
       end
       raise(ArgumentError, "Rule expected") unless Rule===rule
       @rules[tag] = rule  
-      @pattern = nil 
+      @patterns.clear
     end
 
     #
@@ -46,6 +58,7 @@ module WLang
     #
     def add_rules(mod, pairs=nil)
       raise(ArgumentError,"Module expected") unless Module===mod
+      reuse << mod
       pairs = mod::DEFAULT_RULESET if pairs.nil?
       pairs.each_pair do |symbol,method|
         meth = mod.method(method)
@@ -61,7 +74,7 @@ module WLang
     # not intended to be used by users themselve.
     # 
     def pattern(block_symbols) 
-      build_pattern(block_symbols); 
+      @patterns[block_symbols]
     end
 
     #

data/lib/wlang/rulesets/basic_ruleset.rb

@@ -50,23 +50,31 @@ module WLang
         execution(parser, offset)
       end
   
-      # Rule implementation of <tt>%!{wlang/ruby using ... with ...}</tt>
+      # Rule implementation of <tt>%!{wlang/ruby using ... with ...}{...}</tt>
       def self.recursive_application(parser, offset)
         dialect, reached = parser.parse(offset, "wlang/active-string")
         text, reached = parser.parse_block(reached)
     
         # decode expression
         decoded = U.expr(:qdialect, 
+                         ["share", :share, false],
                          ["using", :expr, false], 
                          ["with",  :with, false]).decode(dialect, parser)
         parser.syntax_error(offset) if decoded.nil?
     
         # build context
-        context = U.context_from_using_and_with(decoded)
-    
-        # instantiate
-        instantiated = WLang::instantiate(text, context, decoded[:qdialect])
-        [instantiated, reached]
+        dialect2 = decoded[:qdialect]
+        shared  = decoded[:share].nil? ? :root : decoded[:share]
+        context  = U.context_from_using_and_with(decoded)
+        
+        # TODO: refactor me!!
+        parser.branch(:template => WLang::template(text, dialect2),
+                      :offset   => 0,
+                      :shared   => shared,
+                      :scope    => context) {
+          instantiated, forget = parser.instantiate
+          [instantiated, reached]
+        }
       end
   
     end  # module Basic

data/lib/wlang/rulesets/buffering_ruleset.rb

@@ -41,6 +41,7 @@ module WLang
           end
           ["", reached]
         else
+          text = parser.parse(offset, "wlang/dummy")[0]
           parser.error(offset, "unable to apply output rule >>{#{text}}, not a writable directory (#{file})")
         end
       end
@@ -59,12 +60,11 @@ module WLang
     
           # handle two different cases
           if parser.has_block?(reached)
-            parser.context_push(decoded[:variable] => data)
-            text, reached = parser.parse_block(reached)
-            parser.context_pop
-            [text, reached]
+            parser.branch_scope(decoded[:variable] => data) {
+              parser.parse_block(reached)
+            }
           else
-            parser.context_define(decoded[:variable], data)
+            parser.scope_define(decoded[:variable], data)
             ["", reached]
           end
         else
@@ -77,38 +77,29 @@ module WLang
       def self.input_inclusion(parser, offset)
         uri, reached = parser.parse(offset, "wlang/uri")
     
-        # decode expression
+        # decode the expression
         decoded = U.expr(:uri,
+                      ["share", :share, false],
                       ["using", :using, false],
                       ["with",  :with, false]).decode(uri, parser)
         parser.syntax_error(offset) if decoded.nil?
         
-        # handle wit
-        context = nil
-        if decoded[:using]
-          raise "<<+ does not support multiple with for now." if decoded[:using].size != 1
-          context = decoded[:using][0]
-          raise "Unexpected nil context when duplicated" if context.nil?
-        else
-          context = {}
-        end
+        # Look for share and context
+        shared  = decoded[:share].nil? ? :none : decoded[:share]
+        context = U.context_from_using_and_with(decoded, parser)
         
-        # handle using now
-        if decoded[:with]
-          case context
-            when WLang::Parser::Context::HashScope
-              context = context.__branch(decoded[:with]) 
-            when Hash
-              context = context.merge(decoded[:with])
-            else
-              raise "Unexpected context #{context}"
-          end
-        end
+        # Resolve the file by delegation to the parser
+        file = parser.file_resolve(decoded[:uri])
         
-        file = parser.template.file_resolve(decoded[:uri], false)
+        # Go for it
         if File.file?(file) and File.readable?(file)
-          instantiated = WLang::file_instantiate(file, context)
-          [instantiated, reached]
+          parser.branch(:template => parser.file_template(file),
+                        :offset   => 0,
+                        :shared   => shared,
+                        :scope    => context) {
+            instantiated, forget = parser.instantiate
+            [instantiated, reached]
+          }
         else
           text = parser.parse(offset, "wlang/dummy")[0]
           parser.error(offset, "unable to apply input-inclusion rule <<+{#{text}}, not a file or not readable (#{file})")

data/lib/wlang/rulesets/context_ruleset.rb

@@ -29,12 +29,11 @@ module WLang
     
         # handle two different cases
         if parser.has_block?(reached)
-          parser.context_push(decoded[:variable] => value)
-          text, reached = parser.parse_block(reached)
-          parser.context_pop
-          [text, reached]
+          parser.branch_scope(decoded[:variable] => value) {
+            parser.parse_block(reached)
+          }
         else
-          parser.context_define(decoded[:variable], value)
+          parser.scope_define(decoded[:variable], value)
           ["", reached]
         end
       end
@@ -52,12 +51,11 @@ module WLang
     
         # handle two different cases
         if parser.has_block?(reached)
-          parser.context_push(decoded[:variable] => value)
-          text, reached = parser.parse_block(reached)
-          parser.context_pop
-          [text, reached]
+          parser.branch_scope(decoded[:variable] => value) {
+            parser.parse_block(reached)
+          }
         else
-          parser.context_define(decoded[:variable], value)
+          parser.scope_define(decoded[:variable], value)
           ["", reached]
         end
       end
@@ -75,12 +73,11 @@ module WLang
     
         # handle two different cases
         if parser.has_block?(reached)
-          parser.context_push(decoded[:variable] => value)
-          text, reached = parser.parse_block(reached)
-          parser.context_pop
-          [text, reached]
+          parser.branch_scope(decoded[:variable] => value) {
+            parser.parse_block(reached)
+          }
         else
-          parser.context_define(decoded[:variable], value)
+          parser.scope_define(decoded[:variable], value)
           ["", reached]
         end
       end
@@ -99,12 +96,11 @@ module WLang
     
         # handle two different cases
         if parser.has_block?(reached)
-          parser.context_push(decoded[:variable] => value)
-          text, reached = parser.parse_block(reached)
-          parser.context_pop
-          [text, reached]
+          parser.branch_scope(decoded[:variable] => value) {
+            parser.parse_block(reached)
+          }
         else
-          parser.context_define(decoded[:variable], value)
+          parser.scope_define(decoded[:variable], value)
           ["", reached]
         end
       end

data/lib/wlang/rulesets/imperative_ruleset.rb

@@ -101,10 +101,10 @@ module WLang
             end
         
             # install arguments and parse block2, positioned at block3 
-            parser.context_push(merge_each_args(names, args))
-            parsed, block3 = parser.parse_block(block2)
-            parser.append_buffer(buffer, parsed, true)
-            parser.context_pop
+            parser.branch_scope(merge_each_args(names, args)) {
+              parsed, block3 = parser.parse_block(block2)
+              parser.append_buffer(buffer, parsed, true)
+            }
             first = false
           end
       

data/lib/wlang/rulesets/ruleset_utils.rb

@@ -35,6 +35,9 @@ module WLang
       # USING string for as expression
       USING = VAR + '(' + '\s*,\s*' + VAR + ')*'
       
+      # SHARE string for expression
+      SHARE = '(all|root|none)'
+      
       # Basic blocks for building expressions
       BASIC_BLOCKS = {
         :dialect   => {:str => DIALECT,   :groups => 0, :decoder => nil},
@@ -46,7 +49,8 @@ module WLang
         :uri       => {:str => URI,       :groups => 0, :decoder => nil},
         :with      => {:str => WITH,      :groups => 6, :decoder => :decode_with},
         :multi_as  => {:str => MULTI_AS,  :groups => 1, :decoder => :decode_multi_as},
-        :using     => {:str => USING,     :groups => 1, :decoder => :decode_using}
+        :using     => {:str => USING,     :groups => 1, :decoder => :decode_using},
+        :share     => {:str => SHARE,     :groups => 1, :decoder => :decode_share}
       }
       
       # Regular expressions of built expressions
@@ -134,11 +138,28 @@ module WLang
         expr.split(/\s*,\s*/).collect{|s| decode_expr(s, parser)}
       end
       
+      # Decodes a multi as expression
+      def self.decode_share(expr, parser)
+        expr.to_sym
+      end
+      
+      # Converts something to a usable hash
+      def self.to_hash(hash)
+        case hash
+          when Hash
+            hash.dup
+          when NilClass
+            {}
+          when Array
+            hash.inject({}){|memo, n| memo.merge!(to_hash(n))}
+          else
+            raise ArgumentError, "Unable to convert #{hash} to an hash"
+        end
+      end
+      
       # Builds a hash for 'using ... with ...' rules from a decoded expression
-      def self.context_from_using_and_with(decoded)
-        context = decoded[:using]
-        context = context.dup unless context.nil?
-        context = {} if context.nil?
+      def self.context_from_using_and_with(decoded, parser = nil)
+        context = to_hash(decoded[:using])
         context.merge!(decoded[:with]) unless decoded[:with].nil?
         context  
       end

data/lib/wlang/template.rb

@@ -1,7 +1,9 @@
 module WLang
-  
   # 
-  # Template in a given wlang dialect, providing a default context object.
+  # Template in a given wlang dialect and expecting :braces, :brackets or 
+  # :parentheses as block delimiters. A template is an abstraction over a 
+  # wlang source text. It also provides utilities to create friendly location
+  # messages for offsets in the source text.
   #
   class Template
   
@@ -13,28 +15,19 @@ module WLang
     # Template wlang dialect (wlang/...)
     attr_reader :dialect
 
-    # Instantiation context
-    attr_reader :context
-    
     # Block symbols
     attr_reader :block_symbols
   
     # Attached file source
     attr_accessor :source_file
   
-    #
     # Creates a template instance.
-    #
-    def initialize(source, dialect, context=nil, block_symbols = :braces)
+    def initialize(source, dialect, block_symbols = :braces)
+      dialect = WLang::dialect(dialect)
       raise(ArgumentError, "Source is mandatory") if source.nil?
-      if String===dialect
-        dname, dialect = dialect, WLang::dialect(dialect)
-        raise(ArgumentError, "Unknown dialect #{dname}") if dialect.nil?
-      end     
-      raise(ArgumentError, "Dialect is mandatory") unless WLang::Dialect===dialect
+      raise(ArgumentError, "Dialect instance expected for dialect, #{dialect} received") unless Dialect===dialect
       @source = source
       @dialect = dialect
-      @context = WLang::Parser::Context.new(context)  
       @block_symbols = block_symbols
     end
   
@@ -59,40 +52,29 @@ module WLang
       end
     end
   
-    #
-    # Instantiate the template, with an additional context and an output buffer.
-    #
-    def instantiate(buffer=nil, context=nil)
-      unless context.nil? 
-        @context.push(context)
-      end
-      parser = WLang::Parser.instantiator(self, buffer)
-      instantiated = parser.instantiate
-      unless context.nil?
-        @context.pop
-      end
-      instantiated[0]
+    # Instantiates the template, with optinal context and hosted language.
+    def instantiate(context = {}, hosted = ::WLang::HostedLanguage.new)
+      p = ::WLang::Parser.new(hosted, self, context)
+      p.instantiate[0]
     end
     
     # Returns a friendly position of an offset in the source text
     def where(offset)
       src = source_text
-      "#{@source_file}:#{src.__wlang_line_of(offset)}:#{src.__wlang_column_of(offset)-1}"
+      source_file = self.source_file ? File.expand_path(self.source_file) : "no source file"
+      "#{source_file || 'inline template'}:#{src.__wlang_line_of(offset)}:#{src.__wlang_column_of(offset)-1}"
     end
     
     # Raises a WLang::Error for the given offset
     def error(offset, msg = "")
-      src = source_text
-      line, column = src.__wlang_line_of(offset), src.__wlang_column_of(offset)-1
-      raise WLang::Error, "#{@source_file}:#{line}:#{column} #{msg}"
+      raise WLang::Error, "#{where(offset)} #{msg}"
     end
     
     # Raises a friendly ParseError, with positions and so on
     def parse_error(offset, msg = "")
       src = source_text
-      line, column = src.__wlang_line_of(offset), src.__wlang_column_of(offset)-1
-      ex = ParseError.new("#{@source_file}:#{line}:#{column} #{msg}")
-      ex.line, ex.column = line, column
+      ex = ParseError.new("#{where(offset)} #{msg}")
+      ex.line, ex.column = src.__wlang_line_of(offset), src.__wlang_column_of(offset)-1
       raise ex
     end