wlang 0.8.4 → 0.8.5

data/lib/wlang.rb

@@ -18,7 +18,7 @@ require 'wlang/intelligent_buffer'
 module WLang
   
   # Current version of WLang
-  VERSION = "0.8.4".freeze
+  VERSION = "0.8.5".freeze
   
   # Reusable string for building dialect name based regexps  
   DIALECT_NAME_REGEXP_STR = "[-a-z]+"

data/lib/wlang/errors.rb

@@ -3,35 +3,14 @@ module WLang
   # Main error of all WLang errors.
   class Error < StandardError; end
   
+  # Raise when something fails when evaluting through the parser context
+  class EvalError < StandardError; end
+  
   # Error raised by a WLang parser instanciation when an error occurs. 
-  class ParseError < StandardError; 
-
-    attr_reader :line, :column
-
-    # Creates an error with offset information
-    def initialize(message, offset=nil, template=nil)
-      @offset = offset
-      @line, @column = parse(template) if template
-      unless template and offset
-        super(message) 
-      else
-        super("ParseError at #{@line}:#{@column} : #{message}")
-      end
-      
-    end
+  class ParseError < StandardError;  
     
-    # Reparses the template and finds line:column locations
-    def parse(template)
-      template = template[0,@offset]
-      if template =~ /\n/ then
-        lines = template[0,@offset].split(/\n/)
-      else 
-        lines = [template]
-      end
-      line, column = lines.length, lines.last.length
-      return [line, column]
-    end
+    attr_accessor :line, :column
     
-  end # class ParseError
+  end
   
 end # module WLang

data/lib/wlang/parser.rb

@@ -136,6 +136,8 @@ module WLang
     #
     def evaluate(expression)
       @context.evaluate(expression)
+    rescue Exception => ex
+      raise ::WLang::EvalError, "#{template.where(@offset)} evaluation of '#{expression}' failed", ex.backtrace
     end
   
     #
@@ -199,19 +201,25 @@ module WLang
       encoder.encode(src, options)
     end
   
+    # Raises an exception with a friendly message
+    def error(offset, message)
+      template.error(offset, message)
+    end
+  
     #
     # Raises a ParseError at a given offset.
     #
     def syntax_error(offset, msg=nil)
       text = self.parse(offset, "wlang/dummy", "")
-      raise ParseError, "Parse error at #{offset} on '#{text}': #{msg}"
+      msg = msg.nil? ? '' : ": #{msg}"
+      template.parse_error(offset, "parse error on '#{text}'#{msg}")
     end
   
     #
     # Raises a ParseError at a given offset for a missing block
     #
     def block_missing_error(offset)
-      raise ParseError.new("Block expected", offset, @source_text)
+      template.parse_error(offset, "parse error, block was expected")
     end
   
     #
@@ -219,7 +227,7 @@ module WLang
     # specif. the expected character when EOF found
     #
     def unexpected_eof(offset, expected)
-      raise ParseError.new("'#{expected}' expected, EOF found.", offset, @source_text)
+      template.parse_error(offset, "#{expected} expected, EOF found")
     end
   
     #

data/lib/wlang/parser_context.rb

@@ -104,13 +104,6 @@ module WLang
         else
           @current_scope.__evaluate(expression)  
         end
-      rescue Exception => ex
-        puts "Warning, some wlang exception when evaluating the expression\n#{expression}"
-        puts "Message was: #{ex.message}"
-        puts ex.backtrace.join("\n")
-        puts "Current scope was:\n"
-        puts @current_scope.__underlying.inspect
-        return nil
       end
   
       # Pushes a new scope instance.

data/lib/wlang/ruby_extensions.rb

@@ -17,5 +17,19 @@ class String
   end
   alias :wlang :wlang_instantiate
     
+  def __wlang_column_of(index)
+    return 1 if index == 0
+    newline_index = rindex("\n", index - 1)
+    if newline_index
+      index - newline_index
+    else
+      index + 1
+    end
+  end
+  
+  def __wlang_line_of(index)
+    self[0...index].count("\n") + 1
+  end
+
 end
 

data/lib/wlang/rulesets/buffering_ruleset.rb

@@ -20,8 +20,13 @@ module WLang
       # Rule implementation of <tt><<{wlang/uri}</tt>
       def self.input(parser, offset)
         uri, reached = parser.parse(offset, "wlang/uri")
-        file = parser.template.file_resolve(uri, true)
-        [File.read(file), reached]
+        file = parser.template.file_resolve(uri, false)
+        if File.file?(file) and File.readable?(file)
+          [File.read(file), reached]
+        else
+          text = parser.parse(offset, "wlang/dummy")[0]
+          parser.error(offset, "unable to apply input rule <<{#{text}}, not a file or not readable (#{file})")
+        end
       end
   
       # Rule implementation of <tt>>>{wlang/uri}</tt>
@@ -29,11 +34,15 @@ module WLang
         uri, reached = parser.parse(offset, "wlang/uri")
         file = parser.template.file_resolve(uri, false)
         dir = File.dirname(file)
-        FileUtils.mkdir_p(dir) unless File.exists?(dir)
-        File.open(file, "w") do |file|
-          text, reached = parser.parse_block(reached, nil, file)
+        if File.writable?(dir) or not(File.exists?(dir))
+          FileUtils.mkdir_p(dir) unless File.exists?(dir)
+          File.open(file, "w") do |file|
+            text, reached = parser.parse_block(reached, nil, file)
+          end
+          ["", reached]
+        else
+          parser.error(offset, "unable to apply output rule >>{#{text}}, not a writable directory (#{file})")
         end
-        ["", reached]
       end
     
       # Rule implementation of <<={wlang/uri as x}{...}
@@ -44,18 +53,23 @@ module WLang
         decoded = U.decode_uri_as(uri)
         parser.syntax_error(offset) if decoded.nil?
     
-        file = parser.template.file_resolve(decoded[:uri], true)
-        data = WLang::load_data(file)
+        file = parser.template.file_resolve(decoded[:uri], false)
+        if File.file?(file) and File.readable?(file)
+          data = WLang::load_data(file)
     
-        # handle two different cases
-        if parser.has_block?(reached)
-          parser.context_push(decoded[:variable] => data)
-          text, reached = parser.parse_block(reached)
-          parser.context_pop
-          [text, reached]
+          # handle two different cases
+          if parser.has_block?(reached)
+            parser.context_push(decoded[:variable] => data)
+            text, reached = parser.parse_block(reached)
+            parser.context_pop
+            [text, reached]
+          else
+            parser.context_define(decoded[:variable], data)
+            ["", reached]
+          end
         else
-          parser.context_define(decoded[:variable], data)
-          ["", reached]
+          text = parser.parse(offset, "wlang/dummy")[0]
+          parser.error(offset, "unable to apply data-assignment rule <<={#{text}} (#{file}), not a file or not readable (#{file})")
         end
       end
 
@@ -91,9 +105,14 @@ module WLang
           end
         end
         
-        file = parser.template.file_resolve(decoded[:uri], true)
-        instantiated = WLang::file_instantiate(file, context)
-        [instantiated, reached]
+        file = parser.template.file_resolve(decoded[:uri], false)
+        if File.file?(file) and File.readable?(file)
+          instantiated = WLang::file_instantiate(file, context)
+          [instantiated, reached]
+        else
+          text = parser.parse(offset, "wlang/dummy")[0]
+          parser.error(offset, "unable to apply input-inclusion rule <<+{#{text}}, not a file or not readable (#{file})")
+        end
       end
   
 

data/lib/wlang/template.rb

@@ -52,10 +52,10 @@ module WLang
     # Returns template's source text
     def source_text
       case @source
-      when String
-        @source
-      else
-        @source.to_s
+        when String
+          @source
+        else
+          @source.to_s
       end
     end
   
@@ -73,6 +73,28 @@ module WLang
       end
       instantiated[0]
     end
+    
+    # Returns a friendly position of an offset in the source text
+    def where(offset)
+      src = source_text
+      "#{@source_file}:#{src.__wlang_line_of(offset)}:#{src.__wlang_column_of(offset)-1}"
+    end
+    
+    # Raises a WLang::Error for the given offset
+    def error(offset, msg = "")
+      src = source_text
+      line, column = src.__wlang_line_of(offset), src.__wlang_column_of(offset)-1
+      raise WLang::Error, "#{@source_file}:#{line}:#{column} #{msg}"
+    end
+    
+    # Raises a friendly ParseError, with positions and so on
+    def parse_error(offset, msg = "")
+      src = source_text
+      line, column = src.__wlang_line_of(offset), src.__wlang_column_of(offset)-1
+      ex = ParseError.new("#{@source_file}:#{line}:#{column} #{msg}")
+      ex.line, ex.column = line, column
+      raise ex
+    end
   
   end # class Template
   

data/test/wlang/parser_test.rb

@@ -1,4 +1,4 @@
-require 'test/unit/testcase'
+require 'test/unit'
 require 'wlang'
 module WLang
   
@@ -77,11 +77,11 @@ class ParserTest < Test::Unit::TestCase
   def test_parser_error_find_line_and_column
     assert_error_at_line_column("-{tag", 1, 5)
     assert_error_at_line_column("-{tag with spaces   ", 1, 20)
-    assert_error_at_line_column("-{tag as i}{\n", 1, 12)
-    assert_error_at_line_column("-{tag as i}{\n\n", 1, 12)
-    assert_error_at_line_column("-{tag as i}{\ntext\n", 2, 4)
-    assert_error_at_line_column("-{tag as i}{\n\ntext\n", 3, 4)
-    assert_error_at_line_column("-{tag as i}{\n\n\ntext\n", 4, 4)
+    assert_error_at_line_column("-{tag as i}{\n", 2, 0)
+    assert_error_at_line_column("-{tag as i}{\n\n", 3, 0)
+    assert_error_at_line_column("-{tag as i}{\ntext\n", 3, 0)
+    assert_error_at_line_column("-{tag as i}{\n\ntext\n", 4, 0)
+    assert_error_at_line_column("-{tag as i}{\n\n\ntext\n", 5, 0)
   end
   
 end # ParserTest

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wlang
 version: !ruby/object:Gem::Version 
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors: 
 - Bernard Lambeau
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-14 00:00:00 +01:00
+date: 2010-01-21 00:00:00 +01:00
 default_executable: 
 dependencies: []