wlang 0.10.2 → 2.0.0.beta

data/lib/wlang/wlang_command.rb

@@ -1,51 +0,0 @@
-require 'wlang'
-require 'wlang/wlang_command_options'
-require 'wlang/dialects/standard_dialects'
-module WLang
-  
-  #
-  # Provides the _wlang_ commandline tool. See 'wlang --help' for documentation.
-  #
-  class WLangCommand
-  
-    # Creates a commandline instance.
-    def initialize()
-    end
-
-    # Run _wlang_ commandline on specific arguments 
-    def run(args)
-      # parse the options
-      options = Options.new.parse(args)
-    
-      # get output buffer
-      buffer = STDOUT
-      if options.output_file
-        buffer = File.new(options.output_file, "w")
-      end
-    
-      source = File.read(options.template_file)
-      dialect = options.template_dialect
-      braces = options.template_brace
-      context = options.context_object
-      context = {options.context_name => context} unless options.context_name.nil?
-      template = WLang::file_template(options.template_file, options.template_dialect, braces)
-    
-      if options.verbosity>1
-        puts "Instantiating #{options.template_file}"
-        puts "Using dialect #{dialect}"
-        puts "Block delimiters are " << Template::BLOCK_SYMBOLS[braces].inspect
-        puts "Context is " << context.inspect
-      end
-    
-      buffer << template.instantiate(context || {})
-    
-      # Flush and close if needed
-      if File===buffer
-        buffer.flush
-        buffer.close
-      end
-    end
-    
-  end # class WLang
-  
-end # module WLang

data/lib/wlang/wlang_command_options.rb

@@ -1,163 +0,0 @@
-require 'optparse'
-module WLang
-  class WLangCommand
-  
-    #
-    # Options of the _wlang_ commandline
-    #  
-    class Options
-
-      # Source template file
-      attr_reader :template_file
-  
-      # Template dialect
-      attr_reader :template_dialect
-      
-      # Which brace kind used in template (:braces, :brackes, :parentheses)
-      attr_reader :template_brace
-  
-      # Context file
-      attr_reader :context_file
-
-      # Context object
-      attr_reader :context_object
-  
-      # Context kind [:yaml, :ruby, :dsl]  
-      attr_reader :context_kind
-
-      # Name of the context
-      attr_reader :context_name
-    
-      # Output file
-      attr_reader :output_file
-
-      # Verbose mode?
-      attr_reader :verbosity
-  
-      # Initializes the options with default values
-      def initialize
-        @verbosity = 0
-        @template_brace = :braces
-      end
-  
-      #
-      # Parses commandline options provided as an array of Strings.
-      #
-      def parse(argv)
-        opts = OptionParser.new do |opt|
-          opt.program_name = File.basename $0
-          opt.version = WLang::VERSION
-          opt.release = nil
-          opt.summary_indent = ' ' * 4
-          banner = <<-EOF
-            # Usage #{opt.program_name} [options] template context-file
-        
-            # Template is parsed as a wlang dialect (based on its extension by default) and 
-            # instantiated through a given context file.
-          EOF
-          opt.banner = banner.gsub(/[ \t]+# /, "")
-      
-          opt.separator nil
-          opt.separator "Options:"
-      
-          opt.on("-d", "--dialect=DIALECT", 
-                 "Interpret source template as a given wlang dialect") do |value|
-            @template_dialect = value
-          end
-      
-          opt.on("-m", "--methodize", 
-                 "Use methodization of hashes?") do |value|
-            Kernel.load('wlang/ext/hash_methodize.rb')
-          end
-      
-          opt.on("-o", "--output=OUTPUT",
-                 "Flush instantiation result in output file") do |value|
-            @output_file = value         
-          end
-      
-          opt.on("--brace=BRACE", ["brace", "parenthesis", "bracket"],
-                 "Block delimiters used by the template file (braces, brackets, parentheses)") do |value|
-             # handle template brace
-             case value
-               when "brace", "braces", "{"
-                 @template_brace = :braces
-               when "brackets", "bracket", "["
-                 @template_brace = :brackets
-               when "parentheses", "parenthesis", "("
-                 @template_brace = :parentheses
-               else
-                 raise "Unknown brace kind #{brace}"
-             end
-          end
-      
-          opt.on("--context-name=NAME",
-                 "Name of the context object") do |value|
-            @context_name = value         
-          end
-      
-          opt.on("--context-kind=KIND", ["yaml", "ruby", "dsl"],
-                 "Kind of context object (yaml, ruby, dsl)") do |value|
-            @context_kind = '.' + value         
-          end
-      
-          opt.on("--verbose", "-v",
-                 "Display extra progress as we parse.") do |value|
-            @verbosity = 2
-          end
-
-          # No argument, shows at tail.  This will print an options summary.
-          # Try it and see!
-          opt.on_tail("-h", "--help", "Show this message") do
-            puts opts
-            exit
-          end
-
-          # Another typical switch to print the version.
-          opt.on_tail("--version", "Show version") do
-            puts "wlang version " << WLang::VERSION << " (c) University of Louvain, Bernard & Louis Lambeau"
-            exit
-          end
-      
-          opt.separator nil
-        end   
-    
-        # handle arguments    
-        rest = opts.parse!(argv)
-        if rest.length<1 or rest.length>2
-          puts opts
-          exit
-        end
-    
-        # handle template file
-        @template_file = File.expand_path(rest[0])
-        raise("File '#{@template_file}' not readable")\
-          unless File.file?(@template_file) and File.readable?(@template_file)
-
-        # handle context file
-        if rest.length==2
-          @context_file = rest[1]
-          raise("File '#{@context_file}' not readable")\
-            unless File.file?(@context_file) and File.readable?(@context_file)
-        end
-    
-        # handle template dialect
-        unless @template_dialect
-          extname = File.extname(@template_file)
-          @template_dialect = WLang::FILE_EXTENSIONS[extname]
-          raise("No known dialect for file extension '#{extname}'\n"\
-                "Known extensions are: " << WLang::FILE_EXTENSIONS.keys.join(", "))\
-            if @template_dialect.nil?
-        end
-    
-        # handle context object
-        if @context_file
-          @context_object = WLang::load_data(@context_file, @context_kind)
-        end
-        
-        return self
-      end
-  
-    end # class Options  
-
-  end # class WLangCommand
-end # module WLang

data/spec/basic_object.spec

@@ -1,40 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-describe "WLang's version of BasicObject" do
-  
-  class A 
-    # Methods that we keep
-    KEPT_METHODS = ["__send__", "__id__", "instance_eval", "initialize", 
-                    "object_id", "nil?", "singleton_method_added", "__clean_scope__",
-                    "singleton_method_undefined"]
-
-    def self.__clean_scope__
-      # Removes all methods that are not needed to the class
-      (instance_methods + private_instance_methods).each do |m|
-        undef_method(m.to_s.to_sym) unless KEPT_METHODS.include?(m.to_s)
-      end
-    end
-    __clean_scope__
-  end
-  
-  it "should not have kernel methods except certain" do
-    [:puts, :to_s, :hash].each do |sym|
-      begin
-        A.new.instance_eval{ __send__(sym, []) }
-        "Not pass here".should == ""
-      rescue NoMethodError 
-        true.should == true
-      end
-    end
-  end
-  
-  it "should not gain methods when requiring gems" do
-    Kernel.load(File.join(File.dirname(__FILE__),"global_extensions.rb"))
-    begin
-      A.new.__clean_scope__.instance_eval{ hello_world }
-      "Not pass here".should == ""
-    rescue NoMethodError 
-      true.should == true
-    end
-  end
-  
-end

data/spec/coderay_dialect.spec

@@ -1,8 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-describe("WLang should support coderay encoder") do
-  
-  it("should support basic coderay encoding") {
-    WLang::encode("<h1>This is a title</h1>", "xhtml/coderay/html").should_not be_nil
-  }
-  
-end

data/spec/dialect/apply_post_transform.spec

@@ -1,16 +0,0 @@
-describe "WLang::Dialect#post_transform" do
-  
-  let(:dialect){ WLang::Dialect.new("test", nil) }
-  subject{ dialect.apply_post_transform("hello") }
-  
-  context "when a string has been installed" do
-    before{ dialect.post_transformer = "plain-text/upcase" }
-    it{ should == "HELLO" }
-  end
-  
-  context "when a a has been installed" do
-    before{ dialect.post_transformer = lambda{|txt| "yes!#{txt}"} }
-    it{ should == "yes!hello" }
-  end
-  
-end

data/spec/global_extensions.rb

@@ -1,2 +0,0 @@
-def hello_world
-end

data/spec/hash_scope.spec

@@ -1,76 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-require 'wlang/hash_scope'
-
-describe ::WLang::HashScope do
-  
-  # Builds a new scope instance, with an optional parent and
-  # initial hash
-  def newscope(pairing = nil, parent = nil)
-    ::WLang::HashScope.new(pairing, parent)
-  end
-  
-  it "should act as a basic hash at first glance" do
-    scope = newscope
-    scope.has_key?(:hello).should be_false
-    scope[:hello] = "world"
-    scope.has_key?(:hello).should be_true
-    scope[:hello].should == "world"
-  end
-  
-  it "should support a parent" do
-    parent = newscope(:hello => "world", :mine => false)
-    child = newscope({:mine => true}, parent)
-
-    child.has_key?(:mine).should be_true
-    child.has_key?(:hello).should be_true
-    child[:mine].should be_true
-    child[:hello].should == "world"
-  end
-  
-  it "should never touch its parent" do
-    parent = newscope(:hello => "world")
-    child = newscope(nil, parent)
-    child[:hello].should == "world"
-    child[:hello] = "none"
-    child[:hello].should == "none"
-    parent[:hello].should == "world"
-  end
-  
-  it "should support branching easily" do
-    parent = newscope(:hello => "world")
-    parent.branch do |scope|
-      scope[:who] = "blambeau"
-      scope[:who].should == "blambeau" 
-      scope[:hello].should == "world" 
-      scope[:hello] = "none"
-    end
-    parent.has_key?(:who).should be_false
-    parent[:hello].should == "world"
-  end
-  
-  it "should allow push/pop kind of branching" do
-    scope = newscope(:hello => "world")
-    scope = scope.branch
-    scope[:hello].should == "world"
-    scope[:hello] = "none"
-    scope[:hello].should == "none"
-    scope = scope.parent
-    scope[:hello].should == "world"
-  end
-  
-  it "should respect scoping hierarchy" do
-    scope = newscope(:hello => "world")
-    child = newscope({}, scope)
-    child2 = newscope({}, child)
-
-    scope.parent.should be_nil
-    scope.root.should == scope
-
-    child.parent.should == scope
-    child.root.should == scope
-
-    child2.parent.should == child
-    child2.root.should == scope
-  end
-
-end

data/spec/redcloth_dialect.spec

@@ -1,24 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-describe("WLang should support redcloth encoder") do
-  
-  it("should support basic redcloth encoding") {
-    expected = "<h1>This is a title</h1>"
-    WLang::encode("h1. This is a title", "redcloth/xhtml").should == expected
-  }
-  
-  it("should not perturbate template variables with global variables") {
-    # RedCloth installs a t global method (which becomes a private method
-    # of Object) which was perturbating the HostedLanguage::DSL class.
-    # This test acts as a non-regression one.
-    require 'rubygems'
-    require 'RedCloth'
-    "${t}".wlang(:t => 'wlang').should == 'wlang'
-    begin
-      "${t}".wlang()
-      true.should == false
-    rescue ::WLang::UndefinedVariableError
-      true.should == true
-    end
-  }
-  
-end

data/spec/test_all.rb

@@ -1,8 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
-require 'wlang'
-require 'rspec/autorun'
-test_files = Dir[File.join(File.dirname(__FILE__), '**/*.spec')]
-test_files.each { |file|
-  load(file) 
-}
-

data/spec/wlang.spec

@@ -1,53 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-describe ::WLang do
-  
-  it("should allow easy use of encoders") {
-    WLang::encode('&', 'xhtml/entities-encoding').should == '&'
-    WLang::encode("O'Neil", 'ruby/single-quoting').should == "O\\'Neil"
-    WLang::encode('O"Neil', 'ruby/double-quoting').should == 'O\\"Neil'
-    WLang::encode("O'Neil", 'sql/single-quoting').should == "O\\'Neil"
-    WLang::encode("O'Neil", 'sql/sybase/single-quoting').should == "O''Neil"
-  }
-  
-  it "should allow easy upper camel casing" do
-    WLang::encode('hello_world', 'plain-text/camel-case').should == "HelloWorld"
-    WLang::encode('hello_world', 'plain-text/camel').should == "HelloWorld"
-    WLang::encode('hello_world', 'plain-text/upper-camel').should == "HelloWorld"
-    WLang::encode('this is another example', 'plain-text/camel-case').should == "ThisIsAnotherExample"
-    WLang::encode("this is   yet \n another example", 'plain-text/camel-case').should == "ThisIsYetAnotherExample"
-
-    WLang::encode('hello_world', 'plain-text/lower-camel').should == "helloWorld"
-  end
-  
-  it "should allow easy ruby method casing" do
-    WLang::encode('helloWorld', 'ruby/method-case').should == "hello_world"
-    WLang::encode('HelloWorld', 'ruby/method-case').should == "hello_world"
-    WLang::encode('hello world', 'ruby/method-case').should == "hello_world"
-    WLang::encode('Hello123World', 'ruby/method-case').should == "hello123_world"
-    WLang::encode('HelloWorld_123', 'ruby/method-case').should == "hello_world_123"
-    WLang::encode('123_HelloWorld', 'ruby/method-case').should == "_123_hello_world"
-  end
-  
-  it "should have correct examples in README.rdoc" do
-    expected = "Hello world!"
-    "Hello ${who}!".wlang(:who => 'world').should == expected
-
-    expected = "Hello cruel & world!"
-    "Hello ${who}!".wlang({:who => 'cruel & world'}, 'wlang/xhtml').should == expected
-  
-    expected = "Hello blambeau, llambeau"
-    "Hello *{authors as a}{${a}}{, }".wlang(:authors => ['blambeau', 'llambeau']).should == expected
-
-    expected = "INSERT INTO people VALUES ('O\\'Neil')"
-    "INSERT INTO people VALUES ('{who}')".wlang({:who => "O'Neil"}, 'wlang/sql')
-    
-    expected = "Hello wlang!"
-    tpl = "Hello $(${varname})!".wlang(:varname => 'who')          
-    tpl.wlang({:who => 'wlang'}, 'wlang/active-string', :parentheses).should == expected
-
-    context = {:varname => 'who', :who => 'wlang'}
-    expected = "Hello wlang!"
-    "Hello ${${varname}}!".wlang(context).should == expected
-  end
-  
-end