gorillib 0.1.11 → 0.4.0pre

data/lib/gorillib/pathname.rb

@@ -0,0 +1,78 @@
+require 'pathname'
+require 'gorillib/exception/raisers'
+
+module Gorillib
+  module Pathref
+    ROOT_PATHS = Hash.new unless defined?(ROOT_PATHS)
+
+    extend self
+
+    def register_path(handle, *pathsegs)
+      ArgumentError.arity_at_least!(pathsegs, 1)
+      ROOT_PATHS[handle] = pathsegs
+    end
+
+    def register_paths(pairs = {})
+      pairs.each_pair{ |handle, pathsegs| register_path(handle, *pathsegs) }
+    end
+
+    def unregister_path handle
+      ROOT_PATHS.delete handle
+    end
+
+    # Expand a path with late-evaluated segments.
+    # Calls expand_path -- '~' becomes $HOME, '..' is expanded, etc.
+    #
+    # @example A symbol represents a segment to expand
+    #     Pathname.register_path(:conf_dir, '/etc/delorean')
+    #     Pathname.path_to(:conf_dir)                  # '/etc/delorean'
+    #     Pathname.path_to(:conf_dir, modacity.conf)   # '/etc/delorean/modacity.conf'
+    #
+    # @example References aren't expanded until they're read
+    #     Pathname.register_path(:conf_dir, '/etc/delorean')
+    #     Pathname.register_path(:modacity, :conf_dir, 'modacity.conf')
+    #     Pathname.path_to(:modacity)                  # '/etc/delorean/modacity.conf'
+    #     # if we change the conf_dir, everything under it changes as well
+    #     Pathname.register_path(:conf_dir, '~/.delorean.d')
+    #     Pathname.path_to(:modacity)                  # '/home/flip/delorean.d/modacity.conf'
+    #
+    # @example References can be relative, and can hold symbols themselves
+    #     Pathname.register_path(:conf_dir, '/etc', :appname, :environment)
+    #     Pathname.register_path(:appname, 'happy_app')
+    #     Pathname.register_path(:environment, 'dev')
+    #     Pathname.path_to(:conf_dir)                  # '/etc/happy_app/dev'
+    #
+    # @param  [Array<[String,Symbol]>] pathsegs
+    #   any mixture of strings (literal sub-paths) and symbols (interpreted as references)
+    # @return [Pathname] A single expanded Pathname
+    #
+    def path_to(*pathsegs)
+      relative_path_to(*pathsegs).expand_path
+    end
+
+    # Expand a path with late-evaluated segments
+    # @see `.path_to`
+    #
+    # Calls cleanpath (removing `//` double slashes and useless `..`s), but does
+    # not reference the filesystem or make paths absolute
+    #
+    def relative_path_to(*pathsegs)
+      ArgumentError.arity_at_least!(pathsegs, 1)
+      pathsegs = pathsegs.map{|ps| expand_pathseg(ps) }.flatten
+      new(File.join(*pathsegs)).cleanpath(true)
+    end
+
+  protected
+    # Recursively expand a path handle
+    # @return [Array<String>] an array of path segments, suitable for .join
+    def expand_pathseg(handle)
+      return handle unless handle.is_a?(Symbol)
+      pathsegs = ROOT_PATHS[handle] or raise ArgumentError, "Don't know how to expand path reference '#{handle.inspect}'."
+      pathsegs.map{|ps| expand_pathseg(ps) }.flatten
+    end
+  end
+end
+
+class Pathname
+  extend Gorillib::Pathref
+end

data/lib/gorillib/some.rb

@@ -1,12 +1,14 @@
-require 'gorillib/base'
 require 'set'
 require 'time'
 require 'date'
-require 'gorillib/array/compact_blank'
-require 'gorillib/hash/compact'
-require 'gorillib/enumerable/sum'
-require 'gorillib/datetime/flat'
-require 'gorillib/datetime/parse'
-require 'gorillib/hash/zip'
-require 'gorillib/hash/slice'
-require 'gorillib/hash/keys'
+require 'pathname'
+
+require 'gorillib/base'
+
+require 'gorillib/pathname'
+require 'gorillib/string/simple_inflector'
+require 'gorillib/string/inflections'
+require 'gorillib/string/constantize'
+require 'gorillib/hash/mash'
+require 'gorillib/metaprogramming/delegation'
+require 'gorillib/metaprogramming/concern'

data/lib/gorillib/string/constantize.rb

@@ -1,21 +1,28 @@
+require 'gorillib/string/inflector'
 class String
 
-  # Constantize tries to find a declared constant with the name specified
+  # +constantize+ tries to find a declared constant with the name specified
   # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  # @example
-  #   "Module".constantize #=> Module
-  #   "Class".constantize #=> Class
-  #
-  # This is the extlib version of String#constantize, which has different
-  # behavior wrt using lexical context: see active_support/inflector/methods.rb
+  # or is not initialized.  See Gorillib::Inflector.constantize
   #
+  # Examples
+  #   "Module".constantize  # => Module
+  #   "Class".constantize   # => Class
+  #   "blargle".constantize # => NameError: wrong constant name blargle
   def constantize
-    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
-      raise NameError, "#{self.inspect} is not a valid constant name!"
-    end
-
-    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    Gorillib::Inflector.constantize(self)
   end unless method_defined?(:constantize)
+
+  # +safe_constantize+ tries to find a declared constant with the name specified
+  # in the string. It returns nil when the name is not in CamelCase
+  # or is not initialized.  See Gorillib::Model::Inflector.safe_constantize
+  #
+  # Examples
+  #   "Module".safe_constantize  # => Module
+  #   "Class".safe_constantize   # => Class
+  #   "blargle".safe_constantize # => nil
+  def safe_constantize
+    Gorillib::Inflector.safe_constantize(self)
+  end unless method_defined?(:safe_constantize)
+
 end

data/lib/gorillib/string/inflections.rb

@@ -1,78 +1,8 @@
-# String inflections define new methods on the String class to transform names for different purposes.
-#
-#   "ScaleScore".underscore # => "scale_score"
-#
-# This doesn't define the full set of inflections -- only
-#
-# * camelize
-# * snakeize
-# * underscore
-# * demodulize
-#
-class String
-
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  # @example:
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-  #
-  # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
-  # though there are cases where that does not hold:
-  #
-  #   "SSLError".underscore.camelize # => "SslError"
-  #
-  def camelize(first_letter = :upper)
-    camelized = self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    (first_letter == :lower) ? (self[0..0].downcase + camelized[1..-1]) : camelized
-  end unless method_defined?(:camelize)
-
-  # Converts strings to snakeCase, also known as lowerCamelCase.
-  #
-  # +snakeize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  # @example:
-  #   "active_record".snakeize                # => "activeRecord"
-  #   "active_record/errors".snakeize         # => "activeRecord::Errors"
-  #
-  def snakeize
-    camelize :lower
-  end unless method_defined?(:snakeize)
-
-  # Makes an underscored, lowercase form from the expression in the string.
-  #
-  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-  #
-  # Examples:
-  #   "ActiveRecord".underscore         # => "active_record"
-  #   "ActiveRecord::Errors".underscore # => active_record/errors
-  #
-  # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
-  # though there are cases where that does not hold:
-  #
-  #   "SSLError".underscore.camelize # => "SslError"
-  def underscore
-    word = self.dup
-    word.gsub!(/::/, '/')
-    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-    word.tr!("-", "_")
-    word.downcase!
-    word
-  end unless method_defined?(:underscore)
-
-  # Removes the module part from the expression in the string
-  #
-  # @example
-  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-  #   "Inflections".demodulize #=> "Inflections"
-  def demodulize
-    self.gsub(/^.*::/, '')
-  end unless method_defined?(:demodulize)
+require 'gorillib/string/inflector'
 
+class String
+  def camelize(*args)   Gorillib::Inflector.camelize(self, *args) ; end
+  def snakeize(*args)   Gorillib::Inflector.snakeize(self, *args) ; end
+  def underscore(*args) Gorillib::Inflector.underscore(self, *args) ; end
+  def demodulize(*args) Gorillib::Inflector.demodulize(self, *args) ; end
 end

data/lib/gorillib/string/inflector.rb

@@ -0,0 +1,192 @@
+module Gorillib ; end
+
+# String inflections define new methods on the String class to transform names for different purposes.
+#
+#   "ScaleScore".underscore # => "scale_score"
+#
+# This doesn't define the full set of inflections -- only
+#
+# * camelize
+# * snakeize
+# * underscore
+# * demodulize
+#
+module Gorillib::Inflector
+  extend self
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # @example:
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  #
+  # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
+  # though there are cases where that does not hold:
+  #
+  #   "SSLError".underscore.camelize # => "SslError"
+  #
+  def camelize(str, first_letter = :upper)
+    camelized = str.gsub(/\/(.?)/){ "::#{ $1.upcase }" }.gsub(/(?:^|_)(.)/){ $1.upcase }
+    (first_letter == :lower) ? (str[0..0].downcase + camelized[1..-1]) : camelized
+  end
+
+  # Converts strings to snakeCase, also known as lowerCamelCase.
+  #
+  # +snakeize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # @example:
+  #   "active_record".snakeize                # => "activeRecord"
+  #   "active_record/errors".snakeize         # => "activeRecord::Errors"
+  #
+  def snakeize(str)
+    camelize(str, :lower)
+  end
+
+  # Makes an underscored, lowercase form from the expression in the string.
+  #
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  # Examples:
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  #
+  # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
+  # though there are cases where that does not hold:
+  #
+  #   "SSLError".underscore.camelize # => "SslError"
+  def underscore(str)
+    word = str.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example:
+  #   "puni_puni" # => "puni-puni"
+  def dasherize(underscored_word)
+    underscored_word.gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string:
+  #
+  # @example
+  #   "Gorillib::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize                   #=> "Inflections"
+  #
+  # See also +deconstantize+.
+  def demodulize(str)
+    str.gsub(/^.*::/, '')
+  end
+
+  # Removes the rightmost segment from the constant expression in the string:
+  #
+  #   "Net::HTTP".deconstantize   # => "Net"
+  #   "::Net::HTTP".deconstantize # => "::Net"
+  #   "String".deconstantize      # => ""
+  #   "::String".deconstantize    # => ""
+  #   "".deconstantize            # => ""
+  #
+  # See also +demodulize+.
+  def deconstantize(path)
+    path.to_s[0...(path.rindex('::') || 0)] # implementation based on the one in facets' Module#spacename
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # @example
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  #
+  # This is the extlib version of String#constantize, which has different
+  # behavior wrt using lexical context: see active_support/inflector/methods.rb
+  #
+  def constantize(str)
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ str
+      raise NameError, "#{self.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+
+  # Tries to find a constant with the name specified in the argument string:
+  #
+  #   "Module".safe_constantize     # => Module
+  #   "Test::Unit".safe_constantize # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter whether
+  # it starts with "::" or not. No lexical context is taken into account:
+  #
+  #   C = 'outside'
+  #   module M
+  #     C = 'inside'
+  #     C                    # => 'inside'
+  #     "C".safe_constantize # => 'outside', same as ::C
+  #   end
+  #
+  # nil is returned when the name is not in CamelCase or the constant (or part of it) is
+  # unknown.
+  #
+  #   "blargle".safe_constantize  # => nil
+  #   "UnknownModule".safe_constantize  # => nil
+  #   "UnknownModule::Foo::Bar".safe_constantize  # => nil
+  #
+  def safe_constantize(camel_cased_word)
+    begin
+      constantize(camel_cased_word)
+    rescue NameError => e
+      raise unless e.message =~ /uninitialized constant #{const_regexp(camel_cased_word)}$/ ||
+        e.name.to_s == camel_cased_word.to_s
+    rescue ArgumentError => e
+      raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+    end
+  end
+
+  # Turns a number into an ordinal string used to denote the position in an
+  # ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  # Examples:
+  #   ordinalize(1)     # => "1st"
+  #   ordinalize(2)     # => "2nd"
+  #   ordinalize(1002)  # => "1002nd"
+  #   ordinalize(1003)  # => "1003rd"
+  #   ordinalize(-11)   # => "-11th"
+  #   ordinalize(-1021) # => "-1021st"
+  def ordinalize(number)
+    if (11..13).include?(number.to_i.abs % 100)
+      "#{number}th"
+    else
+      case number.to_i.abs % 10
+      when 1; "#{number}st"
+      when 2; "#{number}nd"
+      when 3; "#{number}rd"
+      else    "#{number}th"
+      end
+    end
+  end
+
+private
+
+  # Mount a regular expression that will match part by part of the constant.
+  # For instance, Foo::Bar::Baz will generate Foo(::Bar(::Baz)?)?
+  def const_regexp(camel_cased_word) #:nodoc:
+    parts = camel_cased_word.split("::")
+    last  = parts.pop
+
+    parts.reverse.inject(last) do |acc, part|
+      part.empty? ? acc : "#{part}(::#{acc})?"
+    end
+  end
+
+end