wlang 0.10.2 → 2.0.0.beta

data/doc/specification/symbols.wtpl

@@ -1,16 +0,0 @@
-<table class="symbols">
-  <tr>
-    <th class="name">name</th>
-    <th class="symbol">symbol</th>
-    <th class="meaning">meaning</th>
-    <th class="remark">remark</th>
-  </tr>
-  *{spec.symbols as s}{
-    <tr>
-    	<td><em>${s.name}</em></td>
-    	<td>${s.symbol}</td>
-    	<td>${s.meaning}</td>
-    	<td>${s.remark}</td>
-    </tr>
-  }
-</table>

data/lib/wlang/dialect_dsl.rb

@@ -1,141 +0,0 @@
-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
-  
-      #
-      # Sets a transformer to use at end of generation time.
-      #
-      def post_transform(transformer = nil, &block) 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

@@ -1,74 +0,0 @@
-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::post_transformer
-      def post_transform(transformer = nil, &block) 
-        @dialect.post_transformer = (transformer || 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/bluecloth_dialect.rb

@@ -1,16 +0,0 @@
-require 'rubygems'
-module WLang
-  class EncoderSet
-    module BlueClothEncoders
-  
-      # Default encoders  
-      DEFAULT_ENCODERS = {"xhtml" => :xhtml_encoding}
-  
-      # RDoc encoding
-      def self.xhtml_encoding(src, options)
-        BlueCloth.new(src).to_html
-      end
-  
-    end # BlueClothEncoders
-  end # module EncoderSet
-end # module WLang

data/lib/wlang/dialects/coderay_dialect.rb

@@ -1,45 +0,0 @@
-require 'rubygems'
-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
-
-      # Coderay recognized formats
-      RECOGNIZED = ["java", "ruby", "html", "yaml", "sql", "css", "javascript", "json", "php", "xml"]
-
-      # Default encoders  
-      DEFAULT_ENCODERS = {}
-      RECOGNIZED.each{|f| DEFAULT_ENCODERS[f] = f.to_sym}
-  
-      # Upcase encoding
-      def self.coderay(src, options)
-        /([a-z]+)$/ =~ options['_encoder_']
-        encoder = $1.to_sym
-        tokens = CodeRay.scan src, encoder
-        highlighted = tokens.html({
-          :wrap => :div, 
-          :css => :class}
-        )
-        return highlighted
-      end
-      
-      RECOGNIZED.each{|f|
-        module_eval <<-EOF
-          def self.#{f}(src, options) 
-            WLang::EncoderSet::CodeRayEncoderSet.coderay(src, options.merge('_encoder_' => #{f.inspect}))
-          end
-        EOF
-      }
-  
-    end # module CodeRay  
-    
-  end
-end

data/lib/wlang/dialects/hosted_dialect.rb

@@ -1,50 +0,0 @@
-module WLang
-  class EncoderSet
-    
-    # Encoders for ruby
-    module Hosted
-  
-      # Default encoders  
-      DEFAULT_ENCODERS = {"main-encoding"  => :main_encoding,
-                          "single-quoting" => :single_quoting, 
-                          "double-quoting" => :double_quoting, 
-                          "regex-escaping" => :regex_escaping,
-                          "method-case"    => :method_case}
-  
-      # No-op encoding here
-      def self.main_encoding(src, options); src; end
-  
-      # 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
-      
-      # Converts any source to a typical ruby method name
-      def self.method_case(src, options)
-        src.strip.gsub(/[^a-zA-Z0-9\s]/," ").
-                  gsub(/([A-Z])/){ " " + $1.downcase}.
-                  strip.
-                  gsub(/^([^a-z])/){ "_" + $1 }.
-                  gsub(/\s+/){"_"}
-      end
-      
-  
-    end # module Hosted
-  
-  end
-  class RuleSet
-
-    # Defines rulset of the wlang/ruby dialect
-    module Hosted
-    
-        # Default mapping between tag symbols and methods
-        DEFAULT_RULESET = {}
-      
-    end # module Hosted
-    
-  end # class RuleSet
-end # module WLang

data/lib/wlang/dialects/plain_text_dialect.rb

@@ -1,69 +0,0 @@
-module WLang
-  class EncoderSet
-    
-    # Defines encoders of the plain-text dialect
-    module PlainText
-
-      # Default encoders  
-      DEFAULT_ENCODERS = {"upcase"      => :upcase, 
-                          "downcase"    => :downcase, 
-                          "capitalize"  => :capitalize,
-                          "camel"       => :camel_case,
-                          "camel-case"  => :camel_case,
-                          "upper-camel" => :camel_case,
-                          "lower-camel" => :lower_camel_case}
-  
-      # 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)
-        src.gsub!(/[^a-zA-Z\s]/," ")
-        src = " " + src.split.join(" ")
-        src.gsub!(/ (.)/) { $1.upcase }    
-      end
-      
-      # Converts a string to lower camelCase
-      def self.lower_camel_case(src, options)
-        camel_case(src, options).gsub(/^([A-Z])/){ $1.downcase }
-      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/hosted")
-        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/hosted")
-        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

@@ -1,33 +0,0 @@
-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