activemodel 3.2.22.5 → 4.0.0.beta1

data/lib/active_model/mass_assignment_security/permission_set.rb

@@ -1,40 +0,0 @@
-require 'set'
-
-module ActiveModel
-  module MassAssignmentSecurity
-    class PermissionSet < Set
-
-      def +(values)
-        super(values.map(&:to_s))
-      end
-
-      def include?(key)
-        super(remove_multiparameter_id(key))
-      end
-
-      def deny?(key)
-        raise NotImplementedError, "#deny?(key) suppose to be overwritten"
-      end
-
-    protected
-
-      def remove_multiparameter_id(key)
-        key.to_s.gsub(/\(.+/m, '')
-      end
-    end
-
-    class WhiteList < PermissionSet
-
-      def deny?(key)
-        !include?(key)
-      end
-    end
-
-    class BlackList < PermissionSet
-
-      def deny?(key)
-        include?(key)
-      end
-    end
-  end
-end

data/lib/active_model/mass_assignment_security/sanitizer.rb

@@ -1,59 +0,0 @@
-require 'active_support/core_ext/module/delegation'
-
-module ActiveModel
-  module MassAssignmentSecurity
-    class Sanitizer
-      def initialize(target=nil)
-      end
-
-      # Returns all attributes not denied by the authorizer.
-      def sanitize(attributes, authorizer)
-        sanitized_attributes = attributes.reject { |key, value| authorizer.deny?(key) }
-        debug_protected_attribute_removal(attributes, sanitized_attributes)
-        sanitized_attributes
-      end
-
-    protected
-
-      def debug_protected_attribute_removal(attributes, sanitized_attributes)
-        removed_keys = attributes.keys - sanitized_attributes.keys
-        process_removed_attributes(removed_keys) if removed_keys.any?
-      end
-
-      def process_removed_attributes(attrs)
-        raise NotImplementedError, "#process_removed_attributes(attrs) suppose to be overwritten"
-      end
-    end
-
-    class LoggerSanitizer < Sanitizer
-      delegate :logger, :to => :@target
-
-      def initialize(target)
-        @target = target
-        super
-      end
-
-      def logger?
-        @target.respond_to?(:logger) && @target.logger
-      end
-
-      def process_removed_attributes(attrs)
-        logger.debug "WARNING: Can't mass-assign protected attributes: #{attrs.join(', ')}" if logger?
-      end
-    end
-
-    class StrictSanitizer < Sanitizer
-      def process_removed_attributes(attrs)
-        return if (attrs - insensitive_attributes).empty?
-        raise ActiveModel::MassAssignmentSecurity::Error, "Can't mass-assign protected attributes: #{attrs.join(', ')}"
-      end
-
-      def insensitive_attributes
-        ['id']
-      end
-    end
-
-    class Error < StandardError
-    end
-  end
-end

data/lib/active_model/observer_array.rb

@@ -1,147 +0,0 @@
-require 'set'
-
-module ActiveModel
-  # Stores the enabled/disabled state of individual observers for
-  # a particular model class.
-  class ObserverArray < Array
-    attr_reader :model_class
-    def initialize(model_class, *args)
-      @model_class = model_class
-      super(*args)
-    end
-
-    # Returns true if the given observer is disabled for the model class.
-    def disabled_for?(observer)
-      disabled_observers.include?(observer.class)
-    end
-
-    # Disables one or more observers. This supports multiple forms:
-    #
-    #   ORM.observers.disable :user_observer
-    #     # => disables the UserObserver
-    #
-    #   User.observers.disable AuditTrail
-    #     # => disables the AuditTrail observer for User notifications.
-    #     #    Other models will still notify the AuditTrail observer.
-    #
-    #   ORM.observers.disable :observer_1, :observer_2
-    #     # => disables Observer1 and Observer2 for all models.
-    #
-    #   ORM.observers.disable :all
-    #     # => disables all observers for all models.
-    #
-    #   User.observers.disable :all do
-    #     # all user observers are disabled for
-    #     # just the duration of the block
-    #   end
-    def disable(*observers, &block)
-      set_enablement(false, observers, &block)
-    end
-
-    # Enables one or more observers. This supports multiple forms:
-    #
-    #   ORM.observers.enable :user_observer
-    #     # => enables the UserObserver
-    #
-    #   User.observers.enable AuditTrail
-    #     # => enables the AuditTrail observer for User notifications.
-    #     #    Other models will not be affected (i.e. they will not
-    #     #    trigger notifications to AuditTrail if previously disabled)
-    #
-    #   ORM.observers.enable :observer_1, :observer_2
-    #     # => enables Observer1 and Observer2 for all models.
-    #
-    #   ORM.observers.enable :all
-    #     # => enables all observers for all models.
-    #
-    #   User.observers.enable :all do
-    #     # all user observers are enabled for
-    #     # just the duration of the block
-    #   end
-    #
-    # Note: all observers are enabled by default. This method is only
-    # useful when you have previously disabled one or more observers.
-    def enable(*observers, &block)
-      set_enablement(true, observers, &block)
-    end
-
-    protected
-
-      def disabled_observers
-        @disabled_observers ||= Set.new
-      end
-
-      def observer_class_for(observer)
-        return observer if observer.is_a?(Class)
-
-        if observer.respond_to?(:to_sym) # string/symbol
-          observer.to_s.camelize.constantize
-        else
-          raise ArgumentError, "#{observer} was not a class or a " +
-            "lowercase, underscored class name as expected."
-        end
-      end
-
-      def start_transaction
-        disabled_observer_stack.push(disabled_observers.dup)
-        each_subclass_array do |array|
-          array.start_transaction
-        end
-      end
-
-      def disabled_observer_stack
-        @disabled_observer_stack ||= []
-      end
-
-      def end_transaction
-        @disabled_observers = disabled_observer_stack.pop
-        each_subclass_array do |array|
-          array.end_transaction
-        end
-      end
-
-      def transaction
-        start_transaction
-
-        begin
-          yield
-        ensure
-          end_transaction
-        end
-      end
-
-      def each_subclass_array
-        model_class.descendants.each do |subclass|
-          yield subclass.observers
-        end
-      end
-
-      def set_enablement(enabled, observers)
-        if block_given?
-          transaction do
-            set_enablement(enabled, observers)
-            yield
-          end
-        else
-          observers = ActiveModel::Observer.descendants if observers == [:all]
-          observers.each do |obs|
-            klass = observer_class_for(obs)
-
-            unless klass < ActiveModel::Observer
-              raise ArgumentError.new("#{obs} does not refer to a valid observer")
-            end
-
-            if enabled
-              disabled_observers.delete(klass)
-            else
-              disabled_observers << klass
-            end
-          end
-
-          each_subclass_array do |array|
-            array.set_enablement(enabled, observers)
-          end
-        end
-      end
-  end
-end

data/lib/active_model/observing.rb

@@ -1,252 +0,0 @@
-require 'singleton'
-require 'active_model/observer_array'
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/enumerable'
-require 'active_support/descendants_tracker'
-
-module ActiveModel
-  module Observing
-    extend ActiveSupport::Concern
-
-    included do
-      extend ActiveSupport::DescendantsTracker
-    end
-
-    module ClassMethods
-      # == Active Model Observers Activation
-      #
-      # Activates the observers assigned. Examples:
-      #
-      #   class ORM
-      #     include ActiveModel::Observing
-      #   end
-      #
-      #   # Calls PersonObserver.instance
-      #   ORM.observers = :person_observer
-      #
-      #   # Calls Cacher.instance and GarbageCollector.instance
-      #   ORM.observers = :cacher, :garbage_collector
-      #
-      #   # Same as above, just using explicit class references
-      #   ORM.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.replace(values.flatten)
-      end
-
-      # Gets an array of observers observing this model.
-      # The array also provides +enable+ and +disable+ methods
-      # that allow you to selectively enable and disable observers.
-      # (see <tt>ActiveModel::ObserverArray.enable</tt> and
-      # <tt>ActiveModel::ObserverArray.disable</tt> for more on this)
-      def observers
-        @observers ||= ObserverArray.new(self)
-      end
-
-      # Gets the current observer instances.
-      def observer_instances
-        @observer_instances ||= []
-      end
-
-      # Instantiate the global observers.
-      def instantiate_observers
-        observers.each { |o| instantiate_observer(o) }
-      end
-
-      # Add a new observer to the pool.
-      # The new observer needs to respond to 'update', otherwise it
-      # raises an +ArgumentError+ exception.
-      def add_observer(observer)
-        unless observer.respond_to? :update
-          raise ArgumentError, "observer needs to respond to `update'"
-        end
-        observer_instances << observer
-      end
-
-      # Notify list of observers of a change.
-      def notify_observers(*arg)
-        observer_instances.each { |observer| observer.update(*arg) }
-      end
-
-      # Total number of observers.
-      def count_observers
-        observer_instances.size
-      end
-
-      protected
-        def instantiate_observer(observer) #:nodoc:
-          # string/symbol
-          if observer.respond_to?(:to_sym)
-            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
-          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.notify_observers(method, self)
-      end
-  end
-
-  # == Active Model Observers
-  #
-  # Observer classes respond to life cycle 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.comment("admin@do.com", "New comment was posted", comment).deliver
-  #     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 <tt>Observer.observe</tt>
-  # 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.
-  #
-  # If you're using an Observer in a Rails application with Active Record, be sure to
-  # read about the necessary configuration in the documentation for
-  # ActiveRecord::Observer.
-  #
-  class Observer
-    include Singleton
-    extend ActiveSupport::DescendantsTracker
-
-    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 }
-        redefine_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
-      #       [Account, Balance]
-      #     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 and
-    # the observer is enabled for the given object's class.
-    def update(observed_method, object, &block) #:nodoc:
-      return unless respond_to?(observed_method)
-      return if disabled_for?(object)
-      send(observed_method, object, &block)
-    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
-
-      def disabled_for?(object)
-        klass = object.class
-        return false unless klass.respond_to?(:observers)
-        klass.observers.disabled_for?(self)
-      end
-  end
-end