attr_default 0.5.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+*.sqlite3
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test/test.sqlite3
+nbproject

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'hobosupport',           '0.9.103', :path => '../web/vendor/gems/hobosupport-0.9.103'
+gem 'hobofields',            '0.9.103', :path => '../web/vendor/gems/hobofields-0.9.103'
+
+# Specify your gem's dependencies in attr_default.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Colin Kelley, RingRevenue
+
+MIT License
+
+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.rdoc

@@ -0,0 +1,106 @@
+= AttrDefault
+
+Dynamic Ruby defaults for ActiveRecord attributes.
+These are lazy evaluated just in time: when first accessed, or just before validation or save.
+This allows dynamic defaults to depend on attributes that are assigned after initialization, or on other dynamic defaults.
+
+Example:
+
+  class User < ActiveRecord::Base
+    attr_default      :middle_name, ''
+    attr_default      :guid, lambda { GuidGenerator.new }
+    attr_default      :managed, lambda { organization.managed? }
+
+    belongs_to :organization
+    ...
+  end
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+  gem 'attr_default'
+
+And then execute:
+
+  $ bundle
+
+Or install it yourself as:
+
+  $ gem install attr_default
+
+== Usage
+
+  require 'attr_default'
+
+This makes the +attr_default+ macro available to all objects derived fromActiveRecord::Base.
+
+=== The attr_default Macro
+
+The +attr_default+ macro takes 2 arguments:
+
+[attr_name]  The name of the attribute, given as a symbol or string.
+[default]    The default value to use, either as a simple value or a Proc. If a Proc, attr_default will call it in the context of the object.
+             This makes it convenient for dynamic defaults to be computed based on other attributes or associations.
+
++attr_default+ can be used for persistent or non-persistent attributes.
+
+=== Timing of Default Computation
+
+Defaults are lazy computed, just in time, whenever the first of these happens:
+
+* The attribute is read.
+* The object's before_validation callback is called.
+* The object's before_save callback is called.
+
+This allows dynamic defaults to depend on other attributes that may be assigned after the initializer, and even other dynamic defaults.
+For example:
+
+  class User < ActiveRecord::Base
+    attr_default      :first_name, 'First'
+    attr_default      :last_name, 'Last'
+    attr_default      :name_addr, lambda { "#{full_name} <#{email}>" }
+
+    def full_name
+      [first_name, middle_name, last_name].select { |name| !name.blank? } * ' '
+    end
+  end
+
+  user1 = User.create :email => 'joe@yahoo.com', :first_name => 'Joe'
+  user1.name_addr # =>  "Joe Last <joe@yahoo.com>"
+
+  user2 = User.create :email => 'jane@yahoo.com'
+  user2.last_name = 'Doe'
+  user2.name_addr # =>  "First Doe <jane@yahoo.com>"
+
+=== Use with Hobofields
+
+With Hobofields, defaults can be set using the +:ruby_default+ option:
+
+  class User < ActiveRecord::Base
+    fields do
+      first_name  :string, :ruby_default => 'First'
+      last_name   :string, :ruby_default => 'Last'
+      email       :string
+      name_addr   :string, :ruby_default => lambda { "#{full_name} <#{email}>" }
+      ...
+    end
+
+    def full_name
+      [first_name, middle_name, last_name].select { |name| name unless name.blank? } * ' '
+    end
+  end
+
+The +:default+ option controls the default in SQL, unless a Ruby Proc is given in which case it is treated as +:ruby_default+.
+
+=== Interaction with +clone+
+
+Dynamic defaults work with +clone+, following the same timing given above.
+
+== Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => :test
+
+desc "Run unit tests."
+task :test do
+  ruby "test/test_attr_default.rb"
+end

data/attr_default.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/attr_default/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.add_dependency 'rake'
+  gem.add_dependency 'rails'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'hobofields'
+  gem.authors       = ["Colin Kelley", "Nick Burwell"]
+  gem.email         = ["colindkelley@gmail.com"]
+  gem.description   = %q{Dynamic Ruby defaults for ActiveRecord attributes}
+  gem.summary       = %q{Dynamic Ruby defaults for ActiveRecord attributes. These are lazy evaluated just in time: when first accessed, or just before validation or save. This allows dynamic defaults to depend on attributes that are assigned after initialization, or on other dynamic defaults.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/.*\.rb})
+  gem.name          = "attr_default"
+  gem.require_paths = ["lib"]
+  gem.version       = AttrDefault::VERSION
+end

data/lib/attr_default.rb

@@ -0,0 +1,88 @@
+module AttrDefault
+  module ClassMethods
+    def attr_default attr_name, default
+      if !method_defined?(:_attr_default_set)
+        include AttrDefault
+      end
+
+      attr_name = attr_name.to_s
+      define_method attr_name do
+        if new_record? && !@_attr_defaults_set_from_clone && !_attr_default_set[attr_name]
+          default_value = Proc === default ? instance_eval(&default) : default.dup
+          send "#{attr_name}=", default_value
+        end
+        read_attribute_with_fixups( attr_name )
+      end
+
+      define_method "#{attr_name}=" do |*args|
+        _attr_default_set[attr_name] = true
+        write_attribute_with_fixups( attr_name, args )
+      end
+
+      touch_proc = lambda { |obj| obj.send(attr_name); true }
+      before_validation   touch_proc
+      before_save         touch_proc
+    end
+
+    # Hobo Fields field declaration
+    def field_added(name, type, args, options)
+      if (default = options[:ruby_default]) && Proc === default
+        attr_default name, default
+      elsif (default = options[:default]) && Proc === default
+        attr_default name, default
+        options.delete(:default)
+        options[:ruby_default] = default
+      end
+    end
+  end
+
+  def _attr_default_set
+    @_attr_default_set ||= {}
+  end
+
+  def read_attribute_with_fixups(attr_name)
+    if needs_time_zone_fixup?(attr_name)
+      cached = @attributes_cache[attr_name] and return cached
+      time = read_attribute(attr_name)
+      @attributes_cache[attr_name] = time.acts_like?(:time) ? time.in_time_zone : time
+    else
+      read_attribute(attr_name)
+    end
+  end
+
+  def write_attribute_with_fixups(attr_name, args)
+    if needs_time_zone_fixup?(attr_name)
+      time = args.first
+      unless time.acts_like?(:time)
+        time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
+      end
+      time = time.in_time_zone rescue nil if time
+      write_attribute(attr_name, time)
+    else
+      write_attribute(attr_name, *args)
+    end
+  end
+
+  def needs_time_zone_fixup?(attr_name)
+    self.class.send(:create_time_zone_conversion_attribute?, attr_name, self.class.columns_hash[attr_name])
+  end
+
+  def clone
+    result = super
+    result.created_at = nil unless !result.class.columns_hash.has_key?('created_at')
+    result.updated_at = nil unless !result.class.columns_hash.has_key?('updated_at')
+    if self.new_record?
+      result.instance_variable_set(:@_attr_default_set, self._attr_default_set.dup)
+    else
+      result.instance_variable_set(:@_attr_defaults_set_from_clone, true)
+    end
+    result
+  end
+end
+
+if defined?(Rails::Railtie)
+  require 'attr_default/railtie'
+else
+  # Rails 2 initialization
+  ActiveRecord::Base.extend(AttrDefault::ClassMethods)
+end

data/lib/attr_default/version.rb

@@ -0,0 +1,3 @@
+module AttrDefault
+  VERSION = "0.5.0"
+end

data/test/test_attr_default.rb

@@ -0,0 +1,255 @@
+WANT_RAILS_VERSION = "~> #{ENV.fetch('WANT_RAILS_VERSION', '2.3.4')}"
+
+require 'rubygems'
+gem 'rails', WANT_RAILS_VERSION
+gem 'activerecord', WANT_RAILS_VERSION
+begin
+  require 'rails/railtie'
+rescue LoadError
+end
+require 'active_record'
+ActiveRecord::ActiveRecordError # work-around from https://rails.lighthouseapp.com/projects/8994/tickets/2577-when-using-activerecordassociations-outside-of-rails-a-nameerror-is-thrown
+require 'test/unit'
+require 'active_support/dependencies'
+require 'active_support/core_ext/logger'
+require 'hobofields' if ENV['INCLUDE_HOBO']
+
+$LOAD_PATH.unshift File.expand_path("lib", File.dirname(__FILE__))
+require 'attr_default'
+Dir.chdir(File.dirname(__FILE__))
+
+if RUBY_PLATFORM == "java"
+  database_adapter = "jdbcsqlite3"
+else
+  database_adapter = "sqlite3"
+end
+
+File.unlink('test.sqlite3') rescue nil
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+ActiveRecord::Base.establish_connection(
+  :adapter => database_adapter,
+  :database => 'test.sqlite3'
+)
+
+ActiveRecord::Base.connection.create_table(:test_users, :force => true) do |t|
+  t.string :first_name
+  t.string :last_name
+  t.boolean :managed
+  t.timestamp :timestamp
+end
+
+ActiveRecord::Base.connection.create_table(:test_numbers, :force => true) do |t|
+  t.string  :type
+  t.integer :test_user_id
+  t.integer :number
+  t.boolean :managed
+  t.timestamp :created_at
+end
+
+if defined?(Rails::Railtie)
+  DefaultValueFor.initialize_railtie
+  DefaultValueFor.initialize_active_record_extensions
+end
+
+class TestUser < ActiveRecord::Base
+  attr_accessor     :password
+  attr_default      :password, '<none>'
+
+  if ENV['INCLUDE_HOBO']
+    fields do
+      first_name    :string, :default => '', :ruby_default => 'John'
+      last_name     :string, :default => 'Doe'
+      timestamp     :timestamp, :default => lambda { (Time.zone || ActiveSupport::TimeZone['Pacific Time (US & Canada)']).now }
+    end
+  else
+    attr_default :first_name, 'John'
+    attr_default :last_name, 'Doe'
+    attr_default :timestamp, lambda { (Time.zone || ActiveSupport::TimeZone['Pacific Time (US & Canada)']).now }
+  end
+
+  has_many :test_numbers
+  has_many :test_numbers_subclass, :class_name => 'TestNumberSubclass'
+end
+
+class TestNumber < ActiveRecord::Base
+  if ENV['INCLUDE_HOBO']
+    fields do
+      managed       :boolean, :default => lambda { test_user.managed }
+    end
+  else
+    attr_default :managed, lambda { test_user.managed }
+  end
+
+  belongs_to :test_user
+end
+
+class TestNumberSubclass < TestNumber
+  if ENV['INCLUDE_HOBO']
+    fields do
+      managed       :boolean, :default => lambda { false }
+    end
+  else
+    attr_default :managed, lambda { false }
+  end
+end
+
+
+class AttrDefaultTest < Test::Unit::TestCase
+  def define_model_class(name = "TestClass", parent_class_name = "ActiveRecord::Base", &block)
+    Object.send(:remove_const, name) rescue nil
+    eval("class #{name} < #{parent_class_name}; end", TOPLEVEL_BINDING)
+    klass = eval(name, TOPLEVEL_BINDING)
+    klass.class_eval do
+      if respond_to?(:table_name=)
+        self.table_name = 'numbers'
+      else
+        set_table_name 'numbers'
+      end
+    end
+    klass.class_eval(&block) if block_given?
+  end
+
+  def test_use_default_if_not_set
+    u = TestUser.new
+    assert_equal nil, u.read_attribute(:last_name)
+    assert_equal "Doe", u.last_name
+  end
+
+  def test_return_the_ActiveRecord_native_type_not_the_lambda_type
+    u = TestUser.new
+    assert_equal 'ActiveSupport::TimeWithZone', u.timestamp.class.name
+    begin
+      old_time_zone, Time.zone = Time.zone, 'Central Time (US & Canada)'
+      u = TestUser.new
+      assert_equal 'ActiveSupport::TimeWithZone', u.timestamp.class.name
+      assert_match /Central Time/, u.timestamp.time_zone.to_s
+    ensure
+      Time.zone = old_time_zone
+    end
+  end
+
+  def test_allow_an_override_to_be_specified
+    u = TestUser.new( :last_name => "override" )
+    assert_equal "override", u.read_attribute(:last_name)
+    assert_equal "override", u.last_name
+  end
+
+  if ENV['INCLUDE_HOBO']
+    def test_hobo_allow_default_and_ruby_default
+      u = TestUser.new
+      assert_equal nil, u.read_attribute(:first_name)
+      assert_equal "", TestUser.field_specs['first_name'].options[:default]
+      assert_equal "John", TestUser.field_specs['first_name'].options[:ruby_default].call
+      assert_equal "John", u.first_name
+    end
+  end
+
+  def test_handle_mutating_the_default_string
+    u = TestUser.new
+    u2 = TestUser.new
+
+    assert_equal "Doe", u2.last_name
+    u.last_name.upcase!
+    assert_equal "Doe", u2.last_name  # should not be DOE
+
+    u3 = TestUser.new
+    assert_equal "Doe", u3.last_name
+  end
+
+  def test_use_default_when_saved_if_not_touched
+    user = TestUser.create! :managed => true
+    number = user.test_numbers.build
+
+    number.save!
+    number.reload
+    assert_equal true, number.read_attribute(:managed)
+    assert_equal true, number.managed
+  end
+
+  def test_clone_touched_state_when_cloned_before_save_new_record_true
+    u = TestUser.new :first_name => 'John', :last_name => 'Doe'
+    u.last_name = 'overridden'
+    u2 = u.clone
+    assert_equal 'overridden', u2.read_attribute(:last_name)
+    assert_equal 'overridden', u2.last_name
+  end
+
+  def test_clone_touched_state_when_cloned_after_save_new_record_false
+    u = TestUser.new :first_name => 'John', :last_name => 'Doe'
+    u.last_name = 'overridden'
+    u2 = u.clone
+    u2.save!
+    u.save!
+    assert u.clone.instance_variable_get(:@_attr_defaults_set_from_clone)
+    assert_equal 'overridden', u.clone.last_name
+    ufind = TestUser.find(u.id)
+    u3 = ufind.clone
+    assert_equal 'overridden', u3.read_attribute(:last_name), u3.attributes.inspect
+    assert_equal 'overridden', u3.last_name
+    u3.save!
+    assert_equal 'overridden', u2.read_attribute(:last_name)
+    assert_equal 'overridden', u2.last_name
+    assert_equal 'overridden', u3.read_attribute(:last_name)
+    assert_equal 'overridden', u3.last_name
+  end
+
+  def test_use_default_when_saved_if_not_touched_and_validation_turned_off
+    user = TestUser.create! :managed => true
+    number = user.test_numbers.build :number => 42
+
+    # not touched or saved yet, still empty
+    assert_equal nil, number.read_attribute(:managed)
+
+    number.save(false)
+
+    # now it should be true
+    assert_equal true, number.read_attribute(:managed)
+    assert_equal true, number.managed
+  end
+
+  def test_use_value_set_on_object_even_when_first_loaded_from_db
+    user = TestUser.create! :managed => true
+    number = user.test_numbers.create! :number => 42, :managed => false
+    number_find = TestNumber.find(number.id)
+    assert_equal false, number_find.managed
+  end
+
+  [false, true].each do |user_managed|
+    define_method "test_default_#{user_managed}_and_param_not_specified" do
+      user = TestUser.create! :managed => user_managed
+      number = user.test_numbers.build
+      assert_equal user_managed, number.managed
+    end
+
+    define_method "test_default_#{user_managed}_and_#{!user_managed}_specified" do
+      user = TestUser.create! :managed => true
+      number = user.test_numbers.build :managed => !user_managed
+      assert_equal !user_managed, number.managed
+    end
+  end
+
+  def test_allow_subclass_to_override_the_default
+    user = TestUser.create! :managed => true
+    number = user.test_numbers.new
+    assert_equal true, number.managed
+    number_subclass = user.test_numbers_subclass.new
+    assert_equal false, number_subclass.managed
+  end
+
+  def test_non_persistent_use_default_if_not_set
+    user = TestUser.new
+    assert_equal "<none>", user.password
+  end
+
+  def test_non_persistent_use_value_if_set_in_initialize
+    user = TestUser.new :password => "supersecret"
+    assert_equal "supersecret", user.password
+  end
+
+  def test_non_persistent_use_value_if_set_after_initialize
+    user = TestUser.new
+    user.password = "supersecret"
+    assert_equal "supersecret", user.password
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: attr_default
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Colin Kelley
+- Nick Burwell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hobofields
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Dynamic Ruby defaults for ActiveRecord attributes
+email: 
+- colindkelley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- attr_default.gemspec
+- lib/attr_default.rb
+- lib/attr_default/version.rb
+- test/test_attr_default.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: "Dynamic Ruby defaults for ActiveRecord attributes. These are lazy evaluated just in time: when first accessed, or just before validation or save. This allows dynamic defaults to depend on attributes that are assigned after initialization, or on other dynamic defaults."
+test_files: 
+- test/test_attr_default.rb