backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/exception.rb

@@ -1,3 +0,0 @@
-module ActiveSupport
-  FrozenObjectError = RUBY_VERSION < '1.9' ? TypeError : RuntimeError
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/file.rb

@@ -1,2 +0,0 @@
-require 'active_support/core_ext/file/atomic'
-require 'active_support/core_ext/file/path'

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/file/atomic.rb

@@ -1,42 +0,0 @@
-class File
-  # 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 |file|
-  #     file.write("hello")
-  #   end
-  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
-    require 'tempfile' unless defined?(Tempfile)
-    require 'fileutils' unless defined?(FileUtils)
-
-    temp_file = Tempfile.new(basename(file_name), temp_dir)
-    temp_file.binmode
-    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 = join(dirname(file_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
-    FileUtils.mv(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

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/file/path.rb

@@ -1,5 +0,0 @@
-class File
-  unless File.allocate.respond_to?(:to_path)
-    alias to_path path
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/float.rb

@@ -1 +0,0 @@
-require 'active_support/core_ext/float/rounding'

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/float/rounding.rb

@@ -1,19 +0,0 @@
-class Float
-  alias precisionless_round round
-  private :precisionless_round
-
-  # 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(precision = nil)
-    if precision
-      magnitude = 10.0 ** precision
-      (self * magnitude).round / magnitude
-    else
-      precisionless_round
-    end
-  end
-end if RUBY_VERSION < '1.9'

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash.rb

@@ -1,9 +0,0 @@
-require 'active_support/core_ext/hash/conversions'
-require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/deep_dup'
-require 'active_support/core_ext/hash/diff'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/hash/slice'

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/conversions.rb

@@ -1,175 +0,0 @@
-require 'active_support/xml_mini'
-require 'active_support/time'
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/string/inflections'
-
-class Hash
-  # Returns a string containing an XML representation of its receiver:
-  #
-  #   {"foo" => 1, "bar" => 2}.to_xml
-  #   # =>
-  #   # <?xml version="1.0" encoding="UTF-8"?>
-  #   # <hash>
-  #   #   <foo type="integer">1</foo>
-  #   #   <bar type="integer">2</bar>
-  #   # </hash>
-  #
-  # To do so, the method loops over the pairs and builds nodes that depend on
-  # the _values_. Given a pair +key+, +value+:
-  #
-  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
-  #
-  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
-  #   and +key+ singularized as <tt>:children</tt>.
-  #
-  # * If +value+ is a callable object it must expect one or two arguments. Depending
-  #   on the arity, the callable is invoked with the +options+ hash as first argument
-  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The 
-  #   callable can add nodes by using <tt>options[:builder]</tt>.
-  #
-  #     "foo".to_xml(lambda { |options, key| options[:builder].b(key) })
-  #     # => "<b>foo</b>"
-  #
-  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
-  #     
-  #     class Foo
-  #       def to_xml(options)
-  #         options[:builder].bar "fooing!"
-  #       end
-  #     end
-  #          
-  #     {:foo => Foo.new}.to_xml(:skip_instruct => true)
-  #     # => "<hash><bar>fooing!</bar></hash>"
-  #
-  # * Otherwise, a node with +key+ as tag is created with a string representation of
-  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
-  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
-  #   added as well according to the following mapping:
-  #
-  #     XML_TYPE_NAMES = {
-  #       "Symbol"     => "symbol",
-  #       "Fixnum"     => "integer",
-  #       "Bignum"     => "integer",
-  #       "BigDecimal" => "decimal",
-  #       "Float"      => "float",
-  #       "TrueClass"  => "boolean",
-  #       "FalseClass" => "boolean",
-  #       "Date"       => "date",
-  #       "DateTime"   => "datetime",
-  #       "Time"       => "datetime"
-  #     }
-  #
-  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
-  #
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
-  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
-  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
-  def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
-
-    options = options.dup
-    options[:indent]  ||= 2
-    options[:root]    ||= "hash"
-    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
-
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-
-    builder.__send__(:method_missing, root) do
-      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
-      yield builder if block_given?
-    end
-  end
-
-  class DisallowedType < StandardError #:nodoc:
-    def initialize(type)
-      super "Disallowed type attribute: #{type.inspect}"
-    end
-  end
-
-  DISALLOWED_XML_TYPES = %w(symbol yaml)
-
-  class << self
-    def from_xml(xml, disallowed_types = nil)
-      typecast_xml_value(unrename_keys(ActiveSupport::XmlMini.parse(xml)), disallowed_types)
-    end
-
-    def from_trusted_xml(xml)
-      from_xml xml, []
-    end
-
-    private
-      def typecast_xml_value(value, disallowed_types = nil)
-        disallowed_types ||= DISALLOWED_XML_TYPES
-
-        case value.class.to_s
-          when 'Hash'
-            if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
-              raise DisallowedType, value['type']
-            end
-
-            if value['type'] == 'array'
-              _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
-              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, disallowed_types) }
-                when "Hash"
-                  [typecast_xml_value(entries, disallowed_types)]
-                else
-                  raise "can't typecast #{entries.inspect}"
-                end
-              end
-            elsif value['type'] == 'file' || 
-               (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
-              content = value["__content__"]
-              if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
-                parser.arity == 1 ? parser.call(content) : parser.call(content, value)
-              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 = Hash[value.map { |k,v| [k, typecast_xml_value(v, disallowed_types)] }]
-
-              # 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, disallowed_types) }
-            value.length > 1 ? value : value.first
-          when 'String'
-            value
-          else
-            raise "can't typecast #{value.class.name} - #{value.inspect}"
-        end
-      end
-
-      def unrename_keys(params)
-        case params.class.to_s
-          when "Hash"
-            Hash[params.map { |k,v| [k.to_s.tr("-", "_"), unrename_keys(v)] } ]
-          when "Array"
-            params.map { |v| unrename_keys(v) }
-          else
-            params
-        end
-      end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/deep_dup.rb

@@ -1,18 +0,0 @@
-class Hash
-  # Returns a deep copy of hash.
-  #
-  #   hash = { :a => { :b => 'b' } }
-  #   dup  = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] #=> nil
-  #   dup[:a][:c]  #=> "c"
-  def deep_dup
-    duplicate = self.dup
-    duplicate.each_pair do |k,v|
-      tv = duplicate[k]
-      duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
-    end
-    duplicate
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/deep_merge.rb

@@ -1,21 +0,0 @@
-class Hash
-  # Returns a new hash with +self+ and +other_hash+ merged recursively.
-  #
-  #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
-  #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
-  #
-  #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
-  #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
-  def deep_merge(other_hash)
-    dup.deep_merge!(other_hash)
-  end
-
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash)
-    other_hash.each_pair do |k,v|
-      tv = self[k]
-      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
-    end
-    self
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/diff.rb

@@ -1,13 +0,0 @@
-class Hash
-  # 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)
-    dup.delete_if { |k, v| h2[k] == v }.merge!(h2.dup.delete_if { |k, v| has_key?(k) })
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/except.rb

@@ -1,23 +0,0 @@
-class Hash
-  # 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))
-  #
-  # If the receiver responds to +convert_key+, the method is called on each of the
-  # arguments. This allows +except+ to play nice with hashes with indifferent access
-  # for instance:
-  #
-  #   {:a => 1}.with_indifferent_access.except(:a)  # => {}
-  #   {:a => 1}.with_indifferent_access.except("a") # => {}
-  #
-  def except(*keys)
-    dup.except!(*keys)
-  end
-
-  # Replaces the hash without the given keys.
-  def except!(*keys)
-    keys.each { |key| delete(key) }
-    self
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -1,24 +0,0 @@
-require 'active_support/hash_with_indifferent_access'
-
-class Hash
-
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
-  #
-  #   {:a => 1}.with_indifferent_access["a"] # => 1
-  #
-  def with_indifferent_access
-    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
-  end
-
-  # Called when object is nested under an object that receives
-  # #with_indifferent_access. This method will be called on the current object
-  # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
-  # desirable.
-  #
-  #   b = {:b => 1}
-  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
-  #
-  alias nested_under_indifferent_access with_indifferent_access
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/keys.rb

@@ -1,54 +0,0 @@
-class Hash
-  # Return a new hash with all keys converted to strings.
-  #
-  #   { :name => 'Rob', :years => '28' }.stringify_keys
-  #   #=> { "name" => "Rob", "years" => "28" }
-  def stringify_keys
-    dup.stringify_keys!
-  end
-
-  # Destructively convert all keys to strings. Same as
-  # +stringify_keys+, but modifies +self+.
-  def stringify_keys!
-    keys.each do |key|
-      self[key.to_s] = delete(key)
-    end
-    self
-  end
-
-  # Return a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+.
-  #
-  #   { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
-  #   #=> { :name => "Rob", :years => "28" }
-  def symbolize_keys
-    dup.symbolize_keys!
-  end
-
-  # Destructively convert all keys to symbols, as long as they respond
-  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
-  def symbolize_keys!
-    keys.each do |key|
-      self[(key.to_sym rescue key) || key] = delete(key)
-    end
-    self
-  end
-
-  alias_method :to_options,  :symbolize_keys
-  alias_method :to_options!, :symbolize_keys!
-
-  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
-  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
-  # as keys, this will fail.
-  #
-  # ==== Examples
-  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
-  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key: name"
-  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
-  def assert_valid_keys(*valid_keys)
-    valid_keys.flatten!
-    each_key do |k|
-      raise(ArgumentError, "Unknown key: #{k}") unless valid_keys.include?(k)
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -1,23 +0,0 @@
-class Hash
-  # Merges the caller into +other_hash+. For example,
-  #
-  #   options = options.reverse_merge(:size => 25, :velocity => 10)
-  #
-  # is equivalent to
-  #
-  #   options = {:size => 25, :velocity => 10}.merge(options)
-  #
-  # This is particularly useful for initializing an options hash
-  # with default values.
-  def reverse_merge(other_hash)
-    other_hash.merge(self)
-  end
-
-  # Destructive +reverse_merge+.
-  def reverse_merge!(other_hash)
-    # right wins if there is no left
-    merge!( other_hash ){|key,left,right| left }
-  end
-
-  alias_method :reverse_update, :reverse_merge!
-end