simple_model 1.1.1 → 1.2.0

data/.gitignore

@@ -3,3 +3,4 @@ pkg/*
 .bundle
 .DS_Store
 nbproject/
+Gemfile.lock

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Joshua T. Mckinney
+Copyright (c) 2010-2012 Joshua T. Mckinney
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -87,13 +87,50 @@ SimpleModel is available through [Rubygems](http://rubygems.org/gems/simple_mode
         item.changes            # => {"price"=>[#<BigDecimal:7fc61b250da8,'0.1E2',9(27)>, #<BigDecimal:7fc61b1ba600,'0.1024E4',9(27)>]}
         item.my_array           # => []
         item.valid?             # => false
+        items.save!             # raises SimpleModel::ValidationError exception
         item.my_array           # => [1]
         item.price = 15 
+        item.persisted?         # => false
         item.save               # => true
+        item.persisted?         # => true
         item.changed?           # => false
         item.previous_changes   # => {"price"=>[#<BigDecimal:7fc61b1ba600,'0.1024E4',9(27)>, #<BigDecimal:7fc61b1730e8,'0.15E2',9(27)>], "saved"=>[nil, true]} 
-                        
 
+### Rails Session Modeling                        
+      require 'simple_model'
+
+        class SessionUser < SimpleModel::Base
+          has_attributes :permissions, :default => []
+          
+          # Returns true only if all required permission are set
+          def authorized?(*required_permissions)
+            (permissions == (required_permissions | permissions))
+          end
+
+           #... lots of other handy methods...#
+        end
+
+        class ApplicationController < ActionController::Base
+          #... omitted for space ...#
+          # Initialize, if necessary, and return our session user object
+          def session_user
+            session[:user] ||= {:permissions => [:foo,:baz]}
+            @session_user  ||= SessionUser.new_with_store(session[:user])
+          end
+          helper_method :session_user
+
+          private
+
+          # redirect if not authorized
+          def authorize(*required_permissions)
+            redirect_to '/sessions/error' unless session_user.authorized?(*required_permissions)
+          end
+        end
+
+        class FoosController < ApplicationController
+          before_filter do |c| c.send(:authorize,:foo) # Make sure session user has permission
+        end
+        
 
 ## Contributing to simple_model
  
@@ -105,6 +142,10 @@ SimpleModel is available through [Rubygems](http://rubygems.org/gems/simple_mode
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
+## Notes
+
+Release 1.2+ no longer create instance variables, just uses the attributes hash as the data store.
+
 ## Thanks
 
 Code based on Rails/ActiveRecord and [Appoxy/SimpleRecord](https://github.com/appoxy/simple_record)

data/lib/simple_model/attributes.rb

@@ -1,175 +1,184 @@
+require 'simple_model/exceptions'
 module SimpleModel
-  # require all that active support we know and love
-  require 'active_support/core_ext/array/extract_options'
-  require 'active_support/core_ext/object/blank'
-  
   module Attributes
     include ExtendCore
     extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
-    #Set attribute values to those supplied at initialization
-    def initialize(*attrs)
-      set_attributes(attrs.extract_options!)
+    include ActiveModel::AttributeMethods 
+    
+    def initialize(*attrs)     
+      attrs = attrs.extract_options! 
+      set(attributes_with_for_init(attrs))
     end
-
-    # Place to store set attributes and their values
+    
+    # Returns true if attribute has been initialized
+    def initialized?(attr)
+      attributes.key?(attr.to_sym)
+    end
+    
     def attributes
-      @attributes ||= {}
-      @attributes
+      @attributes ||= HashWithIndifferentAccess.new
     end
+      
+    def attributes=attrs
+      @attributes = attrs
+    end
+  
+    def get(attr)
+      self.send(attr)
+    end 
+    alias :read :get
 
-    def set_attributes(attrs)
-      attrs.each do |attr|
-        self.send("#{attr[0].to_sym}=",attr[1])
+    # Accepts a hash where the keys are methods and the values are values to be set.
+    # set(:foo => "bar", :dime => 0.1)
+    def set(*attrs)
+      attrs.extract_options!.each do |attr,val|
+        self.send("#{attr.to_s}=",val)
       end
     end
+    alias :set_attributes :set
     
-    # Hook to run method after attribute is converted but before it is set
-    def before_attribute_set(method,val)   
-    end
+    private
     
-    alias :update_attributes :set_attributes
-
-    def self.included(base)
-      base.extend(ClassMethods)
+    def fetch_default_value(arg)
+      return self.send(arg) if (arg.is_a?(Symbol) && self.respond_to?(arg))
+      arg
     end
     
-    def fetch_default 
+    # Returns attribute that have defaults in a hash: {:attrbute => "default value"}
+    def attributes_with_for_init(attrs)
+      d = attrs.with_indifferent_access
+      self.class.defined_attributes.each do |k,v|
+        d[k] = fetch_default_value(v[:default]) if (d[k].blank? && v[:default] && v[:initialize])
+      end
+      d
     end
     
- 
-    module ClassMethods
-      
-      # Hook to call class method after attribute method definitions
-      def after_attribute_definition(attr)  
+    module ClassMethods    
+      # Creates a new instance where the attributes store is set to object
+      # provided, which allows one to pass a session store hash or any other
+      # hash-like object to be used for persistance. Typically used for modeling
+      # session stores for authorization or shopping carts
+      # EX: 
+      #     class ApplicationController < ActionController::Base
+      #       def session_user
+      #         session[:user] ||= {}
+      #         @session_user ||= SessionUser.new_with_store(session[:user])
+      #       end
+      #       helper_method :session_user
+      #     end
+      #
+      def new_with_store(session_hash)
+        new = self.new()
+        new.attributes = session_hash
+        new.set(new.send(:attributes_with_for_init,session_hash))
+        new
       end
       
-      # Defines a reader method that returns a default value if current value
-      # is nil, if :default is present in the options hash
-      def define_reader_with_options(attr,options)
-        if options.has_key?(:default)
-          define_method(attr.to_s) do
-            default = (options[:default].is_a?(Symbol) ? self.send(options[:default]) : options[:default])
-            val = instance_variable_get("@#{attr.to_s}")    
-            val = default unless instance_variable_defined?("@#{attr.to_s}")
-            val
-          end
-        else
-          attr_reader attr 
-        end
+      def defined_attributes
+        @defined_attributes ||= {}
       end
       
-      def define_setter(attr,cast_methods)
-        define_method("#{attr.to_s}=") do |val|
-          val = val.cast_to(cast_methods)
-          before_attribute_set(attr,val)
-          instance_variable_set("@#{attr}", val)
-          attributes[attr] = val
-          val
-        end
+      def defined_attributes=defined_attributes
+        @defined_attributes = defined_attributes
       end
       
-      # Builder for attribute methods
-      def build_attribute_methods(attr,options={},cast_methods=[])
-        define_reader_with_options(attr,options)
-        define_setter(attr,cast_methods)
-        after_attribute_definition attr
+      # The default settings for a SimpeModel class
+      # Options:
+      # * :on_set - accepts a lambda that is run when an attribute is set
+      # * :on_get - accepts a lambda that is run when you get/read an attribute
+      # * :default - the default value for the attribute, can be a symbol that is sent for a method
+      # * :initialize - informations the object whether or not it should initialize the attribute with :default value, defaults to true
+      # ** If :intialize is set to false you must set :allow_blank to false or it will never set the default value
+      # * :allow_blank - when set to false, if an attributes value is blank attempts to set the default value, defaults to true
+      def default_attribute_settings
+        @default_attribute_settings ||= {:attributes_method => :attributes,
+          :on_set => lambda {|obj,attr| attr},
+          :on_get => lambda {|obj,attr| attr},
+          :allow_blank => true,
+          :initialize => true
+        }
       end
-          
-      # Left this use a module eval for reference, saw no noticable improvement
-      # in speed, so I would rather use code than strings for now
-#      def define_setter_with_eval(attr,cast_methods)
-#        module_eval <<-STR, __FILE__, __LINE__
-#          def #{attr.to_s}=#{attr.to_s}
-#              val = #{attr.to_s}.cast_to(#{cast_methods})
-#              before_attribute_set(:#{attr.to_s},val)
-#              @#{attr.to_s} = val
-#              attributes[:#{attr.to_s}] = val
-#              val
-#          end
-#        STR
-#      end
       
-      #creates setter and getter datatype special attribute
-      def has_attributes(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options)
-        end
+      def default_attribute_settings=default_attribute_settings
+        @default_attribute_settings = default_attribute_settings
       end
-      alias :has_attribute :has_attributes
-
-      # Creates setter and getter methods for boolean attributes
-      def has_booleans(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|                 
-          build_attribute_methods(attr,options,[:to_s,:to_b])
-          define_method ("#{attr.to_s}?") do
-            send("#{attr.to_s}".to_sym).to_s.to_b
-          end
-        end
+    
+      def add_defined_attribute(attr,options)
+        self.defined_attributes[attr] = options
+        define_attribute_methods self.defined_attributes.keys
       end
-      alias :has_boolean :has_booleans
-
-      # Creates setter and getter methods for integer attributes
-      def has_ints(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_i])
+      
+      # builds the setter and getter methods
+      def create_attribute_methods(attributes,options)
+        unless attributes.blank?  
+          attributes.each do |attr|
+            define_reader_with_options(attr,options)
+            define_setter_with_options(attr,options)
+          end
         end
       end
-      alias :has_int :has_ints
-
-      # Creates setter and getter methods for currency attributes
-      # attributes are cast to BigDecimal and rounded to nearest cent
-      # #Warning, rounding occurs on all sets, so if you need to keep higher prescsion
-      # use has_decimals
-      def has_currency(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_s,:to_currency])
-
+      
+      def define_reader_with_options(attr,options)
+        add_defined_attribute(attr,options)
+        options = default_attribute_settings.merge(options) if options[:on_get].blank?
+        define_method(attr) do
+          if (options.key?(:default) && (!self.initialized?(attr) || (!options[:allow_blank] && self.attributes[attr].blank?)))
+            self.attributes[attr] = fetch_default_value(options[:default])
+          end
+          options[:on_get].call(self,self.attributes[attr])
         end
-      end
-
-      def has_decimals(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_f,:to_d])
-
+        define_method("#{attr.to_s}?") do
+          val = self.send(attr)
+          if val.respond_to?(:to_b)
+            val = val.to_b 
+          else
+            val = !val.blank? if val.respond_to?(:blank?)
+          end
+          val
         end
       end
-      alias :has_decimal :has_decimals
-
-      # Creates setter and getter methods for float attributes
-      def has_floats(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_f])
-
+          
+      def define_setter_with_options(attr,options)
+        add_defined_attribute(attr,options)
+        options = default_attribute_settings.merge(options) if (options[:on_set].blank? || options[:after_set].blank?) 
+        define_method("#{attr.to_s}=") do |val|
+          val = fetch_default_value(options[:default]) if (!options[:allow_blank] && options.key?(:default) && val.blank?)
+          begin   
+            val = options[:on_set].call(self,val)
+          rescue NoMethodError => e
+            raise ArgumentError, "#{val} could not be set for #{attr}: #{e.message}"
+          end
+          will_change = "#{attr}_will_change!".to_sym
+          self.send(will_change) if (self.respond_to?(will_change) && val != self.attributes[attr])          
+          self.attributes[attr] = val
+          options[:after_set].call(self,val) if options[:after_set] 
         end
       end
-      alias :has_float :has_floats
+    
+      AVAILABLE_ATTRIBUTE_METHODS = {
+        :has_attribute => {:alias => :has_attributes},
+        :has_boolean  => {:cast_to => :to_b, :alias => :has_booleans},
+        :has_currency => {:cast_to => :to_d, :alias => :has_currencies},
+        :has_date => {:cast_to => :to_date, :alias => :has_dates}, 
+        :has_decimal  => {:cast_to => :to_d, :alias => :has_decimals},    
+        :has_float => {:cast_to => :to_f, :alias => :has_floats}, 
+        :has_int => {:cast_to => :to_i, :alias => :has_ints},
+        :has_time => {:cast_to => :to_time, :alias => :has_times}  
+      }
       
-      # Creates setter and getter methods for date attributes
-      def has_dates(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_s,:to_date])
-
+      AVAILABLE_ATTRIBUTE_METHODS.each do |method,method_options|   
+        define_method(method) do |*attributes|
+          options = default_attribute_settings.merge(attributes.extract_options!)
+          options[:on_set] = lambda {|obj,val| val.send(method_options[:cast_to]) } if method_options[:cast_to]
+          create_attribute_methods(attributes,options)
         end
+        module_eval("alias #{method_options[:alias]} #{method}")
       end
-      alias :has_date :has_dates
-      
-      # Creates setter and getter methods for time attributes
-      def has_times(*attrs)
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          build_attribute_methods(attr,options,[:to_s,:to_time])
-
-        end
-      end 
-      alias :has_time :has_times
+    end
+    
+    def self.included(base)
+      base.extend(Attributes::ClassMethods)
+      base.send(:include, ActiveModel::Dirty) if base.is_a?(Class) # Add Dirty to the class
     end
   end
-end
+end

data/lib/simple_model/base.rb

@@ -18,19 +18,22 @@ module SimpleModel
 
   # == SimpleModel::Base
   #
-  # Provides an interface for any class to build tabless models.
+  # Provides an interface for any class to build tableless models.
   # 
   # Implements Validations, Callbacks and Dirty from ActiveModel, and datatype specific
-  # attribute definitions with default options
+  # attribute definitions with default options. SimpleModel::Base is intended as
+  # an example, while it may be used in production, which it is on many of my apps
+  # today, it is recommend you use SimpleModel::Base as an example to implement your
+  # own model actions.
   # 
   # == SimpleModel Actions:
   # 
   # Model actions provide a tool for making use of Active Model callbacks. Each
   # action creates an instance method representing the action, which calls the 
-  # method(s) listed as symbolswhen defining the actions. Model actions also accept 
+  # method(s) listed as symbols when defining the actions. Model actions also accept 
   # a rollback option, which is called if the action fails. If you plan to 
-  # implement SimpleModel's actions make avoid naming you own methods "save", "destory",
-  # "create", and "update", as this will override the methods defined by action.
+  # implement SimpleModel's actions, avoid naming you own methods "save", "destroy",
+  # "create", and "update", as these will override the methods defined by action.
   # 
   # Available Actions:
   #   # save
@@ -53,7 +56,7 @@ module SimpleModel
   #   has_integers :first_int, :second_int, :default => 1
   #   has_times :now, :default => :get_now
   #   
-  #   save :save_record, :rollback => :rollback
+  #   save :save_record, :rollback => :rollback_save
   # 
   #   def save_record
   #     puts "saved"
@@ -64,37 +67,25 @@ module SimpleModel
   #     Time.now
   #   end
   #   
-  #   def rollback
+  #   def rollback_save
   #     puts "rolled back"
   #   end
   # end
-  # 
-  # 
-  #
  
   class Base
     include SimpleModel::Attributes
     include SimpleModel::ErrorHelpers
-
     #Use ActiveModel Resources
     include ActiveModel::Validations
     include ActiveModel::Conversion
     extend ActiveModel::Naming
     extend ActiveModel::Callbacks
     include ActiveModel::Validations::Callbacks
-    include ActiveModel::Dirty
     
     define_model_callbacks :save, :update, :create, :destroy
     
     class << self
       
-      # Collect methods as they are defined, then add to define_attribute_methods
-      def after_attribute_definition(method)
-        @defined_attribute_methods ||= []
-        @defined_attribute_methods << method
-        define_attribute_methods @defined_attribute_methods
-      end
-      
       def save(*methods)
         define_model_action(methods,:save)
       end
@@ -107,54 +98,48 @@ module SimpleModel
         define_model_action(methods,:update)
       end
       
-      #Destroy does not run normal validation by default.
+      # Destroy does not run normal validation in Rails, but with this we can if we choose to.
       def destroy(*methods)   
         define_model_action(methods,:destroy, {:validate => false})
       end     
     end
     
-    has_boolean :saved
+    has_boolean :persisted
     has_boolean :new_record, :default => true
-    attr_accessor :id
-    
-    def persisted?
-      saved?
-    end
-    
-    def before_attribute_set(method,val)
-      change_methods_str = "#{method.to_s}_will_change!".to_sym
-      send(change_methods_str) if val != instance_variable_get("@#{method.to_s}") && self.respond_to?(change_methods_str.to_sym)
-    end   
-    
+    has_attribute :id # may not be an integer
+    alias :saved? :persisted?
+
     private
       
     # Skeleton for action instance methods
     def run_model_action(methods,options)
       completed = true
-      if !options[:validate] ||
-          (options[:validation_methods] && valid_using_other?(options[:validation_methods])) || 
-          self.valid?
-        
+      if (!options[:validate] || (options[:validation_methods] && valid_using_other?(options[:validation_methods])) || self.valid?)     
         methods.each do |method|
           ran = self.send(method)
           completed = ran unless ran
         end
-        
         if completed
-          self.saved = true
+          self.persisted = true
           @previously_changed = changes
           @changed_attributes.clear    
         else
           self.send(options[:rollback]) unless options[:rollback].blank?
         end    
-      else 
+      else
         completed = false
-      end  
+      end
+      if !completed && options[:raise_exception]      
+        if !self.errors.blank?
+          raise ValidationError, self.errors.full_messages.join(" ")
+        else
+          raise ActionError, "failed action: #{methods.join(', ')}"
+        end
+      end 
       completed
-    end
-    
+    end   
     
-    # Run supplied methods as valdation. Each method should return a boolean
+    # Run supplied methods as validation. Each method should return a boolean
     # If using this option, to see if errors are present use object_name.errors.blank?,
     # otherwise if you run object_name.valid? you will over write the errors 
     # generated here.
@@ -164,17 +149,21 @@ module SimpleModel
         valid = false unless self.send(method)
       end
       valid
-    end
-    
+    end   
     
-    # Defines the model action's instantace methods and applied defaults.
-    # Defines methods with :validate options as true by default.
+    # Defines the model action's instance methods and applied defaults. For every
+    # action defined, we also define that actions ! method which raises exceptions
+    # when the action fails.
     def self.define_model_action(methods,action,default_options={:validate => true})
       default_options.merge!(methods.extract_options!)
-      define_method(action) do |opts={}|
-        options = default_options.merge(opts)
-        self.run_callbacks(action) do  
-          run_model_action(methods,options)
+      actions = [action,"#{action}!".to_sym]
+      actions.each do |a|
+        define_method(a) do |opts={}|
+          options = default_options.merge(opts)
+          options[:raise_exception] = a.to_s.match(/\!$/)
+          self.run_callbacks(action) do  
+            run_model_action(methods,options)
+          end
         end
       end
     end

data/lib/simple_model/exceptions.rb

@@ -0,0 +1,5 @@
+module SimpleModel
+  class ActionError < StandardError; end
+  class ValidationError < StandardError; end
+  class ArgumentError < StandardError; end  
+end