mack-facets 0.8.1 → 0.8.2

data/lib/gems/extlib-0.9.8/lib/extlib/rubygems.rb

@@ -0,0 +1,38 @@
+# this is a temporary workaround until rubygems Does the Right thing here
+require 'rubygems'
+module Gem
+  class SourceIndex
+    
+    # This is resolved in 1.1
+    if Version.new(RubyGemsVersion) < Version.new("1.1")
+      
+      # Overwrite this so that a gem of the same name and version won't push one
+      # from the gems directory out entirely.
+      #
+      # @param gem_spec<Gem::Specification> The specification of the gem to add.
+      def add_spec(gem_spec)
+        unless gem_spec.instance_variable_get("@loaded_from") &&
+          @gems[gem_spec.full_name].is_a?(Gem::Specification) && 
+          @gems[gem_spec.full_name].installation_path == 
+            File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
+            
+          @gems[gem_spec.full_name] = gem_spec
+        end
+      end
+      
+    end
+    
+  end
+
+  class Specification
+
+    # Overwrite this so that gems in the gems directory get preferred over gems
+    # from any other location. If there are two gems of different versions in
+    # the gems directory, the later one will load as usual.
+    #
+    # @return <Array[Array]> The object used for sorting gem specs.
+    def sort_obj
+      [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/simple_set.rb

@@ -0,0 +1,39 @@
+module Extlib
+  # Simple set implementation
+  # on top of Hash with merging support.
+  #
+  # In particular this is used to store
+  # a set of callable actions of controller.
+  class SimpleSet < Hash
+
+    # @param arr<Array> Initial set values.
+    #
+    # @return <Array> The array the Set was initialized with
+    def initialize(arr = [])
+      arr.each {|x| self[x] = true}
+    end
+
+    # @param value<Object> Value to add to set.
+    #
+    # @return <TrueClass>
+    def <<(value)
+      self[value] = true
+    end
+
+    # @param arr<Array> Values to merge with set.
+    #
+    # @return <SimpleSet> The set after the Array was merged in.
+    def merge(arr)
+      super(arr.inject({}) {|s,x| s[x] = true; s })
+    end
+
+    # @return <String> A human readable version of the set.
+    def inspect
+      "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>"
+    end
+
+    # def to_a
+    alias_method :to_a, :keys
+
+  end # SimpleSet
+end # Merb

data/lib/gems/extlib-0.9.8/lib/extlib/string.rb

@@ -0,0 +1,132 @@
+require "pathname"
+
+class String
+  ##
+  # @return <String> The string with all regexp special characters escaped.
+  #
+  # @example
+  #   "*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
+  def escape_regexp
+    Regexp.escape self
+  end
+  
+  ##
+  # @return String The string with all regexp special characters unescaped.
+  #
+  # @example
+  #   "\\*\\?\\{\\}\\.".unescape_regexp #=> "*?{}."
+  def unescape_regexp
+    self.gsub(/\\([\.\?\|\(\)\[\]\{\}\^\$\*\+\-])/, '\1')
+  end
+  
+  ##
+  # @return <String> The string converted to snake case.
+  #
+  # @example
+  #   "FooBar".snake_case #=> "foo_bar"
+  # @example
+  #   "HeadlineCNNNews".snake_case #=> "headline_cnn_news"
+  # @example
+  #   "CNN".snake_case #=> "cnn"
+  def snake_case
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+      return $+.downcase
+  end
+
+  ##
+  # @return <String> The string converted to camel case.
+  #
+  # @example
+  #   "foo_bar".camel_case #=> "FooBar"
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  ##
+  # @return <String> The path string converted to a constant name.
+  #
+  # @example
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  ##
+  # @return <String>
+  #   The path that is associated with the constantized string, assuming a
+  #   conventional structure.
+  #
+  # @example
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+
+  ##
+  # @param o<String> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   "merb"/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self, o.to_s)
+  end
+
+  ##
+  # @param other<String> Base path to calculate against
+  #
+  # @return <String> Relative path from between the two
+  #
+  # @example
+  #   "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.."
+  def relative_path_from(other)
+    Pathname.new(self).relative_path_from(Pathname.new(other)).to_s
+  end
+  
+  # Overwrite this method to provide your own translations.
+  def self.translate(value)
+    translations[value] || value
+  end
+
+  def self.translations
+    @translations ||= {}
+  end
+
+  # Matches any whitespace (including newline) and replaces with a single space
+  #
+  # @example
+  #   <<QUERY.compress_lines
+  #     SELECT name
+  #     FROM users
+  #   QUERY
+  #   => "SELECT name FROM users"
+  def compress_lines(spaced = true)
+    split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+  end
+
+  # Useful for heredocs - removes whitespace margin.
+  def margin(indicator = nil)
+    lines = self.dup.split($/)
+
+    min_margin = 0
+    lines.each do |line|
+      if line =~ /^(\s+)/ && (min_margin == 0 || $1.size < min_margin)
+        min_margin = $1.size
+      end
+    end
+    lines.map { |line| line.sub(/^\s{#{min_margin}}/, '') }.join($/)
+  end
+
+ # Formats String for easy translation. Replaces an arbitrary number of
+  # values using numeric identifier replacement.
+  #
+  # @example
+  # "%s %s %s" % %w(one two three) #=> "one two three"
+  # "%3$s %2$s %1$s" % %w(one two three) #=> "three two one"
+  def t(*values)
+    self.class::translate(self) % values.collect! { |value| value.frozen? ? value : self.class::translate(value.to_s) }
+  end
+end # class String

data/lib/gems/extlib-0.9.8/lib/extlib/struct.rb

@@ -0,0 +1,8 @@
+class Struct
+  # Returns a hash containing the names and values for all instance variables in the Struct.
+  def attributes
+    h = {}
+    each_pair { |k,v| h[k] = v }
+    h
+  end
+end # class Struct

data/lib/gems/extlib-0.9.8/lib/extlib/symbol.rb

@@ -0,0 +1,17 @@
+class Symbol
+  
+  def try_dup
+    self
+  end
+  
+  ##
+  # @param o<String, Symbol> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   :merb/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self.to_s, o.to_s)
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/tasks/release.rb

@@ -0,0 +1,15 @@
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{GEM_NAME}-#{GEM_VERSION}.#{ext}" }
+
+  begin
+    sh %{rubyforge login}
+    sh %{rubyforge add_release #{RUBY_FORGE_PROJECT} #{GEM_NAME} #{GEM_VERSION} #{packages.join(' ')}}
+    sh %{rubyforge add_file #{RUBY_FORGE_PROJECT} #{GEM_NAME} #{GEM_VERSION} #{packages.join(' ')}}
+  rescue Exception => e
+    puts
+    puts "Release failed: #{e.message}"
+    puts
+    puts "Set PKG_BUILD environment variable if you do a subrelease (0.9.4.2008_08_02 when version is 0.9.4)"
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/time.rb

@@ -0,0 +1,19 @@
+class Time
+  
+  # @return <String>
+  #   ISO 8601 compatible rendering of the Time object's properties.
+  # 
+  # @example
+  #   Time.now.to_json # => "\"2008-03-28T17:54:20-05:00\""
+  def to_json(*)
+    self.xmlschema.to_json
+  end
+  
+  def to_time
+    self
+  end
+  
+  def to_datetime
+    DateTime.parse self.to_s
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/version.rb

@@ -0,0 +1,3 @@
+module Extlib
+  VERSION = "0.9.8"
+end

data/lib/gems/extlib-0.9.8/lib/extlib/virtual_file.rb

@@ -0,0 +1,10 @@
+require "stringio"
+
+# To use as a parameter to Merb::Template.inline_template
+class VirtualFile < StringIO
+  attr_accessor :path
+  def initialize(string, path)
+    super(string)
+    @path = path
+  end
+end

data/lib/gems/facets-2.4.5/VERSION

@@ -0,0 +1 @@
+facets 2.4.5 stable (2008-10-04)

data/lib/gems/facets-2.4.5/lib/core/facets-live.rb

@@ -0,0 +1,17 @@
+class Object
+
+  def method_missing(methodname, *a, &b)
+    # TODO Use #op_esc convert symbolic method names.
+    begin
+      require "facets/#{class}/#{methodname}"
+      # TODO Would it be better to use #methods.include? ?
+      if respond_to?(methodname)
+        send(methodname, *a, &b)
+      end
+    rescue LoadError
+      super
+    end  
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets-load.rb

@@ -0,0 +1,12 @@
+# This simply adds core/facets to the load path so
+# that you can more easily cherry pick methods,
+# if that's how you prefer to use facets.
+#
+# Ex.
+#
+#   require 'facets-load'
+#   require 'kernel/with'
+#   require 'symbol/to_proc'
+#
+$LOAD_PATH << FILE.dirname(__FILE__) + '/core/facets'
+

data/lib/gems/facets-2.4.5/lib/core/facets.rb

@@ -0,0 +1,11 @@
+# Dynamically load all core libraries.
+
+__DIR__ = File.dirname(__FILE__)
+
+list = []
+Dir.chdir("#{__DIR__}/facets") do
+  list = Dir['*']
+end
+
+list.each{ |f| require "facets/#{f}" }
+

data/lib/gems/facets-2.4.5/lib/core/facets/array.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/combination.rb

@@ -0,0 +1,59 @@
+if RUBY_VERSION < '1.9'
+
+  require 'enumerator'
+
+  class Array
+
+    # Yields the block to each unique combination of _n_ elements.
+    #
+    #   a = %w|a b c d|
+    #   a.combination(3)
+    #
+    # produces
+    #
+    #   [["a", "b", "c"],
+    #    ["a", "b", "d"],
+    #    ["a", "c", "d"],
+    #    ["b", "c", "d"]]
+    #
+    # CREDIT: Florian Gross
+
+    def combination(k=2)
+      if block_given?
+        s = to_a
+        n = s.size
+        return unless (1..n) === k
+        idx = (0...k).to_a
+        loop do
+          yield s.values_at(*idx)
+          i = k - 1
+          i -= 1 while idx[i] == n - k + i
+          break if i < 0
+          idx[i] += 1
+          (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
+        end
+      else
+        to_enum(:combination, k)
+      end
+    end
+
+    # OLD WAY
+    #a = []
+    #s = self
+    #n = s.size
+    #return unless (1..n) === k
+    #dx = (0...k).to_a
+    #loop do
+    #  a << s.values_at(*idx)
+    #  i = k - 1
+    #  i -= 1 while idx[i] == n - k + i
+    #  break if i < 0
+    #  idx[i] += 1
+    #  (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
+    #end
+    #a
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/conjoin.rb

@@ -0,0 +1,58 @@
+class Array
+
+  # This is more advnaced form of #join. It allows for fine control
+  # of separators.
+  #
+  # NOTE: The old version used to default it's separator to ", " and
+  # default the terminating separator to " and ". This is no longer
+  # the case. You must specifically provide these parameters.
+  #
+  #   [1,2,3].conjoin
+  #   => "123"
+  #
+  #   [1,2,3].conjoin(', ', ' and ')
+  #   => "1, 2 and 3
+  #
+  #   [1,2,3].conjoin(', ', :last => ' or ')
+  #   => "1, 2 or 3
+  #
+  #   [1,2,3].conjoin('; ', -1 => ' & ')
+  #   => "1; 2 & 3
+  #
+  #   [1,2,3,4].conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
+  #   => "1.2-3.4"
+  #
+  #   [1,1,2,2].conjoin{ |i, a, b| a == b ? '=' : '!=' }
+  #   => "1=1!=2=2"
+  #
+  #  CREDIT: Trans
+
+  def conjoin(*args, &block)
+    return first.to_s if size < 2
+
+    sep = []
+
+    if block_given?
+      (size - 1).times do |i|
+        sep << yield(i, *slice(i,2))
+      end
+    else
+      options   = (Hash===args.last) ? args.pop : {}
+      separator = args.shift || ""
+      options[-1] = args.shift unless args.empty?
+
+      sep = [separator] * (size - 1)
+
+      if options.key?(:last)
+        options[-1] = options.delete(:last)
+      end
+
+      options[-1] ||= " and "
+
+      options.each{|i, s| sep[i] = s}
+    end
+    zip(sep).join
+  end
+
+end
+