wlang 0.8.4

data/lib/wlang/rulesets/context_ruleset.rb

@@ -0,0 +1,115 @@
+require 'wlang/rulesets/ruleset_utils'
+module WLang
+  class RuleSet
+    
+    #
+    # Provides a ruleset for managing the context/scoping during instantitation.
+    #
+    # For an overview of this ruleset, see the wlang {specification file}[link://files/specification.html].
+    #
+    module Context
+      U=WLang::RuleSet::Utils
+  
+      # Default mapping between tag symbols and methods
+      DEFAULT_RULESET = {'=' => :assignment,
+                         '#=' => :block_assignment, 
+                         '%=' => :modulo_assignment, 
+                         '^=' => :encoding_assignment}
+
+      # Rule implementation of <tt>={wlang/hosted as x}{...}</tt>
+      def self.assignment(parser, offset)
+        expr, reached = parser.parse(offset, "wlang/ruby")
+    
+        # decode expression
+        decoded = U.decode_expr_as(expr)
+        parser.syntax_error(offset) if decoded.nil?
+    
+        # evaluate it
+        value = parser.evaluate(decoded[:expr])
+    
+        # 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]
+        else
+          parser.context_define(decoded[:variable], value)
+          ["", reached]
+        end
+      end
+    
+      # Rule implementation of <tt>#={wlang/active-string}{...}{...}</tt>
+      def self.block_assignment(parser, offset)
+        variable, reached = parser.parse(offset, "wlang/active-string")
+
+        # decode expression
+        decoded = U.decode_var(variable)
+        parser.syntax_error(offset) if decoded.nil?
+    
+        # parse second block in that dialect
+        value, reached = parser.parse_block(reached)
+    
+        # 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]
+        else
+          parser.context_define(decoded[:variable], value)
+          ["", reached]
+        end
+      end
+    
+      # Rule implementation of <tt>%={wlang/active-string as x}{...}{...}</tt>
+      def self.modulo_assignment(parser, offset)
+        dialect_as, reached = parser.parse(offset, "wlang/ruby")
+
+        # decode expression
+        decoded = U.decode_qdialect_as(dialect_as)
+        parser.syntax_error(offset) if decoded.nil?
+    
+        # parse second block in that dialect
+        value, reached = parser.parse_block(reached, decoded[:dialect])
+    
+        # 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]
+        else
+          parser.context_define(decoded[:variable], value)
+          ["", reached]
+        end
+      end
+    
+      # Rule implementation of <tt>^={wlang/active-string as x}{...}{...}</tt>
+      def self.encoding_assignment(parser, offset)
+        encoding_as, reached = parser.parse(offset, "wlang/ruby")
+
+        # decode expression
+        decoded = U.decode_qencoder_as(encoding_as)
+        parser.syntax_error(offset) if decoded.nil?
+    
+        # parse second block in that dialect
+        value, reached = parser.parse_block(reached)
+        value = parser.encode(value, decoded[:encoder])
+    
+        # 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]
+        else
+          parser.context_define(decoded[:variable], value)
+          ["", reached]
+        end
+      end
+    
+    end # module Context
+    
+  end
+end

data/lib/wlang/rulesets/encoding_ruleset.rb

@@ -0,0 +1,73 @@
+module WLang
+  class RuleSet
+
+    #
+    # Encoding RuleSet, commonly installed in any wlang dialect. Note that this 
+    # ruleset overrides <tt>${...}</tt> implemented in WLang::RuleSet::Basic.
+    #
+    # For an overview of this ruleset, see the wlang {specification file}[link://files/specification.html].
+    #
+    module Encoding
+  
+      # Default mapping between tag symbols and methods
+      DEFAULT_RULESET = {'&' => :main_encoding, '&;' => :entities_encoding, 
+                         "&'" => :single_quoting, '&"' => :double_quoting,
+                         "$" => :injection, "'" => :single_quoted, 
+                         '"' => :double_quoted}
+  
+      # Main encoding as <tt>&{...}</tt>
+      def self.main_encoding(parser, offset)
+        parsed, reached = parser.parse(offset)
+        result = parser.encode(parsed, "main-encoding")
+        [result, reached]
+      end
+  
+      # Entities-encoding as <tt>&;{...}</tt>
+      def self.entities_encoding(parser, offset)
+        parsed, reached = parser.parse(offset)
+        result = parser.encode(parsed, "entities-encoding")
+        [result, reached]
+      end
+  
+      # Single-quoting as <tt>&'{...}</tt>
+      def self.single_quoting(parser, offset)
+        parsed, reached = parser.parse(offset)
+        result = parser.encode(parsed, "single-quoting")
+        [result, reached]
+      end
+  
+      # Double-quoting as <tt>&"{...}</tt>
+      def self.double_quoting(parser, offset)
+        parsed, reached = parser.parse(offset)
+        result = parser.encode(parsed, "double-quoting")
+        [result, reached]
+      end
+  
+      # Injection as <tt>${wlang/ruby}</tt>
+      def self.injection(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        result = parser.evaluate(expression)
+        encoded = parser.encode(result.to_s, "main-encoding")
+        [encoded, reached]
+      end
+  
+      # Single-quoted as <tt>'{wlang/ruby}</tt>
+      def self.single_quoted(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        result = parser.evaluate(expression)
+        encoded = parser.encode(result.to_s, "single-quoting")
+        ["'" << encoded, reached]
+      end
+  
+      # Double-quoted as <tt>"{wlang/ruby}</tt>
+      def self.double_quoted(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        result = parser.evaluate(expression)
+        encoded = parser.encode(result.to_s, "double-quoting")
+        ['"' << encoded, reached]
+      end
+  
+    end # module Encoding
+
+  end
+end

data/lib/wlang/rulesets/imperative_ruleset.rb

@@ -0,0 +1,132 @@
+module WLang
+  class RuleSet
+
+    #
+    # Imperative ruleset, providing special tags to iterate and instantiate 
+    # conditionaly. 
+    #
+    # For an overview of this ruleset, see the wlang {specification file}[link://files/specification.html].
+    #
+    module Imperative
+      U=WLang::RuleSet::Utils
+
+      # Regular expression for #1 in <tt>*{wlang/hosted}{...}</tt>
+      EACH_REGEXP = /^([^\s]+)((\s+(using\s+([_a-z]+)))?(\s+(as\s+([a-z]+(,\s+[a-z]+)*)))?)?$/
+      #               1       23   4        5           6   7     8
+      #               1       2                         3   4     5
+      
+      # Default mapping between tag symbols and methods
+      DEFAULT_RULESET = {'?' => :conditional, '*' => :enumeration}
+  
+      #
+      # Conditional as <tt>?{wlang/hosted}{...}{...}</tt>
+      #
+      # (third block is optional) Instantiates #1, looking for an expression in the 
+      # hosting language. Evaluates it, looking for a boolean value (according to 
+      # boolean semantics of the hosting language). If true, instantiates #2, 
+      # otherwise instantiates #3 if present.
+      #
+      def self.conditional(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        value = parser.evaluate(expression)
+        if value
+          then_block, reached = parser.parse_block(reached)
+          if parser.has_block?(reached)
+            else_block, reached = parser.parse_block(reached, "wlang/dummy")
+          end          
+          [then_block, reached]
+        else
+          then_block, reached = parser.parse_block(reached, "wlang/dummy")
+          else_block = ""
+          if parser.has_block?(reached)
+            else_block, reached = parser.parse_block(reached)
+          end          
+          [else_block, reached]
+        end
+      end
+
+      # Install args on the parser
+      def self.merge_each_args(names, args)
+        hash = {}
+        size = names.length>args.length ? args.length : names.length
+        0.upto(size-1) do |i|
+          hash[names[i]] = args[i]
+        end
+        hash
+      end
+  
+      #
+      # Enumeration as <tt>*{wlang/hosted using each as x}{...}{...}</tt>
+      #
+      # (third block is optional) Instantiates #1, looking for an expression in the 
+      # hosting language. Evaluates it, looking for an enumerable. Iterates all its 
+      # elements, instanciating #2 for each of them (the iterated value is set under 
+      # 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")
+    
+        # decode 'wlang/hosted using each as x' expression
+        hash = U.expr(:expr,
+                      ["using", :var, false],
+                      ["as", :multi_as, false]).decode(expression, parser)
+        hash[:using] = "each" unless hash[:using]
+        hash[:as] = [] unless hash[:as]
+        parser.syntax_error(offset, "invalid loop expression '#{expression}'") if hash.nil?
+    
+        # evaluate 'wlang/hosted' sub-expression
+        value = hash[:expr]
+        if value.nil?
+          expression, reached = parser.parse_block(reached, "wlang/dummy")
+          expression, reached = parser.parse_block(reached, "wlang/dummy") if parser.has_block?(reached)
+          ["",reached]
+        else
+          raise "Enumerated value #{value} does not respond to #{hash[:using]}"\
+            unless value.respond_to?(hash[:using])
+
+          # some variables
+          iterator, names = hash[:using].to_sym, hash[:as]
+          buffer = parser.factor_buffer
+          
+          # wlang start index of each block
+          block2, block3, theend = reached, nil, nil # *{}{block2}{block3}theend
+          first = true
+      
+          # iterate now
+          value.send iterator do |*args|
+            if not(first) and parser.has_block?(block3)
+              # parse #3, positioned at reached after that
+              parsed, theend = parser.parse_block(block3)
+              parser.append_buffer(buffer, parsed, true)
+            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
+            first = false
+          end
+      
+          # Empty array special case
+          unless block3
+            parsed, block3 = parser.parse_block(block2, "wlang/dummy")
+          end
+      
+          # Singleton array special case
+          unless theend
+            if parser.has_block?(block3)
+              parsed, theend = parser.parse_block(block3, "wlang/dummy")
+            else
+              theend = block3
+            end
+          end
+          [buffer, theend]
+        end
+    
+      end
+      
+    end  # module Imperative
+
+  end
+end

data/lib/wlang/rulesets/ruleset_utils.rb

@@ -0,0 +1,296 @@
+module WLang
+  class RuleSet
+    module Utils
+  
+      # Regexp string for 'dialect'
+      DIALECT = '[-a-z]+'
+      
+      # Regexp string for 'encoder'
+      ENCODER = '[-a-z]+'
+      
+      # Regexp string for 'qualified/dialect'
+      QDIALECT = DIALECT + '([\/]' + DIALECT + ')*'
+      
+      # Regexp string for 'qualified/encoder'
+      QENCODER = ENCODER + '([\/]' + ENCODER + ')*'
+      
+      # Regexp string for 'user_variable'
+      VAR = '[a-z][a-z0-9_]*'
+      
+      # Regexp string for expression in the hosting language
+      EXPR = '.*?'
+      
+      # Regexp string for URI expresion
+      URI = '[^\s]+'
+      
+      # Part of a with expression
+      WITH_PART = '(' + VAR + ')' + '\s*:\s*(' + EXPR + ')'
+      
+      # Regexp string for with expression
+      WITH = WITH_PART + '(\s*,\s*(' + WITH_PART + '))*'
+      
+      # Regexp string for as expression
+      MULTI_AS = VAR + '(' + '\s*,\s*' + VAR + ')*'
+      
+      # USING string for as expression
+      USING = VAR + '(' + '\s*,\s*' + VAR + ')*'
+      
+      # Basic blocks for building expressions
+      BASIC_BLOCKS = {
+        :dialect   => {:str => DIALECT,   :groups => 0, :decoder => nil},
+        :encoder   => {:str => ENCODER,   :groups => 0, :decoder => nil},
+        :qdialect  => {:str => QDIALECT,  :groups => 1, :decoder => nil},
+        :qencoder  => {:str => QENCODER,  :groups => 1, :decoder => nil},
+        :var       => {:str => VAR,       :groups => 0, :decoder => nil},
+        :expr      => {:str => EXPR,      :groups => 0, :decoder => :decode_expr},
+        :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}
+      }
+      
+      # Regular expressions of built expressions
+      REGEXPS = {}
+      
+      # Builds an expression.
+      def self.expr(*args)
+        expr = REGEXPS[args]
+        if expr.nil?
+          # 1) we simply create an equivalent regular expression in _str_
+          str, hash, count = '^\s*', {}, 0
+          args.each do |arg|
+            case arg
+              when Symbol
+                raise ArgumentError, "No reusable RuleSet::Utils block called #{arg}"\
+                  unless BASIC_BLOCKS[arg]
+                str << '(' << BASIC_BLOCKS[arg][:str] << ')'
+                hash[arg] = [(count+=1), BASIC_BLOCKS[arg][:decoder]]
+                count += BASIC_BLOCKS[arg][:groups]
+              when Array
+                keyword, what, mandatory = arg
+                raise ArgumentError, "No reusable RuleSet::Utils block called #{what}"\
+                  unless BASIC_BLOCKS[what]
+                mandatory = true if mandatory.nil?
+                unless mandatory
+                  str << '('
+                  count += 1
+                end
+                str << '\s+' << keyword << '\s+'
+                str << '(' << BASIC_BLOCKS[what][:str] << ')'
+                str << ')?' unless mandatory
+                hash[keyword.to_sym] = [(count+=1), BASIC_BLOCKS[what][:decoder]]
+                count += BASIC_BLOCKS[what][:groups]
+              else
+                raise ArgumentError, "Symbol or Array expected"
+            end
+          end
+          str << '\s*$'
+          
+          # here is the expression, on which we put a decode method
+          expr = {:regexp  => Regexp.new(str), :places  => hash}
+          def expr.decode(str, parser=nil)
+            matchdata = self[:regexp].match(str)
+            return nil if matchdata.nil?
+            decoded = {}
+            self[:places].each_pair do |k,v|
+              value = matchdata[v[0]]
+              value = Utils.send(v[1], value, parser)\
+                if v[1] and not(value.nil?)
+              decoded[k] = value
+            end
+            return decoded
+          end
+          
+          # and we save it!
+          REGEXPS[args] = expr   
+        end
+        expr
+      end
+      
+      # Decodes an expression using the parser
+      def self.decode_expr(expr, parser) 
+        return expr if parser.nil?
+        parser.evaluate(expr)
+      end
+        
+      # Regular expression for WITH
+      RG_WITH = Regexp.new('^' + WITH + '$')
+    
+      # Decodes a with expression
+      def self.decode_with(expr, parser, hash={})
+        matchdata = RG_WITH.match(expr)
+        return hash if matchdata.nil?
+        hash[matchdata[1]] = decode_expr(matchdata[2], parser)
+        decode_with(matchdata[4], parser, hash)
+      end
+      
+      # Decodes a multi as expression
+      def self.decode_multi_as(expr, parser)
+        expr.split(/\s*,\s*/)
+      end
+      
+      # Decodes a multi as expression
+      def self.decode_using(expr, parser)
+        expr.split(/\s*,\s*/).collect{|s| decode_expr(s, parser)}
+      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?
+        context.merge!(decoded[:with]) unless decoded[:with].nil?
+        context  
+      end
+      
+      
+      ### DEPRECATED API ####################################################
+        
+      # Regular expression for 'user_variable'
+      RG_VAR = Regexp.new('^\s*(' + VAR + ')\s*$')
+      
+      # Regular expression for expression in the hosting language
+      RG_EXPR = Regexp.new('^\s*(' + EXPR + ')\s*$')
+      
+      # Regular expression for expression in the hosting language
+      RG_URI = Regexp.new('^\s*(' + URI + ')\s*$')
+      
+      # Part of a with expression
+      RG_WITH_PART = Regexp.new('(' + VAR + ')' + '\s*:\s*([^,]+)')
+      
+      # Regular expression for 'dialect'
+      RG_DIALECT = Regexp.new('^\s*(' + DIALECT + ')\s*$')
+      
+      # Regular expression for 'encoder'
+      RG_ENCODER = Regexp.new('^\s*(' + ENCODER + ')\s*$')
+      
+      # Regular expression for 'qualified/dialect'
+      RG_QDIALECT = Regexp.new('^\s*(' + QDIALECT + ')\s*$')
+      
+      # Regular expression for 'qualified/encoder'
+      RG_QENCODER = Regexp.new('^\s*(' + QENCODER + ')\s*$')
+      
+      # Regexp string for 'qualified/dialect as var'
+      QDIALECT_AS = '(' + QDIALECT + ')\s+as\s+(' + VAR + ')'
+      
+      # Regular expression for 'qualified/dialect as var'
+      RG_QDIALECT_AS = Regexp.new('^\s*(' + QDIALECT_AS + ')\s*$')
+      
+      # Regexp string for 'qualified/dialect with ...'
+      QDIALECT_WITH = '(' + QDIALECT + ')\s+as\s+(' + WITH + ')'
+      
+      # Regular expression for 'qualified/dialect with ...'
+      RG_QDIALECT_WITH = Regexp.new('^\s*(' + QDIALECT_WITH + ')\s*$')
+      
+      # Regexp string for 'qualified/encoder as var'
+      QENCODER_AS = '(' + QENCODER + ')\s+as\s+(' + VAR + ')'
+      
+      # Regular expression for 'qualified/encoder as var'
+      RG_QENCODER_AS = Regexp.new('^\s*(' + QENCODER_AS + ')\s*$')
+      
+      # Regexp string for 'wlang/hosted as var'
+      EXPR_AS = '(' + EXPR + ')\s+as\s+(' + VAR + ')'
+      
+      # Regular expression for 'wlang/hosted as var'
+      RG_EXPR_AS = Regexp.new('^\s*(' + EXPR_AS + ')\s*$')
+      
+      # Regexp string for 'wlang/uri as var'
+      URI_AS = '(' + URI + ')\s+as\s+(' + VAR + ')'
+      
+      # Regular expression for 'wlang/uri as var'
+      RG_URI_AS = Regexp.new('^\s*(' + URI_AS + ')\s*$')
+  
+      # Regespc string for 'wlang/uri with ...'
+      URI_WITH = '(' + URI + ')\s+with\s+(' + WITH + ')'
+            
+      # Regular expression for 'wlang/uri as var'
+      RG_URI_WITH = Regexp.new('^\s*(' + URI_WITH + ')\s*$')
+      
+      # Decodes a simple var expression
+      def self.decode_var(src)
+        match = RG_VAR.match(src)
+        return nil unless match
+        {:variable => match[1]} 
+      end
+      
+      # Decodes a 'qualified/dialect as var'. Returns a hash
+      # with :dialect and :variable keys, or nil if _str_ does
+      # not match.
+      def self.decode_qdialect_as(str)
+        match = RG_QDIALECT_AS.match(str)
+        return nil unless match
+        {:dialect => match[2], :variable => match[4]} 
+      end
+      
+      # Decodes a 'qualified/encoder as var'. Returns a hash
+      # with :encoder and :variable keys, or nil if _str_ does
+      # not match.
+      def self.decode_qencoder_as(str)
+        match = RG_QENCODER_AS.match(str)
+        return nil unless match
+        {:encoder => match[2], :variable => match[4]} 
+      end
+      
+      # Decodes a 'wlang/hosted as var'. Returns a hash
+      # with :expression and :variable keys, or nil if _str_ does
+      # not match.
+      def self.decode_expr_as(str)
+        match = RG_EXPR_AS.match(str)
+        return nil unless match
+        {:expr => match[2], :variable => match[3]} 
+      end
+      
+      # Decodes a 'wlang/uri as var'. Returns a hash
+      # with :uri and :variable keys, or nil if _str_ does
+      # not match.
+      def self.decode_uri_as(str)
+        match = RG_URI_AS.match(str)
+        return nil unless match
+        {:uri => match[2], :variable => match[3]} 
+      end
+      
+      # Decodes a 'wlang/uri with ...'. Returns a hash
+      # with :uri and :with keys (with being another hash), or nil if _str_ does
+      # not match.
+      def self.decode_uri_with(str, parser=nil, optional=false)
+        match = RG_URI_WITH.match(str)
+        if match.nil?
+          return nil unless optional
+          match = RG_URI.match(str)
+          return nil if match.nil?
+          return {:uri => match[1], :with => nil}
+        else
+          with_expr, with = match[3], {}
+          exprs = with_expr.split(/\s*,\s*/)
+          exprs.each do |expr|
+            RG_WITH_PART =~ expr
+            with[$1] = parser.nil? ? $2 : parser.evaluate($2)
+          end
+          {:uri => match[2], :with => with} 
+        end
+      end
+  
+      # Decodes a 'wlang/dialect with ...'. Returns a hash
+      # with :dialect and :with keys (with being another hash), 
+      # or nil if _str_ does not match.
+      def self.decode_qdialect_with(str, parser=nil, optional=false)
+        match = RG_QDIALECT_WITH.match(str)
+        if match.nil?
+          return nil unless optional
+          match = RG_QDIALECT.match(str)
+          return nil if match.nil?
+          return {:dialect => match[1], :with => nil}
+        else
+          with_expr, with = match[3], {}
+          exprs = with_expr.split(/\s*,\s*/)
+          exprs.each do |expr|
+            RG_WITH_PART =~ expr
+            with[$1] = parser.nil? ? $2 : parser.evaluate($2)
+          end
+          {:dialect => match[2], :with => with} 
+        end
+      end
+
+    end
+  end
+end