wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/dialects/redcloth_dialect.rb

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

data/lib/wlang/dialects/ruby_dialect.rb

@@ -1,118 +0,0 @@
-module WLang
-  class EncoderSet
-    
-    # Encoders for ruby
-    module Ruby
-  
-      # Default encoders  
-      DEFAULT_ENCODERS = {"main-encoding"  => :main_encoding,
-                          "single-quoting" => :single_quoting, 
-                          "double-quoting" => :double_quoting, 
-                          "regex-escaping" => :regex_escaping,
-                          "method-case"    => :method_case,
-                          "literal"        => :to_literal}
-  
-      # 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
-      
-      # Ruby classes for which value.inspect will work for returning
-      # a valid literal
-      SAFE_LITERAL_CLASSES = {}
-      [NilClass, TrueClass, FalseClass,
-       Fixnum, Bignum,
-       Float, 
-       String,
-       Symbol,
-       Class, 
-       Module,
-       Regexp].each{|c| SAFE_LITERAL_CLASSES[c] = true}
-       
-      #
-      # Converts _value_ to a ruby literal and returns it.
-      #
-      # Behavior of the algorithm when th value cannot be recognized depends
-      # on the :fallback option:
-      #   * when set to :fail, it raises a NoSuchLiteralError
-      #   * when set to :inspect, it returns <code>value.inspect</code>
-      #   * when set to :marshal it uses <code>Marshal::dump(value)</code>
-      #   * when set to :json it uses <code>JSON::generate(value)</code>
-      #
-      def self.to_literal(value, options = {:fallback => :fail})
-        if value.respond_to?(:to_ruby_literal)
-          value.to_ruby_literal
-        elsif value.respond_to?(:to_ruby)
-          value.to_ruby
-        elsif value == (1.0/0)
-          return '(1.0/0)'
-        elsif value == -(1.0/0)
-          return '(-1.0/0)'
-        elsif SAFE_LITERAL_CLASSES.key?(value.class)
-          value.inspect
-        elsif value.kind_of?(Array)
-          "[" + value.collect{|v| to_literal(v, options)}.join(', ') + "]"
-        elsif value.kind_of?(Hash)
-          "{" + value.collect{|pair| "#{to_literal(pair[0], options)} => #{to_literal(pair[1], options)}"}.join(', ') + "}"
-        elsif value.kind_of?(Date)
-          "Date::parse(#{value.to_s.inspect})"
-        elsif value.kind_of?(Time)
-          "Time::parse(#{value.inspect.inspect})"
-        else
-          case options[:fallback]
-            when :to_s
-              value.to_s
-            when :inspect
-              value.inspect
-            when :marshal
-              "Marshal::load(#{Marshal::dump(value).inspect})"
-            when :json
-              require 'json'
-              JSON::generate(value)
-            when :fail, nil
-              raise WLang::Error, "Unable to convert #{value.inspect} to a ruby literal"
-            else
-              raise ArgumentError, "Invalid fallback option #{options[:fallback]}"
-          end
-        end
-      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 = {'+' => :inclusion}
-    
-        # Rule implementation of <tt>+{wlang/ruby}</tt>.
-        def self.inclusion(parser, offset)
-          expression, reached = parser.parse(offset, "wlang/hosted")
-          value = parser.evaluate(expression)
-          result = WLang::EncoderSet::Ruby.to_literal(value)
-          [result, reached]
-        end
-  
-    end # module Ruby
-    
-  end # class RuleSet
-end # module WLang

data/lib/wlang/dialects/sql_dialect.rb

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

@@ -1,181 +0,0 @@
-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
-
-# yaml dialect
-WLang::dialect("yaml", ".yaml", ".yml") do
-  ruby_require "wlang/dialects/yaml_dialect" do
-    encoders WLang::EncoderSet::YAML
-  end
-end
-
-# sql dialect
-WLang::dialect("sql", ".sql") do
-  ruby_require "wlang/dialects/sql_dialect" do
-    encoders WLang::EncoderSet::SQL
-  end
-  dialect("sybase", '.sybsql') do
-    ruby_require "wlang/dialects/sql_dialect" do
-      encoders WLang::EncoderSet::SQL::Sybase
-    end
-  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
-
-# redcloth (textile) dialect
-WLang::dialect("redcloth") do
-  ruby_require "RedCloth", "wlang/dialects/redcloth_dialect" do
-    encoders WLang::EncoderSet::RedClothEncoders
-  end
-end
-
-# bluecloth (markdown) dialect
-WLang::dialect("bluecloth") do
-  ruby_require "BlueCloth", "wlang/dialects/bluecloth_dialect" do
-    encoders WLang::EncoderSet::BlueClothEncoders
-  end
-end
-
-# wlang dialects
-WLang::dialect("wlang") do
-  
-  # Dummy dialect, no tag at all
-  dialect("dummy") do
-  end
-  
-  # wlang/ruby dialect
-  dialect("hosted") do
-    ruby_require "wlang/dialects/hosted_dialect" do
-      encoders WLang::EncoderSet::Hosted
-      rules    WLang::RuleSet::Basic
-      rules    WLang::RuleSet::Encoding
-      rules    WLang::RuleSet::Imperative
-      rules    WLang::RuleSet::Context
-      rules    WLang::RuleSet::Hosted
-    end
-  end
-  
-  # wlang/active-string dialect
-  dialect("active-string") do
-    rules WLang::RuleSet::Basic
-    rules WLang::RuleSet::Imperative
-  end
-  
-  # wlang/active-text dialect
-  dialect("active-text") do
-    rules WLang::RuleSet::Basic
-    rules WLang::RuleSet::Imperative
-    rules WLang::RuleSet::Buffering
-    rules WLang::RuleSet::Context
-  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::Buffering
-      rules WLang::RuleSet::Context
-      rules WLang::RuleSet::Ruby
-    end
-  end
-  
-  # wlang/ruby dialect
-  dialect("yaml", ".wyaml", ".wyml") do
-    ruby_require "wlang/dialects/yaml_dialect" do
-      encoders WLang::EncoderSet::YAML
-      rules WLang::RuleSet::Basic
-      rules WLang::RuleSet::Encoding
-      rules WLang::RuleSet::Imperative
-      rules WLang::RuleSet::Buffering
-      rules WLang::RuleSet::Context
-      rules WLang::RuleSet::YAML
-    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

data/lib/wlang/dialects/xhtml_dialect.rb

@@ -1,63 +0,0 @@
-require 'cgi'
-module WLang
-  class EncoderSet
-    
-    # Defines encoders of the whtml dialect
-    module XHtml
-  
-      # Default encoders  
-      DEFAULT_ENCODERS = {"main-encoding"     => :entities_encoding,
-                          "single-quoting"    => :single_quoting,
-                          "double-quoting"    => :double_quoting,
-                          "entities-encoding" => :entities_encoding}
-  
-  
-      # 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
-    
-      # Entities-encoding
-      def self.entities_encoding(src, options); 
-        CGI::escapeHTML(src)
-      end
-  
-    end # module XHtml  
-  end
-  class RuleSet
-    
-    # Defines rulset of the wlang/xhtml dialect
-    module XHtml
-    
-      # Default mapping between tag symbols and methods
-      DEFAULT_RULESET = {'@' => :at}
-  
-      def self.at(parser, offset)
-        # parse the url
-        url, reached = parser.parse(offset, 'wlang/active-string')
-        url = WLang::encode(url, 'wlang/xhtml/double-quoting')
-        
-        # parse the label if there is one
-        label = nil
-        if parser.has_block?(reached)
-          label, reached = parser.parse_block(reached) 
-          label = WLang::encode(label, 'wlang/xhtml/entities-encoding')
-        end
-        
-        if label and url.respond_to?(:to_xhtml_link)
-          [url.to_xhtml_link(url, label), reached]
-        elsif url.respond_to?(:to_xhtml_href)
-          [url.to_xhtml_href(url), reached]
-        elsif label
-          ["<a href=\"#{url}\">#{label}</a>", reached]
-        else
-          [url, reached]
-        end
-      end
-  
-    end # module XHtml
-    
-  end
-end
-

data/lib/wlang/dialects/yaml_dialect.rb

@@ -1,30 +0,0 @@
-require "yaml"
-module WLang
-  class EncoderSet
-    module YAML
-  
-      # Default encoders  
-      DEFAULT_ENCODERS = {}
-  
-    end # module YAML
-  end
-  class RuleSet
-    module YAML
-    
-        # Default mapping between tag symbols and methods
-        DEFAULT_RULESET = {'+' => :inclusion}
-    
-        # Rule implementation of <tt>+{wlang/ruby}</tt>.
-        def self.inclusion(parser, offset)
-          expression, reached = parser.parse(offset, "wlang/hosted")
-          value = parser.evaluate(expression)
-          col = parser.buffer.__wlang_column_of(parser.buffer.length)
-          result = value.to_yaml.
-                         gsub(/^\s*---\s*|\n$/,"").
-                         __wlang_realign(col-1, true)
-          [result, reached]
-        end
-  
-    end # module YAML
-  end # class RuleSet
-end # module WLang