attr_accessible_block 0.2.0

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem "activerecord", ">= 2.3.5"
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem 'sqlite3-ruby', '~> 1.3.2'
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.3)
+    arel (2.0.6)
+    builder (2.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+    sqlite3-ruby (1.3.2)
+    tzinfo (0.3.23)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 2.3.5)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda
+  sqlite3-ruby (~> 1.3.2)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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,94 @@
+AttrAccessibleBlock 0.2
+=======================
+
+This is an ActiveRecord plugin with possibility to define block inside the `attr_accessible` class method.
+
+Tested with Rails 2.3 and 3.0
+
+Because of block, it's possible to define accessibles for instances, nor just for the class level.
+
+It's also still possible to define class level accessibles, so an old `attr_accessible :name` will work.
+
+Main features:
+
+* Possibility to add an accessible attributes based on current `record` state (eg. record.new_record?)
+* Possibility to add additional variables and use it in the block (eg. user.role) `ActiveRecord::AttrAccessibleBlock.before_options :user, lambda { User.current || User.new }`
+* Possibility to add permanently total accessibility in defined condition (eg.user.admin?) `ActiveRecord::AttrAccessibleBlock.always_accessible { user.admin? }`
+
+Also it's possible to check directly is attribute mass-assignable or no using `attr_accessible?` instance method.
+
+See an examples to understand the conception.
+
+Installation
+============
+
+    script/plugin install git://github.com//dmitry/attr_accessible_block.git
+
+Examples
+========
+
+How many times you had code like that:
+
+    class User < ActiveRecord::Base
+      attr_accessible :password, :password_confirmation
+
+      # ...
+    end
+
+And in controller:
+
+    def create
+      user = User.new(params[:user])
+      user.email = params[:user][:email]
+      user.save
+
+      # ...
+    end
+
+Now it's possible to do it easier:
+
+    class User < ActiveRecord::Base
+      attr_accessible do
+        self << [:password, :password_confirmation]
+        self << :email if record.new_record?
+      end
+    end
+
+And creation of the user now can be written more DRYer
+
+    user = User.create(params[:user])
+
+And on user update changing of email will be rejected because of `new_record?` method.
+
+Sometimes you may need to check is attribute of model assignable or no (this method mostly interesting when doing form inputs). You can do it with using `attr_accessible?` method:
+
+    user.assignable?(:email) # returns false
+    user.assignable?(:password) # returns true
+
+How do I add something similar to `record`, for example I want to check current users role?
+
+Easy, with `sentient_user` gem and add the code to the `config/initializers/plugins.rb` file:
+
+    ActiveRecord::AttrAccessibleBlock.before_options :user, lambda { User.current || User.new }
+
+Now `user` method available, you can check:
+
+    attr_accessible do
+      self << [:password, :password_confirmation]
+      self << :email if record.new_record? || user.manager?
+      self << [:some_secret_fields, :another] if user.manager?
+    end
+
+What if I want to provide an total accessibility for the admin user?
+
+Just add this code to the `config/initializers/plugins.rb` file:
+
+    ActiveRecord::AttrAccessibleBlock.always_accessible { user.admin? }
+
+NOTICE: when using attr_accessible as a block, then no second parameter is available for the `attributes=` method (guard_protected_attributes = true). Instead use power of blocks! Also do not use attr_protected, because it's bad :)
+
+Should be STI compatible, but haven't tested yet. Need's feedback on this feature. Feel free to contact with me if something goes wrong.
+
+For more answers on your questions you can look into tests and source code.
+
+Copyright (c) 2010 Dmitry Polushkin, released under the MIT license

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "attr_accessible_block"
+  gem.homepage = "http://github.com/dmitry/attr_accessible_block"
+  gem.license = "MIT"
+  gem.summary = %Q{Attribute accessible block (attr_accessible with a block, dynamic)}
+  gem.description = %Q{Now it's possible to change attr_accessible using definition of the required accessible attributes in a block.}
+  gem.email = "dmitry.polushkin@gmail.com"
+  gem.authors = ["Dmitry Polushkin"]
+  gem.version = '0.2.0'
+  gem.add_runtime_dependency 'activerecord', '>= 2.3.5'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "attr_accessible_block #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'attr_accessible_block'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/attr_accessible_block.rb

@@ -0,0 +1,73 @@
+class ActiveRecord::Base
+  class << self
+    alias_method :old_attr_accessible, :attr_accessible
+  end
+  def self.attr_accessible(*attributes, &block)
+    if block_given?
+      write_inheritable_attribute(:attr_accessible_block, block)
+      self.superclass.send :alias_method, :old_attributes=, :attributes=
+      define_method :attributes= do |attrs|
+        ActiveRecord::AttrAccessibleBlock.new(attrs, self, &block)
+
+        send(:old_attributes=, attrs)
+      end
+    else
+      old_attr_accessible(*attributes)
+    end
+  end
+
+  def attr_accessible?(attribute)
+    klass = self.class
+    block = klass.read_inheritable_attribute(:attr_accessible_block)
+    if block
+      attributes = {attribute => nil}
+      ActiveRecord::AttrAccessibleBlock.new(attributes, self, &block)
+      attributes.has_key?(attribute)
+    else
+      # rails 2/3 compatibility
+      if klass.respond_to?(:accessible_attributes)
+        klass.accessible_attributes.include?(attribute.to_s)
+      else
+        klass._accessible_attributes.include?(attribute)
+      end
+    end
+  end
+end
+
+
+class ActiveRecord::AttrAccessibleBlock < Array
+  attr_reader :attrs, :record
+
+  def initialize(attrs, record, &block)
+    @attrs = attrs
+
+    @@before_options.each do |name, func|
+      instance_variable_set("@#{name}", func.call)
+    end
+
+    @record = record
+
+    unless instance_eval(&@@always_accessible)
+      instance_eval(&block)
+
+      flatten!
+      reject_attrs!
+    end
+  end
+
+  def self.before_options(name, func)
+    @@before_options ||= {}
+    @@before_options[name] = func
+    attr_reader name
+  end
+
+  def self.always_accessible(&block)
+    @@always_accessible = block
+  end
+
+  private
+
+  def reject_attrs!
+    @attrs.reject! { |k,v| !self.include?(k.to_sym) }
+  end
+end

data/tasks/attr_accessible_block_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :attr_accessible_block do
+#   # Task goes here
+# end

data/test/schema.rb

@@ -0,0 +1,58 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users, :force => true do |t|
+    t.string :email, :null => false
+    t.string :password, :null => false
+    t.string :role, :null => false
+  end
+
+  create_table :profiles, :force => true do |t|
+    t.references :user, :null => false
+    t.string :first_name, :null => false
+    t.string :last_name, :null => false
+  end
+
+  create_table :locations, :force => true do |t|
+    t.string :name, :null => false
+    t.string :code, :null => false
+  end
+end
+
+class User < ActiveRecord::Base
+  attr_accessible do
+    self << [:password, :profile_attributes]
+    self << :email if record.new_record? || 'manager' == user.role
+  end
+
+  has_one :profile
+  accepts_nested_attributes_for :profile
+
+  before_create :set_default_role
+
+  validates_presence_of :email, :password
+
+  def self.current
+    User.last
+  end
+
+  private
+
+  def set_default_role
+    self.role ||= 'default'
+  end
+end
+
+class Profile < ActiveRecord::Base
+  attr_accessible do
+    self << [:first_name, :last_name] if record.new_record?
+  end
+
+  belongs_to :user
+
+  validates_presence_of :first_name, :last_name
+end
+
+class Location < ActiveRecord::Base
+  attr_accessible :name
+
+  validates_presence_of :name, :code  
+end

data/test/test_attr_accessible_block.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+ActiveRecord::AttrAccessibleBlock.before_options :user, lambda { User.current || User.new }
+ActiveRecord::AttrAccessibleBlock.always_accessible { 'admin' == user.role }
+
+class AttrAccessibleBlockTest < Test::Unit::TestCase
+  def setup
+    setup_db
+
+    [User, Profile].each do |k|
+      k.delete_all
+    end
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_should_reject
+    user = User.create(:email => 'test@test.com', :password => 'test', :role => 'admin')
+    assert user.valid?
+    assert !user.new_record?
+    assert_equal 'test', user.password
+    assert_equal 'test@test.com', user.email
+    assert_equal 'default', user.role
+  end
+
+  def test_should_always_accessible
+    user = User.new(:email => 'test@test.com', :password => 'test', :profile_attributes => {:first_name => 'first name', :last_name => 'last name'})
+    user.role = 'admin'
+    assert user.save
+    assert !user.profile.new_record?
+    assert_equal 'admin', user.role
+    assert_equal 'first name', user.profile.first_name
+    assert user.update_attributes(:profile_attributes => {:id => user.profile.id, :first_name => 'first'})
+    assert_equal 'first', user.profile.first_name
+  end
+
+  def test_should_change_only_on_create
+    user = User.create(:email => 'test@test.com', :password => 'test')
+    assert user.update_attributes(:email => 'new@new.com')
+    assert_equal 'test@test.com', user.email
+  end
+
+  def test_should_work_attr_accessible_question_with_block
+    user = User.new(:email => 'test@test.com', :password => 'test')
+    assert_equal true, user.attr_accessible?(:email)
+    assert_equal true, user.attr_accessible?(:password)
+    user.save
+    assert_equal false, user.attr_accessible?(:email)
+    assert_equal true, user.attr_accessible?(:password)
+  end
+
+  def test_should_work_attr_accessible_question_without_block
+    l = Location.new(:name => 'name', :code => 'code')
+    assert_equal true, l.attr_accessible?(:name)
+    assert_equal false, l.attr_accessible?(:code)
+  end
+
+  def test_should_access_to_before_options_reader
+    user = User.new(:email => 'test@test.com', :password => 'test', :profile_attributes => {:first_name => 'first name', :last_name => 'last name'})
+    user.role = 'manager'
+    assert user.save
+    user.attributes = {:email => 'new@new.com'}
+    assert user.save
+    assert_equal 'new@new.com', user.email
+  end
+
+  def test_simple_attr_accessible_should_work_as_expected
+    l = Location.create(:name => 'name', :code => 'code')
+    assert !l.valid?
+    assert_equal 'name', l.name
+    assert_equal nil, l.code
+    l.update_attribute(:code, 'code')
+    assert l.valid?
+    assert_equal 'code', l.code
+    l.code = 'changed'
+    l.save
+    assert l.valid?
+    assert_equal 'changed', l.code
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'test/unit'
+
+gem 'activerecord', '~> 3.0'
+
+require 'active_support'
+require 'active_record'
+require 'logger'
+
+require 'attr_accessible_block'
+
+ActiveRecord::Base.logger = Logger.new("test.log")
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+def setup_db
+  ActiveRecord::Migration.verbose = false
+  load "schema.rb"
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification 
+name: attr_accessible_block
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Dmitry Polushkin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-16 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 3
+        - 2
+        version: 1.3.2
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id007
+description: Now it's possible to change attr_accessible using definition of the required accessible attributes in a block.
+email: dmitry.polushkin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- init.rb
+- install.rb
+- lib/attr_accessible_block.rb
+- tasks/attr_accessible_block_tasks.rake
+- test/schema.rb
+- test/test_attr_accessible_block.rb
+- test/test_helper.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/dmitry/attr_accessible_block
+licenses: 
+- MIT
+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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Attribute accessible block (attr_accessible with a block, dynamic)
+test_files: 
+- test/schema.rb
+- test/test_attr_accessible_block.rb
+- test/test_helper.rb