ceedling 0.31.1 → 1.0.1

data/lib/ceedling/file_finder_helper.rb

@@ -1,54 +1,114 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'fileutils'
 require 'ceedling/constants' # for Verbosity enumeration
+require 'ceedling/exceptions'
 
 class FileFinderHelper
 
-  constructor :streaminator
+  constructor :loginator
   
   
-  def find_file_in_collection(file_name, file_list, complain, extra_message="")
-    file_to_find = nil
+  def find_file_in_collection(filename, file_list, complain, original_filepath="")
+    # Search our collection for the specified base filename
+    matches = file_list.find_all {|v| File.basename(v) == filename }
     
-    file_list.each do |item|
-      base_file = File.basename(item)
-
-      # case insensitive comparison
-      if (base_file.casecmp(file_name) == 0)
-        # case sensitive check
-        if (base_file == file_name)
-          file_to_find = item
-          break
-        else
-          blow_up(file_name, "However, a filename having different capitalization was found: '#{item}'.")
+    case matches.length 
+      when 0 
+        matches = file_list.find_all {|v| v =~ /(?:\\|\/|^)#{filename}$/i}
+        if (matches.length > 0)
+          blow_up(filename, "However, a filename having different capitalization was found: '#{matches[0]}'.")
+        end
+
+        return handle_missing_file(filename, complain)
+      when 1
+        return matches[0]
+      else
+        # Determine the closest match by looking for matching path segments, especially paths ENDING the same
+        best_match_index = 0
+        best_match_value = 0
+        reverse_original_pieces = original_filepath.split(/(?:\\|\/)/).reverse
+        matches.each_with_index do |m,i|
+          reverse_match_pieces = m.split(/(?:\\|\/)/).reverse
+
+          num = reverse_original_pieces.zip(reverse_match_pieces).inject(0){|s,v| v[0] == v[1] ? s+3 : s}
+          num = reverse_original_pieces.inject(num){|s,v| reverse_match_pieces.include?(v) ? s+1 : s}
+          if num > best_match_value
+            best_match_index = i 
+            best_match_value = num 
+          end
         end
+        return matches[best_match_index]
+    end
+
+    return nil
+  end
+
+  def find_best_path_in_collection(pathname, path_list, complain, description)
+    # search our collection for the specified exact path
+    raise "No path list provided for #{description} search" if path_list.nil?
+    return pathname if path_list.include?(pathname)
+
+    # Determine the closest match by looking for matching path segments, especially paths ENDING the same
+    best_match_index = 0
+    best_match_value = 0
+    reverse_original_pieces = pathname.split(/(?:\\|\/)/).reverse
+    path_list.each_with_index do |p,i|
+      reverse_match_pieces = p.split(/(?:\\|\/)/).reverse
+      # 
+      num = reverse_original_pieces.zip(reverse_match_pieces).inject(0){|s,v| v[0] == v[1] ? s+3 : s}
+      num = reverse_original_pieces.inject(num){|s,v| reverse_match_pieces.include?(v) ? s+1 : s}
+      if num > best_match_value
+        best_match_index = i 
+        best_match_value = num 
       end
-      
     end
-    
-    if file_to_find.nil?
+
+    # If none of the options were a good match, handle to the best of our ability
+    if (best_match_value == 0) && (reverse_original_pieces.length > 0)
       case (complain)
-        when :error then blow_up(file_name, extra_message) 
-        when :warn  then gripe(file_name, extra_message)
-        #when :ignore then      
+        when :error
+          raise CeedlingException.new( "Found no path `#{pathname}` in #{description} search paths." ) 
+        when :warn
+          warning = "Found no path `#{pathname}` in #{description} search paths."
+          @loginator.log( warning, Verbosity::COMPLAIN )
+        when :ignore 
+          # nothing further to do
       end
     end
-    
-    return file_to_find
+
+    return path_list[best_match_index]
+  end
+
+  def handle_missing_file(filename, complain)
+    case (complain)
+      when :error then blow_up(filename) 
+      when :warn
+        gripe(filename)
+        return nil
+      when :ignore then return nil
+    end
+
+    return nil
   end
 
+  ### Private ###
+
   private
-  
-  def blow_up(file_name, extra_message="")
-    error = "ERROR: Found no file '#{file_name}' in search paths."
-    error += ' ' if (extra_message.length > 0)
-    @streaminator.stderr_puts(error + extra_message, Verbosity::ERRORS)
-    raise
+
+  def blow_up(filename, extra_message="")
+    error = ["Found no file `#{filename}` in search paths.", extra_message].join(' ').strip
+    raise CeedlingException.new( error )
   end
-  
-  def gripe(file_name, extra_message="")
-    warning = "WARNING: Found no file '#{file_name}' in search paths."
-    warning += ' ' if (extra_message.length > 0)
-    @streaminator.stderr_puts(warning + extra_message, Verbosity::COMPLAIN)
+    
+  def gripe(filename, extra_message="")
+    warning = ["Found no file `#{filename}` in search paths.", extra_message].join(' ').strip
+    @loginator.log( warning, Verbosity::COMPLAIN )
   end
 
 end

data/lib/ceedling/file_path_collection_utils.rb

@@ -0,0 +1,137 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'set'
+require 'pathname'
+require 'fileutils'
+require 'ceedling/file_path_utils'
+require 'ceedling/exceptions'
+
+
+class FilePathCollectionUtils
+  
+  constructor :file_wrapper
+
+  def setup()
+    # TODO: Update Dir.pwd() to use a project root once it has been figured out
+    @working_dir_path = Pathname.new( Dir.pwd() )
+  end
+
+  # Build up a directory path list from one or more strings or arrays of (+:/-:) simple paths & globs
+  def collect_paths(paths)
+    plus  = Set.new # All real, expanded directory paths to add
+    minus = Set.new # All real, expanded paths to exclude
+    
+    # Iterate each path possibly decorated with aggregation modifiers and/or containing glob characters
+    paths.each do |path|
+      dirs = [] # Working list for evaluated directory paths
+    
+      # Get path stripped of any +:/-: aggregation modifier
+      _path = FilePathUtils.no_aggregation_decorators( path )
+
+      # If it's a glob, modify it for Ceedling's recursive subdirectory convention
+      _reformed = FilePathUtils::reform_subdirectory_glob( _path )
+
+      # Expand paths using Ruby's Dir.glob()
+      #  - A simple path will yield that path
+      #  - A path glob will expand to one or more paths
+      # Note: `sort()` because of Github Issue #860
+      @file_wrapper.directory_listing( _reformed ).sort.each do |entry|
+        # For each result, add it to the working list *only* if it's a directory
+        # Previous validation has already made warnings about filepaths in the list
+        dirs << entry if @file_wrapper.directory?(entry)
+      end
+      
+      # For recursive directory glob at end of a path, collect parent directories too.
+      # Ceedling's recursive glob convention includes parent directories (unlike Ruby's glob).
+      if path.end_with?('/**') or path.end_with?('/*')
+        parents = []
+        
+        dirs.each {|dir| parents << File.join(dir, '..')}
+
+        # Handle edge case of subdirectory glob but no subdirectories and therefore no parents
+        # (Containing parent directory still exists)
+        parents << FilePathUtils.no_decorators( _path ) if dirs.empty?
+
+        dirs = parents + dirs
+      end
+
+      # Based on aggregation modifiers, add entries to plus and minus sets.
+      # Use full, absolute paths to ensure logical paths are compared properly.
+      # './<path>' is logically equivalent to '<path>' but is not equivalent as strings.
+      # Because plus and minus are sets, each insertion eliminates any duplicates
+      # (such as the parent directories for each directory as added above).
+      dirs.each do |dir|
+        abs_path = File.expand_path( dir )
+        if FilePathUtils.add_path?( path )
+          plus << abs_path
+        else
+          minus << abs_path
+        end
+      end
+    end
+
+    # Use Set subtraction operator to remove any excluded paths
+    paths = (plus - minus).to_a
+    paths.map! {|path| shortest_path_from_working(path) }
+
+    return paths
+  end
+
+
+  # Given a file list, add to it or remove from it considering (+:/-:) aggregation operators.
+  # Rake's FileList does not robustly handle relative filepaths and patterns.
+  # So, we rebuild the FileList ourselves and return it.
+  # TODO: Replace FileList with our own, better version.
+  def revise_filelist(list, revisions)
+    plus  = Set.new # All real, expanded directory paths to add
+    minus = Set.new # All real, expanded paths to exclude
+    
+    # Build base plus set for revised path
+    list.each do |path|
+      # Start with expanding all list entries to absolute paths
+      plus << File.expand_path( path )
+    end
+
+    revisions.each do |revision|
+      # Include or exclude revisions in file list
+      path = FilePathUtils.no_aggregation_decorators( revision )
+      
+      # Working list of revisions
+      filepaths = []
+
+      # Expand path by pattern as needed and add only filepaths to working list
+      @file_wrapper.directory_listing( path ).each do |entry|
+        filepaths << File.expand_path( entry ) if !@file_wrapper.directory?( entry )
+      end
+
+      # Handle +: / -: revisions
+      if FilePathUtils.add_path?( revision )
+        plus.merge( filepaths )
+      else
+        minus.merge( filepaths )
+      end
+    end
+
+    # Use Set subtraction operator to remove any excluded paths
+    paths = (plus - minus).to_a
+    paths.map! {|path| shortest_path_from_working(path) }
+
+    return FileList.new( paths )
+  end
+
+  def shortest_path_from_working(path)
+    begin
+      # Reform path from full absolute to nice, neat relative path instead
+      (Pathname.new( path ).relative_path_from( @working_dir_path )).to_s
+    rescue StandardError
+      # If we can't form a relative path between these paths, use the absolute
+      path 
+    end
+  end
+
+end

data/lib/ceedling/file_path_utils.rb

@@ -1,7 +1,15 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'rubygems'
 require 'rake' # for ext()
 require 'fileutils'
 require 'ceedling/system_wrapper'
+require 'ceedling/constants'
 
 # global utility methods (for plugins, project files, etc.)
 def ceedling_form_filepath(destination_path, original_filepath, new_extension=nil)
@@ -12,14 +20,12 @@ end
 
 class FilePathUtils
 
-  GLOB_MATCHER = /[\*\?\{\}\[\]]/
-
   constructor :configurator, :file_wrapper
 
 
-  ######### class methods ##########
+  ######### Class methods ##########
 
-  # standardize path to use '/' path separator & have no trailing path separator
+  # Standardize path to use '/' path separator & have no trailing path separator
   def self.standardize(path)
     if path.is_a? String
       path.strip!
@@ -34,52 +40,59 @@ class FilePathUtils
     return executable
   end
 
-  # extract directory path from between optional add/subtract aggregation modifiers and up to glob specifiers
-  # note: slightly different than File.dirname in that /files/foo remains /files/foo and does not become /files
-  def self.extract_path(path)
-    path = path.sub(/^(\+|-):/, '')
+  # Extract path from between optional aggregation modifiers 
+  # and up to last path separator before glob specifiers.
+  # Examples:
+  #  - '+:foo/bar/baz/'       => 'foo/bar/baz'
+  #  - 'foo/bar/ba?'          => 'foo/bar'
+  #  - 'foo/bar/baz/'         => 'foo/bar/baz'
+  #  - 'foo/bar/baz/file.x'   => 'foo/bar/baz/file.x'
+  #  - 'foo/bar/baz/file*.x'  => 'foo/bar/baz'
+  def self.no_decorators(path)
+    path = self.no_aggregation_decorators(path)
+
+    # Find first occurrence of glob specifier: *, ?, {, }, [, ]
+    find_index = (path =~ PATTERNS::GLOB)
 
-    # find first occurrence of path separator followed by directory glob specifier: *, ?, {, }, [, ]
-    find_index = (path =~ GLOB_MATCHER)
+    # Return empty path if first character is part of a glob
+    return '' if find_index == 0
 
-    # no changes needed (lop off final path separator)
+    # If path contains no glob, clean it up and return whole path
     return path.chomp('/') if (find_index.nil?)
 
-    # extract up to first glob specifier
+    # Extract up to first glob specifier
     path = path[0..(find_index-1)]
 
-    # lop off everything up to and including final path separator
+    # Keep everything from start of path string up to and 
+    # including final path separator before glob character
     find_index = path.rindex('/')
     return path[0..(find_index-1)] if (not find_index.nil?)
 
-    # return string up to first glob specifier if no path separator found
-    return path
+    # Otherwise, return empty string
+    # (Not enough of a usable path exists free of glob operators)
+    return ''
   end
 
-  # return whether the given path is to be aggregated (no aggregation modifier defaults to same as +:)
+  # Return whether the given path is to be aggregated (no aggregation modifier defaults to same as +:)
   def self.add_path?(path)
-    return (path =~ /^-:/).nil?
+    return !path.strip.start_with?('-:')
   end
 
-  # get path (and glob) lopping off optional +: / -: prefixed aggregation modifiers
-  def self.extract_path_no_aggregation_operators(path)
-    return path.sub(/^(\+|-):/, '')
+  # Get path (and glob) lopping off optional +: / -: prefixed aggregation modifiers
+  def self.no_aggregation_decorators(path)
+    return path.sub(/^(\+|-):/, '').strip()
   end
 
-  # all the globs that may be in a path string work fine with one exception;
-  # to recurse through all subdirectories, the glob is dir/**/** but our paths use
-  # convention of only dir/**
-  def self.reform_glob(path)
-    return path if (path =~ /\/\*\*$/).nil?
-    return path + '/**'
+  # To recurse through all subdirectories, the RUby glob is <dir>/**/**, but our paths use
+  # convenience convention of only <dir>/** at tail end of a path.
+  def self.reform_subdirectory_glob(path)
+    return path if path.end_with?( '/**/**' )
+    return path + '/**' if path.end_with?( '/**' )
+    return path
   end
 
   ######### instance methods ##########
 
-  def form_temp_path(filepath, prefix='')
-    return File.join( @configurator.project_temp_path, prefix + File.basename(filepath) )
-  end
-
   ### release ###
   def form_release_build_cache_path(filepath)
     return File.join( @configurator.project_release_build_cache_path, File.basename(filepath) )
@@ -89,31 +102,20 @@ class FilePathUtils
     return File.join( @configurator.project_release_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
   end
 
-  def form_release_build_c_object_filepath(filepath)
-    return File.join( @configurator.project_release_build_output_c_path, File.basename(filepath).ext(@configurator.extension_object) )
-  end
-
-  def form_release_build_asm_object_filepath(filepath)
-    return File.join( @configurator.project_release_build_output_asm_path, File.basename(filepath).ext(@configurator.extension_object) )
+  def form_release_build_objects_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_path}/%n#{@configurator.extension_object}")
   end
 
-  def form_release_build_c_objects_filelist(files)
-    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_c_path}/%n#{@configurator.extension_object}")
-  end
-
-  def form_release_build_asm_objects_filelist(files)
-    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_asm_path}/%n#{@configurator.extension_object}")
-  end
-
-  def form_release_build_c_list_filepath(filepath)
-    return File.join( @configurator.project_release_build_output_c_path, File.basename(filepath).ext(@configurator.extension_list) )
+  def form_release_build_list_filepath(filepath)
+    return File.join( @configurator.project_release_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
   end
 
   def form_release_dependencies_filelist(files)
     return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_dependencies_path}/%n#{@configurator.extension_dependencies}")
   end
 
-  ### tests ###
+  ### Tests ###
+
   def form_test_build_cache_path(filepath)
     return File.join( @configurator.project_test_build_cache_path, File.basename(filepath) )
   end
@@ -122,71 +124,57 @@ class FilePathUtils
     return File.join( @configurator.project_test_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
   end
 
-  def form_pass_results_filepath(filepath)
-    return File.join( @configurator.project_test_results_path, File.basename(filepath).ext(@configurator.extension_testpass) )
+  def form_pass_results_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testpass) )
   end
 
-  def form_fail_results_filepath(filepath)
-    return File.join( @configurator.project_test_results_path, File.basename(filepath).ext(@configurator.extension_testfail) )
+  def form_fail_results_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testfail) )
   end
 
   def form_runner_filepath_from_test(filepath)
-    return File.join( @configurator.project_test_runners_path, File.basename(filepath, @configurator.extension_source)) + @configurator.test_runner_file_suffix + @configurator.extension_source
+    return File.join( @configurator.project_test_runners_path, File.basename(filepath, @configurator.extension_source)) + @configurator.test_runner_file_suffix + EXTENSION_CORE_SOURCE
   end
 
   def form_test_filepath_from_runner(filepath)
     return filepath.sub(/#{TEST_RUNNER_FILE_SUFFIX}/, '')
   end
 
-  def form_runner_object_filepath_from_test(filepath)
-    return (form_test_build_c_object_filepath(filepath)).sub(/(#{@configurator.extension_object})$/, "#{@configurator.test_runner_file_suffix}\\1")
-  end
-
-  def form_test_build_c_object_filepath(filepath)
-    return File.join( @configurator.project_test_build_output_c_path, File.basename(filepath).ext(@configurator.extension_object) )
-  end
-
-  def form_test_build_asm_object_filepath(filepath)
-    return File.join( @configurator.project_test_build_output_asm_path, File.basename(filepath).ext(@configurator.extension_object) )
+  def form_test_executable_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_executable) )
   end
 
-  def form_test_executable_filepath(filepath)
-    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_executable) )
-  end
-
-  def form_test_build_map_filepath(filepath)
-    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_map) )
+  def form_test_build_map_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_map) )
   end
 
   def form_test_build_list_filepath(filepath)
     return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
   end
 
-  def form_preprocessed_file_filepath(filepath)
-    return File.join( @configurator.project_test_preprocess_files_path, File.basename(filepath) )
+  def form_preprocessed_includes_list_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_includes_path, subdir, File.basename(filepath) + @configurator.extension_yaml )
   end
 
-  def form_preprocessed_includes_list_filepath(filepath)
-    return File.join( @configurator.project_test_preprocess_includes_path, File.basename(filepath) )
+  def form_preprocessed_file_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, File.basename(filepath) )
   end
 
-  def form_test_build_objects_filelist(sources)
-    return (@file_wrapper.instantiate_file_list(sources)).pathmap("#{@configurator.project_test_build_output_c_path}/%n#{@configurator.extension_object}")
+  def form_preprocessed_file_full_expansion_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_FULL_EXPANSION_DIR, File.basename(filepath) )
   end
 
-  def form_preprocessed_mockable_headers_filelist(mocks)
-    list = @file_wrapper.instantiate_file_list(mocks)
-    headers = list.map do |file|
-      module_name = File.basename(file).sub(/^#{@configurator.cmock_mock_prefix}/, '').sub(/\.[a-zA-Z]+$/,'')
-      "#{@configurator.project_test_preprocess_files_path}/#{module_name}#{@configurator.extension_header}"
-    end
-    return headers
+  def form_preprocessed_file_directives_only_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_DIRECTIVES_ONLY_DIR, File.basename(filepath) )
+  end
+
+  def form_test_build_objects_filelist(path, sources)
+    return (@file_wrapper.instantiate_file_list(sources)).pathmap("#{path}/%n#{@configurator.extension_object}")
   end
 
-  def form_mocks_source_filelist(mocks)
+  def form_mocks_source_filelist(path, mocks)
     list = (@file_wrapper.instantiate_file_list(mocks))
-    sources = list.map{|file| "#{@configurator.cmock_mock_path}/#{file}#{@configurator.extension_source}"}
-    return sources
+    return list.map{ |file| File.join(path, File.basename(file).ext(@configurator.extension_source)) }
   end
 
   def form_test_dependencies_filelist(files)

data/lib/ceedling/file_system_wrapper.rb

@@ -1,3 +1,9 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class FileSystemWrapper
 

data/lib/ceedling/file_wrapper.rb

@@ -1,6 +1,14 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'rubygems'
 require 'rake' # for FileList
 require 'fileutils'
+require 'pathname'
 require 'ceedling/constants'
 
 
@@ -20,16 +28,27 @@ class FileWrapper
     return File.exist?(filepath)
   end
 
+  def extname(filepath)
+    return File.extname(filepath)
+  end
+
+  # Is path a directory and does it exist?
   def directory?(path)
     return File.directory?(path)
   end
 
+  def relative?(path)
+    return Pathname.new( path).relative?
+  end
+
   def dirname(path)
     return File.dirname(path)
   end
 
   def directory_listing(glob)
-    return Dir.glob(glob, File::FNM_PATHNAME)
+    # Note: `sort()` to ensure platform-independent directory listings (Github Issue #860)
+    # FNM_PATHNAME => Case insensitive globs
+    return Dir.glob(glob, File::FNM_PATHNAME).sort()
   end
 
   def rm_f(filepath, options={})
@@ -40,22 +59,42 @@ class FileWrapper
     FileUtils.rm_r(filepath, **options={})
   end
 
+  def rm_rf(path, options={})
+    FileUtils.rm_rf(path, **options={})
+  end
+
   def cp(source, destination, options={})
     FileUtils.cp(source, destination, **options)
   end
 
+  def cp_r(source, destination, options={})
+    FileUtils.cp_r(source, destination, **options)
+  end
+
+  def mv(source, destination, options={})
+    FileUtils.mv(source, destination, **options)
+  end
+
   def compare(from, to)
     return FileUtils.compare_file(from, to)
   end
 
+  # Is filepath A newer than B?
+  def newer?(filepathA, filepathB)
+    return false unless File.exist?(filepathA)
+    return false unless File.exist?(filepathB)
+
+    return (File.mtime(filepathA) > File.mtime(filepathB))
+  end
+
   def open(filepath, flags)
     File.open(filepath, flags) do |file|
       yield(file)
     end
   end
 
-  def read(filepath)
-    return File.read(filepath)
+  def read(filepath, length=nil)
+    return File.read(filepath, length)
   end
 
   def touch(filepath, options={})