backbone-deep-rails 0.0.2 → 0.0.3

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

@@ -1,29 +0,0 @@
-class Hash
-  # By default, only instances of Hash itself are extractable.
-  # Subclasses of Hash may implement this method and return
-  # true to declare themselves as extractable. If a Hash
-  # is extractable, Array#extract_options! pops it from
-  # the Array when it is the last element of the Array.
-  def extractable_options?
-    instance_of?(Hash)
-  end
-end
-
-class Array
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
-  def extract_options!
-    if last.is_a?(Hash) && last.extractable_options?
-      pop
-    else
-      {}
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-require 'enumerator'
-
-class Array
-  # Splits or iterates over the array in groups of size +number+,
-  # padding any remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", "6"]
-  #   ["7", nil, nil]
-  #
-  #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
-  #   ["1", "2"]
-  #   ["3", " "]
-  #
-  #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
-  #   ["1", "2"]
-  #   ["3"]
-  def in_groups_of(number, fill_with = nil)
-    if fill_with == false
-      collection = self
-    else
-      # size % number gives how many extra we have;
-      # subtracting from number gives how many to add;
-      # modulo number ensures we don't add group of just fill.
-      padding = (number - size % number) % number
-      collection = dup.concat([fill_with] * padding)
-    end
-
-    if block_given?
-      collection.each_slice(number) { |slice| yield(slice) }
-    else
-      groups = []
-      collection.each_slice(number) { |group| groups << group }
-      groups
-    end
-  end
-
-  # Splits or iterates over the array in +number+ of groups, padding any
-  # remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
-  #   ["1", "2", "3", "4"]
-  #   ["5", "6", "7", nil]
-  #   ["8", "9", "10", nil]
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, '&nbsp;') {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", "&nbsp;"]
-  #   ["6", "7", "&nbsp;"]
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5"]
-  #   ["6", "7"]
-  def in_groups(number, fill_with = nil)
-    # size / number gives minor group size;
-    # size % number gives how many objects need extra accommodation;
-    # each group hold either division or division + 1 items.
-    division = size / number
-    modulo = size % number
-
-    # create a new array avoiding dup
-    groups = []
-    start = 0
-
-    number.times do |index|
-      length = division + (modulo > 0 && modulo > index ? 1 : 0)
-      padding = fill_with != false &&
-        modulo > 0 && length == division ? 1 : 0
-      groups << slice(start, length).concat([fill_with] * padding)
-      start += length
-    end
-
-    if block_given?
-      groups.each { |g| yield(g) }
-    else
-      groups
-    end
-  end
-
-  # Divides the array into one or more subarrays based on a delimiting +value+
-  # or the result of an optional block.
-  #
-  #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
-  #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
-  def split(value = nil)
-    using_block = block_given?
-
-    inject([[]]) do |results, element|
-      if (using_block && yield(element)) || (value == element)
-        results << []
-      else
-        results.last << element
-      end
-
-      results
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-class Array
-  # The human way of thinking about adding stuff to the end of a list is with append
-  alias_method :append,  :<<
-
-  # The human way of thinking about adding stuff to the beginning of a list is with prepend
-  alias_method :prepend, :unshift
-end

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

@@ -1,30 +0,0 @@
-class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's https://github.com/marcandre/backports/
-  # Returns a random element or +n+ random elements from the array.
-  # If the array is empty and +n+ is nil, returns <tt>nil</tt>.
-  # If +n+ is passed and its value is less than 0, it raises an +ArgumentError+ exception.
-  # If the value of +n+ is equal or greater than 0 it returns <tt>[]</tt>.
-  #
-  #   [1,2,3,4,5,6].sample     # => 4
-  #   [1,2,3,4,5,6].sample(3)  # => [2, 4, 5]
-  #   [1,2,3,4,5,6].sample(-3) # => ArgumentError: negative array size
-  #              [].sample     # => nil
-  #              [].sample(3)  # => []
-  def sample(n=nil)
-    return self[Kernel.rand(size)] if n.nil?
-    n = n.to_int
-  rescue Exception => e
-    raise TypeError, "Coercion error: #{n.inspect}.to_int => Integer failed:\n(#{e.message})"
-  else
-    raise TypeError, "Coercion error: obj.to_int did NOT return an Integer (was #{n.class})" unless n.kind_of? Integer
-    raise ArgumentError, "negative array size" if n < 0
-    n = size if n > size
-    result = Array.new(self)
-    n.times do |i|
-      r = i + Kernel.rand(size - i)
-      result[i], result[r] = result[r], result[i]
-    end
-    result[n..size] = []
-    result
-  end unless method_defined? :sample
-end

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

@@ -1,16 +0,0 @@
-class Array
-  # Returns an unique array based on the criteria given as a +Proc+.
-  #
-  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
-  #
-  def uniq_by
-    hash, array = {}, []
-    each { |i| hash[yield(i)] ||= (array << i) }
-    array
-  end
-
-  # Same as uniq_by, but modifies self.
-  def uniq_by!
-    replace(uniq_by{ |i| yield(i) })
-  end
-end

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

@@ -1,48 +0,0 @@
-class Array
-  # Wraps its argument in an array unless it is already an array (or array-like).
-  #
-  # Specifically:
-  #
-  # * If the argument is +nil+ an empty list is returned.
-  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
-  # * Otherwise, returns an array with the argument as its single element.
-  #
-  #   Array.wrap(nil)       # => []
-  #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
-  #   Array.wrap(0)         # => [0]
-  #
-  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
-  #
-  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  # such a +nil+ right away.
-  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
-  # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
-  #
-  # The last point is particularly worth comparing for some enumerables:
-  #
-  #   Array(:foo => :bar)      # => [[:foo, :bar]]
-  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
-  #
-  #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
-  #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
-  #
-  # There's also a related idiom that uses the splat operator:
-  #
-  #   [*object]
-  #
-  # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
-  #
-  # Thus, in this case the behavior is different for +nil+, and the differences with
-  # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
-  def self.wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary || [object]
-    else
-      [object]
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-require 'benchmark'
-
-class << Benchmark
-  def ms
-    1000 * realtime { yield }
-  end
-end

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

@@ -1 +0,0 @@
-require 'active_support/core_ext/big_decimal/conversions'

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

@@ -1,45 +0,0 @@
-require 'bigdecimal'
-
-begin
-  require 'psych'
-rescue LoadError
-end
-
-require 'yaml'
-
-class BigDecimal
-  YAML_TAG = 'tag:yaml.org,2002:float'
-  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
-
-  # This emits the number without any scientific notation.
-  # This is better than self.to_f.to_s since it doesn't lose precision.
-  #
-  # Note that reconstituting YAML floats to native floats may lose precision.
-  def to_yaml(opts = {})
-    return super if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
-
-    YAML.quick_emit(nil, opts) do |out|
-      string = to_s
-      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
-    end
-  end
-
-  def encode_with(coder)
-    string = to_s
-    coder.represent_scalar(nil, YAML_MAPPING[string] || string)
-  end
-
-  # Backport this method if it doesn't exist
-  unless method_defined?(:to_d)
-    def to_d
-      self
-    end
-  end
-
-  DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
-    _original_to_s(format)
-  end
-  alias_method :_original_to_s, :to_s
-  alias_method :to_s, :to_formatted_s
-end

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

@@ -1,4 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/subclasses'

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

@@ -1,115 +0,0 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/array/extract_options'
-
-class Class
-  # Declare a class-level attribute whose value is inheritable by subclasses.
-  # Subclasses can change their own value and it will not impact parent class.
-  #
-  #   class Base
-  #     class_attribute :setting
-  #   end
-  #
-  #   class Subclass < Base
-  #   end
-  #
-  #   Base.setting = true
-  #   Subclass.setting            # => true
-  #   Subclass.setting = false
-  #   Subclass.setting            # => false
-  #   Base.setting                # => true
-  #
-  # In the above case as long as Subclass does not assign a value to setting
-  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
-  # would read value assigned to parent class. Once Subclass assigns a value then
-  # the value assigned by Subclass would be returned.
-  #
-  # This matches normal Ruby method inheritance: think of writing an attribute
-  # on a subclass as overriding the reader method. However, you need to be aware
-  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
-  # In such cases, you don't want to do changes in places but use setters:
-  #
-  #   Base.setting = []
-  #   Base.setting                # => []
-  #   Subclass.setting            # => []
-  #
-  #   # Appending in child changes both parent and child because it is the same object:
-  #   Subclass.setting << :foo
-  #   Base.setting               # => [:foo]
-  #   Subclass.setting           # => [:foo]
-  #
-  #   # Use setters to not propagate changes:
-  #   Base.setting = []
-  #   Subclass.setting += [:foo]
-  #   Base.setting               # => []
-  #   Subclass.setting           # => [:foo]
-  #
-  # For convenience, a query method is defined as well:
-  #
-  #   Subclass.setting?       # => false
-  #
-  # Instances may overwrite the class value in the same way:
-  #
-  #   Base.setting = true
-  #   object = Base.new
-  #   object.setting          # => true
-  #   object.setting = false
-  #   object.setting          # => false
-  #   Base.setting            # => true
-  #
-  # To opt out of the instance reader method, pass :instance_reader => false.
-  #
-  #   object.setting          # => NoMethodError
-  #   object.setting?         # => NoMethodError
-  #
-  # To opt out of the instance writer method, pass :instance_writer => false.
-  #
-  #   object.setting = false  # => NoMethodError
-  def class_attribute(*attrs)
-    options = attrs.extract_options!
-    instance_reader = options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_writer, true)
-
-    attrs.each do |name|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{name}() nil end
-        def self.#{name}?() !!#{name} end
-
-        def self.#{name}=(val)
-          singleton_class.class_eval do
-            remove_possible_method(:#{name})
-            define_method(:#{name}) { val }
-          end
-
-          if singleton_class?
-            class_eval do
-              remove_possible_method(:#{name})
-              def #{name}
-                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
-              end
-            end
-          end
-          val
-        end
-
-        if instance_reader
-          remove_possible_method :#{name}
-          def #{name}
-            defined?(@#{name}) ? @#{name} : self.class.#{name}
-          end
-
-          def #{name}?
-            !!#{name}
-          end
-        end
-      RUBY
-
-      attr_writer name if instance_writer
-    end
-  end
-
-  private
-  def singleton_class?
-    ancestors.first != self
-  end
-end

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

@@ -1,168 +0,0 @@
-require 'active_support/core_ext/array/extract_options'
-
-# Extends the class object with class and instance accessors for class attributes,
-# just like the native attr* accessors for instance attributes.
-class Class
-  # Defines a class attribute if it's not defined and creates a reader method that
-  # returns the attribute value.
-  #
-  #   class Person
-  #     cattr_reader :hair_colors
-  #   end
-  #
-  #   Person.class_variable_set("@@hair_colors", [:brown, :black])
-  #   Person.hair_colors     # => [:brown, :black]
-  #   Person.new.hair_colors # => [:brown, :black]
-  #
-  # The attribute name must be a valid method name in Ruby.
-  #
-  #   class Person
-  #     cattr_reader :"1_Badname "
-  #   end
-  #   # => NameError: invalid attribute name
-  #
-  # If you want to opt out the instance reader method, you can pass <tt>:instance_reader => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
-  #
-  #   class Person
-  #     cattr_reader :hair_colors, :instance_reader => false
-  #   end
-  #
-  #   Person.new.hair_colors # => NoMethodError
-  def cattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
-
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-  end
-
-  # Defines a class attribute if it's not defined and creates a writer method to allow
-  # assignment to the attribute.
-  #
-  #   class Person
-  #     cattr_writer :hair_colors
-  #   end
-  #
-  #   Person.hair_colors = [:brown, :black]
-  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black]
-  #   Person.new.hair_colors = [:blonde, :red]
-  #   Person.class_variable_get("@@hair_colors") # => [:blonde, :red]
-  #
-  # The attribute name must be a valid method name in Ruby.
-  #
-  #   class Person
-  #     cattr_writer :"1_Badname "
-  #   end
-  #   # => NameError: invalid attribute name
-  #
-  # If you want to opt out the instance writer method, pass <tt>:instance_writer => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
-  #
-  #   class Person
-  #     cattr_writer :hair_colors, :instance_writer => false
-  #   end
-  #
-  #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
-  #
-  # Also, you can pass a block to set up the attribute with a default value.
-  #
-  #   class Person
-  #     cattr_writer :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
-  #   end
-  #
-  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def cattr_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
-      self.send("#{sym}=", yield) if block_given?
-    end
-  end
-
-  # Defines both class and instance accessors for class attributes.
-  #
-  #   class Person
-  #     cattr_accessor :hair_colors
-  #   end
-  #
-  #   Person.hair_colors = [:brown, :black, :blonde, :red]
-  #   Person.hair_colors     # => [:brown, :black, :blonde, :red]
-  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-  #
-  # If a subclass changes the value then that would also change the value for
-  # parent class. Similarly if parent class changes the value then that would
-  # change the value of subclasses too.
-  #
-  #   class Male < Person
-  #   end
-  #
-  #   Male.hair_colors << :blue
-  #   Person.hair_colors # => [:brown, :black, :blonde, :red, :blue]
-  #
-  # To opt out of the instance writer method, pass <tt>:instance_writer => false</tt>.
-  # To opt out of the instance reader method, pass <tt>:instance_reader => false</tt>.
-  #
-  #   class Person
-  #     cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
-  #   end
-  #
-  #   Person.new.hair_colors = [:brown]  # => NoMethodError
-  #   Person.new.hair_colors             # => NoMethodError
-  #
-  # Or pass <tt>:instance_accessor => false</tt>, to opt out both instance methods.
-  #
-  #   class Person
-  #     cattr_accessor :hair_colors, :instance_accessor => false
-  #   end
-  #
-  #   Person.new.hair_colors = [:brown]  # => NoMethodError
-  #   Person.new.hair_colors             # => NoMethodError
-  #
-  # Also you can pass a block to set up the attribute with a default value.
-  #
-  #   class Person
-  #     cattr_accessor :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
-  #   end
-  #
-  #   Person.class_variable_get("@@hair_colors") #=> [:brown, :black, :blonde, :red]
-  def cattr_accessor(*syms, &blk)
-    cattr_reader(*syms)
-    cattr_writer(*syms, &blk)
-  end
-end