mack-active_record 0.8.2 → 0.8.3

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/enumerable.rb

@@ -1,107 +0,0 @@
-require 'active_support/ordered_hash'
-
-module Enumerable
-  # Ruby 1.8.7 introduces group_by, but the result isn't ordered. Override it.
-  remove_method(:group_by) if [].respond_to?(:group_by) && RUBY_VERSION < '1.9'
-
-  # Collect an enumerable into sets, grouped by the result of a block. Useful,
-  # for example, for grouping records by date.
-  #
-  # Example:
-  #
-  #   latest_transcripts.group_by(&:day).each do |day, transcripts| 
-  #     p "#{day} -> #{transcripts.map(&:class).join(', ')}"
-  #   end
-  #   "2006-03-01 -> Transcript"
-  #   "2006-02-28 -> Transcript"
-  #   "2006-02-27 -> Transcript, Transcript"
-  #   "2006-02-26 -> Transcript, Transcript"
-  #   "2006-02-25 -> Transcript"
-  #   "2006-02-24 -> Transcript, Transcript"
-  #   "2006-02-23 -> Transcript"
-  def group_by
-    assoc = ActiveSupport::OrderedHash.new
-
-    each do |element|
-      key = yield(element)
-
-      if assoc.has_key?(key)
-        assoc[key] << element
-      else
-        assoc[key] = [element]
-      end
-    end
-
-    assoc
-  end unless [].respond_to?(:group_by)
-
-  # Calculates a sum from the elements. Examples:
-  #
-  #  payments.sum { |p| p.price * p.tax_rate }
-  #  payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #  payments.inject { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #  [5, 15, 10].sum # => 30
-  #  ["foo", "bar"].sum # => "foobar"
-  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
-  #
-  # The default sum of an empty list is zero. You can override this default:
-  #
-  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  #
-  def sum(identity = 0, &block)
-    return identity unless size > 0
-
-    if block_given?
-      map(&block).sum
-    else
-      inject { |sum, element| sum + element }
-    end
-  end
-
-  # Iterates over a collection, passing the current element *and* the
-  # +memo+ to the block. Handy for building up hashes or
-  # reducing collections down to one object. Examples:
-  #
-  #   %w(foo bar).each_with_object({}) { |str, hsh| hsh[str] = str.upcase } #=> {'foo' => 'FOO', 'bar' => 'BAR'}
-  #
-  # *Note* that you can't use immutable objects like numbers, true or false as
-  # the memo. You would think the following returns 120, but since the memo is
-  # never changed, it does not.
-  #
-  #   (1..5).each_with_object(1) { |value, memo| memo *= value } # => 1
-  #
-  def each_with_object(memo, &block)
-    returning memo do |m|
-      each do |element|
-        block.call(element, m)
-      end
-    end
-  end unless [].respond_to?(:each_with_object)
-
-  # Convert an enumerable to a hash. Examples:
-  #
-  #   people.index_by(&:login)
-  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
-  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
-  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
-  # 
-  def index_by
-    inject({}) do |accum, elem|
-      accum[yield(elem)] = elem
-      accum
-    end
-  end
-  
-  # Returns true if the collection has more than 1 element. Functionally equivalent to collection.size > 1.
-  # Works with a block too ala any?, so people.many? { |p| p.age > 26 } # => returns true if more than 1 person is over 26.
-  def many?(&block)
-    size = block_given? ? select(&block).size : self.size
-    size > 1
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/exception.rb

@@ -1,41 +0,0 @@
-module ActiveSupport
-  if RUBY_VERSION >= '1.9'
-    FrozenObjectError = RuntimeError
-  else
-    FrozenObjectError = TypeError
-  end
-end
-
-class Exception # :nodoc:
-  def clean_message
-    Pathname.clean_within message
-  end
-  
-  TraceSubstitutions = []
-  FrameworkRegexp = /generated|vendor|dispatch|ruby|script\/\w+/
-  
-  def clean_backtrace
-    backtrace.collect do |line|
-      Pathname.clean_within(TraceSubstitutions.inject(line) do |result, (regexp, sub)|
-        result.gsub regexp, sub
-      end)
-    end
-  end
-  
-  def application_backtrace
-    before_application_frame = true
-    
-    trace = clean_backtrace.reject do |line|
-      non_app_frame = (line =~ FrameworkRegexp)
-      before_application_frame = false unless non_app_frame
-      non_app_frame && ! before_application_frame
-    end
-    
-    # If we didn't find any application frames, return an empty app trace.
-    before_application_frame ? [] : trace
-  end
-  
-  def framework_backtrace
-    clean_backtrace.grep FrameworkRegexp
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/file/atomic.rb

@@ -1,46 +0,0 @@
-require 'tempfile'
-
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module File #:nodoc:
-      module Atomic
-        # Write to a file atomically.  Useful for situations where you don't
-        # want other processes or threads to see half-written files.
-        #
-        #   File.atomic_write("important.file") do |file|
-        #     file.write("hello")
-        #   end
-        #
-        # If your temp directory is not on the same filesystem as the file you're 
-        # trying to write, you can provide a different temporary directory.
-        # 
-        #   File.atomic_write("/data/something.important", "/data/tmp") do |f|
-        #     file.write("hello")
-        #   end
-        def atomic_write(file_name, temp_dir = Dir.tmpdir)
-          temp_file = Tempfile.new(basename(file_name), temp_dir)
-          yield temp_file
-          temp_file.close
-
-          begin
-            # Get original file permissions
-            old_stat = stat(file_name)
-          rescue Errno::ENOENT
-            # No old permissions, write a temp file to determine the defaults
-            check_name = ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}"
-            open(check_name, "w") { }
-            old_stat = stat(check_name)
-            unlink(check_name)
-          end
-
-          # Overwrite original file with temp file
-          rename(temp_file.path, file_name)
-
-          # Set correct permissions on new file
-          chown(old_stat.uid, old_stat.gid, file_name)
-          chmod(old_stat.mode, file_name)
-        end
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/file.rb

@@ -1,5 +0,0 @@
-require 'active_support/core_ext/file/atomic'
-
-class File #:nodoc:
-  extend ActiveSupport::CoreExtensions::File::Atomic
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/float/rounding.rb

@@ -1,24 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Float #:nodoc:
-      module Rounding
-        def self.included(base) #:nodoc:
-          base.class_eval do
-            alias_method :round_without_precision, :round
-            alias_method :round, :round_with_precision
-          end
-        end
-
-        # Rounds the float with the specified precision.
-        #
-        #   x = 1.337
-        #   x.round    # => 1
-        #   x.round(1) # => 1.3
-        #   x.round(2) # => 1.34
-        def round_with_precision(precision = nil)
-          precision.nil? ? round_without_precision : (self * (10 ** precision)).round / (10 ** precision).to_f
-        end
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/float/time.rb

@@ -1,27 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Float #:nodoc:
-      module Time
-        # Deprication helper methods not available as core_ext is loaded first.
-        def years
-          ::ActiveSupport::Deprecation.warn(self.class.deprecated_method_warning(:years, "Fractional years are not respected. Convert value to integer before calling #years."), caller)
-          years_without_deprecation
-        end
-        def months
-          ::ActiveSupport::Deprecation.warn(self.class.deprecated_method_warning(:months, "Fractional months are not respected. Convert value to integer before calling #months."), caller)
-          months_without_deprecation
-        end
-
-        def months_without_deprecation
-          ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
-        end
-        alias :month :months
-      
-        def years_without_deprecation
-          ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
-        end
-        alias :year :years
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/float.rb

@@ -1,7 +0,0 @@
-require 'active_support/core_ext/float/rounding'
-require 'active_support/core_ext/float/time'
-
-class Float #:nodoc:
-  include ActiveSupport::CoreExtensions::Float::Rounding
-  include ActiveSupport::CoreExtensions::Float::Time
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/hash/conversions.rb

@@ -1,259 +0,0 @@
-require 'date'
-require 'cgi'
-require 'builder'
-require 'xmlsimple'
-
-# Locked down XmlSimple#xml_in_string
-class XmlSimple
-  # Same as xml_in but doesn't try to smartly shoot itself in the foot.
-  def xml_in_string(string, options = nil)
-    handle_options('in', options)
-
-    @doc = parse(string)
-    result = collapse(@doc.root)
-
-    if @options['keeproot']
-      merge({}, @doc.root.name, result)
-    else
-      result
-    end
-  end
-
-  def self.xml_in_string(string, options = nil)
-    new.xml_in_string(string, options)
-  end
-end
-
-# This module exists to decorate files deserialized using Hash.from_xml with
-# the <tt>original_filename</tt> and <tt>content_type</tt> methods.
-module FileLike #:nodoc:
-  attr_writer :original_filename, :content_type
-
-  def original_filename
-    @original_filename || 'untitled'
-  end
-
-  def content_type
-    @content_type || 'application/octet-stream'
-  end
-end
-
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
-      module Conversions
-
-        XML_TYPE_NAMES = {
-          "Symbol"     => "symbol",
-          "Fixnum"     => "integer",
-          "Bignum"     => "integer",
-          "BigDecimal" => "decimal",
-          "Float"      => "float",
-          "Date"       => "date",
-          "DateTime"   => "datetime",
-          "Time"       => "datetime",
-          "TrueClass"  => "boolean",
-          "FalseClass" => "boolean"
-        } unless defined?(XML_TYPE_NAMES)
-
-        XML_FORMATTING = {
-          "symbol"   => Proc.new { |symbol| symbol.to_s },
-          "date"     => Proc.new { |date| date.to_s(:db) },
-          "datetime" => Proc.new { |time| time.xmlschema },
-          "binary"   => Proc.new { |binary| ActiveSupport::Base64.encode64(binary) },
-          "yaml"     => Proc.new { |yaml| yaml.to_yaml }
-        } unless defined?(XML_FORMATTING)
-
-        # TODO: use Time.xmlschema instead of Time.parse;
-        #       use regexp instead of Date.parse
-        unless defined?(XML_PARSING)
-          XML_PARSING = {
-            "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
-            "date"         => Proc.new  { |date|    ::Date.parse(date) },
-            "datetime"     => Proc.new  { |time|    ::Time.parse(time).utc rescue ::DateTime.parse(time).utc },
-            "integer"      => Proc.new  { |integer| integer.to_i },
-            "float"        => Proc.new  { |float|   float.to_f },
-            "decimal"      => Proc.new  { |number|  BigDecimal(number) },
-            "boolean"      => Proc.new  { |boolean| %w(1 true).include?(boolean.strip) },
-            "string"       => Proc.new  { |string|  string.to_s },
-            "yaml"         => Proc.new  { |yaml|    YAML::load(yaml) rescue yaml },
-            "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
-            "file"         => Proc.new do |file, entity|
-              f = StringIO.new(ActiveSupport::Base64.decode64(file))
-              f.extend(FileLike)
-              f.original_filename = entity['name']
-              f.content_type = entity['content_type']
-              f
-            end
-          }
-
-          XML_PARSING.update(
-            "double"   => XML_PARSING["float"],
-            "dateTime" => XML_PARSING["datetime"]
-          )
-        end
-
-        def self.included(klass)
-          klass.extend(ClassMethods)
-        end
-
-        # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
-        # passed to enclose the param names (see example below).
-        #
-        # ==== Example:
-        #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
-        #
-        #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
-        def to_query(namespace = nil)
-          collect do |key, value|
-            value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-          end.sort * '&'
-        end
-        
-        alias_method :to_param, :to_query
-
-        def to_xml(options = {})
-          options[:indent] ||= 2
-          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
-                                   :root => "hash" })
-          options[:builder].instruct! unless options.delete(:skip_instruct)
-          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
-          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
-
-          options[:builder].__send__(:method_missing, root) do
-            each do |key, value|
-              case value
-                when ::Hash
-                  value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
-                when ::Array
-                  value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
-                when ::Method, ::Proc
-                  # If the Method or Proc takes two arguments, then
-                  # pass the suggested child element name.  This is
-                  # used if the Method or Proc will be operating over
-                  # multiple records and needs to create an containing
-                  # element that will contain the objects being
-                  # serialized.
-                  if 1 == value.arity
-                    value.call(options.merge({ :root => key, :skip_instruct => true }))
-                  else
-                    value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
-                  end
-                else
-                  if value.respond_to?(:to_xml)
-                    value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
-                  else
-                    type_name = XML_TYPE_NAMES[value.class.name]
-
-                    key = dasherize ? key.to_s.dasherize : key.to_s
-
-                    attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
-                    if value.nil?
-                      attributes[:nil] = true
-                    end
-
-                    options[:builder].tag!(key,
-                      XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
-                      attributes
-                    )
-                  end
-              end
-            end
-            
-            yield options[:builder] if block_given?
-          end
-
-        end
-
-        module ClassMethods
-          def from_xml(xml)
-            # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
-            typecast_xml_value(undasherize_keys(XmlSimple.xml_in_string(xml,
-              'forcearray'   => false,
-              'forcecontent' => true,
-              'keeproot'     => true,
-              'contentkey'   => '__content__')
-            ))
-          end
-
-          private
-            def typecast_xml_value(value)
-              case value.class.to_s
-                when 'Hash'
-                  if value['type'] == 'array'
-                    child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
-                    if entries.nil? || (c = value['__content__'] && c.blank?)
-                      []
-                    else
-                      case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
-                      when "Array"
-                        entries.collect { |v| typecast_xml_value(v) }
-                      when "Hash"
-                        [typecast_xml_value(entries)]
-                      else
-                        raise "can't typecast #{entries.inspect}"
-                      end
-                    end
-                  elsif value.has_key?("__content__")
-                    content = value["__content__"]
-                    if parser = XML_PARSING[value["type"]]
-                      if parser.arity == 2
-                        XML_PARSING[value["type"]].call(content, value)
-                      else
-                        XML_PARSING[value["type"]].call(content)
-                      end
-                    else
-                      content
-                    end
-                  elsif value['type'] == 'string' && value['nil'] != 'true'
-                    ""
-                  # blank or nil parsed values are represented by nil
-                  elsif value.blank? || value['nil'] == 'true'
-                    nil
-                  # If the type is the only element which makes it then 
-                  # this still makes the value nil, except if type is
-                  # a XML node(where type['value'] is a Hash)
-                  elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
-                    nil
-                  else
-                    xml_value = value.inject({}) do |h,(k,v)|
-                      h[k] = typecast_xml_value(v)
-                      h
-                    end
-                    
-                    # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
-                    # how multipart uploaded files from HTML appear
-                    xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
-                  end
-                when 'Array'
-                  value.map! { |i| typecast_xml_value(i) }
-                  case value.length
-                    when 0 then nil
-                    when 1 then value.first
-                    else value
-                  end
-                when 'String'
-                  value
-                else
-                  raise "can't typecast #{value.class.name} - #{value.inspect}"
-              end
-            end
-
-            def undasherize_keys(params)
-              case params.class.to_s
-                when "Hash"
-                  params.inject({}) do |h,(k,v)|
-                    h[k.to_s.tr("-", "_")] = undasherize_keys(v)
-                    h
-                  end
-                when "Array"
-                  params.map { |v| undasherize_keys(v) }
-                else
-                  params
-              end
-            end
-        end
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/hash/deep_merge.rb

@@ -1,23 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
-      # Allows for deep merging
-      module DeepMerge
-        # Returns a new hash with +self+ and +other_hash+ merged recursively.
-        def deep_merge(other_hash)
-          self.merge(other_hash) do |key, oldval, newval|
-            oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
-            newval = newval.to_hash if newval.respond_to?(:to_hash)
-            oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
-          end
-        end
-
-        # Returns a new hash with +self+ and +other_hash+ merged recursively.
-        # Modifies the receiver in place.
-        def deep_merge!(other_hash)
-          replace(deep_merge(other_hash))
-        end
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/hash/diff.rb

@@ -1,19 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
-      module Diff
-        # Returns a hash that represents the difference between two hashes.
-        #
-        # Examples:
-        #
-        #   {1 => 2}.diff(1 => 2)         # => {}
-        #   {1 => 2}.diff(1 => 3)         # => {1 => 2}
-        #   {}.diff(1 => 2)               # => {1 => 2}
-        #   {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
-        def diff(h2)
-          self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) })
-        end
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/hash/except.rb

@@ -1,25 +0,0 @@
-require 'set'
-
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
-      # Return a hash that includes everything but the given keys. This is useful for
-      # limiting a set of parameters to everything but a few known toggles:
-      #
-      #   @person.update_attributes(params[:person].except(:admin))
-      module Except
-        # Returns a new hash without the given keys.
-        def except(*keys)
-          dup.except!(*keys)
-        end
-
-        # Replaces the hash without the given keys.
-        def except!(*keys)
-          keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-          keys.each { |key| delete(key) }
-          self
-        end
-      end
-    end
-  end
-end