openteam-modest_model 0.1.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Mike Fulcher
+
+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,72 @@
+# ModestModel [![Build Status](https://secure.travis-ci.org/6twenty/modest_model.png)](https://secure.travis-ci.org/6twenty/modest_model.png])
+
+## Overview
+
+Inspired by [Crafting Rails Applications](http://pragprog.com/book/jvrails/crafting-rails-applications), ModestModel provides an ActiveModel-compliant class that allows you to quickly create simple, table-less models. The intended use is to back interactions with external APIs with Ruby-friendly models rather than raw structured data (such as hashes).
+
+**Notice:** we're extending ModestModel's features significantly to give developers more flexibility and freedom when working with table-less models. Some of the upcoming features include:
+
+- **ActiveRecord support:** including simple delegation of methods like `save` and `destroy`, associations (`has_many`, `belongs_to` and friends) and other commonly used ActiveRecord features
+- **Basic objects:** to make working with simple key/value data sets easier and friendlier (think of a blend of a Hash and a Struct bundled with a collection of helpful methods)
+
+## Example
+
+```ruby
+json = MyExternalApi.call('/some/path.json')
+attributes_hash = JSON.decode(json)
+
+# => {'name' => 'Michael', 'email' => 'michael@example.com'}
+
+class SampleModel < ModestModel::Base
+  attributes :name, :email
+end
+
+SampleModel.new(attributes_hash)
+
+# => #<SampleModel @name="Michael"...
+```
+    
+## Installation
+
+ModestModel has been tested and works on MRI 1.8.7 and 1.9.2.
+
+### Rubygems
+
+```ruby
+gem install modest_model
+```
+
+### Bundler
+
+```ruby
+gem 'modest_model'
+```
+
+### Usage
+
+Similar to ActiveRecord models, simply create a class which inherits from `ModestModel::Base`. You'll need to define some attributes - this is achieved by calling the `attributes` method passing in the attribute names you require:
+
+```ruby
+class SampleModel < ModestModel::Base
+  attributes :name, :email
+end
+```
+
+## Features
+
+ModestModel includes the following ActiveModel modules:
+
+* `ActiveModel::Conversion`
+* `ActiveModel::Naming`
+* `ActiveModel::Translation`
+* `ActiveModel::Serialization`
+* `ActiveModel::Validations`
+* `ActiveModel::AttributeMethods`
+
+These allow your ModestModel models to act almost the same as an ActiveRecord model, but without the database. You can mass-assign attributes, add validations, add translations, and call familiar methods like `model_name.human` and `to_json`.
+
+ModestModel was extracted from the Mail Form gem described in chapter 2, "Building Models with Active Model", of [Crafting Rails Applications](http://pragprog.com/book/jvrails/crafting-rails-applications) by Jose Valim. This chapter therefore provides an excellent in-depth explanation of the inner workings of ModestModel.
+
+## Credits
+
+This code has been derived from [Crafting Rails Applications](http://pragprog.com/book/jvrails/crafting-rails-applications) by Jose Valim, so all credit goes to Jose and [Plataforma](http://blog.plataformatec.com.br/) for granting permission to release this gem.

data/Rakefile

@@ -0,0 +1,35 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+  require 'bundler/gem_tasks'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ModestModel'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/modest_model.rb

@@ -0,0 +1,12 @@
+begin
+  require 'active_model'
+rescue LoadError => e
+  retry if require('rubygems')
+end
+
+module ModestModel
+  autoload :Base,         File.expand_path('../modest_model/base', __FILE__)
+  autoload :Validators,   File.expand_path('../modest_model/validators', __FILE__)
+  autoload :CombinedAttr, File.expand_path('../modest_model/combined_attr', __FILE__)
+  autoload :Resource,     File.expand_path('../modest_model/resource', __FILE__)
+end

data/lib/modest_model/base.rb

@@ -0,0 +1,69 @@
+module ModestModel
+  class Base
+    include   ActiveModel::Conversion
+    extend    ActiveModel::Naming
+    extend    ActiveModel::Translation
+    include   ActiveModel::Serialization
+    include   ActiveModel::Validations
+    include   ActiveModel::AttributeMethods
+
+    include   ModestModel::Validators
+    extend    ModestModel::CombinedAttr
+    
+    def initialize(attributes = {}, options={})
+      self.assign_attributes(attributes, options)
+    end
+
+    class_attribute :_attributes
+    self._attributes = []
+
+    attribute_method_prefix 'clear_'
+    attribute_method_suffix '?'
+
+    def self.attributes(*names)
+      attr_accessor *names
+      define_attribute_methods names
+
+      self._attributes += names
+    end
+
+    def attributes
+      self._attributes.inject({}) do |hash, attr|
+        hash[attr.to_s] = send(attr)
+        hash
+      end
+    end
+    
+    def attributes= attributes, options = {}
+      assign_attributes attributes, options = {}
+    end
+    
+    def [] attr
+      attributes[attr.to_s]
+    end
+    
+    def []= attr, val
+      self.send "#{attr}=", val
+    end
+    
+    def persisted?
+      false
+    end
+    
+    protected
+    
+    def assign_attributes attributes, options = {}
+      attributes.each do |attr, value|
+        self[attr] = value
+      end unless attributes.blank?
+    end
+        
+    def clear_attribute(attribute)
+      send("#{attribute}=", nil)
+    end
+
+    def attribute?(attribute)
+      send(attribute).present?
+    end
+  end
+end

data/lib/modest_model/callbacks.rb

@@ -0,0 +1,42 @@
+module ModestModel
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_initialize, :after_find, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+    
+    def found #:nodoc:
+      run_callbacks(:find) { super }
+    end
+
+    def destroy #:nodoc:
+      run_callbacks(:destroy) { super }
+    end
+
+  private
+
+    def create_or_update #:nodoc:
+      run_callbacks(:save) { super }
+    end
+
+    def create #:nodoc:
+      run_callbacks(:create) { super }
+    end
+
+    def update(*) #:nodoc:
+      run_callbacks(:update) { super }
+    end
+  end
+end

data/lib/modest_model/combined_attr.rb

@@ -0,0 +1,9 @@
+module ModestModel
+  module CombinedAttr
+    def attribute *attrs
+      validations = attrs.extract_options!
+      attributes *attrs
+      validates *(attrs +[validations]) if validations.any?
+    end
+  end
+end

data/lib/modest_model/resource.rb

@@ -0,0 +1,9 @@
+module ModestModel
+  autoload :Tenacity,  File.expand_path('../tenacity',  __FILE__)
+  autoload :Callbacks, File.expand_path('../callbacks', __FILE__)
+  
+  class Resource < Base
+    include ModestModel::Tenacity
+    include ModestModel::Callbacks
+  end
+end

data/lib/modest_model/tenacity.rb

@@ -0,0 +1,181 @@
+module ModestModel
+
+  class ResourceNotFound < ::StandardError; end
+  class InvalidResource < ::StandardError; end
+  
+  module Tenacity
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :_find
+      self._find = Proc.new {}
+      
+      class_attribute :_save
+      self._save = Proc.new {}
+      
+      class_attribute :_destroy
+      self._destroy = Proc.new {}
+      
+      class_attribute :primary_key
+      set_primary_key :id
+    end
+    
+    module ClassMethods
+      
+      def undefine_attribute_method attr # :nodoc:
+        self._attributes = self._attributes - [attr]
+        undef_method attr if method_defined? attr
+        undef_method "#{attr}=" if method_defined? "#{attr}="
+      end
+      
+      # Sets the +primary_key+ and its associated attribute
+      def set_primary_key attr
+        undefine_attribute_method :id if attr == :id # Remove id, always
+        if self.primary_key
+          undefine_attribute_method self.primary_key
+          # TODO: remove any validations on the current PK
+          # self._validators.except!(self.primary_key.to_sym)
+        end
+        self.primary_key = attr
+        attributes attr
+        # TODO: add a presence validation on the new PK
+        # validates  attr, :presence => true
+      end
+      
+      # When a block is passed, that block is set to +_find+.
+      # When +id_+ is passed (or no +block+ is passed) a new record is instantiated with the passed +id_+ and the +_find+ block is called.
+      # If the return from the +_find+ block is +nil+ or +false+, a ResourceNotFound error is raised.
+      def find id_=nil, &block
+        if block_given?
+          self._find = block
+        else
+          resource = new(primary_key.to_sym => id_)
+          resource.send(:call_find!) || raise(ModestModel::ResourceNotFound)
+          resource.found
+        end
+      end
+      
+      # TODO - docs
+      def create attributes = nil, options = {}, &block
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, options, &block) }
+        else
+          object = new(attributes, options)
+          yield(object) if block_given?
+          object.save
+          object
+        end
+      end
+      
+      # The passed +block+ is set to +_save+ and called on save
+      def save &block
+        self._save = block if block_given?
+      end
+
+      # The passed +block+ is set to +_destroy+ and called on destroyed
+      def destroy &block
+        self._destroy = block if block_given?
+      end
+    end
+    
+    module InstanceMethods
+      
+      def initialize attributes = {}, options={} #:nodoc:
+        super attributes, options
+        @new_resource = true
+        @destroyed  = false
+      end
+      
+      def found #:nodoc:
+        @new_resource = false
+        return self
+      end      
+      
+      def to_param #:nodoc:
+        send(self.class.primary_key)
+      end
+      
+      def new_resource? #:nodoc:
+        @new_resource
+      end
+      alias :new_record? :new_resource?
+
+      def destroyed? #:nodoc:
+        @destroyed
+      end
+
+      def persisted? #:nodoc:
+        false
+      end
+
+      # Runs the save block and returns true if the operation was successful, false if not
+      def save(*)
+        create_or_update
+      end
+      
+      # Runs the save block and returns true if the operation was successful or raises an InvalidResource error if not
+      def save!(*)
+        create_or_update || raise(ModestModel::InvalidResource)
+      end
+      
+      # Runs the destroy block and sets the resource as destroyed
+      def destroy
+        call_destroy!
+        @destroyed = true
+        return self
+      end
+
+      # Updates a single attribute and calls save.
+      # This is especially useful for boolean flags on existing records. Also note that
+      #
+      # * Validation is skipped.
+      # * Callbacks are invoked.
+      #
+      def update_attribute(name, value)
+        send("#{name.to_s}=", value)
+        save(:validate => false)
+      end
+
+      # Updates the attributes of the model from the passed-in hash and calls save the
+      # will fail and false will be returned.
+      def update_attributes(attributes, options = {})
+        self.assign_attributes(attributes, options)
+        save
+      end
+
+      # Updates its receiver just like +update_attributes+ but calls <tt>save!</tt> instead
+      # of +save+, so an exception is raised if the resource is invalid.
+      def update_attributes!(attributes, options = {})
+        self.assign_attributes(attributes, options)
+        save!
+      end 
+
+      private
+        
+        def create_or_update #:nodoc:
+          valid? ? (new_resource? ? create : update) : false
+        end
+        
+        def create #:nodoc:
+          @new_resource = false
+          call_save!
+        end
+        
+        def update #:nodoc:
+          call_save!
+        end
+        
+        def call_save! #:nodoc:
+          instance_exec &self.class._save
+        end
+
+        def call_find! #:nodoc:
+          instance_exec &self.class._find
+        end
+
+        def call_destroy! #:nodoc:
+          instance_exec &self.class._destroy
+        end
+    end
+  end
+end