wlang 0.8.4

data/lib/wlang/template.rb

@@ -0,0 +1,79 @@
+module WLang
+  
+  # 
+  # Template in a given wlang dialect, providing a default context object.
+  #
+  class Template
+  
+    # Recognized symbols for blocks
+    BLOCK_SYMBOLS = {:braces   => ['{', '}'],
+                     :brackets => ['[', ']'],
+                     :parentheses => ['(', ')']}
+  
+    # Template wlang dialect (wlang/...)
+    attr_reader :dialect
+
+    # Instantiation context
+    attr_reader :context
+    
+    # Block symbols
+    attr_reader :block_symbols
+  
+    # Attached file source
+    attr_accessor :source_file
+  
+    #
+    # Creates a template instance.
+    #
+    def initialize(source, dialect, context=nil, block_symbols = :braces)
+      raise(ArgumentError, "Source is mandatory") if source.nil?
+      if String===dialect
+        dname, dialect = dialect, WLang::dialect(dialect)
+        raise(ArgumentError, "Unknown dialect #{dname}") if dialect.nil?
+      end     
+      raise(ArgumentError, "Dialect is mandatory") unless WLang::Dialect===dialect
+      @source = source
+      @dialect = dialect
+      @context = WLang::Parser::Context.new(context)  
+      @block_symbols = block_symbols
+    end
+  
+    # Resolved a relative uri
+    def file_resolve(uri, exists=false)
+      raise("Unable to resolve #{uri}, this template is not attached to a file")\
+        unless @source_file
+      target = File.join(File.dirname(@source_file), uri)
+      if exists and not(File.exists?(target))
+        raise "File '#{uri}' does not exists"
+      end
+      target
+    end
+  
+    # Returns template's source text
+    def source_text
+      case @source
+      when String
+        @source
+      else
+        @source.to_s
+      end
+    end
+  
+    #
+    # Instantiate the template, with an additional context and an output buffer.
+    #
+    def instantiate(buffer=nil, context=nil)
+      unless context.nil? 
+        @context.push(context)
+      end
+      parser = WLang::Parser.instantiator(self, buffer)
+      instantiated = parser.instantiate
+      unless context.nil?
+        @context.pop
+      end
+      instantiated[0]
+    end
+  
+  end # class Template
+  
+end # module WLang

data/lib/wlang/wlang_command.rb

@@ -0,0 +1,54 @@
+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
+      unless options.context_name.nil?
+        context = {options.context_name => context}
+      end
+      template = WLang::Template.new(source, dialect, context, braces)
+      template.source_file = options.template_file
+    
+      if options.verbosity>1
+        puts "Instantiating #{options.template_file}"
+        puts "Using dialect #{dialect} : #{dialect.class}"
+        puts "Block delimiters are " << Template::BLOCK_SYMBOLS[braces].inspect
+        puts "Context is " << context.inspect
+      end
+    
+      buffer << template.instantiate
+    
+      # 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

@@ -0,0 +1,158 @@
+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("-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/test/sandbox.rb

@@ -0,0 +1 @@
+puts "blambeau".to_sym

data/test/test_all.rb

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

data/test/wlang/anagram_bugs_test.rb

@@ -0,0 +1,111 @@
+require 'test/unit'
+require 'wlang'
+module WLang
+
+  # Tests the IntelligentBuffer class
+  class AnagramBugsTest < Test::Unit::TestCase
+    include IntelligentBuffer::Methods
+   
+    def test_on_anagram_spacing_policy
+      WLang::dialect("anagram") do
+        rule '=~' do |parser,offset|
+          match, reached = parser.parse(offset, "wlang/dummy")
+          block, reached = parser.parse_block(reached, "wlang/dummy")
+
+          # puts "Here is the block ==="
+          # puts "#{block.gsub(/ /, '.').gsub(/\n/, "\\n\n")}"
+          # puts "=== Here is the block"
+
+          [block, reached]
+        end
+      end
+      template = %q{
+        =~{String}{
+          this is an anagram template
+        }
+      }.gsub(/^ {8}/, '').strip
+      result = template.wlang_instantiate({}, "anagram")
+      assert IntelligentBuffer===result
+#      assert_equal("this is an anagram template", result)
+
+      template = %q{
+        =~{String}{
+          module MyModule
+          end
+        }
+      }.gsub(/^ {8}/, '').strip
+      result = template.wlang_instantiate({}, "anagram")
+      assert IntelligentBuffer===result
+      assert_equal("module MyModule\nend\n", result)
+    end
+    
+    def test_missing_end_bug
+      WLang::dialect("anagram") do
+        rules WLang::RuleSet::Basic
+        rules WLang::RuleSet::Imperative
+        rule '=~' do |parser,offset|
+          match, reached = parser.parse(offset, "wlang/dummy")
+          match = parser.evaluate(match)
+          block, reached = parser.parse_block(reached, "wlang/dummy")
+          block = block.strip_block(block)
+          block = block.tabto(block,0)
+          parser.evaluate("matching_rules") << [match, block]
+    
+          # puts "Here is the block ==="
+          # puts "#{block.gsub(/ /, '.').gsub(/\n/, "\\n\n")}"
+          # puts "=== Here is the block"
+    
+          ["", reached]
+        end
+        rule '+~' do |parser,offset|
+          what, reached = parser.parse(offset, "wlang/dummy")
+          evaluated = parser.evaluate(what)
+          raise "Unexpected case, #{what} leads to nil" unless evaluated
+    
+          rules = parser.evaluate("matching_rules")
+          found = rules.find {|r| r[0]===evaluated}
+          raise "Unexpected case: no match for #{what.class}" unless found
+    
+          context = {"n" => evaluated, "matching_rules" => rules}
+          inst = found[1].wlang_instantiate(context, "anagram")
+          
+          inst2 = inst.gsub(/ /, '.').gsub(/\n/, "\\n\n")
+          # puts "Here is the inst ==="
+          # puts "#{inst2}"
+          # puts "=== Here is the inst"
+          
+          found = [inst, reached]
+        end
+      end
+      template = %Q{
+        =~{Array}{
+          module MyModule
+            *{n as c}{
+              +~{c}
+            }
+          end
+        }
+        =~{Integer}{
+          +{n}
+        }
+        +~{n}
+      }.gsub(/ {8}/,'').strip
+      context = {'n' => [10, 20, 30], 'matching_rules' => []}
+      result = template.wlang_instantiate(context, "anagram")
+    
+      # template = template.gsub(/ /, '.').gsub(/\n/, "\\n\n")
+      # puts "Here is the template ==="
+      # puts "#{template}"
+      # puts "=== Here is the template"
+    
+      # result = result.gsub(/ /, '.').gsub(/\n/, "\\n\n")
+      # puts "Here is the result ==="
+      # puts "#{result}"
+      # puts "=== Here is the result"
+      result = result.strip
+      expected = "module MyModule\n  10\n  \n  20\n  \n  30\n\nend"
+      assert_equal expected, result
+    end
+    
+  end
+end

data/test/wlang/basic_ruleset_test.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'wlang'
+require 'wlang/test_utils'
+require 'wlang/rulesets/basic_ruleset'
+require 'wlang/rulesets/context_ruleset'
+require 'wlang/rulesets/buffering_ruleset'
+
+# Tests the Basic ruleset
+class WLang::BasicRuleSetTest < Test::Unit::TestCase
+  include WLang::TestUtils
+  
+  # Installs a dialect on wlang
+  def setup
+    WLang::dialect "basic-test" do 
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Context
+      rules WLang::RuleSet::Buffering
+    end
+  end
+
+  # tests !{wlang/hosted} operator
+  def test_execution
+    tests = [
+      ["!{name}", "blambeau", {"name" => "blambeau"}],
+      ["!{!{var}}", "blambeau", {"var" => "name", "name" => "blambeau"}],
+      ["!{'hello'.upcase}", "HELLO", {}]
+    ]
+    tests.each do |t|
+      template, expected, context = t
+      result = template.wlang(context, "basic-test")
+      assert_equal(expected, result) 
+    end
+  end
+    
+  # Tests recursive_application rule
+  def test_recursive_application
+    tests = [
+      ["#={code}{%{wlang/dummy}{+{variable}}}"\
+       "%!{basic-test with variable: 'hello'}{+{code}}", "hello"],
+      ["<<={data.rb as context}"\
+       "#={code}{%{wlang/dummy}{+{author}}}"\
+       "%!{basic-test using context}{+{code}}", "blambeau"]
+    ]
+    tests.each do |test|
+      template, expected = test
+      template = relative_template(template, "basic-test", __FILE__)
+      result = template.instantiate()
+      assert_equal(expected, result)
+    end
+  end
+  
+end # class WLang::BasicRuleSetTest