vibes-bj 1.2.1

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

@@ -0,0 +1,96 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module DateTime #:nodoc:
+      # Converting datetimes to formatted strings, dates, and times.
+      module Conversions
+        def self.append_features(base) #:nodoc:
+          base.class_eval do
+            alias_method :default_inspect, :inspect
+            alias_method :to_default_s, :to_s unless (instance_methods(false) & [:to_s, 'to_s']).empty?
+
+            # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows
+            # DateTimes outside the range of what can be created with Time.
+            remove_method :to_time if instance_methods.include?(:to_time)
+          end
+
+          super
+
+          base.class_eval do
+            alias_method :to_s, :to_formatted_s
+            alias_method :inspect, :readable_inspect
+          end
+        end
+
+        # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
+        # 
+        # This method is aliased to <tt>to_s</tt>.
+        # 
+        # === Examples:
+        #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
+        # 
+        #   datetime.to_formatted_s(:db)            # => "2007-12-04 00:00:00"
+        #   datetime.to_s(:db)                      # => "2007-12-04 00:00:00"
+        #   datetime.to_s(:number)                  # => "20071204000000"
+        #   datetime.to_formatted_s(:short)         # => "04 Dec 00:00"
+        #   datetime.to_formatted_s(:long)          # => "December 04, 2007 00:00"
+        #   datetime.to_formatted_s(:long_ordinal)  # => "December 4th, 2007 00:00"
+        #   datetime.to_formatted_s(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
+        #
+        # == Adding your own datetime formats to to_formatted_s
+        # DateTime formats are shared with Time. You can add your own to the
+        # Time::DATE_FORMATS hash. Use the format name as the hash key and
+        # either a strftime string or Proc instance that takes a time or
+        # datetime argument as the value.
+        #
+        #   # config/initializers/time_formats.rb
+        #   Time::DATE_FORMATS[:month_and_year] = "%B %Y"
+        #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
+        def to_formatted_s(format = :default)
+          return to_default_s unless formatter = ::Time::DATE_FORMATS[format]
+          formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+        end
+
+        # Returns the +utc_offset+ as an +HH:MM formatted string. Examples:
+        #
+        #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
+        #   datetime.formatted_offset         # => "-06:00"
+        #   datetime.formatted_offset(false)  # => "-0600"
+        def formatted_offset(colon = true, alternate_utc_string = nil)
+          utc? && alternate_utc_string || utc_offset.to_utc_offset_s(colon)
+        end
+        
+        # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000"
+        def readable_inspect
+          to_s(:rfc822)
+        end
+
+        # Converts self to a Ruby Date object; time portion is discarded
+        def to_date
+          ::Date.new(year, month, day)
+        end
+
+        # Attempts to convert self to a Ruby Time object; returns self if out of range of Ruby Time class
+        # If self has an offset other than 0, self will just be returned unaltered, since there's no clean way to map it to a Time
+        def to_time
+          self.offset == 0 ? ::Time.utc_time(year, month, day, hour, min, sec) : self
+        end
+
+        # To be able to keep Times, Dates and DateTimes interchangeable on conversions
+        def to_datetime
+          self
+        end
+
+        # Converts datetime to an appropriate format for use in XML
+        def xmlschema
+          strftime("%Y-%m-%dT%H:%M:%S%Z")
+        end if RUBY_VERSION < '1.9'
+        
+        # Converts self to a floating-point number of seconds since the Unix epoch 
+        def to_f
+          days_since_unix_epoch = self - ::DateTime.civil(1970)
+          (days_since_unix_epoch * 86_400).to_f
+        end
+      end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/duplicable.rb

@@ -0,0 +1,37 @@
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, and numbers; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end

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

@@ -0,0 +1,69 @@
+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
+    inject ActiveSupport::OrderedHash.new do |grouped, element|
+      (grouped[yield(element)] ||= []) << element
+      grouped
+    end
+  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
+
+  # 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/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/exception.rb

@@ -0,0 +1,41 @@
+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/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/file.rb

@@ -0,0 +1,21 @@
+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.important", "/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/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/float.rb

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

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/float/rounding.rb

@@ -0,0 +1,24 @@
+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/spec/rails_root/vendor/rails/activesupport/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,13 @@
+%w(keys indifferent_access reverse_merge conversions diff slice except).each do |ext|
+  require "active_support/core_ext/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
+  include ActiveSupport::CoreExtensions::Hash::Except
+end

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

@@ -0,0 +1,259 @@
+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