riml 0.2.4 → 0.2.5

data/bin/riml

@@ -38,11 +38,19 @@ module Riml
           append_filenames_to_list_if_all_exist(options.check_syntax_files, *filenames)
         end
 
-        opts.on("-t", "--source-path PATH", "Path riml uses for `riml_source` and `riml_include` to find files. Defaults to pwd.") do |path|
-          if Dir.exists?(path)
+        opts.on("-S", "--source-path PATH", "Colon-separated path riml uses to find files for `riml_source`. Defaults to pwd.") do |path|
+          begin
             Riml.source_path = path
-          else
-            abort "Couldn't find directory #{path.inspect}."
+          rescue UserArgumentError => e
+            abort e.message
+          end
+        end
+
+        opts.on("-I", "--include-path PATH", "Colon-separated path riml uses to find files for `riml_include`. Defaults to pwd.") do |path|
+          begin
+            Riml.include_path = path
+          rescue UserArgumentError => e
+            abort e.message
           end
         end
 
@@ -72,10 +80,11 @@ module Riml
 
     def self.append_filenames_to_list_if_all_exist(list, *filenames)
       filenames.each do |fname|
-        if File.exists?(fname)
+        expanded = File.expand_path(fname)
+        if File.exists?(expanded)
           list << fname
         else
-          abort "Couldn't find file #{fname.inspect}."
+          raise UserArgumentError, "Couldn't find file #{fname.inspect}."
         end
       end
     end

data/lib/ast_rewriter.rb

@@ -68,7 +68,7 @@ module Riml
       old_ast = ast
       ast.children.each do |node|
         next unless RimlCommandNode === node && node.name == 'riml_include'
-        node.each_existing_file! do |file|
+        node.each_existing_file! do |file, fullpath|
           if from_file && @included_file_refs[file] == from_file
             msg = "#{from_file.inspect} can't include #{file.inspect}, as " \
                   " #{file.inspect} already included #{from_file.inspect}"
@@ -77,8 +77,7 @@ module Riml
             raise UserArgumentError, "#{file.inspect} can't include itself"
           end
           @included_file_refs[from_file] = file
-          full_path = File.join(Riml.source_path, file)
-          riml_src = File.read(full_path)
+          riml_src = File.read(fullpath)
           # recursively parse included files with this ast_rewriter in order
           # to pick up any classes that are defined there
           rewritten_ast = Parser.new.parse(riml_src, self, file)

data/lib/compiler.rb

@@ -557,8 +557,8 @@ module Riml
       def compile(node)
         if node.name == 'riml_source'
           node.name = 'source'
-          node.each_existing_file! do |file|
-            root_node(node).current_compiler.compile_queue << file
+          node.each_existing_file! do |basename, full_path|
+            root_node(node).current_compiler.compile_queue << full_path
           end
         elsif node.name == 'riml_include'
           # riml_include has to be top-level
@@ -566,10 +566,9 @@ module Riml
             error_msg = %Q(riml_include error, has to be called at top-level)
             raise IncludeNotTopLevel, error_msg
           end
-          node.each_existing_file! do |file|
-            full_path = File.join(Riml.source_path, file)
+          node.each_existing_file! do |basename, full_path|
             riml_src = File.read(full_path)
-            node.compiled_output << root_node(node).current_compiler.compile_include(riml_src, file)
+            node.compiled_output << root_node(node).current_compiler.compile_include(riml_src, basename)
           end
           return node.compiled_output
         end

data/lib/nodes.rb

@@ -355,26 +355,38 @@ module Riml
       end
     end
 
+    # yields full file path for each existing file found in Riml.source_path
     def each_existing_file!
-      files = []
+      files = {}
       arguments.map(&:value).each do |file|
-        if File.exists?(File.join(Riml.source_path, file))
-          files << file
+        if base_path = paths.detect do |path|
+             full = File.join(path, file)
+             File.exists?(full)
+           end
+          files[file] = File.join(base_path, file)
         else
           raise Riml::FileNotFound, "#{file.inspect} could not be found in " \
-            "source path (#{Riml.source_path.inspect})"
+            "#{name.upcase}_PATH (#{paths.join(':').inspect})"
         end
       end
-      return unless block_given?
+      return files.values unless block_given?
       # all files exist
-      files.each do |f|
+      files.each do |basename, full_path|
         begin
-          yield f
+          yield basename, full_path
         rescue Riml::IncludeFileLoop
-          arguments.delete_if { |arg| arg.value == f }
+          arguments.delete_if { |arg| arg.value == basename }
         end
       end
     end
+
+    def paths
+      if name == 'riml_include'
+        Riml.include_path
+      else
+        Riml.source_path
+      end
+    end
   end
 
   class OperatorNode < Struct.new(:operator, :operands)

data/lib/riml.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 require File.expand_path('../environment', __FILE__)
 require 'nodes'
 require 'lexer'
@@ -12,11 +14,11 @@ module Riml
   end
 
   # parse code (or tokens) into nodes
-  def self.parse(input, ast_rewriter = AST_Rewriter.new)
+  def self.parse(input, ast_rewriter = AST_Rewriter.new, filename = nil)
     unless input.is_a?(Array) || input.is_a?(String)
       raise ArgumentError, "input must be tokens or code, is #{input.class}"
     end
-    Parser.new.parse(input, ast_rewriter)
+    Parser.new.parse(input, ast_rewriter, filename)
   end
 
   # compile nodes (or tokens or code or file) into output code
@@ -27,7 +29,7 @@ module Riml
       nodes = parser.parse(input)
     elsif input.is_a?(File)
       source = input.read
-      nodes = parser.parse(source)
+      nodes = parser.parse(source, AST_Rewriter.new, input.path)
     else
       raise ArgumentError, "input must be nodes, tokens, code or file, is #{input.class}"
     end
@@ -74,10 +76,19 @@ module Riml
   end
 
   def self.source_path
-    @source_path ||= Dir.getwd
+    get_path(:source_path)
   end
+
   def self.source_path=(path)
-    @source_path = path
+    set_path(:source_path, path)
+  end
+
+  def self.include_path
+    get_path(:include_path)
+  end
+
+  def self.include_path=(path)
+    set_path(:include_path, path)
   end
 
   def self.warn(warning)
@@ -103,6 +114,32 @@ module Riml
     @warning_buffer ||= WarningBuffer.new
   end
 
+  def self.set_path(name, path)
+    return instance_variable_set("@#{name}", nil) if path.nil?
+    path = path.split(':') if path.is_a?(String)
+    path.each do |dir|
+      unless Dir.exists?(dir)
+        raise UserArgumentError, "Error trying to set #{name.to_s}. " \
+          "Directory #{dir.inspect} doesn't exist"
+      end
+    end
+    instance_variable_set("@#{name}", path)
+  end
+  self.source_path  = nil  # eliminate ivar warnings
+  self.include_path = nil  # eliminate ivar warnings
+
+  def self.get_path(name)
+    ivar = instance_variable_get("@#{name}")
+    return ivar if ivar
+    # RIML_INCLUDE_PATH or RIML_SOURCE_PATH
+    val = if (path = ENV["RIML_#{name.to_s.upcase}"])
+      path
+    else
+      [Dir.getwd]
+    end
+    set_path(name, val)
+  end
+
   def self.threaded_compile_files(*filenames)
     threads = []
     filenames.each do |fname|
@@ -116,10 +153,10 @@ module Riml
 
   # This is for when another file is sourced within a file we're compiling.
   def self.process_compile_queue!(compiler)
-    while filename = compiler.compile_queue.shift
-      unless compiler.sourced_files_compiled.include?(filename)
-        compiler.sourced_files_compiled << filename
-        compile(File.open(File.join(Riml.source_path, filename)), compiler.parser, compiler)
+    while full_path = compiler.compile_queue.shift
+      unless compiler.sourced_files_compiled.include?(full_path)
+        compiler.sourced_files_compiled << full_path
+        compile(File.open(full_path), compiler.parser, compiler)
       end
     end
   end
@@ -128,11 +165,16 @@ module Riml
   INCLUDE_COMMENT_FMT = File.read(File.expand_path("../included.vim", __FILE__))
 
   def self.write_file(output, fname)
-    file_basename = File.basename(fname)
-    unless File.extname(file_basename).empty?
-      file_basename = file_basename.split(".").tap {|parts| parts.pop}.join(".")
+    # absolute path, output into same directory as file
+    dir = if fname[0] == File::SEPARATOR
+      Pathname.new(fname).parent.to_s
+    # relative path, output into current working directory
+    else
+      Dir.getwd
     end
-    File.open("#{file_basename}.vim", 'w') do |f|
+    basename_without_riml_ext = File.basename(fname).sub(/\.riml\Z/i, '')
+    full_path = File.join(dir, "#{basename_without_riml_ext}.vim")
+    File.open(full_path, 'w') do |f|
       f.write FILE_HEADER + output
     end
   end

data/version.rb

@@ -1,4 +1,4 @@
 module Riml
-  # last changed: Apr. 21, 2013
-  VERSION = [0,2,4]
+  # last changed: Apr. 28, 2013
+  VERSION = [0,2,5]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riml
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-22 00:00:00.000000000 Z
+date: 2013-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc