wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/rule.rb

@@ -1,66 +0,0 @@
-module WLang
-
-  #
-  # A Rule is designed to perform a replacement job when the special tag associated 
-  # with it is found in a Template. Rules are always installed on a RuleSet (using 
-  # RuleSet#add_rule), which is itself installed on a Dialect. Note that the method 
-  # mentionned previously provides a DRY shortcut, allowing not using this class 
-  # directly.
-  #  
-  # Example:
-  #    # Rule subclassing can be avoided by providing a block to new
-  #    # The following rule job is to upcase the text inside +{...} tags:
-  #    rule = Rule.new do |parser,offset|
-  #      parsed, reached = parser.parse(offset)
-  #      [parsed.upcase, reached]
-  #    end
-  #
-  # Creating a a new rule can be made in two ways: by subclassing this class and
-  # overriding the start_tag method or by passing a block to new. In both cases,
-  # <b>rules should always be stateless</b>, to allow reusable dialects that could
-  # even be used in a multi-threading environment. Implementing a rule correctly 
-  # must be considered non trivial due to the strong protocol between the parser 
-  # and its rules and the stateless convention. Always have a look to helpers 
-  # provided by RuleSet (to create simple rules easily) before deciding to implement
-  # a rule using this class.
-  #
-  # == Detailed API
-  class Rule
-
-    #
-    # Creates a new rule. If no block is given, the invocation of new MUST be made 
-    # on a subclass overriding start_tag. Otherwise, the block is considered as the 
-    # effective stateless implementation of start_tag and will be called with the 
-    # 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
-  
-    #
-    # Fired when the parser has reached an offset matching this rule.
-    #
-    # This method MUST return an array [_replacement_, _offset_] where _replacement_ 
-    # is what replaces the tag itself in the resulting text and _offset_ is the 
-    # new offset reached in the source text (where parsing will continue). 
-    # _offset_ should always be such that <tt>text[offset,1]=='}'</tt> to allow
-    # higher stages to continue their job correctly. Utility methods for parsing 
-    # text parts are provided by the parser itself (see WLang::Parser).
-    #
-    # Arguments:
-    # - parser: WLang parser currently parsing the text.
-    # - offset: offset reached in the text, corresponding to the first character
-    #   of the first block associated with the matching tag.
-    #
-    def start_tag(parser, offset)
-      raise(NotImplementedError) unless @block
-      @block.call(parser, offset)
-    end
-
-  end # class Rule
-
-end # module WLang

data/lib/wlang/rule_set.rb

@@ -1,106 +0,0 @@
-require 'wlang/rule'
-module WLang
-  
-  #
-  # This class allows grouping matching rules together to build a given dialect.
-  # Rules are always added with add_rule, which also allows creating simple rules 
-  # on the fly (that is, without subclassing Rule).
-  #
-  # Examples:
-  #   # we will create a simple dialect with a special tag:
-  #   #   <tt>+{...}</tt> which will uppercase its contents
-  #   upcaser = RuleSet.new
-  #   upcaser.add_rule '+' do |parser,offset|
-  #     parsed, offset = parser.parse(offset)
-  #     [parsed.upcase, offset] 
-  #   end 
-  #
-  # == Detailed API
-  class RuleSet
-
-    # Which modules are reused
-    attr_reader :reuse
-
-    #
-    # Creates an new dialect rule set.
-    #    
-    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
-    # tag associated to the rule (without the '{', that is '$' for the tag ${...}
-    # for example. If rule is ommited and a block is given, a new Rule instance is 
-    # created on the fly with _block_ as implementation (see Rule#new). 
-    # Otherwise rule is expected to be a Rule instance. This method check its 
-    # arguments, raising an ArgumentError if incorrect. 
-    #
-    def add_rule(tag, rule=nil, &block) 
-      if rule.nil? 
-        raise(ArgumentError,"Block required") unless block_given?
-        rule = Rule.new(&block)
-      end
-      raise(ArgumentError, "Rule expected") unless Rule===rule
-      @rules[tag] = rule  
-      @patterns.clear
-    end
-
-    #
-    # Add rules defined in a given RuleSet module.
-    #
-    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)
-        raise(ArgumentError,"No such method: #{method}") if meth.nil?
-        add_rule(symbol, &meth.to_proc)
-      end
-    end
-  
-    #
-    # Returns a Regexp instance with recognizes all tags installed in the rule set.
-    # The returned Regexp is backslashing aware (it matches <tt>\${</tt> for example)
-    # as well as '{' and '}' aware. This pattern is used by WLang::Parser and is
-    # not intended to be used by users themselve.
-    # 
-    def pattern(block_symbols) 
-      @patterns[block_symbols]
-    end
-
-    #
-    # Returns the Rule associated with a given tag, _nil_ if no such rule.
-    #
-    def [](tag) @rules[tag];  end
-  
-    
-    ### protected section ######################################################
-    protected
-  
-    # Internal implementation of pattern.
-    def build_pattern(block_symbols)
-      start, stop = WLang::Template::BLOCK_SYMBOLS[block_symbols]
-      start, stop = Regexp.escape(start), Regexp.escape(stop)
-      s = '([\\\\]{0,2}('
-      i=0
-      @rules.each_key do |tag|
-        s << '|' if i>0
-        s << '(' << Regexp.escape(tag) << ')'
-        i += 1
-      end
-      s << ")#{start})|[\\\\]{0,2}#{start}|[\\\\]{0,2}#{stop}"
-      Regexp.new(s)
-    end
-  
-  end # class RuleSet
-
-end # module WLang

data/lib/wlang/rulesets/basic_ruleset.rb

@@ -1,83 +0,0 @@
-require 'wlang/rulesets/ruleset_utils'
-module WLang
-  class RuleSet
-    
-    #
-    # Basic ruleset, commonly included by any wlang dialect (but some tags, like
-    # <tt>${...}</tt> may be overriden). This ruleset is often installed conjointly
-    # with WLang::RuleSet::Encoding which provides interresting overridings of 
-    # <tt>${...}</tt> and <tt>+{...}</tt>. 
-    #
-    # For an overview of this ruleset, see the wlang {specification file}[link://files/specification.html].
-    #
-    module Basic
-      U=WLang::RuleSet::Utils
-  
-      # Default mapping between tag symbols and methods
-      DEFAULT_RULESET = {'!' => :execution, '%' => :modulation, '^' => :encoding,
-                         '+' => :inclusion, '$' => :injection, '%!' => :recursive_application}
-  
-      # Rule implementation of <tt>!{wlang/ruby}</tt>.
-      def self.execution(parser, offset)
-        expression, reached = parser.parse(offset, "wlang/hosted")
-        value = parser.evaluate(expression)
-        result = value.nil? ? "" : value.to_s
-        [result, reached]
-      end
-  
-      # Rule implementation of <tt>%{wlang/active-string}{...}</tt>.
-      def self.modulation(parser, offset)
-        dialect, reached = parser.parse(offset, "wlang/active-string")
-        result, reached = parser.parse_block(reached, dialect)
-        [result, reached]
-      end
-  
-      # Rule implementation of <tt>^{wlang/active-string}{...}</tt>
-      def self.encoding(parser, offset)
-        encoder, reached = parser.parse(offset, "wlang/active-string")
-        result, reached = parser.parse_block(reached)
-        result = parser.encode(result, encoder)
-        [result, reached]
-      end
-    
-      # Rule implementation of <tt>${wlang/ruby}</tt>
-      def self.injection(parser, offset)
-        execution(parser, offset)
-      end
-  
-      # Rule implementation of <tt>+{wlang/ruby}</tt>
-      def self.inclusion(parser, offset)
-        execution(parser, offset)
-      end
-  
-      # 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
-        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(true)
-          [instantiated, reached]
-        }
-      end
-  
-    end  # module Basic
-  
-  end
-end

data/lib/wlang/rulesets/buffering_ruleset.rb

@@ -1,115 +0,0 @@
-require 'wlang/rulesets/ruleset_utils'
-require 'fileutils'
-
-module WLang
-  class RuleSet
-    
-    #
-    # Buffering ruleset, providing special tags to load/instantiate accessible files
-    # and outputting instantiation results in other files. 
-    #
-    # For an overview of this ruleset, see the wlang {specification file}[link://files/specification.html].
-    #
-    module Buffering
-      U=WLang::RuleSet::Utils
-  
-      # Default mapping between tag symbols and methods
-      DEFAULT_RULESET = {'<<' => :input, '>>' => :output,
-                         '<<=' => :data_assignment, '<<+' => :input_inclusion}
-  
-      # Rule implementation of <tt><<{wlang/uri}</tt>
-      def self.input(parser, offset)
-        uri, reached = parser.parse(offset, "wlang/uri")
-        file = parser.template.file_resolve(uri, false)
-        if File.file?(file) and File.readable?(file)
-          [File.read(file), reached]
-        else
-          text = parser.parse(offset, "wlang/dummy")[0]
-          parser.error(offset, "unable to apply input rule <<{#{text}}, not a file or not readable (#{file})")
-        end
-      end
-  
-      # Rule implementation of <tt>>>{wlang/uri}</tt>
-      def self.output(parser, offset)
-        uri, reached = parser.parse(offset, "wlang/uri")
-        file = parser.template.file_resolve(uri, false)
-        dir = File.dirname(file)
-        if File.writable?(dir) or not(File.exists?(dir))
-          FileUtils.mkdir_p(dir) unless File.exists?(dir)
-          File.open(file, "w") do |file|
-            text, reached = parser.parse_block(reached, nil, file)
-          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
-    
-      # Rule implementation of <<={wlang/uri as x}{...}
-      def self.data_assignment(parser, offset)
-        uri, reached = parser.parse(offset, "wlang/uri")
-    
-        # decode expression
-        decoded = U.decode_uri_as(uri)
-        parser.syntax_error(offset) if decoded.nil?
-    
-        file = parser.template.file_resolve(decoded[:uri], false)
-        if File.file?(file) and File.readable?(file)
-          data = WLang::load_data(file)
-    
-          # handle two different cases
-          if parser.has_block?(reached)
-            parser.branch_scope(decoded[:variable] => data) {
-              parser.parse_block(reached)
-            }
-          else
-            parser.scope_define(decoded[:variable], data)
-            ["", reached]
-          end
-        else
-          text = parser.parse(offset, "wlang/dummy")[0]
-          parser.error(offset, "unable to apply data-assignment rule <<={#{text}} (#{file}), not a file or not readable (#{file})")
-        end
-      end
-
-      # Rule implementation of <<+{wlang/uri with ...}
-      def self.input_inclusion(parser, offset)
-        uri, reached = parser.parse(offset, "wlang/uri")
-    
-        # 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?
-        
-        # Look for share and context
-        shared  = decoded[:share].nil? ? :none : decoded[:share]
-        context = U.context_from_using_and_with(decoded, parser)
-        
-        # Resolve the file by delegation to the parser
-        file = parser.file_resolve(decoded[:uri])
-        
-        # Go for it
-        if File.file?(file) and File.readable?(file)
-          parser.branch(:template => parser.file_template(file),
-                        :offset   => 0,
-                        :shared   => shared,
-                        :scope    => context) {
-            # We ask the parser to instantiate and apply 
-            # post transformation in all cases
-            instantiated, forget = parser.instantiate(true)
-            [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})")
-        end
-      end
-  
-
-    end # module Buffering
-    
-  end
-end

data/lib/wlang/rulesets/context_ruleset.rb

@@ -1,111 +0,0 @@
-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/hosted")
-    
-        # 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.branch_scope(decoded[:variable] => value) {
-            parser.parse_block(reached)
-          }
-        else
-          parser.scope_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.branch_scope(decoded[:variable] => value) {
-            parser.parse_block(reached)
-          }
-        else
-          parser.scope_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/hosted")
-
-        # 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.branch_scope(decoded[:variable] => value) {
-            parser.parse_block(reached)
-          }
-        else
-          parser.scope_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/hosted")
-
-        # 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.branch_scope(decoded[:variable] => value) {
-            parser.parse_block(reached)
-          }
-        else
-          parser.scope_define(decoded[:variable], value)
-          ["", reached]
-        end
-      end
-    
-    end # module Context
-    
-  end
-end