abiquo-etk 0.4.13

data/vendor/activesupport-2.3.8/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-2.3.8/lib/active_support/core_ext/string/inflections.rb

@@ -0,0 +1,167 @@
+require 'active_support/inflector' unless defined?(ActiveSupport::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".singularize            # => "sheep"
+        #   "word".singularize             # => "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
+
+        # 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 = '-')
+          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
+          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-2.3.8/lib/active_support/core_ext/string/iterators.rb

@@ -0,0 +1,23 @@
+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
+          while c = scanner.scan(char)
+            yield c
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/string/multibyte.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Implements multibyte methods for easier access to multibyte characters in a String instance.
+      module Multibyte
+        unless '1.9'.respond_to?(:force_encoding)
+          # == Multibyte proxy
+          #
+          # +mb_chars+ is a multibyte safe proxy for string methods.
+          #
+          # In Ruby 1.8 and older 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. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
+          #
+          #   name = 'Claus Müller'
+          #   name.reverse  #=> "rell??M sualC"
+          #   name.length   #=> 13
+          #
+          #   name.mb_chars.reverse.to_s   #=> "rellüM sualC"
+          #   name.mb_chars.length         #=> 12
+          #
+          # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
+          # it becomes easy to run one version of your code on multiple Ruby versions.
+          #
+          # == Method chaining
+          #
+          # 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.mb_chars.reverse.length #=> 12
+          #
+          # == Interoperability and configuration
+          #
+          # The Chars 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. For
+          # information about how to change the default Multibyte behaviour see ActiveSupport::Multibyte.
+          def mb_chars
+            if ActiveSupport::Multibyte.proxy_class.wants?(self)
+              ActiveSupport::Multibyte.proxy_class.new(self)
+            else
+              self
+            end
+          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::Chars.consumes?(self)
+          end
+
+          unless '1.8.7 and later'.respond_to?(:chars)
+            def chars
+              ActiveSupport::Deprecation.warn('String#chars has been deprecated in favor of String#mb_chars.', caller)
+              mb_chars
+            end
+          end
+        else
+          def mb_chars #:nodoc
+            self
+          end
+          
+          def is_utf8? #:nodoc
+            case encoding
+            when Encoding::UTF_8
+              valid_encoding?
+            when Encoding::ASCII_8BIT, Encoding::US_ASCII
+              dup.force_encoding(Encoding::UTF_8).valid_encoding?
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/string/output_safety.rb

@@ -0,0 +1,112 @@
+require 'erb'
+
+class ERB
+  module Util
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
+
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERb templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
+    def html_escape(s)
+      s = s.to_s
+      if s.html_safe?
+        s
+      else
+        s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.html_safe
+      end
+    end
+
+    undef :h
+    alias h html_escape
+
+    module_function :html_escape
+    module_function :h
+
+    # A utility method for escaping HTML entities in JSON strings.
+    # This method is also aliased as <tt>j</tt>.
+    #
+    # In your ERb templates, use this method to escape any HTML entities:
+    #   <%=j @person.to_json %>
+    #
+    # ==== Example:
+    #   puts json_escape("is a > 0 & a < 10?")
+    #   # => is a \u003E 0 \u0026 a \u003C 10?
+    def json_escape(s)
+      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
+    end
+
+    alias j json_escape
+    module_function :j
+    module_function :json_escape
+  end
+end
+
+class Object
+  def html_safe?
+    false
+  end
+end
+
+class Fixnum
+  def html_safe?
+    true
+  end
+end
+
+module ActiveSupport #:nodoc:
+  class SafeBuffer < String
+    alias safe_concat concat
+
+    def concat(value)
+      if value.html_safe?
+        super(value)
+      else
+        super(ERB::Util.h(value))
+      end
+    end
+    alias << concat
+
+    def +(other)
+      dup.concat(other)
+    end
+
+    def html_safe?
+      true
+    end
+
+    def html_safe
+      self
+    end
+
+    def to_s
+      self
+    end
+
+    def to_yaml(*args)
+      to_str.to_yaml(*args)
+    end
+  end
+end
+
+class String
+  alias safe_concat concat
+
+  def as_str
+    self
+  end
+
+  def html_safe
+    ActiveSupport::SafeBuffer.new(self)
+  end
+
+  def html_safe?
+    false
+  end
+end

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

@@ -0,0 +1,33 @@
+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.respond_to?(:to_str) && self[0, prefix.length] == prefix
+        end
+
+        # Does the string end with the specified +suffix+?
+        def ends_with?(suffix)
+          suffix.respond_to?(:to_str) && self[-suffix.length, suffix.length] == suffix
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/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-2.3.8/lib/active_support/core_ext/string.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/bytesize'
+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/multibyte'
+require 'active_support/core_ext/string/xchar'
+require 'active_support/core_ext/string/filters'
+require 'active_support/core_ext/string/behavior'
+require 'active_support/core_ext/string/output_safety'
+
+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::Behavior
+  include ActiveSupport::CoreExtensions::String::Multibyte
+end

data/vendor/activesupport-2.3.8/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-2.3.8/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