3mix-castronaut 0.5.0.2

data/vendor/activesupport/lib/active_support/core_ext/string/access.rb

@@ -0,0 +1,82 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      unless '1.9'.respond_to?(:force_encoding)
+        # Makes it easier to access parts of a string, such as specific characters and substrings.
+        module Access
+          # 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) # => nil
+          def at(position)
+            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) # => nil
+          def from(position)
+            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)
+            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)
+            chars[0..(limit - 1)].to_s
+          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)
+            (chars[(-limit)..-1] || self).to_s
+          end
+        end
+      else
+        module Access #:nodoc:
+          def at(position)
+            self[position]
+          end
+
+          def from(position)
+            self[position..-1]
+          end
+
+          def to(position)
+            self[0..position]
+          end
+
+          def first(limit = 1)
+            self[0..(limit - 1)]
+          end
+
+          def last(limit = 1)
+            from(-limit) || self
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/conversions.rb

@@ -0,0 +1,28 @@
+require 'date'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Converting strings to other objects
+      module Conversions
+        # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
+        def ord
+          self[0]
+        end if RUBY_VERSION < '1.9'
+
+        # Form can be either :utc (default) or :local.
+        def to_time(form = :utc)
+          ::Time.send("#{form}_time", *::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
+        end
+
+        def to_date
+          ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
+        end
+
+        def to_datetime
+          ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/filters.rb

@@ -0,0 +1,26 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      module Filters
+        # 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
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/inflections.rb

@@ -0,0 +1,148 @@
+require 'active_support/inflector'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # 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 database from the name of a class.
+      #
+      #   "ScaleScore".tableize # => "scale_scores"
+      module Inflections
+        # Returns the plural form of the word in the string.
+        #
+        #   "post".pluralize             # => "posts"
+        #   "octopus".pluralize          # => "octopi"
+        #   "sheep".pluralize            # => "sheep"
+        #   "words".pluralize            # => "words"
+        #   "the blue mailman".pluralize # => "the blue mailmen"
+        #   "CamelOctopus".pluralize     # => "CamelOctopi"
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        # The reverse of +pluralize+, returns the singular form of a word in a string.
+        #
+        #   "posts".singularize            # => "post"
+        #   "octopi".singularize           # => "octopus"
+        #   "sheep".singluarize            # => "sheep"
+        #   "word".singluarize             # => "word"
+        #   "the blue mailmen".singularize # => "the blue mailman"
+        #   "CamelOctopi".singularize      # => "CamelOctopus"
+        def singularize
+          Inflector.singularize(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 Inflector.camelize(self, true)
+            when :lower then 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
+          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.
+        #
+        #   "ActiveRecord".underscore         # => "active_record"
+        #   "ActiveRecord::Errors".underscore # => active_record/errors
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        #   "puni_puni" # => "puni-puni"
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        # Removes the module part from the constant expression in the string.
+        #
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+        #   "Inflections".demodulize                                       # => "Inflections"
+        def demodulize
+          Inflector.demodulize(self)
+        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
+          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
+          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
+          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)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        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.
+        #
+        # Examples
+        #   "Module".constantize # => Module
+        #   "Class".constantize  # => Class
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/iterators.rb

@@ -0,0 +1,21 @@
+require 'strscan'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Custom string iterators
+      module Iterators
+        def self.append_features(base)
+          super unless '1.9'.respond_to?(:each_char)
+        end
+
+        # Yields a single-character string for each character in the string.
+        # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
+        def each_char
+          scanner, char = StringScanner.new(self), /./mu
+          loop { yield(scanner.scan(char) || break) }
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/starts_ends_with.rb

@@ -0,0 +1,35 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Additional string tests.
+      module StartsEndsWith
+        def self.append_features(base)
+          if '1.8.7 and up'.respond_to?(:start_with?)
+            base.class_eval do
+              alias_method :starts_with?, :start_with?
+              alias_method :ends_with?, :end_with?
+            end
+          else
+            super
+            base.class_eval do
+              alias_method :start_with?, :starts_with?
+              alias_method :end_with?, :ends_with?
+            end
+          end
+        end
+
+        # Does the string start with the specified +prefix+?
+        def starts_with?(prefix)
+          prefix = prefix.to_s
+          self[0, prefix.length] == prefix
+        end
+
+        # Does the string end with the specified +suffix+?
+        def ends_with?(suffix)
+          suffix = suffix.to_s
+          self[-suffix.length, suffix.length] == suffix      
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/unicode.rb

@@ -0,0 +1,66 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Define methods for handling unicode data.
+      module Unicode
+        def self.append_features(base)
+          if '1.8.7 and later'.respond_to?(:chars)
+            base.class_eval { remove_method :chars }
+          end
+          super
+        end
+
+        unless '1.9'.respond_to?(:force_encoding)
+          # +chars+ is a Unicode safe proxy for string methods. It creates and returns an instance of the
+          # ActiveSupport::Multibyte::Chars class which encapsulates the original string. A Unicode safe version of all
+          # the String methods are defined on this proxy class. Undefined methods are forwarded to String, so all of the
+          # string overrides can also be called through the +chars+ proxy.
+          #
+          #   name = 'Claus Müller'
+          #   name.reverse              # => "rell??M sualC"
+          #   name.length               # => 13
+          #
+          #   name.chars.reverse.to_s   # => "rellüM sualC"
+          #   name.chars.length         # => 12
+          #   
+          #
+          # All the methods on the chars proxy which normally return a string will return a Chars object. This allows
+          # method chaining on the result of any of these methods.
+          #
+          #   name.chars.reverse.length # => 12
+          #
+          # The Char object tries to be as interchangeable with String objects as possible: sorting and comparing between
+          # String and Char work like expected. The bang! methods change the internal string representation in the Chars
+          # object. Interoperability problems can be resolved easily with a +to_s+ call.
+          #
+          # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars and
+          # ActiveSupport::Multibyte::Handlers::UTF8Handler.
+          def chars
+            ActiveSupport::Multibyte::Chars.new(self)
+          end
+
+          # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
+          # them), returns false otherwise.
+          def is_utf8?
+            ActiveSupport::Multibyte::Handlers::UTF8Handler.consumes?(self)
+          end
+        else
+          def chars #:nodoc:
+            self
+          end
+
+          def is_utf8? #:nodoc:
+            case encoding
+              when Encoding::UTF_8
+                valid_encoding?
+              when Encoding::ASCII_8BIT
+                dup.force_encoding('UTF-8').valid_encoding?
+              else
+                false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/string/xchar.rb

@@ -0,0 +1,11 @@
+begin
+  # See http://bogomips.org/fast_xs/ by Eric Wong
+  require 'fast_xs'
+
+  class String
+    alias_method :original_xs, :to_xs if method_defined?(:to_xs)
+    alias_method :to_xs, :fast_xs
+  end
+rescue LoadError
+  # fast_xs extension unavailable.
+end

data/vendor/activesupport/lib/active_support/core_ext/string.rb

@@ -0,0 +1,18 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/string/starts_ends_with'
+require 'active_support/core_ext/string/iterators'
+require 'active_support/core_ext/string/unicode'
+require 'active_support/core_ext/string/xchar'
+require 'active_support/core_ext/string/filters'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Access
+  include ActiveSupport::CoreExtensions::String::Conversions
+  include ActiveSupport::CoreExtensions::String::Filters
+  include ActiveSupport::CoreExtensions::String::Inflections
+  include ActiveSupport::CoreExtensions::String::StartsEndsWith
+  include ActiveSupport::CoreExtensions::String::Iterators
+  include ActiveSupport::CoreExtensions::String::Unicode
+end

data/vendor/activesupport/lib/active_support/core_ext/symbol.rb

@@ -0,0 +1,14 @@
+unless :to_proc.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    #   # The same as people.collect { |p| p.name }
+    #   people.collect(&:name)
+    #
+    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    #   people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/test/unit/assertions.rb

@@ -0,0 +1,64 @@
+module Test 
+  module Unit 
+    #--
+    # FIXME: no Proc#binding in Ruby 2, must change this API
+    #++
+    module Assertions 
+      # Test numeric difference between the return value of an expression as a result of what is evaluated
+      # in the yielded block.
+      #
+      #   assert_difference 'Article.count' do
+      #     post :create, :article => {...}
+      #   end
+      #
+      # An arbitrary expression is passed in and evaluated.
+      #
+      #   assert_difference 'assigns(:article).comments(:reload).size' do
+      #     post :create, :comment => {...}
+      #   end
+      #
+      # An arbitrary positive or negative difference can be specified. The default is +1.
+      #
+      #   assert_difference 'Article.count', -1 do
+      #     post :delete, :id => ...
+      #   end
+      #
+      # An array of expressions can also be passed in and evaluated.
+      #
+      #   assert_difference [ 'Article.count', 'Post.count' ], +2 do
+      #     post :create, :article => {...}
+      #   end
+      #
+      # A error message can be specified.
+      #
+      #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
+      #     post :delete, :id => ...
+      #   end
+      def assert_difference(expressions, difference = 1, message = nil, &block)
+        expression_evaluations = Array(expressions).collect{ |expression| lambda { eval(expression, block.send!(:binding)) } }
+
+        original_values = expression_evaluations.inject([]) { |memo, expression| memo << expression.call }
+        yield
+        expression_evaluations.each_with_index do |expression, i|
+          assert_equal original_values[i] + difference, expression.call, message
+        end
+      end
+
+      # Assertion that the numeric result of evaluating an expression is not changed before and after
+      # invoking the passed in block.
+      #
+      #   assert_no_difference 'Article.count' do
+      #     post :create, :article => invalid_attributes
+      #   end
+      #
+      # A error message can be specified.
+      #
+      #   assert_no_difference 'Article.count', "An Article should not be destroyed" do
+      #     post :create, :article => invalid_attributes
+      #   end
+      def assert_no_difference(expressions, message = nil, &block)
+        assert_difference expressions, 0, message, &block
+      end
+    end
+  end
+end

data/vendor/activesupport/lib/active_support/core_ext/test.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/test/unit/assertions'

data/vendor/activesupport/lib/active_support/core_ext/time/behavior.rb

@@ -0,0 +1,13 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Time #:nodoc:
+      module Behavior
+        # Enable more predictable duck-typing on Time-like classes. See
+        # Object#acts_like?.
+        def acts_like_time?
+          true
+        end
+      end
+    end
+  end
+end