wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/rulesets/encoding_ruleset.rb

@@ -1,73 +0,0 @@
-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/hosted")
-        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/hosted")
-        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/hosted")
-        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

@@ -1,132 +0,0 @@
-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/hosted")
-        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/hosted")
-    
-        # 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.branch_scope(merge_each_args(names, args)) {
-              parsed, block3 = parser.parse_block(block2)
-              parser.append_buffer(buffer, parsed, true)
-            }
-            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

@@ -1,317 +0,0 @@
-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 + ')*'
-      
-      # SHARE string for expression
-      SHARE = '(all|root|none)'
-      
-      # 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},
-        :share     => {:str => SHARE,     :groups => 1, :decoder => :decode_share}
-      }
-      
-      # 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
-      
-      # 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, parser = nil)
-        context = to_hash(decoded[:using])
-        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