mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/lore/facets/pathname.rb

@@ -0,0 +1,172 @@
+# = 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'
+
+class Pathname
+
+  # Alternate to Pathname#new.
+  #
+  #   Pathname['/usr/share']
+  #
+  def self.[](path)
+    new(path)
+  end
+
+  # Active path separator.
+  #
+  #   p1 = Pathname.new('/')
+  #   p2 = p1 / 'usr' / 'share'   #=> Pathname:/usr/share
+  #
+  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
+
+  # Try to get this into standard Pathname class.
+  alias_method :/, :+
+
+  # CREDIT Daniel Burger
+
+  # Platform dependent null device.
+  #
+  def self.null
+    case RUBY_PLATFORM
+    when /mswin/i
+      'NUL'
+    when /amiga/i
+      'NIL:'
+    when /openvms/i
+      'NL:'
+    else
+      '/dev/null'
+    end
+  end
+
+  #
+  def rootname
+    self.class.new(File.rootname(to_s))
+  end
+
+#   # Already included in 1.8.4+ version of Ruby (except for inclusion flag)
+#   if not instance_methods.include?(:ascend)
+#
+#     # Calls the _block_ for every successive parent directory of the
+#     # directory path until the root (absolute path) or +.+ (relative path)
+#     # is reached.
+#     def ascend(inclusive=false,&block) # :yield:
+#       cur_dir = self
+#       yield( cur_dir.cleanpath ) if inclusive
+#       until cur_dir.root? or cur_dir == Pathname.new(".")
+#         cur_dir = cur_dir.parent
+#         yield cur_dir
+#       end
+#     end
+#
+#   end
+#
+#   # Already included in 1.8.4+ version of Ruby
+#   if ! instance_methods.include?(:descend)
+#
+#     # Calls the _block_ for every successive subdirectory of the
+#     # directory path from the root (absolute path) until +.+
+#     # (relative path) is reached.
+#     def descend()
+#       @path.scan(%r{[^/]*/?})[0...-1].inject('') do |path, dir|
+#         yield Pathname.new(path << dir)
+#       path
+#       end
+#     end
+#
+#   end
+
+  #
+  def split_root
+    head, tail = *::File.split_root(to_s)
+    [self.class.new(head), self.class.new(tail)]
+  end
+
+  #
+  def glob(match, *opts)
+    flags = 0
+    opts.each do |opt|
+      case opt when Symbol, String
+        flags += File.const_get("FNM_#{opt}".upcase)
+      else
+        flags += opt
+      end
+    end
+    Dir.glob(::File.join(self.to_s, match), flags).collect{ |m| self.class.new(m) }
+  end
+
+  #
+  def glob_first(match, *opts)
+    flags = 0
+    opts.each do |opt|
+      case opt when Symbol, String
+        flags += ::File.const_get("FNM_#{opt}".upcase)
+      else
+        flags += opt
+      end
+    end
+    file = ::Dir.glob(::File.join(self.to_s, match), flags).first
+    file ? self.class.new(file) : nil
+  end
+
+  #
+  def empty?
+    Dir.glob(::File.join(self.to_s, '*')).empty?
+  end
+
+end
+
+# Constant alias of Pathname (short is better!)
+Path = Pathname
+
+class NilClass
+  # Provide platform dependent null path.
+  #
+  # CREDIT Daniel Burger
+  def to_path
+    Pathname.null
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/lore/facets/rbconfig.rb

@@ -0,0 +1,45 @@
+# = Ruby Configuration Extensions
+#
+# An extended rendition of the Ruby's standard Config module.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2006 Thomas Sawyer
+#
+# 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 'rbconfig'
+
+module Config
+
+  def self.inspect
+    CONFIG.inspect
+  end
+
+  # In case rubygems has already defined it.
+  unless self.respond_to?(:datadir)
+    # Return the path to the data directory associated with the
+    # given library/package name. Normally this is just
+    #
+    #   "#{Config::CONFIG['datadir']}/#{name}"
+    #
+    # but may be modified by tools like RubyGems to handle
+    # versioned data directories.
+
+    def self.datadir(package_name)
+      File.join(CONFIG['datadir'], package_name)
+    end
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/lore/facets/set.rb

@@ -0,0 +1,27 @@
+require 'set'
+
+class Set
+  def power_set
+    if empty?
+      Set[ self ]
+    else
+      any_value = [to_a.first]
+      subsubs = (self - any_value).power_set
+      subsubs + subsubs.map{ |subset| subset + any_value }
+    end
+  end
+end
+
+class Array
+  def power_set
+    if empty?
+      [self]
+    else
+      subset  = dup
+      value   = [ subset.pop ]
+      subsubs = subset.power_set
+      subsubs.concat( subsubs.map{ |subset| subset + value } )
+    end
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/lore/facets/shellwords.rb

@@ -0,0 +1,89 @@
+# = Shellwords Extended
+#
+# Adds extensions to Shellwords, namely #escape.
+#
+# == Authors
+#
+# * Thomas Sawuer
+#
+# == Copying
+#
+# Copyright (c) 2007 Thomas Sawyer
+#
+# 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 'shellwords'
+
+module Shellwords
+
+  module_function
+
+  # Escape special characters used in most
+  # unix shells to use it, eg. with system().
+
+  def escape(cmdline)
+    cmdline.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+  end
+
+end
+
+
+class Array
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_shellwords
+    flags = (Hash===last ? pop : {})
+    flags = flags.to_shellwords
+    flags + ' ' + self #join(" ")
+  end
+
+  def to_shell
+    to_shellwords.join(' ')
+  end
+
+  # Original name.
+  alias_method :to_console, :to_shell
+end
+
+
+class Hash
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+
+  def to_shellwords
+    flags = collect do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when Array
+        v.collect{ |e| "#{m}#{f}='#{e}'" }.join(' ')
+      when true
+        "#{m}#{f}"
+      when false, nil
+        ''
+      else
+        "#{m}#{f}='#{v}'"
+      end
+    end
+    flags #.join(" ")
+  end
+
+  def to_shell
+    to_shellwords.join(' ')
+  end
+
+  # Original name.
+  alias_method :to_console, :to_shell
+end
+

data/lib/gems/facets-2.4.5/lib/lore/facets/uri.rb

@@ -0,0 +1,249 @@
+# = URI Extensions
+#
+# Convenience extensions to URI module.
+#
+# == Authors
+#
+# * Thomas Sawyer (7rans)
+#
+# == Copyright
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# 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 'uri'
+#require 'cgi'
+
+require 'facets/blank'
+
+module URI
+
+  module_function
+
+  # Decode the uri components.
+
+  def decode(uri)
+    # gmosx: hmm is this needed?
+    # guard against invalid filenames for example pictures with
+    # spaces uploaded by users
+    escaped_uri = uri.gsub(/ /, "+")
+
+    if md = URI::REGEXP::REL_URI.match(escaped_uri)
+
+      path = "#{md[5]}#{md[6]}"
+      type = File.extname(path)
+      query_string = md[7]
+
+#      real_path = "#{$root_dir}/#{path}"
+
+      parameters = URI.query_to_hash(query_string)
+      path.gsub!(/\+/, " ")
+
+      return [path, type, parameters, query_string]
+
+    end # match
+
+    # this is usefull for uncovering bugs!
+    raise ArgumentError.new("the parameter '#{uri}' is not a valid uri")
+  end
+
+  # Extend the basic query string parser provided by the cgi module.
+  # converts single valued params (the most common case) to
+  # objects instead of arrays
+  #
+  # Input:
+  # the query string
+  #
+  # Output:
+  # hash of parameters, contains arrays for multivalued parameters
+  # (multiselect, checkboxes , etc)
+  # If no query string is provided (nil or "") returns an empty hash.
+
+  def query_to_hash(query_string)
+    return {} unless query_string
+
+    query_parameters = cgi_parse(query_string)
+
+    query_parameters.each { |key, val|
+      # replace the array with an object
+      query_parameters[key] = val[0] if 1 == val.length
+    }
+
+    # set default value to nil! cgi sets this to []
+    query_parameters.default = nil
+
+    return query_parameters
+  end
+
+  alias_method :query_string_to_hash, :query_to_hash
+
+  # Given a hash with parameter/value pairs construct a
+  # standard query string.
+  #
+  #   URI.hash_to_query(:a => 1, :b => 2)
+  #   => "a=1&b=2"
+
+  def hash_to_query(parameters)
+    return '' unless parameters
+    pairs = []
+    parameters.each do |param, value|
+      pairs << "#{param}=#{cgi_escape(value.to_s)}"
+    end
+    #return pairs.join('&')
+    return pairs.join(";")
+  end
+
+  alias_method :hash_to_query_string, :hash_to_query
+
+  #
+  # TODO: How does this compare to URI.escape?
+
+  def cgi_escape(string)
+    string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+    end.tr(' ', '+')
+  end
+
+  #
+
+  def cgi_unescape(string)
+    string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+  end
+
+  #
+
+  def cgi_parse(query)
+    params = Hash.new([].freeze)
+
+    query.split(/[&;]/n).each do |pairs|
+      key, value = pairs.split('=',2).collect{|v| cgi_unescape(v) }
+      if params.has_key?(key)
+        params[key].push(value)
+      else
+        params[key] = [value]
+      end
+    end
+
+    params
+  end
+
+  # This method returns the query string of a uri
+  #
+  # Input:
+  # the uri
+  #
+  # Output:
+  # the query string.
+  # returns nil if no query string
+
+  def get_query_string(uri)
+    return nil unless uri
+    # gmosx: INVESTIGATE ruby's URI seems to differently handle
+    # abs and rel uris.
+    if md = URI::REGEXP::ABS_URI.match(uri)
+      return md[8]
+    elsif md = URI::REGEXP::REL_URI.match(uri)
+      return md[7]
+    end
+    return nil
+  end
+
+  # Removes the query string from a uri
+  #
+  # Input:
+  # the uri
+  #
+  # Output:
+  # the chomped uri.
+
+  def chomp_query_string(uri)
+    return nil unless uri
+    query_string = self.get_query_string(uri)
+    return uri.dup.chomp("?#{query_string}")
+  end
+
+  # Get a uri and a hash of parameters. Inject the hash values
+  # as parameters in the query sting path. Returns the full
+  # uri.
+  #
+  # Input:
+  # the uri to filter (String)
+  # hash of parameters to update
+  #
+  # Output:
+  # the full updated query string
+  #
+  # TODO: optimize
+
+  def update_query_string(uri, parameters)
+    query_string = self.get_query_string(uri)
+    rest = uri.dup.gsub(/\?#{query_string}/, "")
+
+    hash = self.query_string_to_hash(query_string)
+    hash.update(parameters)
+    query_string = self.hash_to_query_string(hash)
+
+    unless query_string.blank?
+      return "#{rest}?#{query_string}"
+    else
+      return rest
+    end
+  end
+
+  # TODO: find a better name.
+  # Gets the request uri, injects extra parameters in the query string
+  # and returns a new uri. The request object is not modified.
+  # There is always a qs string so an extra test is skipped.
+
+  def update_request_uri(request, parameters)
+    hash = request.parameters.dup()
+    hash.update(parameters)
+
+    # use this in hash_to_querystring.
+    query_string = hash.collect { |k, v|
+      "#{k}=#{v}"
+    }.join(";")
+
+    #return "#{request.translated_uri}?#{query_string}"
+    return "#{request.path}?#{query_string}"
+  end
+
+  module Kernel
+    #
+    def uri(s, w=%r{[^a-zA-Z_0-9./-]})
+      URI.escape(s, w)
+    end
+
+    #
+    def unuri(s)
+      URI.unescape(s)
+    end
+  end
+
+  module Hash
+    #
+    def to_uri
+      URI.hash_to_query(self)
+    end
+  end
+
+end
+
+class Object #:nodoc:
+  include URI::Kernel
+end
+
+class Hash #:nodoc:
+  include URI::Hash
+end
+