backbone-deep-rails 0.0.2 → 0.0.3

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

@@ -1,14 +0,0 @@
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/filters'
-require 'active_support/core_ext/string/multibyte'
-require 'active_support/core_ext/string/starts_ends_with'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/string/access'
-require 'active_support/core_ext/string/xchar'
-require 'active_support/core_ext/string/behavior'
-require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/output_safety'
-require 'active_support/core_ext/string/exclude'
-require 'active_support/core_ext/string/encoding'
-require 'active_support/core_ext/string/strip'
-require 'active_support/core_ext/string/inquiry'

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

@@ -1,99 +0,0 @@
-require "active_support/multibyte"
-
-class String
-  unless '1.9'.respond_to?(:force_encoding)
-    # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".at(0)  # => "h"
-    #   "hello".at(4)  # => "o"
-    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
-    def at(position)
-      mb_chars[position, 1].to_s
-    end
-
-    # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".from(0)  # => "hello"
-    #   "hello".from(2)  # => "llo"
-    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
-    def from(position)
-      mb_chars[position..-1].to_s
-    end
-
-    # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".to(0)  # => "h"
-    #   "hello".to(2)  # => "hel"
-    #   "hello".to(10) # => "hello"
-    def to(position)
-      mb_chars[0..position].to_s
-    end
-
-    # Returns the first character of the string or the first +limit+ characters.
-    #
-    # Examples:
-    #   "hello".first     # => "h"
-    #   "hello".first(2)  # => "he"
-    #   "hello".first(10) # => "hello"
-    def first(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        mb_chars[0...limit].to_s
-      end
-    end
-
-    # Returns the last character of the string or the last +limit+ characters.
-    #
-    # Examples:
-    #   "hello".last     # => "o"
-    #   "hello".last(2)  # => "lo"
-    #   "hello".last(10) # => "hello"
-    def last(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        mb_chars[(-limit)..-1].to_s
-      end
-    end
-  else
-    def at(position)
-      self[position]
-    end
-
-    def from(position)
-      self[position..-1]
-    end
-
-    def to(position)
-      self[0..position]
-    end
-
-    def first(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        to(limit - 1)
-      end
-    end
-
-    def last(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        from(-limit)
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-class String
-  # Enable more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
-  def acts_like_string?
-    true
-  end
-end

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

@@ -1,66 +0,0 @@
-# encoding: utf-8
-require 'date'
-require 'active_support/core_ext/time/publicize_conversion_methods'
-require 'active_support/core_ext/time/calculations'
-
-class String
-  # Returns the codepoint of the first character of the string, assuming a
-  # single-byte character encoding:
-  #
-  #   "a".ord # => 97
-  #   "à".ord # => 224, in ISO-8859-1
-  #
-  # This method is defined in Ruby 1.8 for Ruby 1.9 forward compatibility on
-  # these character encodings.
-  #
-  # <tt>ActiveSupport::Multibyte::Chars#ord</tt> is forward compatible with
-  # Ruby 1.9 on UTF8 strings:
-  #
-  #   "a".mb_chars.ord # => 97
-  #   "à".mb_chars.ord # => 224, in UTF8
-  #
-  # Note that the 224 is different in both examples. In ISO-8859-1 "à" is
-  # represented as a single byte, 224. In UTF8 it is represented with two
-  # bytes, namely 195 and 160, but its Unicode codepoint is 224. If we
-  # call +ord+ on the UTF8 string "à" the return value will be 195. That is
-  # not an error, because UTF8 is unsupported, the call itself would be
-  # bogus.
-  def ord
-    self[0]
-  end unless method_defined?(:ord)
-
-  # +getbyte+ backport from Ruby 1.9
-  alias_method :getbyte, :[] unless method_defined?(:getbyte)
-
-  # Form can be either :utc (default) or :local.
-  def to_time(form = :utc)
-    return nil if self.blank?
-    d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset).map { |arg| arg || 0 }
-    d[6] *= 1000000
-    ::Time.send("#{form}_time", *d[0..6]) - d[7]
-  end
-
-  # Converts a string to a Date value.
-  #
-  #   "1-1-2012".to_date   #=> Sun, 01 Jan 2012
-  #   "01/01/2012".to_date #=> Sun, 01 Jan 2012
-  #   "2012-12-13".to_date #=> Thu, 13 Dec 2012
-  #   "12/13/2012".to_date #=> ArgumentError: invalid date
-  def to_date
-    return nil if self.blank?
-    ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
-  end
-
-  # Converts a string to a DateTime value.
-  #
-  #   "1-1-2012".to_datetime            #=> Sun, 01 Jan 2012 00:00:00 +0000
-  #   "01/01/2012 23:59:59".to_datetime #=> Sun, 01 Jan 2012 23:59:59 +0000
-  #   "2012-12-13 12:50".to_datetime    #=> Thu, 13 Dec 2012 12:50:00 +0000
-  #   "12/13/2012".to_datetime          #=> ArgumentError: invalid date
-  def to_datetime
-    return nil if self.blank?
-    d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 }
-    d[5] += d.pop
-    ::DateTime.civil(*d)
-  end
-end

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

@@ -1,11 +0,0 @@
-class String
-  if defined?(Encoding) && "".respond_to?(:encode)
-    def encoding_aware?
-      true
-    end
-  else
-    def encoding_aware?
-      false
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-class String
-  # The inverse of <tt>String#include?</tt>. Returns true if the string
-  # does not include the other string.
-  #
-  #   "hello".exclude? "lo" #=> false
-  #   "hello".exclude? "ol" #=> true
-  #   "hello".exclude? ?h   #=> false
-  def exclude?(string)
-    !include?(string)
-  end
-end

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

@@ -1,49 +0,0 @@
-require 'active_support/core_ext/string/multibyte'
-
-class String
-  # Returns the string, first removing all whitespace on both ends of
-  # the string, and then changing remaining consecutive whitespace
-  # groups into one space each.
-  #
-  # Examples:
-  #   %{ Multi-line
-  #      string }.squish                   # => "Multi-line string"
-  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
-  def squish
-    dup.squish!
-  end
-
-  # Performs a destructive squish. See String#squish.
-  def squish!
-    strip!
-    gsub!(/\s+/, ' ')
-    self
-  end
-
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
-  #
-  #   "Once upon a time in a world far far away".truncate(27)
-  #   # => "Once upon a time in a wo..."
-  #
-  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
-  #
-  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
-  #   # => "Once upon a time in a..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>:length</tt>:
-  #
-  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
-  #   # => "And they f... (continued)"
-  def truncate(length, options = {})
-    text = self.dup
-    options[:omission] ||= "..."
-
-    length_with_room_for_omission = length - options[:omission].mb_chars.length
-    chars = text.mb_chars
-    stop = options[:separator] ?
-      (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
-
-    (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
-  end
-end

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

@@ -1,202 +0,0 @@
-require 'active_support/inflector/methods'
-require 'active_support/inflector/transliterate'
-
-# String inflections define new methods on the String class to transform names for different purposes.
-# For instance, you can figure out the name of a table from the name of a class.
-#
-#   "ScaleScore".tableize # => "scale_scores"
-#
-class String
-  # Returns the plural form of the word in the string.
-  #
-  # If the optional parameter +count+ is specified,
-  # the singular form will be returned if <tt>count == 1</tt>.
-  # For any other value of +count+ the plural will be returned.
-  #
-  # ==== Examples
-  #   "post".pluralize             # => "posts"
-  #   "octopus".pluralize          # => "octopi"
-  #   "sheep".pluralize            # => "sheep"
-  #   "words".pluralize            # => "words"
-  #   "the blue mailman".pluralize # => "the blue mailmen"
-  #   "CamelOctopus".pluralize     # => "CamelOctopi"
-  #   "apple".pluralize(1)         # => "apple"
-  #   "apple".pluralize(2)         # => "apples"
-  def pluralize(count = nil)
-    if count == 1
-      self
-    else
-      ActiveSupport::Inflector.pluralize(self)
-    end
-  end
-
-  # The reverse of +pluralize+, returns the singular form of a word in a string.
-  #
-  #   "posts".singularize            # => "post"
-  #   "octopi".singularize           # => "octopus"
-  #   "sheep".singularize            # => "sheep"
-  #   "word".singularize             # => "word"
-  #   "the blue mailmen".singularize # => "the blue mailman"
-  #   "CamelOctopi".singularize      # => "CamelOctopus"
-  def singularize
-    ActiveSupport::Inflector.singularize(self)
-  end
-
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.constantize
-  #
-  # Examples
-  #   "Module".constantize  # => Module
-  #   "Class".constantize   # => Class
-  #   "blargle".constantize # => NameError: wrong constant name blargle
-  def constantize
-    ActiveSupport::Inflector.constantize(self)
-  end
-
-  # +safe_constantize+ tries to find a declared constant with the name specified
-  # in the string. It returns nil when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
-  #
-  # Examples
-  #   "Module".safe_constantize  # => Module
-  #   "Class".safe_constantize   # => Class
-  #   "blargle".safe_constantize # => nil
-  def safe_constantize
-    ActiveSupport::Inflector.safe_constantize(self)
-  end
-
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
-  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-  def camelize(first_letter = :upper)
-    case first_letter
-      when :upper then ActiveSupport::Inflector.camelize(self, true)
-      when :lower then ActiveSupport::Inflector.camelize(self, false)
-    end
-  end
-  alias_method :camelcase, :camelize
-
-  # Capitalizes all the words and replaces some characters in the string to create
-  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-  # used in the Rails internals.
-  #
-  # +titleize+ is also aliased as +titlecase+.
-  #
-  #   "man from the boondocks".titleize # => "Man From The Boondocks"
-  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
-  def titleize
-    ActiveSupport::Inflector.titleize(self)
-  end
-  alias_method :titlecase, :titleize
-
-  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  #
-  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-  #
-  #   "ActiveModel".underscore         # => "active_model"
-  #   "ActiveModel::Errors".underscore # => "active_model/errors"
-  def underscore
-    ActiveSupport::Inflector.underscore(self)
-  end
-
-  # Replaces underscores with dashes in the string.
-  #
-  #   "puni_puni" # => "puni-puni"
-  def dasherize
-    ActiveSupport::Inflector.dasherize(self)
-  end
-
-  # Removes the module part from the constant expression in the string.
-  #
-  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-  #   "Inflections".demodulize                                       # => "Inflections"
-  #
-  # See also +deconstantize+.
-  def demodulize
-    ActiveSupport::Inflector.demodulize(self)
-  end
-
-  # Removes the rightmost segment from the constant expression in the string.
-  #
-  #   "Net::HTTP".deconstantize   # => "Net"
-  #   "::Net::HTTP".deconstantize # => "::Net"
-  #   "String".deconstantize      # => ""
-  #   "::String".deconstantize    # => ""
-  #   "".deconstantize            # => ""
-  #
-  # See also +demodulize+.
-  def deconstantize
-    ActiveSupport::Inflector.deconstantize(self)
-  end
-
-  # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-  #
-  # ==== Examples
-  #
-  #   class Person
-  #     def to_param
-  #       "#{id}-#{name.parameterize}"
-  #     end
-  #   end
-  #
-  #   @person = Person.find(1)
-  #   # => #<Person id: 1, name: "Donald E. Knuth">
-  #
-  #   <%= link_to(@person.name, person_path) %>
-  #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-  def parameterize(sep = '-')
-    ActiveSupport::Inflector.parameterize(self, sep)
-  end
-
-  # Creates the name of a table like Rails does for models to table names. This method
-  # uses the +pluralize+ method on the last word in the string.
-  #
-  #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
-  #   "egg_and_ham".tableize     # => "egg_and_hams"
-  #   "fancyCategory".tableize   # => "fancy_categories"
-  def tableize
-    ActiveSupport::Inflector.tableize(self)
-  end
-
-  # Create a class name from a plural table name like Rails does for table names to models.
-  # Note that this returns a string and not a class. (To convert to an actual class
-  # follow +classify+ with +constantize+.)
-  #
-  #   "egg_and_hams".classify # => "EggAndHam"
-  #   "posts".classify        # => "Post"
-  #
-  # Singular names are not handled correctly.
-  #
-  #   "business".classify # => "Busines"
-  def classify
-    ActiveSupport::Inflector.classify(self)
-  end
-
-  # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
-  # Like +titleize+, this is meant for creating pretty output.
-  #
-  #   "employee_salary" # => "Employee salary"
-  #   "author_id"       # => "Author"
-  def humanize
-    ActiveSupport::Inflector.humanize(self)
-  end
-
-  # Creates a foreign key name from a class name.
-  # +separate_class_name_and_id_with_underscore+ sets whether
-  # the method should put '_' between the name and 'id'.
-  #
-  # Examples
-  #   "Message".foreign_key        # => "message_id"
-  #   "Message".foreign_key(false) # => "messageid"
-  #   "Admin::Post".foreign_key    # => "post_id"
-  def foreign_key(separate_class_name_and_id_with_underscore = true)
-    ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
-  end
-end