epitools 0.5.14 → 0.5.15

data/VERSION

@@ -1 +1 @@
-0.5.14
+0.5.15

data/epitools.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "epitools"
-  s.version = "0.5.14"
+  s.version = "0.5.15"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["epitron"]

data/lib/epitools/core_ext/enumerable.rb

@@ -19,8 +19,8 @@ module Enumerable
   #
   alias_method :includes?,  :include?
 
-  
-  #  
+
+  #
   # Skip the first n elements and return an Enumerator for the rest, or pass them
   # in succession to the block, if given. This is like "drop", but returns an enumerator
   # instead of converting the whole thing to an array.
@@ -38,32 +38,32 @@ module Enumerable
       enum_for :skip, n
     end
   end
-  
+
   #
   # Split this enumerable into chunks, given some boundary condition. (Returns an array of arrays.)
   #
   # Options:
-  #   :include_boundary => true  #=> include the element that you're splitting at in the results  
+  #   :include_boundary => true  #=> include the element that you're splitting at in the results
   #                                  (default: false)
-  #   :after => true             #=> split after the matched element (only has an effect when used with :include_boundary)  
+  #   :after => true             #=> split after the matched element (only has an effect when used with :include_boundary)
   #                                  (default: false)
   #   :once => flase             #=> only perform one split (default: false)
   #
-  # Examples: 
-  #   [1,2,3,4,5].split{ |e| e == 3 }                           
+  # Examples:
+  #   [1,2,3,4,5].split{ |e| e == 3 }
   #   #=> [ [1,2], [4,5] ]
   #
-  #   [1,2,3,4,5].split(:include_boundary=>true) { |e| e == 3 } 
-  #   #=> [ [1,2], [3,4,5] ] 
+  #   [1,2,3,4,5].split(:include_boundary=>true) { |e| e == 3 }
+  #   #=> [ [1,2], [3,4,5] ]
   #
   #   chapters = File.read("ebook.txt").split(/Chapter \d+/, :include_boundary=>true)
   #   #=> [ ["Chapter 1", ...], ["Chapter 2", ...], etc. ]
   #
   def split_at(matcher=nil, options={}, &block)
     # TODO: Ruby 1.9 returns Enumerators for everything now. Maybe use that?
-    
+
     return self unless self.any?
-    
+
     include_boundary = options[:include_boundary] || false
 
     if matcher.nil?
@@ -79,18 +79,18 @@ module Enumerable
 
     chunks = []
     current_chunk = []
-    
+
     splits = 0
-    max_splits = options[:once] == true ? 1 : options[:max_splits]    
+    max_splits = options[:once] == true ? 1 : options[:max_splits]
 
     each do |e|
 
       if boundary_test_proc.call(e) and (max_splits == nil or splits < max_splits)
-        
-        if current_chunk.empty? and not include_boundary 
+
+        if current_chunk.empty? and not include_boundary
           next # hit 2 boundaries in a row... just keep moving, people!
         end
-        
+
         if options[:after]
           # split after boundary
           current_chunk << e        if include_boundary   # include the boundary, if necessary
@@ -104,13 +104,13 @@ module Enumerable
         end
 
         splits += 1
-        
+
       else
         current_chunk << e
       end
 
     end
-    
+
     chunks << current_chunk if current_chunk.any?
 
     chunks # resultset
@@ -141,15 +141,15 @@ module Enumerable
 
   #
   # Sum the elements
-  #  
+  #
   def sum
     if block_given?
-      inject(0) { |total,elem| total + yield(elem) }    
+      inject(0) { |total,elem| total + yield(elem) }
     else
       inject(0) { |total,elem| total + elem }
     end
   end
-  
+
   #
   # Average the elements
   #
@@ -164,7 +164,7 @@ module Enumerable
   # recursively on that element.
   #
   # Example:
-  #   [ [1,2], [3,4] ].deep_map{|e| e ** 2 } #=> [ [1,4], [9,16] ] 
+  #   [ [1,2], [3,4] ].deep_map{|e| e ** 2 } #=> [ [1,4], [9,16] ]
   #
   def deep_map(depth=nil, &block)
     map do |obj|
@@ -181,14 +181,14 @@ module Enumerable
 
   alias_method :recursive_map,    :deep_map
   alias_method :map_recursively,  :deep_map
-  alias_method :map_recursive,    :deep_map 
+  alias_method :map_recursive,    :deep_map
 
   #
   # The same as "select", except that if an element is an Array or Enumerable, select is called
   # recursively on that element.
   #
   # Example:
-  #   [ [1,2], [3,4] ].deep_select{|e| e % 2 == 0 } #=> [ [2], [4] ] 
+  #   [ [1,2], [3,4] ].deep_select{|e| e % 2 == 0 } #=> [ [2], [4] ]
   #
   def deep_select(depth=nil, &block)
     map do |*args|
@@ -211,9 +211,9 @@ module Enumerable
 
     end.compact
   end
-  
+
   alias_method :recursive_select, :deep_select
-  
+
 
   #
   # Identical to "reduce" in ruby1.9 (or foldl in haskell.)
@@ -225,31 +225,31 @@ module Enumerable
     result = nil
 
     raise "Error: pass a parameter OR a block, not both!" unless !!methodname ^ block_given?
-      
+
     if methodname
-      
+
       each_with_index do |e,i|
         if i == 0
-          result = e 
+          result = e
           next
         end
-        
-        result = result.send(methodname, e)      
+
+        result = result.send(methodname, e)
       end
-      
+
     else
-      
+
       each_with_index do |e,i|
         if i == 0
-          result = e 
+          result = e
           next
         end
-        
-        result = block.call(result, e)      
+
+        result = block.call(result, e)
       end
-      
+
     end
-    
+
     result
   end
 
@@ -269,16 +269,16 @@ module Enumerable
 
   #
   # Does the opposite of #zip -- converts [ [:a, 1], [:b, 2] ] to [ [:a, :b], [1, 2] ]
-  #  
+  #
   def unzip
     # TODO: make it work for arrays containing uneven-length contents
     to_a.transpose
   end
-  
+
   #
   # Associative grouping; groups all elements who share something in common with each other.
   # You supply a block which takes two elements, and have it return true if they are "neighbours"
-  # (eg: belong in the same group). 
+  # (eg: belong in the same group).
   #
   # Example:
   #   [1,2,5,6].group_neighbours_by { |a,b| b-a <= 1 } #=> [ [1,2], [5,6] ]
@@ -296,13 +296,13 @@ module Enumerable
         cluster = [b]
       end
     end
-    
+
     result << cluster if cluster.any?
-    
-    result    
+
+    result
   end
-  alias_method :group_neighbors_by, :group_neighbours_by 
-  
+  alias_method :group_neighbors_by, :group_neighbours_by
+
 
   #
   # Convert the array into a stable iterator (Iter) object.

data/lib/epitools/path.rb

@@ -67,6 +67,7 @@ class Path
   # The file extension, including the . (eg: ".mp3")
   attr_reader :ext
 
+
   ## initializers
 
   def initialize(newpath, hints={})
@@ -74,13 +75,13 @@ class Path
   end
 
   def initialize_copy(other)
-    @dirs = other.dirs.dup
-    @base = other.base.dup
-    @ext  = other.ext.dup
+    @dirs = other.dirs && other.dirs.dup
+    @base = other.base && other.base.dup
+    @ext  = other.ext  && other.ext.dup
   end
 
-  def self.glob(str)
-    Dir[str].map { |entry| new(entry) }
+  def self.glob(str, hints={})
+    Dir[str].map { |entry| new(entry, hints) }
   end
 
   def self.[](path)
@@ -114,26 +115,6 @@ class Path
   attr_writer :base
   attr_writer :dirs
 
-  #
-  # Clear out the internal state of this object, so that it can be reinitialized.
-  #
-  def reset!
-    [:@dirs, :@base, :@ext].each { |var| remove_instance_variable var }
-    self
-  end
-
-
-  #
-  # Reload this path (update cached values.)
-  #
-  def reload!
-    temp = path
-    reset!
-    self.path = temp
-    self
-  end
-
-
   #
   # This is the core that initializes the whole class.
   #
@@ -153,6 +134,13 @@ class Path
         self.dir, self.filename = File.split(newpath)
       end
     end
+
+    # FIXME: Make this work with globs.
+    if hints[:relative]
+      update(relative_to(Path.pwd))
+    elsif hints[:relative_to]
+      update(relative_to(hints[:relative_to]))
+    end
   end
 
   def filename=(newfilename)
@@ -192,6 +180,30 @@ class Path
     end
   end
 
+  #
+  # Clear out the internal state of this object, so that it can be reinitialized.
+  #
+  def reset!
+    [:@dirs, :@base, :@ext].each { |var| remove_instance_variable var }
+    self
+  end
+
+  #
+  # Reload this path (update cached values.)
+  #
+  def reload!
+    temp = path
+    reset!
+    self.path = temp
+    self
+  end
+
+  def update(other)
+    @dirs = other.dirs
+    @base = other.base
+    @ext  = other.ext
+  end
+
   ## getters
 
   # Joins and returns the full path
@@ -203,6 +215,15 @@ class Path
     end
   end
 
+  #
+  # Is this a relative path?
+  #
+  def relative?
+    # FIXME: Need a Path::Relative subclass, so that "dir/filename" can be valid.
+    #        (If the user changes dirs, the relative path should change too.)
+    dirs.first == ".."
+  end
+
   #
   # Path relative to current directory (Path.pwd)
   #
@@ -210,44 +231,29 @@ class Path
     relative_to(pwd)
   end
 
-  def relative_to(to)
-    from = path.split(File::SEPARATOR)
-    to = Path[to].path.split(File::SEPARATOR)
-    p [from, to]
-    from.length.times do
-      break if from[0] != to[0]
-      from.shift; to.shift
-    end
-    fname = from.pop
-    join(*(from.map { RELATIVE_PARENTDIR } + to))
-  end
-
-  def relative_to2(anchor=nil)
-    anchor ||= Path.pwd
-
-    # operations to transform anchor into self
-
+  def relative_to(anchor)
     # stage 1: go ".." until we find a common dir prefix
     #          (discard everything and go '/' if there's no common dir)
     # stage 2: append the rest of the other path
 
-    # find common prefix
-    smaller, bigger = [ anchor.dirs, self.dirs ].sort_by(&:size)
-    common_prefix_end = bigger.zip(smaller).index { |a,b | a != b }
-    common_prefix = bigger[0...common_prefix_end]
+    first_mismatch = dirs.zip(anchor.dirs).index { |a,b| a != b }
 
-    if common_prefix.any?
-      dots = nil
-    end
+    num_dots = anchor.dirs.size - first_mismatch
 
-    self.dirs & anchor.dirs
+    result = self.dup
+    result.dirs = ([".."] * num_dots) + dirs[first_mismatch..-1]
 
+    result
   end
 
   # The current directory (with a trailing /)
   def dir
     if dirs
-      File::SEPARATOR + File.join(*dirs)
+      if relative?
+        File.join(*dirs)
+      else
+        File::SEPARATOR + File.join(*dirs)
+      end
     else
       nil
     end
@@ -356,8 +362,7 @@ class Path
   end
 
   def parent_of?(child)
-    # If `self` is a parent of `child`, it's a prefix.
-    child.path[/^#{Regexp.escape self.path}\/.+/] != nil
+    dirs == child.dirs[0...dirs.size]
   end
 
   ## comparisons
@@ -384,6 +389,7 @@ class Path
 
   #
   # Path["/etc"].join("anything{}").path == "/etc/anything{}"
+  # (globs ignored)
   #
   def join(other)
     Path.new File.join(self, other)
@@ -391,6 +397,7 @@ class Path
 
   #
   # Path["/etc"]/"passwd" == Path["/etc/passwd"]
+  # (globs permitted)
   #
   def /(other)
     # / <- fixes jedit syntax highlighting bug.
@@ -578,41 +585,28 @@ class Path
   #   Path["Songy Song.aac"].rename(:dir=>"/music2")
   #   Path["/music2/Songy Song.aac"].exists? #=> true
   #
-  def rename!(options)
-raise "Broken!"
-
-    dest = rename(options)
-    self.path = dest.path # become dest
-    self
-  end
-
   def rename(options)
-raise "Broken!"
-
     raise "Options must be a Hash" unless options.is_a? Hash
     dest = self.with(options)
 
     raise "Error: destination (#{dest.inspect}) already exists" if dest.exists?
     File.rename(path, dest)
 
-    dest
+    update(dest)
+
+    self
   end
 
   #
   # Renames the file the specified full path (like Dir.rename.)
   #
   def rename_to(path)
-raise "Broken!"
-
     rename :path=>path.to_s
   end
-  alias_method :mv,       :rename_to
 
   def rename_to!(path)
-raise "Broken!"
     rename! :path=>path.to_s
   end
-  alias_method :mv!,       :rename_to!
 
   #
   # Generate two almost identical methods: mkdir and mkdir_p
@@ -646,17 +640,9 @@ raise "Broken!"
     FileUtils.mv(path, dest)
   end
 
-  def join(other)
-    if uri?
-      Path[URI.join(path, other).to_s]
-    else
-      Path[File.join(path, other)]
-    end
-  end
-
   def ln_s(dest)
     dest = Path[dest]
-    FileUtils.ln_s self, dest
+    FileUtils.ln_s(self, dest)
   end
 
   ## Owners and permissions
@@ -1017,6 +1003,10 @@ raise "Broken!"
 end
 
 
+class Path::Relative < Path
+  # FIXME: Implement this.
+end
+
 #
 # A wrapper for URL objects.
 #
@@ -1042,32 +1032,24 @@ class Path::URL < Path
   #
   # When this is: http://host.com:port/path/filename.ext?param1=value1&param2=value2&...
   #
-  def to_s
-    uri.to_s
-  end
+  def to_s; uri.to_s; end
 
 
   #
   # ...this is: 'http'
   #
-  def scheme
-    uri.scheme
-  end
+  def scheme; uri.scheme; end
   alias_method :protocol, :scheme
 
   #
   # ...and this is: 'host.com'
   #
-  def host
-    uri.host
-  end
+  def host; uri.host; end
 
   #
   # ...and this is: 80
   #
-  def port
-    uri.port
-  end
+  def port; uri.port; end
 
   #
   # ...and this is: {param1: value1, param2: value2, ...etc... }
@@ -1080,6 +1062,11 @@ class Path::URL < Path
     end
   end
 
+  def join(other)
+    Path.new URI.join(path, other).to_s
+  end
+
+
   # ...and `path` is /path/filename.ext
 
   def open(mode="r", &block)

data/spec/path_spec.rb

@@ -1,4 +1,5 @@
 require 'epitools'
+require 'epitools/permutations'
 
 describe Path do
 
@@ -31,7 +32,11 @@ describe Path do
   end
 
   it "'relative_to's" do
-    Path["/etc"].relative_to(Path["/tmp"]).should == "../tmp"
+    Path["/etc"].relative_to(Path["/tmp"]).should == "../etc/"
+  end
+
+  it "should glob with relative paths" do
+    raise "not implemented"
   end
 
   it "handles directories" do
@@ -204,14 +209,19 @@ describe Path do
   end
 
   it "renames" do
-    path = Path.tmpfile
+    path = Path.tmp
 
-    str = path.to_s
+    path.rm
+    path.touch
+
+    path.exists?.should == true
+
+    old_name = path.to_s
 
     path.rename(:ext=>".dat")
 
-    path.to_s.should_not == str
-    path.to_s.should == str+".dat"
+    path.to_s.should == old_name+".dat"
+    path.to_s.should_not == old_name
   end
 
   it "rms" do
@@ -236,7 +246,7 @@ describe Path do
   end
 
   it "checksums" do
-    a, b = Path["*.rb"].take(2)
+    a, b = Path["**/*.rb"].take(2)
     [:sha1, :sha2, :md5].each do |meth|
       sum1 = a.send(meth)
       sum2 = b.send(meth)
@@ -333,7 +343,8 @@ describe Path do
     tmp.touch
     tmp2.touch
 
-    newmode = tmp.mode
+    tmp.mode.should == tmp2.mode
+
     tmp.chmod("+x")
     system("chmod", "+x", tmp2)
     tmp.mode.should == tmp2.mode
@@ -350,14 +361,13 @@ describe Path do
     tmp = Path.tmpfile
     tmp.rm if tmp.exists?
     tmp.mkdir
-    p tmp
-    p tmp.dirs
+
     #tmp.to_s.endswith('/').should == true
     file = tmp/"file"
     file.touch
-    p file
+
     file.dirs.should == tmp.dirs
-    file.filename.should != tmp.filename
+    file.filename.should_not == tmp.filename
   end
 
   it 'parents and childs properly' do
@@ -372,12 +382,12 @@ describe Path do
       root   => parent,
       root   => child,
       root   => neither,
-    }.each do |p, c|
-      p.parent_of?(c).should == true
-      c.parent_of?(p).should == false
+    }.each do |parent, child|
+      parent.should be_parent_of child
+      child.should_not be_parent_of parent
 
-      c.child_of?(p).should == true
-      p.child_of?(c).should == false
+      child.should be_child_of parent
+      parent.should_not be_child_of child
     end
 
     neither.parent_of?(child).should == false
@@ -388,7 +398,7 @@ describe Path do
     path = Path.tmpfile
     path.exe?.should == false
     path.chmod(0o666)
-    p path.mode
+
     (path.mode & 0o666).should > 0
   end
 
@@ -407,8 +417,9 @@ describe Path do
   end
 
   it 'swaps two files' do
-    raise "errorn!"
     # swap two regular files
+
+
     # swap a symlink and a regular file
     # swap two symlinks
   end
@@ -426,7 +437,7 @@ describe Path do
 
   it "shouldn't glob with Path#join" do
     path = Path["/etc"].join("blah{}")
-    path.should == "/etc/blah{}"
+    path.path.should == "/etc/blah{}"
   end
 
   it "should glob with Path#/" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.5.15
   prerelease: 
 platform: ruby
 authors: