facets 2.9.3 → 3.0.0

data/lib/standard/facets/ostruct/to_ostruct.rb

@@ -0,0 +1,65 @@
+require 'ostruct'
+
+class OpenStruct
+  #
+  def to_ostruct
+    self
+  end
+end
+
+class Hash
+  # Turns a hash into a generic object using an OpenStruct.
+  #
+  #     o = {'a' => 1}.to_ostruct
+  #     o.a  #=> 1
+  #
+  def to_ostruct
+    OpenStruct.new(self)
+  end
+
+  ## Recursively converts a Hash object to an OpenStruct object.
+  ##
+  ## Returns a copy of the hash as an OpenStruct.
+  #def to_ostruct()
+  #  struct = OpenStruct.new(self.clone())
+  #  each do |k, v|
+  #    struct.__send__("#{k}=", v.to_ostruct()) if v.is_a?(Hash)
+  #    struct.__send__(k).map! {|x| x.is_a?(Hash) ? x.to_ostruct() : x} if v.is_a?(Array)
+  #  end
+  #  return struct
+  #end
+
+  # Like `#to_ostruct` but recusively objectifies all hash elements as well.
+  #
+  #     o = {'a' => { 'b' => 1 }}.to_ostruct_recurse
+  #     o.a.b  #=> 1
+  #
+  # The `exclude` parameter is used internally to prevent infinite
+  # recursion and is not intended to be utilized by the end-user.
+  # But for more advance use, if there is a particular subhash you
+  # would like to prevent from being converted to an OpoenStruct
+  # then include it in the `exclude` hash referencing itself. e.g.
+  #
+  #     h = { 'a' => { 'b' => 1 } }
+  #     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+  #     o.a['b']  #=> 1
+  #
+  # CREDIT: Alison Rowland, Jamie Macey, Mat Schaffer
+  def to_ostruct_recurse(exclude={})
+    return exclude[self] if exclude.key?( self )
+    o = exclude[self] = OpenStruct.new
+    h = self.dup
+    each_pair do |k,v|
+      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
+    end
+    o.merge!(h)
+  end
+end
+
+class NilClass
+  # Create an empty OpenStruct object.
+  def to_ostruct
+    OpenStruct.new
+  end
+end
+

data/lib/standard/facets/pathname.rb

@@ -1,189 +1,26 @@
-# = Pathname
-#
-# Ruby's standard Pathname class with extensions.
-#
-# == Authors:
-#
-# * Daniel Burger
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2006 Thomas Sawyer, Daniel Burger
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
 require 'pathname'
-require 'facets/file/rootname'
-require 'facets/fileutils/outofdate'
-
-class Pathname
-
-  # Alias #to_s to #to_str when #to_str is not defined.
-  #
-  alias_method(:to_str, :to_s) unless method_defined?(:to_str)
-
-  # Alternate to Pathname#new.
-  #
-  #   Pathname['/usr/share']
-  #
-  def self.[](path)
-    new(path)
-  end
-
-  # Start a path. Another alias for #new.
-  #
-  #   Pathname / 'usr'
-  #
-  def self./(path)
-    new(path)
-  end
-
-  # Root constant for building paths from root directory onward.
-  def self.root
-    Pathname.new('/')
-  end
-
-  # Home constant for building paths from root directory onward.
-  #
-  # TODO: Pathname#home needs to be more robust.
-  #
-  def self.home
-    Pathname.new('~')
-  end
-
-  # Work constant for building paths from root directory onward.
-  #
-  def self.work
-    Pathname.new('.')
-  end
-
-  # Platform dependent null device.
-  #
-  # CREDIT Daniel Burger
-  def self.null
-    case RUBY_PLATFORM
-    when /mswin/i
-      'NUL'
-    when /amiga/i
-      'NIL:'
-    when /openvms/i
-      'NL:'
-    else
-      '/dev/null'
-    end
-  end
-
-  # Try to get this into standard Pathname class.
-  alias_method :/, :+
-
-  #
-  def rootname
-    self.class.new(File.rootname(to_s))
-  end
 
-  #
-  def split_root
-    head, tail = *::File.split_root(to_s)
-    [self.class.new(head), self.class.new(tail)]
-  end
+require 'facets/pathname/home'
+require 'facets/pathname/null'
+require 'facets/pathname/op_div'
+require 'facets/pathname/op_fetch'
+require 'facets/pathname/root'
+require 'facets/pathname/work'
 
-  # Glob pathnames.
-  def glob(match, *opts)
-    flags = glob_flags(opts)
-    Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
-  end
+require 'facets/pathname/empty'
+require 'facets/pathname/exists'
+require 'facets/pathname/glob'
+require 'facets/pathname/outofdate'
+require 'facets/pathname/readline'
+require 'facets/pathname/rootname'
+require 'facets/pathname/safe'
+require 'facets/pathname/split_root'
+require 'facets/pathname/to_str'
+require 'facets/pathname/uptodate'
+require 'facets/pathname/visit'
 
-  # Return the first glob match.
-  #
-  # DEPRECATE: While slightly faster then glob().first, not really worth it
-  # unless this can be rewritten to shortcut on first match (using fnmatch?).
-  # In wich case, is there a better name for this method?
-  def glob_first(match, *opts)
-    flags = glob_flags(opts)
-    file = ::Dir.glob(::File.join(self.to_s, match), flags).first
-    file ? self.class.new(file) : nil
-  end
+require 'facets/pathname/to_path'
 
-  # Return globbed matches with pathnames relative to the current pathname.
-  def glob_relative(match, *opts)
-    flags = glob_flags(opts)
-    files = Dir.glob(::File.join(self.to_s, match), flags)
-    files = files.map{ |f| f.sub(self.to_s.chomp('/') + '/', '') }
-    files.collect{ |m| self.class.new(m) }
-  end
-
-  private
-
-  def glob_flags(opts)
-    flags = 0
-    opts.each do |opt|
-      case opt when Symbol, String
-        flags += ::File.const_get("FNM_#{opt}".upcase)
-      else
-        flags += opt
-      end
-    end
-    flags
-  end
-
-  public
-
-  #
-  def empty?
-    Dir.glob(::File.join(to_s, '*')).empty?
-  end
-
-  #
-  def uptodate?(*sources)
-    ::FileUtils.uptodate?(to_s, sources.flatten)
-  end
-
-  #
-  def outofdate?(*sources)
-    ::FileUtils.outofdate?(to_s, sources.flatten)
-  end
-
-  # Recursively visit a directory located by its path, yielding each resource
-  # as its full matching pathname object. If called on a file, yield the file.
-  #
-  # call-seq:
-  #   visit => yield each file
-  #   visit(all: true) => yield visited directories as well
-  #   visit(hidden: true) => yield hidden files and directories as well
-  #
-  # Example use case:
-  #
-  #   # Locate any file but *.haml within app/**/*
-  #   Pathname.new("app").visit do |f|
-  #     next unless f.to_s =~ /\.haml$/
-  #     f
-  #   end 
-  #
-  # TODO: Use #map instead of #each ?
-  # 
-  # CREDIT: Jean-Denis Vauguet
-  def visit(options = {:all => false, :hidden => false})
-    if self.directory?
-      children.each do |entry|
-        next if entry.basename.to_s[0] == "." && !options[:hidden]
-        yield(entry) unless entry.directory? && !options[:all]
-        ##entry.visit(:all => options[:all]) { |sub_entry| yield sub_entry } if entry.directory?
-        entry.visit(:all => options[:all], :hidden => options[:hidden]) do |sub_entry|
-          yield(sub_entry)
-        end if entry.directory?
-      end
-    else
-      yield self
-    end
-  end
 
 ##   # Already included in 1.8.4+ version of Ruby (except for inclusion flag)
 ##   if not instance_methods.include?(:ascend)
@@ -217,37 +54,3 @@ class Pathname
 ##
 ##   end
 
-  # Does a directory contain a matching entry?
-  # Or if the pathname is a file, same as #fnmatch.
-  def include?(pattern,*opts)
-    if directory?
-      glob_first(pattern,*opts)
-    else
-      fnmatch(pattern,*opts)
-    end
-  end
-
-end
-
-class NilClass
-  # Provide platform dependent null path.
-  #
-  # @standard
-  #   require 'facets/pathname'
-  #
-  # @author Daniel Burger
-  def to_path
-    Pathname.null
-  end
-end
-
-class Array
-  # Convert array to Pathname instance.
-  #
-  # @standard
-  #   require 'facets/pathname'
-  #
-  def to_path
-    Pathname.new(join('/'))
-  end
-end

data/lib/standard/facets/pathname/chdir.rb

@@ -0,0 +1,15 @@
+class Pathname
+
+  # Change current working directory of the process
+  # to the given path
+  #
+  # See Dir.chdir
+  #
+  # CREDIT: Ryan Duryea
+
+  def chdir(&block)
+    Dir.chdir(self, &block)
+  end
+
+end
+

data/lib/standard/facets/pathname/empty.rb

@@ -0,0 +1,10 @@
+class Pathname
+
+  # Is a directory path empty?
+  #
+  # Returns [Boolean]
+  def empty?
+    Dir.glob(::File.join(to_s, '*')).empty?
+  end
+
+end

data/lib/standard/facets/pathname/exists.rb

@@ -0,0 +1,6 @@
+class Pathname
+
+  # Pluralized alias for `#exist?` method.
+  alias :exists? :exist?
+
+end

data/lib/standard/facets/pathname/glob.rb

@@ -0,0 +1,57 @@
+class Pathname
+
+  # Glob pathnames.
+  def glob(match, *opts)
+    flags = glob_flags(opts)
+    Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
+  end
+
+  # Return the first glob match.
+  #
+  # DEPRECATE: While slightly faster then glob().first, not really worth it
+  # unless this can be rewritten to shortcut on first match (using fnmatch?).
+  # In wich case, is there a better name for this method?
+  def glob_first(match, *opts)
+    flags = glob_flags(opts)
+    file = ::Dir.glob(::File.join(self.to_s, match), flags).first
+    file ? self.class.new(file) : nil
+  end
+
+  # Return globbed matches with pathnames relative to the current pathname.
+  def glob_relative(match, *opts)
+    flags = glob_flags(opts)
+    files = Dir.glob(::File.join(self.to_s, match), flags)
+    files = files.map{ |f| f.sub(self.to_s.chomp('/') + '/', '') }
+    files.collect{ |m| self.class.new(m) }
+  end
+
+  # Does a directory contain a matching entry?
+  # Or if the pathname is a file, same as #fnmatch.
+  #
+  # TODO: Move to own file? Better name?
+  #
+  # Returns [Pathname]
+
+  def include?(pattern,*opts)
+    if directory?
+      glob_first(pattern,*opts)
+    else
+      fnmatch(pattern,*opts)
+    end
+  end
+
+private
+
+  def glob_flags(opts)
+    flags = 0
+    opts.each do |opt|
+      case opt when Symbol, String
+        flags += ::File.const_get("FNM_#{opt}".upcase)
+      else
+        flags += opt
+      end
+    end
+    flags
+  end
+
+end

data/lib/standard/facets/pathname/home.rb

@@ -0,0 +1,12 @@
+class Pathname
+
+  # Home constant for building paths from root directory onward.
+  #
+  # TODO: Pathname#home needs to be more robust.
+  #
+  # Returns [Pathname]
+  def self.home
+    Pathname.new('~')
+  end
+
+end

data/lib/standard/facets/pathname/null.rb

@@ -0,0 +1,20 @@
+class Pathname
+
+  # Platform dependent null device.
+  #
+  # CREDIT: Daniel Burger
+
+  def self.null
+    case RUBY_PLATFORM
+    when /mswin/i
+      'NUL'
+    when /amiga/i
+      'NIL:'
+    when /openvms/i
+      'NL:'
+    else
+      '/dev/null'
+    end
+  end
+
+end

data/lib/standard/facets/pathname/op_div.rb

@@ -0,0 +1,15 @@
+class Pathname
+
+  # Start a path. Another alias for #new.
+  #
+  #   Pathname / 'usr'
+  #
+  def self./(path)
+    new(path)
+  end
+
+  # Try to get this into standard Pathname class.
+  alias_method :/, :+
+
+end
+