backlog 0.0.2 → 0.0.3

data/vendor/rails/activesupport/lib/active_support/core_ext/date_time.rb

@@ -1,8 +0,0 @@
-require 'date'
-require "#{File.dirname(__FILE__)}/time/behavior"
-require "#{File.dirname(__FILE__)}/date_time/calculations"
-require "#{File.dirname(__FILE__)}/date_time/conversions"
-
-DateTime.send(:include, ActiveSupport::CoreExtensions::Time::Behavior)
-DateTime.send(:include, ActiveSupport::CoreExtensions::DateTime::Calculations)
-DateTime.send(:include, ActiveSupport::CoreExtensions::DateTime::Conversions)

data/vendor/rails/activesupport/lib/active_support/core_ext/date_time/calculations.rb

@@ -1,173 +0,0 @@
-require 'rational'
-
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module DateTime #:nodoc:
-      # Enables the use of time calculations within DateTime itself
-      module Calculations
-
-        # Seconds since midnight: DateTime.now.seconds_since_midnight
-        def seconds_since_midnight
-          self.sec + (self.min * 60) + (self.hour * 3600)
-        end
-
-        # Returns a new DateTime where one or more of the elements have been changed according to the +options+ parameter. The time options
-        # (hour, minute, sec) reset cascadingly, so if only the hour is passed, then minute and sec is set to 0. If the hour and
-        # minute is passed, then sec is set to 0.
-        def change(options)
-          ::DateTime.civil(
-            options[:year]  || self.year,
-            options[:month] || self.month,
-            options[:mday]  || self.mday,
-            options[:hour]  || self.hour,
-            options[:min]   || (options[:hour] ? 0 : self.min),
-            options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
-            options[:offset]  || self.offset,
-            options[:start]  || self.start
-          )
-        end
-
-        # Uses Date to provide precise Time calculations for years, months, and days.  The +options+ parameter takes a hash with
-        # any of these keys: :months, :days, :years.
-        def advance(options)
-          d = ::Date.new(year + (options.delete(:years) || 0), month, day)
-          d = d >> options.delete(:months) if options[:months]
-          d = d +  options.delete(:days)   if options[:days]
-          change(options.merge(:year => d.year, :month => d.month, :mday => d.day))
-        end
-
-        # Returns a new DateTime representing the time a number of seconds ago
-        # Do not use this method in combination with x.months, use months_ago instead!
-        def ago(seconds)
-          self.since(-seconds)
-        end
-
-        # Returns a new DateTime representing the time a number of seconds since the instance time
-        # Do not use this method in combination with x.months, use months_since instead!
-        def since(seconds)
-          self + Rational(seconds, 86400)
-        end
-        alias :in :since
-
-        # Returns a new DateTime representing the time a number of specified months ago
-         def months_ago(months)
-           months_since(-months)
-         end
-
-         def months_since(months)
-           year, month, mday = self.year, self.month, self.mday
-
-           month += months
-
-           # in case months is negative
-           while month < 1
-             month += 12
-             year -= 1
-           end
-
-           # in case months is positive
-           while month > 12
-             month -= 12
-             year += 1
-           end
-
-           max = ::Time.days_in_month(month, year)
-           mday = max if mday > max
-
-           change(:year => year, :month => month, :mday => mday)
-         end
-
-         # Returns a new DateTime representing the time a number of specified years ago
-         def years_ago(years)
-           change(:year => self.year - years)
-         end
-
-         def years_since(years)
-           change(:year => self.year + years)
-         end
-
-         # Short-hand for years_ago(1)
-         def last_year
-           years_ago(1)
-         end
-
-         # Short-hand for years_since(1)
-         def next_year
-           years_since(1)
-         end
-
-         # Short-hand for months_ago(1)
-         def last_month
-           months_ago(1)
-         end
-
-         # Short-hand for months_since(1)
-         def next_month
-           months_since(1)
-         end
-
-         # Returns a new DateTime representing the "start" of this week (Monday, 0:00)
-         def beginning_of_week
-           days_to_monday = self.wday!=0 ? self.wday-1 : 6
-           (self - days_to_monday).midnight
-         end
-         alias :monday :beginning_of_week
-         alias :at_beginning_of_week :beginning_of_week
-
-         # Returns a new DateTime representing the start of the given day in next week (default is Monday).
-         def next_week(day = :monday)
-           days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
-           ((self + 7).beginning_of_week + days_into_week[day]).change(:hour => 0)
-         end
-
-         # Returns a new DateTime representing the start of the day (0:00)
-         def beginning_of_day
-           change(:hour => 0)
-         end
-         alias :midnight :beginning_of_day
-         alias :at_midnight :beginning_of_day
-         alias :at_beginning_of_day :beginning_of_day
-
-         # Returns a new DateTime representing the end of the day (23:59:59)
-         def end_of_day
-           change(:hour => 23, :min => 59, :sec => 59)
-         end
-
-         # Returns a new DateTime representing the start of the month (1st of the month, 0:00)
-         def beginning_of_month
-           change(:mday => 1,:hour => 0, :min => 0, :sec => 0)
-         end
-         alias :at_beginning_of_month :beginning_of_month
-
-         # Returns a new DateTime representing the end of the month (last day of the month, 0:00)
-         def end_of_month
-           last_day = ::Time.days_in_month( self.month, self.year )
-           change(:mday => last_day,:hour => 0, :min => 0, :sec => 0)
-         end
-         alias :at_end_of_month :end_of_month
-
-         # Returns  a new DateTime representing the start of the quarter (1st of january, april, july, october, 0:00)
-         def beginning_of_quarter
-           beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
-         end
-         alias :at_beginning_of_quarter :beginning_of_quarter
-
-         # Returns  a new DateTime representing the start of the year (1st of january, 0:00)
-         def beginning_of_year
-           change(:month => 1,:mday => 1,:hour => 0, :min => 0, :sec => 0)
-         end
-         alias :at_beginning_of_year :beginning_of_year
-
-         # Convenience method which returns a new DateTime representing the time 1 day ago
-         def yesterday
-           self - 1
-         end
-
-         # Convenience method which returns a new DateTime representing the time 1 day since the instance time
-         def tomorrow
-           self + 1
-         end
-      end
-    end
-  end
-end

data/vendor/rails/activesupport/lib/active_support/core_ext/date_time/conversions.rb

@@ -1,33 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module DateTime #:nodoc:
-      # Getting datetimes in different convenient string representations and other objects
-      module Conversions
-        DATE_FORMATS = {
-          :db     => "%Y-%m-%d %H:%M:%S",
-          :time   => "%H:%M",
-          :short  => "%d %b %H:%M",
-          :long   => "%B %d, %Y %H:%M",
-          :rfc822 => "%a, %d %b %Y %H:%M:%S %z"
-        }
-        def self.included(klass)
-          klass.send(:alias_method, :to_datetime_default_s, :to_s)
-          klass.send(:alias_method, :to_s, :to_formatted_s)
-        end
-        
-        def to_formatted_s(format = :default)
-          DATE_FORMATS[format] ? strftime(DATE_FORMATS[format]).strip : to_datetime_default_s          
-        end
-
-        def to_date
-          ::Date.new(year, month, day)
-        end
-        
-        # To be able to keep Times and DateTimes interchangeable on conversions
-        def to_datetime
-          self
-        end        
-      end
-    end
-  end
-end

data/vendor/rails/activesupport/lib/active_support/core_ext/enumerable.rb

@@ -1,62 +0,0 @@
-module Enumerable
-  # Collect an enumerable into sets, grouped by the result of a block. Useful,
-  # for example, for grouping records by date.
-  #
-  # e.g. 
-  #
-  #   latest_transcripts.group_by(&:day).each do |day, transcripts| 
-  #     p "#{day} -> #{transcripts.map(&:class) * ', '}"
-  #   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
-    inject({}) do |groups, element|
-      (groups[yield(element)] ||= []) << element
-      groups
-    end
-  end if RUBY_VERSION < '1.9'
-
-  # Calculates a sum from the elements. Examples:
-  #
-  #  payments.sum { |p| p.price * p.tax_rate }
-  #  payments.sum(&:price)
-  #
-  # This is instead of payments.inject { |sum, p| sum + p.price }
-  #
-  # Also calculates sums without the use of a block:
-  #   [5, 15, 10].sum # => 30
-  #
-  # The default identity (sum of an empty list) is zero. 
-  # However, 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
-
-  # 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
-  
-end

data/vendor/rails/activesupport/lib/active_support/core_ext/exception.rb

@@ -1,33 +0,0 @@
-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 |line, (regexp, sub)|
-        line.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/vendor/rails/activesupport/lib/active_support/core_ext/file.rb

@@ -1,21 +0,0 @@
-require 'tempfile'
-
-# 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.imporant", "/data/tmp") do |f|
-#   file.write("hello")
-# end
-def File.atomic_write(file_name, temp_dir = Dir.tmpdir)
-  temp_file = Tempfile.new(File.basename(file_name), temp_dir)
-  yield temp_file
-  temp_file.close
-  File.rename(temp_file.path, file_name)
-end

data/vendor/rails/activesupport/lib/active_support/core_ext/hash.rb

@@ -1,12 +0,0 @@
-%w(keys indifferent_access reverse_merge conversions diff slice).each do |ext|
-  require "#{File.dirname(__FILE__)}/hash/#{ext}"
-end
-
-class Hash #:nodoc:
-  include ActiveSupport::CoreExtensions::Hash::Keys
-  include ActiveSupport::CoreExtensions::Hash::IndifferentAccess
-  include ActiveSupport::CoreExtensions::Hash::ReverseMerge
-  include ActiveSupport::CoreExtensions::Hash::Conversions
-  include ActiveSupport::CoreExtensions::Hash::Diff
-  include ActiveSupport::CoreExtensions::Hash::Slice
-end

data/vendor/rails/activesupport/lib/active_support/core_ext/hash/conversions.rb

@@ -1,221 +0,0 @@
-require 'date'
-require 'xml_simple'
-require 'cgi'
-require 'base64'
-
-# Extensions needed for Hash#to_query
-class Object
-  def to_param #:nodoc:
-    to_s
-  end
-
-  def to_query(key) #:nodoc:
-    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
-  end
-end
-
-class Array
-  def to_query(key) #:nodoc:
-    collect { |value| value.to_query("#{key}[]") } * '&'
-  end
-end
-
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
-      module Conversions
-        XML_TYPE_NAMES = {
-          "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 = {
-          "date"     => Proc.new { |date| date.to_s(:db) },
-          "datetime" => Proc.new { |time| time.xmlschema },
-          "binary"   => Proc.new { |binary| Base64.encode64(binary) },
-          "yaml"     => Proc.new { |yaml| yaml.to_yaml }
-        } unless defined?(XML_FORMATTING)
-
-        unless defined?(XML_PARSING)
-          XML_PARSING = {
-            "date"         => Proc.new  { |date|    ::Date.parse(date) },
-            "datetime"     => Proc.new  { |time|    ::Time.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|     Base64.decode64(bin) },
-            # FIXME: Get rid of eval and institute a proper decorator here
-            "file"         => Proc.new do |file, entity|
-              f = StringIO.new(Base64.decode64(file))
-              eval "def f.original_filename() '#{entity["name"]}' || 'untitled' end"
-              eval "def f.content_type()      '#{entity["content_type"]}' || 'application/octet-stream' end"
-              f
-            end
-          }
-
-          XML_PARSING.update(
-            "double"   => XML_PARSING["float"],
-            "dateTime" => XML_PARSING["datetime"]
-          )
-        end
-
-        def self.included(klass)
-          klass.extend(ClassMethods)
-        end
-
-        def to_query(namespace = nil)
-          collect do |key, value|
-            value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-          end.sort * '&'
-        end
-
-        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(xml,
-              'forcearray'   => false,
-              'forcecontent' => true,
-              'keeproot'     => true,
-              'contentkey'   => '__content__')
-            ))
-          end
-          
-          def create_from_xml(xml)
-            ActiveSupport::Deprecation.warn("Hash.create_from_xml has been renamed to Hash.from_xml", caller)
-            from_xml(xml)
-          end
-
-          private
-            def typecast_xml_value(value)
-              case value.class.to_s
-                when "Hash"
-                  if value.has_key?("__content__")
-                    content = translate_xml_entities(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'
-                    ""
-                  else
-                    xml_value = (value.blank? || value['type'] || value['nil'] == 'true') ? nil : 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
-                    if xml_value.is_a?(Hash) && xml_value["file"].is_a?(StringIO)
-                      xml_value["file"]
-                    else
-                      xml_value
-                    end
-                  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.inspect}"
-              end
-            end
-
-            def translate_xml_entities(value)
-              value.gsub(/&lt;/,   "<").
-                    gsub(/&gt;/,   ">").
-                    gsub(/&quot;/, '"').
-                    gsub(/&apos;/, "'").
-                    gsub(/&amp;/,  "&")
-            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