cassandra_object 0.6.0.pre

data/vendor/activemodel/lib/active_model/deprecated_error_methods.rb

@@ -0,0 +1,33 @@
+module ActiveModel
+  module DeprecatedErrorMethods
+    def on(attribute)
+      message = "Errors#on have been deprecated, use Errors#[] instead.\n"
+      message << "Also note that the behaviour of Errors#[] has changed. Errors#[] now always returns an Array. An empty Array is "
+      message << "returned when there are no errors on the specified attribute."
+      ActiveSupport::Deprecation.warn(message)
+
+      errors = self[attribute]
+      errors.size < 2 ? errors.first : errors
+    end
+
+    def on_base
+      ActiveSupport::Deprecation.warn "Errors#on_base have been deprecated, use Errors#[:base] instead"
+      ActiveSupport::Deprecation.silence { on(:base) }
+    end
+
+    def add_to_base(msg)
+      ActiveSupport::Deprecation.warn "Errors#add_to_base(msg) has been deprecated, use Errors#[:base] << msg instead"
+      self[:base] << msg
+    end
+
+    def invalid?(attribute)
+      ActiveSupport::Deprecation.warn "Errors#invalid?(attribute) has been deprecated, use Errors#[attribute].any? instead"
+      self[attribute].any?
+    end
+
+    def each_full
+      ActiveSupport::Deprecation.warn "Errors#each_full has been deprecated, use Errors#to_a.each instead"
+      to_a.each { |error| yield error }
+    end
+  end
+end

data/vendor/activemodel/lib/active_model/dirty.rb

@@ -0,0 +1,126 @@
+module ActiveModel
+  # Track unsaved attribute changes.
+  #
+  # A newly instantiated object is unchanged:
+  #   person = Person.find_by_name('Uncle Bob')
+  #   person.changed?       # => false
+  #
+  # Change the name:
+  #   person.name = 'Bob'
+  #   person.changed?       # => true
+  #   person.name_changed?  # => true
+  #   person.name_was       # => 'Uncle Bob'
+  #   person.name_change    # => ['Uncle Bob', 'Bob']
+  #   person.name = 'Bill'
+  #   person.name_change    # => ['Uncle Bob', 'Bill']
+  #
+  # Save the changes:
+  #   person.save
+  #   person.changed?       # => false
+  #   person.name_changed?  # => false
+  #
+  # Assigning the same value leaves the attribute unchanged:
+  #   person.name = 'Bill'
+  #   person.name_changed?  # => false
+  #   person.name_change    # => nil
+  #
+  # Which attributes have changed?
+  #   person.name = 'Bob'
+  #   person.changed        # => ['name']
+  #   person.changes        # => { 'name' => ['Bill', 'Bob'] }
+  #
+  # Resetting an attribute returns it to its original state:
+  #   person.reset_name!    # => 'Bill'
+  #   person.changed?       # => false
+  #   person.name_changed?  # => false
+  #   person.name           # => 'Bill'
+  #
+  # Before modifying an attribute in-place:
+  #   person.name_will_change!
+  #   person.name << 'y'
+  #   person.name_change    # => ['Bill', 'Billy']
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
+      attribute_method_affix :prefix => 'reset_', :suffix => '!'
+    end
+
+    # Do any attributes have unsaved changes?
+    #   person.changed? # => false
+    #   person.name = 'bob'
+    #   person.changed? # => true
+    def changed?
+      !changed_attributes.empty?
+    end
+
+    # List of attributes with unsaved changes.
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ['name']
+    def changed
+      changed_attributes.keys
+    end
+
+    # Map of changed attrs => [original value, new value].
+    #   person.changes # => {}
+    #   person.name = 'bob'
+    #   person.changes # => { 'name' => ['bill', 'bob'] }
+    def changes
+      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
+    end
+
+    # Map of attributes that were changed when the model was saved.
+    #   person.name # => 'bob'
+    #   person.name = 'robert'
+    #   person.save
+    #   person.previous_changes # => {'name' => ['bob, 'robert']}
+    def previous_changes
+      previously_changed_attributes
+    end
+
+    private
+      # Map of change <tt>attr => original value</tt>.
+      def changed_attributes
+        @changed_attributes ||= {}
+      end
+
+      # Map of fields that were changed when the model was saved
+      def previously_changed_attributes
+        @previously_changed || {}
+      end
+
+      # Handle <tt>*_changed?</tt> for +method_missing+.
+      def attribute_changed?(attr)
+        changed_attributes.include?(attr)
+      end
+
+      # Handle <tt>*_change</tt> for +method_missing+.
+      def attribute_change(attr)
+        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      end
+
+      # Handle <tt>*_was</tt> for +method_missing+.
+      def attribute_was(attr)
+        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+      end
+
+      # Handle <tt>*_will_change!</tt> for +method_missing+.
+      def attribute_will_change!(attr)
+        begin
+          value = __send__(attr)
+          value = value.duplicable? ? value.clone : value
+        rescue TypeError, NoMethodError
+        end
+
+        changed_attributes[attr] = value
+      end
+
+      # Handle <tt>reset_*!</tt> for +method_missing+.
+      def reset_attribute!(attr)
+        __send__("#{attr}=", changed_attributes[attr]) if attribute_changed?(attr)
+      end
+  end
+end

data/vendor/activemodel/lib/active_model/errors.rb

@@ -0,0 +1,162 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/ordered_hash'
+
+module ActiveModel
+  class Errors < ActiveSupport::OrderedHash
+    include DeprecatedErrorMethods
+
+    def initialize(base)
+      @base = base
+      super()
+    end
+
+    alias_method :get, :[]
+    alias_method :set, :[]=
+
+    def [](attribute)
+      if errors = get(attribute.to_sym)
+        errors
+      else
+        set(attribute.to_sym, [])
+      end
+    end
+
+    def []=(attribute, error)
+      self[attribute.to_sym] << error
+    end
+
+    def each
+      each_key do |attribute|
+        self[attribute].each { |error| yield attribute, error }
+      end
+    end
+
+    def size
+      values.flatten.size
+    end
+
+    def to_a
+      full_messages
+    end
+
+    def count
+      to_a.size
+    end
+
+    def to_xml(options={})
+      require 'builder' unless defined? ::Builder
+      options[:root]    ||= "errors"
+      options[:indent]  ||= 2
+      options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
+
+      options[:builder].instruct! unless options.delete(:skip_instruct)
+      options[:builder].errors do |e|
+        to_a.each { |error| e.error(error) }
+      end
+    end
+
+    # Adds an error message (+messsage+) to the +attribute+, which will be returned on a call to <tt>on(attribute)</tt>
+    # for the same attribute and ensure that this error object returns false when asked if <tt>empty?</tt>. More than one
+    # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
+    # If no +messsage+ is supplied, :invalid is assumed.
+    # If +message+ is a Symbol, it will be translated, using the appropriate scope (see translate_error).
+    def add(attribute, message = nil, options = {})
+      message ||= :invalid
+      message = generate_message(attribute, message, options) if message.is_a?(Symbol)
+      self[attribute] << message
+    end
+
+    # Will add an error message to each of the attributes in +attributes+ that is empty.
+    def add_on_empty(attributes, custom_message = nil)
+      [attributes].flatten.each do |attribute|
+        value = @base.send(:read_attribute_for_validation, attribute)
+        is_empty = value.respond_to?(:empty?) ? value.empty? : false
+        add(attribute, :empty, :default => custom_message) unless !value.nil? && !is_empty
+      end
+    end
+
+    # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
+    def add_on_blank(attributes, custom_message = nil)
+      [attributes].flatten.each do |attribute|
+        value = @base.send(:read_attribute_for_validation, attribute)
+        add(attribute, :blank, :default => custom_message) if value.blank?
+      end
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    #   class Company
+    #     validates_presence_of :name, :address, :email
+    #     validates_length_of :name, :in => 5..30
+    #   end
+    #
+    #   company = Company.create(:address => '123 First St.')
+    #   company.errors.full_messages # =>
+    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Address can't be blank"]
+    def full_messages
+      full_messages = []
+
+      each do |attribute, messages|
+        messages = Array(messages)
+        next if messages.empty?
+
+        if attribute == :base
+          messages.each {|m| full_messages << m }
+        else
+          attr_name = attribute.to_s.gsub('.', '_').humanize
+          attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
+          options = { :default => "{{attribute}} {{message}}", :attribute => attr_name,
+                      :scope => @base.class.i18n_scope }
+
+          messages.each do |m|
+            full_messages << I18n.t(:"errors.format", options.merge(:message => m))
+          end
+        end
+      end
+
+      full_messages
+    end
+
+    # Translates an error message in its default scope (<tt>activemodel.errors.messages</tt>).
+    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>, if it's not there,
+    # it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not there it returns the translation of the
+    # default message (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name,
+    # translated attribute name and the value are available for interpolation.
+    #
+    # When using inheritence in your models, it will check all the inherited models too, but only if the model itself
+    # hasn't been found. Say you have <tt>class Admin < User; end</tt> and you wanted the translation for the <tt>:blank</tt>
+    # error +message+ for the <tt>title</tt> +attribute+, it looks for these translations:
+    #
+    # <ol>
+    # <li><tt>activemodel.errors.models.admin.attributes.title.blank</tt></li>
+    # <li><tt>activemodel.errors.models.admin.blank</tt></li>
+    # <li><tt>activemodel.errors.models.user.attributes.title.blank</tt></li>
+    # <li><tt>activemodel.errors.models.user.blank</tt></li>
+    # <li><tt>activemodel.errors.messages.blank</tt></li>
+    # <li>any default you provided through the +options+ hash (in the activemodel.errors scope)</li>
+    # </ol>
+    def generate_message(attribute, message = :invalid, options = {})
+      message, options[:default] = options[:default], message if options[:default].is_a?(Symbol)
+
+      defaults = @base.class.lookup_ancestors.map do |klass|
+        [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{message}",
+          :"models.#{klass.name.underscore}.#{message}" ]
+      end
+
+      defaults << options.delete(:default)
+      defaults = defaults.compact.flatten << :"messages.#{message}"
+
+      key = defaults.shift
+      value = @base.send(:read_attribute_for_validation, attribute)
+
+      options = { :default => defaults,
+        :model => @base.class.model_name.human,
+        :attribute => @base.class.human_attribute_name(attribute),
+        :value => value,
+        :scope => [@base.class.i18n_scope, :errors]
+      }.merge(options)
+
+      I18n.translate(key, options)
+    end
+  end
+end

data/vendor/activemodel/lib/active_model/lint.rb

@@ -0,0 +1,91 @@
+# You can test whether an object is compliant with the ActiveModel API by
+# including ActiveModel::Lint::Tests in your TestCase. It will included
+# tests that tell you whether your object is fully compliant, or if not,
+# which aspects of the API are not implemented.
+#
+# These tests do not attempt to determine the semantic correctness of the
+# returned values. For instance, you could implement valid? to always
+# return true, and the tests would pass. It is up to you to ensure that
+# the values are semantically meaningful.
+#
+# Objects you pass in are expected to return a compliant object from a
+# call to to_model. It is perfectly fine for to_model to return self.
+module ActiveModel
+  module Lint
+    module Tests
+      # valid?
+      # ------
+      #
+      # Returns a boolean that specifies whether the object is in a valid or invalid
+      # state.
+      def test_valid?
+        assert model.respond_to?(:valid?), "The model should respond to valid?"
+        assert_boolean model.valid?, "valid?"
+      end
+
+      # new_record?
+      # -----------
+      #
+      # Returns a boolean that specifies whether the object has been persisted yet.
+      # This is used when calculating the URL for an object. If the object is
+      # not persisted, a form for that object, for instance, will be POSTed to the
+      # collection. If it is persisted, a form for the object will put PUTed to the
+      # URL for the object.
+      def test_new_record?
+        assert model.respond_to?(:new_record?), "The model should respond to new_record?"
+        assert_boolean model.new_record?, "new_record?"
+      end
+
+      def test_destroyed?
+        assert model.respond_to?(:destroyed?), "The model should respond to destroyed?"
+        assert_boolean model.destroyed?, "destroyed?"
+      end
+
+      # naming
+      # ------
+      #
+      # Model.model_name must returns a string with some convenience methods as
+      # :human and :partial_path. Check ActiveModel::Naming for more information.
+      #
+      def test_model_naming
+        assert model.class.respond_to?(:model_name), "The model should respond to model_name"
+        model_name = model.class.model_name
+        assert_kind_of String, model_name
+        assert_kind_of String, model_name.human
+        assert_kind_of String, model_name.partial_path
+      end
+
+      # errors
+      # ------
+      #
+      # Returns an object that has :[] and :full_messages defined on it. See below
+      # for more details.
+
+      # Returns an Array of Strings that are the errors for the attribute in
+      # question. If localization is used, the Strings should be localized
+      # for the current locale. If no error is present, this method should
+      # return an empty Array.
+      def test_errors_aref
+        assert model.respond_to?(:errors), "The model should respond to errors"
+        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+      end
+
+      # Returns an Array of all error messages for the object. Each message
+      # should contain information about the field, if applicable.
+      def test_errors_full_messages
+        assert model.respond_to?(:errors), "The model should respond to errors"
+        assert model.errors.full_messages.is_a?(Array), "errors#full_messages should return an Array"
+      end
+
+      private
+        def model
+          assert @model.respond_to?(:to_model), "The object should respond_to to_model"
+          @model.to_model
+        end
+
+        def assert_boolean(result, name)
+          assert result == true || result == false, "#{name} should be a boolean"
+        end
+    end
+  end
+end

data/vendor/activemodel/lib/active_model/locale/en.yml

@@ -0,0 +1,27 @@
+en:
+  activemodel:
+    errors:
+      # model.errors.full_messages format.
+      format: "{{attribute}} {{message}}"
+
+      # The values :model, :attribute and :value are always available for interpolation
+      # The value :count is available when applicable. Can be used for pluralization.
+      messages:
+        inclusion: "is not included in the list"
+        exclusion: "is reserved"
+        invalid: "is invalid"
+        confirmation: "doesn't match confirmation"
+        accepted: "must be accepted"
+        empty: "can't be empty"
+        blank: "can't be blank"
+        too_long: "is too long (maximum is {{count}} characters)"
+        too_short: "is too short (minimum is {{count}} characters)"
+        wrong_length: "is the wrong length (should be {{count}} characters)"
+        not_a_number: "is not a number"
+        greater_than: "must be greater than {{count}}"
+        greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+        equal_to: "must be equal to {{count}}"
+        less_than: "must be less than {{count}}"
+        less_than_or_equal_to: "must be less than or equal to {{count}}"
+        odd: "must be odd"
+        even: "must be even"

data/vendor/activemodel/lib/active_model/naming.rb

@@ -0,0 +1,45 @@
+require 'active_support/inflector'
+
+module ActiveModel
+  class Name < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path
+    alias_method :cache_key, :collection
+
+    def initialize(klass)
+      super(klass.name)
+      @klass = klass
+      @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+      @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
+      @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
+      @human = ActiveSupport::Inflector.humanize(@element).freeze
+      @collection = ActiveSupport::Inflector.tableize(self).freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+    end
+
+    # Transform the model name into a more humane format, using I18n. By default,
+    # it will underscore then humanize the class name (BlogPost.model_name.human #=> "Blog post").
+    # Specify +options+ with additional translating options.
+    def human(options={})
+      return @human unless @klass.respond_to?(:lookup_ancestors) &&
+                           @klass.respond_to?(:i18n_scope)
+
+      defaults = @klass.lookup_ancestors.map do |klass|
+        klass.model_name.underscore.to_sym
+      end
+
+      defaults << options.delete(:default) if options[:default]
+      defaults << @human
+
+      options.reverse_merge! :scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
+    end
+  end
+
+  module Naming
+    # Returns an ActiveModel::Name object for module. It can be
+    # used to retrieve all kinds of naming-related information.
+    def model_name
+      @_model_name ||= ActiveModel::Name.new(self)
+    end
+  end
+end

data/vendor/activemodel/lib/active_model/observing.rb

@@ -0,0 +1,191 @@
+require 'observer'
+require 'singleton'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/string/inflections'
+
+module ActiveModel
+  module Observing
+    extend ActiveSupport::Concern
+
+    included do
+      extend Observable
+    end
+
+    module ClassMethods
+      # Activates the observers assigned. Examples:
+      #
+      #   # Calls PersonObserver.instance
+      #   ActiveRecord::Base.observers = :person_observer
+      #
+      #   # Calls Cacher.instance and GarbageCollector.instance
+      #   ActiveRecord::Base.observers = :cacher, :garbage_collector
+      #
+      #   # Same as above, just using explicit class references
+      #   ActiveRecord::Base.observers = Cacher, GarbageCollector
+      #
+      # Note: Setting this does not instantiate the observers yet. +instantiate_observers+ is
+      # called during startup, and before each development request.
+      def observers=(*values)
+        @observers = values.flatten
+      end
+
+      # Gets the current observers.
+      def observers
+        @observers ||= []
+      end
+
+      # Instantiate the global Active Record observers.
+      def instantiate_observers
+        observers.each { |o| instantiate_observer(o) }
+      end
+
+      protected
+        def instantiate_observer(observer) #:nodoc:
+          # string/symbol
+          if observer.respond_to?(:to_sym)
+            observer = observer.to_s.camelize.constantize.instance
+          elsif observer.respond_to?(:instance)
+            observer.instance
+          else
+            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
+          end
+        end
+
+        # Notify observers when the observed class is subclassed.
+        def inherited(subclass)
+          super
+          changed
+          notify_observers :observed_class_inherited, subclass
+        end
+    end
+
+    private
+      # Fires notifications to model's observers
+      #
+      # def save
+      #   notify_observers(:before_save)
+      #   ...
+      #   notify_observers(:after_save)
+      # end
+      def notify_observers(method)
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
+  end
+
+  # Observer classes respond to lifecycle callbacks to implement trigger-like
+  # behavior outside the original class. This is a great way to reduce the
+  # clutter that normally comes when the model class is burdened with
+  # functionality that doesn't pertain to the core responsibility of the
+  # class. Example:
+  #
+  #   class CommentObserver < ActiveModel::Observer
+  #     def after_save(comment)
+  #       Notifications.deliver_comment("admin@do.com", "New comment was posted", comment)
+  #     end
+  #   end
+  #
+  # This Observer sends an email when a Comment#save is finished.
+  #
+  #   class ContactObserver < ActiveModel::Observer
+  #     def after_create(contact)
+  #       contact.logger.info('New contact added!')
+  #     end
+  #
+  #     def after_destroy(contact)
+  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+  #     end
+  #   end
+  #
+  # This Observer uses logger to log when specific callbacks are triggered.
+  #
+  # == Observing a class that can't be inferred
+  #
+  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
+  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
+  # differently than the class you're interested in observing, you can use the Observer.observe class method which takes
+  # either the concrete class (Product) or a symbol for that class (:product):
+  #
+  #   class AuditObserver < ActiveModel::Observer
+  #     observe :account
+  #
+  #     def after_update(account)
+  #       AuditTrail.new(account, "UPDATED")
+  #     end
+  #   end
+  #
+  # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
+  #
+  #   class AuditObserver < ActiveModel::Observer
+  #     observe :account, :balance
+  #
+  #     def after_update(record)
+  #       AuditTrail.new(record, "UPDATED")
+  #     end
+  #   end
+  #
+  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
+  #
+  class Observer
+    include Singleton
+
+    class << self
+      # Attaches the observer to the supplied model classes.
+      def observe(*models)
+        models.flatten!
+        models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model }
+        define_method(:observed_classes) { models }
+      end
+
+      # Returns an array of Classes to observe.
+      #
+      # You can override this instead of using the +observe+ helper.
+      #
+      #   class AuditObserver < ActiveModel::Observer
+      #     def self.observed_classes
+      #       [AccountObserver, BalanceObserver]
+      #     end
+      #   end
+      def observed_classes
+        Array.wrap(observed_class)
+      end
+
+      # The class observed by default is inferred from the observer's class name:
+      #   assert_equal Person, PersonObserver.observed_class
+      def observed_class
+        if observed_class_name = name[/(.*)Observer/, 1]
+          observed_class_name.constantize
+        else
+          nil
+        end
+      end
+    end
+
+    # Start observing the declared classes and their subclasses.
+    def initialize
+      observed_classes.each { |klass| add_observer!(klass) }
+    end
+
+    def observed_classes #:nodoc:
+      self.class.observed_classes
+    end
+
+    # Send observed_method(object) if the method exists.
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    # Special method sent by the observed class when it is inherited.
+    # Passes the new subclass.
+    def observed_class_inherited(subclass) #:nodoc:
+      self.class.observe(observed_classes + [subclass])
+      add_observer!(subclass)
+    end
+
+    protected
+      def add_observer!(klass) #:nodoc:
+        klass.add_observer(self)
+      end
+  end
+end

data/vendor/activemodel/lib/active_model/railtie.rb

@@ -0,0 +1,2 @@
+require "active_model"
+require "rails"