wlang 0.8.4

data/lib/wlang/dialect_dsl.rb

@@ -0,0 +1,136 @@
+module WLang
+  class Dialect
+    
+    #
+    # Installs the Domain Specific Language allowing to create new dialects easily.
+    # Below is a self-explaining example on how to use it.
+    #
+    #   #
+    #   # Starts a new _wlang_ dialect that will have children.
+    #   # 
+    #   WLang::dialect("wlang") do
+    #
+    #     #
+    #     # Starts a _wlang/xhtml_ dialect that will be attached to .wtpl and .whtml
+    #     # file extensions.
+    #     #
+    #     dialect("xhtml", ".wtpl", ".whtm") do 
+    #
+    #       # If your dialect needs external gems or files, use ruby_require instead
+    #       # of built-in require: it will allow avoiding all users to have required 
+    #       # dependencies for dialects they don't use.
+    #       ruby_require "somegem", "wlang/rulesets/basic_ruleset", "wlang/dialects/coderay_dialect" do
+    #
+    #         # RuleSet defined as Ruby modules can be installed using _rules_.
+    #         # Here: we automatically add the standard Basic ruleset to our dialect.
+    #         rules WLang::RuleSet::Basic
+    #
+    #         # You can also install inline rules if they are not designed to be 
+    #         # reusable by others.
+    #         # Here, we add a #{...} rule that replaces all spaces by '#' symbols
+    #         # For rule implementation, see Rule class.
+    #         rule "#" do |parser, offset|
+    #           text, reached = parser.parse(offset)
+    #           text = text.gsub(/\s/, '#')
+    #           [text, reached]
+    #         end 
+    #
+    #         # Encoders can be installed the same way(s)
+    #         # Here: we install all coderay encoders defined in a module
+    #         encoders WLang::EncoderSet::CodeRay
+    #
+    #         # And inline encoders can be installed as well
+    #         # Encoder below will be allowed as ^{wlang/xhtml/upcase}{...} for example
+    #         encoder 'upcase' do |src, options|
+    #           src.upcase
+    #         end
+    #
+    #       end # ruby_require
+    #
+    #     end # wlang/xhtml dialect
+    # 
+    #   end # wlang dialect
+    #
+    class DSL
+  
+      # Initializes dsl with a real dialect instance
+      def initialize(dialect)
+        raise(ArgumentError, "Dialect expected") unless WLang::Dialect===dialect
+        @dialect = dialect
+      end
+  
+      #
+      # Handles dialect dependencies: all _src_ dependencies will be correctly loaded 
+      # at dialect building time (dialect are lazy loaded to avoid having all users 
+      # to have all dependencies of standard dialects).
+      #
+      # This method should always be used instead of _require_. It takes a block that
+      # will be executed at building-time. Any code with dependency usage should be
+      # part of the block ! 
+      #
+      def ruby_require(*src) end
+  
+      #
+      # Starts definition of a sub-dialect of the current one. _name_ is not allowed
+      # to be a qualified name. _extensions_ allows wlang to automatically infer
+      # dialects used by template files. A block is expected and should contain
+      # sub-dialect installation.  
+      #
+      def dialect(name, *extensions, &block)
+        child = WLang::Dialect.new(name, @dialect, &block)
+        extensions.each do |ext|
+          ext = ('.' << ext) unless ext[0,1]=='.'
+          WLang::FILE_EXTENSIONS[ext] = child.qualified_name
+        end
+        @dialect.add_child_dialect(name, child)
+      end
+  
+      #
+      # Adds a dialect encoder under _name_. Encoder's code is provided by the block.
+      # This block should always take <tt>|src, options|</tt> arguments: _src_ is
+      # the string to encode, _options_ is a Hash instance containing additional 
+      # encoding options.
+      #
+      def encoder(name, &block) end
+  
+      #
+      # Adds reusable encoders defined in a Ruby module. _mod_ must be a Module instance.
+      # If _pairs_ is ommitted (nil), all encoders of the module are added, under their
+      # standard names (see DEFAULT_ENCODERS under WLang::EncoderSet::XHtml for example).
+      # Otherwise, _pairs_ is expected to be a Hash providing a mapping between encoder 
+      # names and _mod_ methods (whose names are given by ruby symbols).  
+      #
+      def encoders(mod, pairs=nil) end
+  
+      #  
+      # Maps an inline rule with some tag symbols. _symbol_ must be ASCII symbols 
+      # allowed by the wlang specification. The rule implementation is provided by
+      # the block. see Rule class about rule implementation. 
+      # 
+      def rule(symbol, &block) end
+
+      #  
+      # Adds reusable rules defined in a Ruby module. _mod_ must be a Module instance.
+      # If _pairs_ is ommitted (nil), all rules of the module are added, under their
+      # standard tag symbols (see DEFAULT_RULESET under WLang::RuleSet::Basic for example).
+      # Otherwise, _pairs_ is expected to be a Hash providing a mapping between tag 
+      # symbols and _mod_ methods (whose names are given by ruby symbols).  
+      #
+      def rules(mod, pairs=nil) end
+  
+      #  
+      # Request wlang to associate _args_ files extensions with this dialect. File 
+      # extensions may also be installed at construction (see dialect).
+      #
+      def extensions(*args)
+        args.each do |ext|
+          ext = ('.' << ext) unless ext[0,1]=='.'
+          WLang::FILE_EXTENSIONS[ext] = @dialect.qualified_name
+        end
+      end
+      alias :extension :extensions 
+  
+    end # class DSL
+  
+  end
+end

data/lib/wlang/dialect_loader.rb

@@ -0,0 +1,69 @@
+module WLang
+  class Dialect
+
+    #
+    # Implements the same API as WLang::Dialect::DSL but used for effective loading.
+    # This class exists because of the lazy loading design pattern implemented by
+    # wlang on dialects. It does not convey any user-centric information.
+    #
+    class Loader
+  
+      # Initializes dsl with a real dialect instance
+      def initialize(dialect)
+        @dialect = dialect
+      end
+  
+      # See WLang::Dialect::DSL#ruby_require
+      def ruby_require(*src) 
+        src.each do |s|
+          begin
+            require "rubygems" unless "wlang"==s[0,5]
+          rescue LoadError => ex
+            STDERR.puts "= Error, wlang depends on 'rubygems'\n"\
+                        "= Please install it (methods differs from system, in debian : 'apt-get install rubygems')\n"\
+                        "= Exception raised : '#{ex.message}'"
+            exit -1
+          end
+          begin
+            require s
+          rescue LoadError => ex
+            STDERR.puts "= Error in dialect '#{@dialect}'\n"\
+                        "= This dialect depends on gem or file '#{s}' (try: 'gem install #{s}')\n"\
+                        "= Exception raised : '#{ex.message}'"
+            exit -1
+          end
+        end
+        yield if block_given?
+      end
+  
+      # See WLang::Dialect::DSL#dialect
+      def dialect(name, *extensions, &block) end
+  
+      # See WLang::Dialect::DSL#encoder
+      def encoder(name, &block) 
+        @dialect.add_encoder(name, &block)
+      end
+  
+      # See WLang::Dialect::DSL#encoders
+      def encoders(mod, pairs=nil) 
+        @dialect.add_encoders(mod, pairs)
+      end
+    
+      # See WLang::Dialect::DSL#rule
+      def rule(symbol, &block) 
+        @dialect.add_rule(symbol, &block)
+      end
+  
+      # See WLang::Dialect::DSL#rules
+      def rules(mod, pairs=nil) 
+        @dialect.add_rules(mod, pairs)
+      end
+    
+      # See WLang::Dialect::DSL#extensions
+      def extensions(*args) end
+      alias :extension :extensions 
+  
+    end # class Loader
+    
+  end
+end

data/lib/wlang/dialects/coderay_dialect.rb

@@ -0,0 +1,35 @@
+require 'coderay'
+module WLang
+  class EncoderSet
+    
+    #
+    # Allows coderay highlighter to be used as encoder. When using standard dialects,
+    # these encoders are installed under <tt>xhtml/coderay/ruby</tt>, 
+    # <tt>xhtml/coderay/html</tt>, etc. qualified names. 
+    #
+    # Available languages are: java, ruby, html, yaml.   
+    #
+    module CodeRayEncoderSet
+
+      # Default encoders  
+      DEFAULT_ENCODERS = {"java" => :coderay, "ruby" => :coderay, "html" => :coderay, 
+                          "yaml" => :coderay}
+  
+      # Upcase encoding
+      def self.coderay(src, options);
+        /([a-z]+)$/ =~ options['_encoder_']
+        encoder = $1.to_sym
+        tokens = CodeRay.scan src, encoder
+        highlighted = tokens.html({
+          :line_numbers => :inline, 
+          :wrap => :div, 
+          :css => :style,
+          :style => :cygnus}
+        )
+        return highlighted
+      end
+  
+    end # module CodeRay  
+    
+  end
+end

data/lib/wlang/dialects/plain_text_dialect.rb

@@ -0,0 +1,75 @@
+module WLang
+  class EncoderSet
+    
+    # Defines encoders of the plain-text dialect
+    module PlainText
+
+      # Default encoders  
+      DEFAULT_ENCODERS = {"upcase" => :upcase, 
+                          "downcase" => :downcase, 
+                          "capitalize" => :capitalize,
+                          "camel-case" => :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
+  
+      # Downcase encoding
+      def self.downcase(src, options); src.downcase; end
+  
+      # Capitalize encoding
+      def self.capitalize(src, options); src.capitalize; end
+  
+      # 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 = " " + src.split.join(" ")
+        src.gsub!(/ (.)/) { $1.upcase }    
+      end
+    
+    end # module PlainText
+    
+  end
+  class RuleSet
+    
+    # Defines rulset of the plain-text dialect
+    module PlainText
+    
+      # Default mapping between tag symbols and methods
+      DEFAULT_RULESET = {'+' => :upcase, '-' => :downcase}
+  
+      # Upcase rule as <tt>+{wlang/hosted}</tt>
+      def self.upcase(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        value = parser.evaluate(expression)
+        value = value.nil? ? "" : value.to_s
+        result = WLang::EncoderSet::PlainText.upcase(value)
+        [result, reached]
+      end
+  
+      # Downcase rule as <tt>-{wlang/hosted}</tt>
+      def self.downcase(parser, offset)
+        expression, reached = parser.parse(offset, "wlang/ruby")
+        value = parser.evaluate(expression)
+        value = value.nil? ? "" : value.to_s
+        result = EncoderSet::PlainText.downcase(value)
+        [result, reached]
+      end
+  
+    end # module PlainText
+    
+  end
+end

data/lib/wlang/dialects/rdoc_dialect.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rdoc/markup/to_html'
+module WLang
+  class EncoderSet
+    
+    # Provides the rdoc encoder
+    module RDocEncoders
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"html" => :rdoc_encoding, "div" => :rdoc_encoding, "nop" => :nop_encoding}
+  
+      # RDoc encoding
+      def self.rdoc_encoding(src, options); 
+        encoder = RDoc::Markup::ToHtml.new
+        if options['_template_'] and options['_template_'].source_file
+          encoder.instance_eval do
+            @from_path = File.dirname(options['_template_'].source_file)
+          end
+        end
+        encoder.convert(src) 
+      end
+  
+      # RDoc encoding, removing enclosing <tt><p>...</p></tt>
+      def self.nop_encoding(src, options); 
+        rdoc = RDoc::Markup::ToHtml.new.convert(src)
+        rdoc = $1 if /^\s*<p>\s*(.*?)\s+<\/p>\s*$/m =~ rdoc
+        rdoc
+      end
+  
+    end # RDoc
+    
+  end
+end

data/lib/wlang/dialects/ruby_dialect.rb

@@ -0,0 +1,35 @@
+module WLang
+  class EncoderSet
+    
+    # Encoders for ruby
+    module Ruby
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"single-quoting" => :single_quoting, 
+                          "double-quoting" => :double_quoting, 
+                          "regex-escaping" => :regex_escaping}
+  
+      # Single-quoting encoding
+      def self.single_quoting(src, options); src.gsub(/([^\\])'/,%q{\1\\\'}); end
+  
+      # Double-quoting encoding
+      def self.double_quoting(src, options); src.gsub('"','\"'); end
+  
+      # Regexp-escaping encoding
+      def self.regex_escaping(src, options); Regexp.escape(src); end
+  
+    end # module Ruby  
+  
+  end
+  class RuleSet
+
+    # Defines rulset of the wlang/ruby dialect
+    module Ruby
+    
+        # Default mapping between tag symbols and methods
+        DEFAULT_RULESET = {}
+    
+    end # module Ruby
+    
+  end
+end

data/lib/wlang/dialects/sql_dialect.rb

@@ -0,0 +1,38 @@
+module WLang
+  class EncoderSet
+    
+    # Encoders for ruby
+    module SQL
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"single-quoting" => :single_quoting}
+  
+      # Upcase encoding
+      def self.single_quoting(src, options); src.gsub("'","\\\\'"); end
+  
+    end # module SQL
+    
+    # Encoders for ruby
+    module SQL::Sybase
+  
+      # Default encoders  
+      DEFAULT_ENCODERS = {"single-quoting" => :single_quoting}
+  
+      # Upcase encoding
+      def self.single_quoting(src, options); src.gsub("'","''"); end
+  
+    end # module SQL::Sybase  
+    
+  end  
+  class RuleSet
+    
+    # Defines rulset of the wlang/ruby dialect
+    module SQL
+    
+        # Default mapping between tag symbols and methods
+        DEFAULT_RULESET = {}
+    
+    end # module SQL
+    
+  end
+end

data/lib/wlang/dialects/standard_dialects.rb

@@ -0,0 +1,113 @@
+require "wlang/rulesets/basic_ruleset"
+require "wlang/rulesets/encoding_ruleset"
+require "wlang/rulesets/imperative_ruleset"
+require "wlang/rulesets/buffering_ruleset"
+require "wlang/rulesets/context_ruleset"
+  
+WLang::data_loader(".yml", ".yaml") do |file|
+  require "yaml"
+  YAML.load(File.open(file))
+end
+  
+WLang::data_loader(".rb", ".ruby", ".dsl") do |file|
+  Kernel.eval(File.read(file))
+end
+
+# plain-text dialect
+WLang::dialect("plain-text") do
+  ruby_require("wlang/dialects/plain_text_dialect") do
+    encoders WLang::EncoderSet::PlainText 
+  end
+end
+
+# ruby dialect
+WLang::dialect("ruby", ".rb", ".ruby") do
+  ruby_require "wlang/dialects/ruby_dialect" do
+    encoders WLang::EncoderSet::Ruby
+  end
+end
+
+# ruby dialect
+WLang::dialect("xhtml", ".html", ".xhtml", ".htm") do
+  ruby_require "cgi", "wlang/dialects/xhtml_dialect" do
+    encoders WLang::EncoderSet::XHtml
+  end
+  dialect("coderay") do
+    ruby_require("coderay", "wlang/dialects/coderay_dialect") do
+      encoders WLang::EncoderSet::CodeRayEncoderSet
+    end
+  end
+end
+
+# rdoc dialect
+WLang::dialect("rdoc") do
+  ruby_require "rdoc", "wlang/dialects/rdoc_dialect" do
+    encoders WLang::EncoderSet::RDocEncoders
+  end
+end
+
+# wlang dialects
+WLang::dialect("wlang") do
+  
+  # Dummy dialect, no tag at all
+  dialect("dummy") do
+  end
+  
+  # wlang/active-string dialect
+  dialect("active-string") do
+    rules WLang::RuleSet::Basic
+  end
+  
+  # wlang/uri dialect
+  dialect("uri") do
+    rules WLang::RuleSet::Basic
+  end
+  
+  # wlang/ruby dialect
+  dialect("ruby", ".wrb", ".wruby") do
+    ruby_require "wlang/dialects/ruby_dialect" do
+      encoders WLang::EncoderSet::Ruby
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Encoding
+      rules WLang::RuleSet::Imperative
+      rules WLang::RuleSet::Context
+      rules WLang::RuleSet::Ruby
+    end
+  end
+  
+  # wlang/ruby dialect
+  dialect("xhtml", ".wtpl", ".whtml") do
+    ruby_require "cgi", "wlang/dialects/xhtml_dialect" do
+      encoders WLang::EncoderSet::XHtml
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Encoding
+      rules WLang::RuleSet::Imperative
+      rules WLang::RuleSet::Buffering
+      rules WLang::RuleSet::Context
+      rules WLang::RuleSet::XHtml
+    end
+  end
+  
+  # wlang/ruby dialect
+  dialect("sql", ".wsql") do
+    ruby_require "wlang/dialects/sql_dialect" do
+      encoders WLang::EncoderSet::SQL
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Encoding
+      rules WLang::RuleSet::Imperative
+      rules WLang::RuleSet::SQL
+    end
+
+    dialect("sybase") do 
+      ruby_require "wlang/dialects/sql_dialect" do
+        encoders WLang::EncoderSet::SQL
+        encoders WLang::EncoderSet::SQL::Sybase
+        rules WLang::RuleSet::Basic
+        rules WLang::RuleSet::Encoding
+        rules WLang::RuleSet::Imperative
+        rules WLang::RuleSet::SQL
+      end
+    end
+  end
+  
+end