active_layer 0.0.9

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# Version 0.0.9
+	* Completed the initial scope including the following layers persistence, validations, and attribute guarding

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Adam Cooper
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+# ActiveLayer
+
+ActiveLayer provides validations, attribute filtering, and persistence in a layer sitting on top of a model.
+
+This was born out of frustration with overly complex ActiveRecord validations and model contortions.
+
+# Quick Example
+
+		class User < ActiveRecord::Base; end
+		# Every user field you want.. 
+		
+		# This layer uses the ActiveRecord adapter which pulls in several other pieces
+		class UserLayer
+			include ActiveLayer::ActiveRecord
+			
+			attr_accessible :name, :email, :address
+			
+			validates :name, :email, :presence => true
+			validates :address_validation
+			
+			before_validate :normalize_address
+			
+			def normalize_address; end
+			def address_validation
+				errors.add(:address, :invalid) if address.blank?
+			end
+		end
+		
+		# Now how to use it:
+		user = User.find(1)
+		layer = UserLayer.new(user)
+		layer.update_attributes( {:name => '', :admin => true, :address => 'on a busy road'} )   # => false
+		layer.errors[:name].present # => true
+		user.errors[:name].present => true
+		user.admin  # => false   - was filtered out
+		
+# Some of the players
+
+ * ActiveLayer::Proxy
+ * ActiveLayer::Validations
+ * ActiveLayer::Attributes
+ * ActiveLayer::Persistence
+
+# ActiveLayer::Proxy
+
+This module provides the ability to delegate method calls down to the object and typically you would not use this element directly.  However, it does provide one key method *active__layer__object* which provides access to the underlying object/model.  This may be necessary in certain cases.
+
+# ActiveLayer::Validations
+
+Currently the majority of the functionality resides in this module and provides the ability for composable validation classes to be layered together.  This module is completely compatible with the wonderful ActiveModel::Validation module and in fact just wraps it and provides extra functionality.
+
+Currently the following is supported:
+
+ * Standard ActiveModel::Validators support (Each, With, Custom, etc.)
+ * Custom validation methods
+ * before_validation and after_validation hooks  (Just like ActiveRecord)
+ * Nested ActiveLayer validations  (This is neat!)
+ * All existing custom validators should 'just work'
+
+## Examples
+
+		class AddressValidator
+			include ActiveLayer::Validations
+
+			before_validation :normalize_address
+			validates :address, :presence => true
+			validate :custom_method
+	
+			def normalize_address; end
+			def custom_method; end
+		end
+		
+		class EmailValidator
+			include ActiveLayer::Validations
+			
+			validates :email, :presence => true
+		end
+
+		class UserValidator
+			include ActiveLayer::Validations
+			
+			validates :name, :presence => true
+			validates_with EmailValidator 
+			validates_with AddressValidator, :attributes => [:addresses]
+		end
+		
+		# the EmailValidator will get passed the user object
+		# the AddressValidator will get passed each address of the user and merge the errors back up
+		user = User.find(1)
+		validator = UserValidator.new(user)
+		validator.valid?   # => true/false
+		
+		
+# ActiveLayer::Attributes
+
+This module provides the ability to bulk assign attributes with attribute protection via att_accessible.  By default all attributes are not assignable and you must declare which attributes are accessible.  Note, each attribute is available for individual assigning or reading.
+
+## Examples
+
+		class FlawedUserFilter
+			all_attributes_accessible!
+			# All attributes are now assignable
+		end
+		
+		class UserFilter
+			attr_accessible :name, :address
+		end
+		
+		user = User.find(1)
+		filter = UserFilter.new(user)
+		filter.attributes = {:name => 'Bob', 'admin' => true}
+		user.admin  #  => false
+		
+
+
+
+# ActiveLayer::Persistence
+
+This layer is responsible for providing the save and update_attributes methods that function very similar to ActiveRecord.  Both layers invoke the validations in the layer, if currently mixed in and ultimately delegate to the proxy object for saving.  If the Attributes module is mixed in then the guards will be used however, if it is not mixed then active_layer_object.attributes=(hash) will be invoked.
+
+ Note: If you plan to use Persistence with Attributes then you must mix-in the Attributes module *after* the Persistence module
+
+## Examples
+
+		class UserPersistor
+			include ActiveLayer::Persistence
+		end
+	
+		user = User.find(1)
+		persistor = UserPersistor.new(user)
+		persistor.save
+		persistor.save!  # will raise an ActiveLayer::RecordInvalidError with a #record method
+		persistor.update_attributes(:name => 'new')
+		persistor.update_attributes!(:name => 'new')
+
+
+
+# TODO / Plans
+
+ * Ensure that the valid? method calls the underlying proxy object.valid?
+ * Nested attribute support - similar to Rails - but in an adaptable manner for use in other ORMs
+ * Add support for additional ORMs
+ * Ideas?
+
+# License
+
+ActiveLayer is available under the terms of the MIT license (see
+LICENSE.txt for details).
+

data/lib/active_layer/active_record/persistence.rb

@@ -0,0 +1,29 @@
+require 'activerecord'
+
+module ActiveLayer
+  module ActiveRecord
+    # override the initialize because the submodels should handle their own translations
+    # This will allow drop in compatibility with existing functionality
+    class RecordInvalidError < ::ActiveRecord::RecordInvalidError
+      attr_reader :record
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(", "))
+      end
+    end
+
+    module Persistence
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+
+        def save!
+          unless save
+            raise RecordInvalidError.new(self)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_layer/active_record.rb

@@ -0,0 +1,16 @@
+module ActiveLayer
+  # This is a helper module that is only responsible for pulling in all the modules
+  module ActiveRecord
+    autoload :Persistence, 'active_layer/active_record/persistence'
+
+    extend ActiveSupport::Concern
+
+    include ::ActiveLayer::Validations
+    include ::ActiveLayer::Persistence 
+    include ::ActiveLayer::Attributes  # hook in after the Persistence layer
+
+    # we only need this if ActiveRecord is actually defined.
+    include ::ActiveLayer::ActiveRecord::Persistence if defined?(::ActiveRecord)
+    
+  end
+end

data/lib/active_layer/attributes.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/keys'
+
+module ActiveLayer
+  class UnknownAttributeError < StandardError; end
+
+  # Adds the ability to pass attributes to the ActiveLayer Object.
+  #  - Provides support for 'attr_accessible' class method to only allow certain attributes through
+  #      - By default all attributes are filter out -> opt in model
+  #      - You can enable all attributes passed through with 'all_attributes_accessible!'
+  #  - Hooks into the ActiveLayer::Persistence module to tie in with the update_attributes
+  #      - To enable this functionality, it must be inluded after the Persistence module
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveLayer::Proxy
+
+    included do
+      class_attribute :accessible_attributes
+      self.accessible_attributes = []
+    end
+    
+    module ClassMethods
+      def attr_accessible(*attributes)
+        self.accessible_attributes = Set.new(attributes.map(&:to_s)) + (accessible_attributes || [])
+      end
+      
+      def all_attributes_accessible!
+        self.accessible_attributes = nil
+      end
+      
+    end
+    
+    module InstanceMethods
+
+      def attributes=(new_attributes)
+        return if new_attributes.nil?
+        attributes = new_attributes.stringify_keys
+
+        safe_attributes = if accessible_attributes.nil? 
+          attributes
+        else
+          attributes.reject { |key, value| !accessible_attributes.include?(key.gsub(/\(.+/, "")) }
+        end
+        
+        safe_attributes.each do |k, v|
+          respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(UnknownAttributeError, "unknown attribute: #{k}")
+        end
+      end
+      
+      # override persistence saving to pull in the guard functionality
+      def active_layer_attributes_setting(new_attributes)
+        attributes = new_attributes
+      end
+      
+      
+    end # InstanceMethods
+  end # Attributes
+end # ActiveLayer

data/lib/active_layer/orm/active_record_hooks.rb

@@ -0,0 +1,4 @@
+module ActiveLayer
+  class RecordNotSaved < ::ActiveRecord::RecordNotSaved
+  end
+end

data/lib/active_layer/persistence.rb

@@ -0,0 +1,68 @@
+module ActiveLayer
+  # This module introduces save and update_attribute methods delegating to the proxy object
+  #
+  # This module provides two hook methods to allow the including class to control how the attributes get set on the proxy object
+  # and how the proxy object gets saved.
+  #
+  # Here are the defaults
+  # 
+  #     def active_layer_save
+  #       active_layer_object.save
+  #     end
+  # 
+  #     def active_layer_attributes_setting(new_attributes)
+  #       active_layer_object.attributes = new_attributes
+  #     end
+  # 
+  module Persistence
+    extend ActiveSupport::Concern
+    include ActiveLayer::Proxy
+    
+    module InstanceMethods
+      def save
+        valid = self.respond_to?(:valid?, false) ? valid? : true
+
+        if valid
+          active_layer_save
+        else
+          false
+        end
+      end
+      
+      def save!
+        unless save
+          raise RecordInvalidError.new(self)
+        end
+      end
+      
+      def update_attributes(new_attributes)
+        active_layer_attributes_setting(new_attributes)
+        save
+      end
+
+      def update_attributes!(new_attributes)
+        active_layer_attributes_setting(new_attributes)
+        save!
+      end
+
+      # hook method to override saving behaviour
+      def active_layer_save
+        active_layer_object.save
+      end
+      
+      # another hook method to control attributes=
+      def active_layer_attributes_setting(new_attributes)
+        active_layer_object.attributes = new_attributes
+      end
+      
+    end
+  end
+
+  class RecordInvalidError < RuntimeError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super(@record.errors.full_messages.join(", "))
+    end
+  end
+end

data/lib/active_layer/proxy.rb

@@ -0,0 +1,47 @@
+module ActiveLayer
+  # This class provides the delegation to the actual object.
+  # You probably don't want to use this object directly but rather the other classes depend on it.
+  module Proxy
+    extend ActiveSupport::Concern
+    
+    included do
+      attr_writer :active_layer_object
+    end
+    
+    module InstanceMethods
+      def initialize(*args, &block)
+        self.active_layer_object = args.first
+        super()
+      end  
+      
+      def active_layer_object
+        raise "active_layer_object was not set" if @active_layer_object.nil?
+        @active_layer_object
+      end
+      
+      def method_missing(method, *args, &block)
+        # puts "passing: #{method} + #{args.inspect} to #{active_layer_object.inspect}"
+        unless @active_layer_object.nil?
+          active_layer_object.send(method, *args, &block)
+        else
+          super
+        end
+      end
+      
+      def read_attribute_for_validation(key)
+        if active_layer_object.respond_to?(:read_attribute_for_validation)
+          active_layer_object.read_attribute_for_validation(key)
+        else
+          active_layer_object.send(key)
+        end
+      end
+    
+      def respond_to?(method, use_proxy = true)
+        super(method) || ( use_proxy && @active_layer_object && @active_layer_object.respond_to?(method) )
+      end
+      
+      
+    end
+    
+  end
+end

data/lib/active_layer/validations/each_validator.rb

@@ -0,0 +1,32 @@
+module ActiveLayer
+  module Validations
+    #
+    # This class hooks into the standard validations and allows the new ActiveLayer::Validations to function 
+    # as a NestedValidator
+    # 
+    #     class MyValidator
+    #        include AciveLayer::Validations
+    #        validates MyOtherValidator, :attributes => :sub_models
+    #     end
+    #
+    #   In the above case this class will be used to adapt the MyOtherValidator to look like an ActiveModel::Validator
+    #
+    class EachValidator < ActiveModel::EachValidator
+      attr_accessor :active_layer_validator
+
+      #
+      # The parent_validations will be the parent class that has mixed in the ActiveLayer::Validations module
+      #
+      def validate_each(parent_validations, attribute, value)
+        nested_attribute = parent_validations.read_attribute_for_validation(attribute)
+
+        Array.wrap(nested_attribute).each do |element|
+          active_layer_validator.active_layer_object = element
+          active_layer_validator.valid?
+          parent_validations.merge_errors(active_layer_validator.errors, "#{attribute}.")
+        end
+      end
+  
+    end  
+  end
+end

data/lib/active_layer/validations/object_validator.rb

@@ -0,0 +1,19 @@
+#
+# This class hooks into the standard validations and allows the new ModelValidator to function 
+# as a NestedValidator
+#
+module ActiveLayer
+  module Validations
+    class ObjectValidator < ActiveModel::Validator
+      attr_accessor :active_layer_validator
+
+      def validate(record)
+        # need to save the original errors because they get wiped during validation
+        record.keep_errors do
+          active_layer_validator.active_layer_object = record
+          active_layer_validator.valid?
+        end
+      end
+    end  
+  end
+end

data/lib/active_layer/validations/validator.rb

@@ -0,0 +1,64 @@
+module ActiveLayer
+  module Validations
+    # This module allows the ActiveLayer::Validations class to adapt to become
+    # an ActiveModel Validator
+    module Validator
+      extend ActiveSupport::Concern
+      
+      included do
+        attr_accessor :_validator
+      end
+      
+      module InstanceMethods
+
+        def initialize(*args, &block)
+          if args.first.is_a?(Hash)
+            options = args.first
+            if options.has_key?(:attributes)
+              self._validator = EachValidator.new(options)
+            else
+              self._validator = ObjectValidator.new(options)
+            end
+            _validator.active_layer_validator = self
+          end
+          super 
+        end
+
+        # adapter methods
+        def setup(record)
+          # nothing to do...
+        end
+
+        # adapter methods
+        def attributes
+          _validator && _validator.respond_to?(:attributes) ? _validator.attributes : []
+        end
+
+        def errors
+          if _validator
+            @errors ||= ActiveModel::Errors.new(self)
+          else
+            super
+          end
+        end
+        
+        # This method is called in two contexts, as part of the validation callbacks when it's setup
+        # as an adapter and to register a standard callback
+        #
+        def validate(*args, &block)
+          # puts "calling validate on #{self.class.name}"
+          if _validator
+            _validator.validate(*args, &block)
+          else
+            super
+          end
+        end
+        
+
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/active_layer/validations.rb

@@ -0,0 +1,54 @@
+module ActiveLayer
+  module Validations
+    autoload :Validator, 'active_layer/validations/validator'
+    autoload :EachValidator, 'active_layer/validations/each_validator'
+    autoload :ObjectValidator, 'active_layer/validations/object_validator'
+
+    extend ActiveSupport::Concern
+    include ActiveLayer::Proxy
+    include ActiveModel::Validations
+    include ActiveLayer::Validations::Validator
+    
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :validation
+    end
+
+    module InstanceMethods
+     
+      # model validation methods
+      def errors
+        if active_layer_object.respond_to?(:errors)
+          active_layer_object.errors
+        else
+          super
+        end
+      end
+
+
+      def keep_errors(prefix = "")
+        original_errors = errors.dup
+        result = yield
+        merge_errors(original_errors, prefix)
+        result
+      end
+
+      def merge_errors(other_errors, prefix = nil)
+        other_errors.each do |child_attribute, message|
+          attribute = "#{prefix}#{child_attribute}"
+          errors[attribute] << message
+          errors[attribute].uniq!
+        end
+      end
+
+      def valid?(*)
+        _run_validation_callbacks do
+          super
+          #keep_errors { active_layer_object.valid? }
+        end
+      end
+    
+    end
+
+  end  # Validations
+end # ActiveLayer

data/lib/active_layer/version.rb

@@ -0,0 +1,3 @@
+module ActiveLayer
+  VERSION = "0.0.9"
+end

data/lib/active_layer.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_model'
+require 'active_layer/version'
+
+module ActiveLayer
+  autoload :ActiveRecord, 'active_layer/active_record'
+  autoload :Attributes, 'active_layer/attributes'
+  autoload :Persistence, 'active_layer/persistence'
+  autoload :Proxy, 'active_layer/proxy'
+  autoload :Validations, 'active_layer/validations'
+end
+

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: active_layer
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 9
+  version: 0.0.9
+platform: ruby
+authors: 
+- Adam Cooper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: -1848230021
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta3
+        version: 3.0.0.beta3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: -1848230021
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta3
+        version: 3.0.0.beta3
+  type: :runtime
+  version_requirements: *id002
+description: Subscribing to single responsibility principility ActiveLayer aims to provide a layer of context over top a model.
+email: 
+- adam.cooper@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/active_layer/active_record/persistence.rb
+- lib/active_layer/active_record.rb
+- lib/active_layer/attributes.rb
+- lib/active_layer/orm/active_record_hooks.rb
+- lib/active_layer/persistence.rb
+- lib/active_layer/proxy.rb
+- lib/active_layer/validations/each_validator.rb
+- lib/active_layer/validations/object_validator.rb
+- lib/active_layer/validations/validator.rb
+- lib/active_layer/validations.rb
+- lib/active_layer/version.rb
+- lib/active_layer.rb
+- LICENSE
+- CHANGELOG.md
+- README.md
+has_rdoc: true
+homepage: http://github.com/adamcooper/active_layer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: active_layer
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ActiveLayer provides validations, attribute filtering, and persistence in a layer sitting on top of any model.
+test_files: []
+