alfred 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@alfred --create

data/.travis.yml

@@ -0,0 +1 @@
+rvm: 1.9.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in alfred.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/alfred.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "alfred/version"
+ 
+Gem::Specification.new do |s|
+  s.name        = "alfred"
+  s.version     = Alfred::VERSION
+  s.authors     = ["Daniel Spangenberg"]
+  s.email       = ["daniel.spangenberg@parcydo.com"]
+  s.homepage    = "http://rubygems.org/gems/alfred"
+  s.summary     = %q{Alfred is the unobtrusive butler who takes care of the uninvited guests.}
+  s.description = %q{Alfred provides better attr_accessor handling on your application.}
+
+  s.rubyforge_project = "alfred"
+
+  s.add_dependency "rails", "~> 3.1.0.rc"
+  s.add_development_dependency "activerecord"
+  s.add_development_dependency "rr"
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/alfred.rb

@@ -0,0 +1,18 @@
+require 'rails'
+
+module Alfred
+  autoload :Models, 'alfred/models'
+
+  # Automaticly add password_confirmation if password exists.
+  mattr_accessor :auto_password_confirmation
+  @@auto_password_confirmation = true
+
+  # Default way to setup Alfred. Run rails generate alfred:install to create
+  # a fresh initializer with all configuration values.
+  def self.setup
+    yield self
+  end
+end
+
+require 'alfred/engine'
+require 'alfred/orm/active_record' if defined?(ActiveRecord)

data/lib/alfred/engine.rb

@@ -0,0 +1,4 @@
+module Alfred
+  class Engine < Rails::Engine
+  end
+end

data/lib/alfred/generators/alfred/install_generator.rb

@@ -0,0 +1,13 @@
+module Alfred
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a Alfred initializer."
+
+      def copy_initializer
+        template "alfred.rb", "config/initializers/alfred.rb"
+      end
+    end
+  end
+end

data/lib/alfred/generators/templates/alfred.rb

@@ -0,0 +1,6 @@
+# Use this hook to configure Alfred.
+Alfred.setup do |config|
+  # Configure if password_confirmation should
+  # automaticly added if password exists.
+  # config.auto_password_confirmation = true
+end

data/lib/alfred/models.rb

@@ -0,0 +1,53 @@
+module Alfred
+  module Models
+    def alfred_accessible(*args)
+      alfred(:accessible, *args)
+    end
+
+    def alfred_protected(*args)
+      alfred(:protected, *args)
+    end
+
+  private
+
+    def alfred(method, *args)
+      options = args.extract_options!
+
+      if options[:as]
+        if method == :accessible
+          args = args + accessible_attributes(options[:inherit] || :default).to_a
+        else
+          args = args + protected_attributes(options[:inherit] || :default).to_a
+        end
+        args = args + [{ as: options[:as] }]
+      end
+
+      if args.include?(:password) && Alfred.auto_password_confirmation
+        args = args + [:password_confirmation]
+      end
+
+      if options[:on] && [:create, :update].include?(options[:on])
+        if options[:on] == :create
+          before = :before_create
+        else
+          before = :before_update
+        end
+        if method == :accessible
+          self.class.send(:define_method, before) do
+            attr_accessible(*args)
+          end
+        else
+          self.class.send(:define_method, before) do
+            attr_protected(*args)
+          end
+        end
+      else
+        if method == :accessible
+          attr_accessible(*args)
+        else
+          attr_protected(*args)
+        end
+      end      
+    end
+  end
+end

data/lib/alfred/orm/active_record.rb

@@ -0,0 +1,3 @@
+require 'active_record'
+
+ActiveRecord::Base.extend Alfred::Models

data/lib/alfred/version.rb

@@ -0,0 +1,3 @@
+module Alfred
+  VERSION = "0.0.1"
+end

data/spec/models_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+class AlfredModel
+  include ActiveModel::MassAssignmentSecurity
+  extend Alfred::Models
+  attr_accessor :a, :b, :c, :d, :e, :f
+end
+
+describe Alfred::Models do
+
+  describe "accessible" do
+
+    describe "create attr_accessible" do
+      it "add's attr_accessible with default role" do
+        class AAModel < AlfredModel
+          alfred_accessible :a, :b
+        end
+        AAModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+      end
+
+      it "appends attr_accessible to default role" do
+        class ABModel < AlfredModel
+          alfred_accessible :a, :b
+          alfred_accessible :c, :d
+        end
+        ABModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :c, :d].map(&:to_s)))
+      end
+
+      it "add's attr_accessible with custom role" do
+        class ACModel < AlfredModel
+          alfred_accessible :a, :b, as: :custom
+        end
+        ACModel.accessible_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+      end
+
+      it "appends attr_accessible to custom role" do
+        class ADModel < AlfredModel
+          alfred_accessible :a, :b, as: :custom
+          alfred_accessible :c, :d, as: :custom
+        end
+        ADModel.accessible_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :c, :d].map(&:to_s)))
+      end
+
+      it "add's attr_accessible to event" do
+        class AEModel < AlfredModel
+          alfred_accessible :a, :b, on: :create
+        end
+        AEModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([].map(&:to_s)))
+        AEModel.before_create
+        AEModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+      end
+
+      it "appends attr_accessible with custom role to event" do
+        class AFModel < AlfredModel
+          alfred_accessible :a, :b, as: :custom, on: :create
+        end
+        AFModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([].map(&:to_s)))
+        AFModel.before_create
+        AFModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([].map(&:to_s)))
+        AFModel.accessible_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+      end
+    end
+
+    describe "inheritance" do
+      it "inherits from default role" do
+        class AGModel < AlfredModel
+          alfred_accessible :a, :b
+          alfred_accessible :c, :d, as: :custom
+          alfred_accessible :e, :f, as: :custom2
+        end
+        AGModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+        AGModel.accessible_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :c, :d].map(&:to_s)))
+        AGModel.accessible_attributes(:custom2).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :e, :f].map(&:to_s)))
+      end
+
+      it "inherits from custom role" do
+        class AHModel < AlfredModel
+          alfred_accessible :a, :b
+          alfred_accessible :c, :d, as: :custom
+          alfred_accessible :e, :f, as: :custom2, inherit: :custom
+        end
+        AHModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b].map(&:to_s)))
+        AHModel.accessible_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :c, :d].map(&:to_s)))
+        AHModel.accessible_attributes(:custom2).should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:a, :b, :c, :d, :e, :f].map(&:to_s)))
+      end
+    end
+
+    describe "auto password confirmation" do
+      it "add's automatically password_confirmation if enabled" do
+        Alfred.auto_password_confirmation = true
+        class AIModel < AlfredModel
+          attr_accessor :password, :password_confirmation
+          alfred_accessible :password
+        end
+        AIModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:password, :password_confirmation].map(&:to_s)))
+      end
+
+      it "not add's automatically password_confirmation if disabled" do
+        Alfred.auto_password_confirmation = false
+        class AJModel < AlfredModel
+          attr_accessor :password, :password_confirmation
+          alfred_accessible :password
+        end
+        AJModel.accessible_attributes.should eq(ActiveModel::MassAssignmentSecurity::WhiteList.new([:password].map(&:to_s)))
+      end
+    end
+
+  end
+
+  describe "protected" do
+
+     describe "create attr_protected" do
+       it "add's attr_protected with default role" do
+         class PAModel < AlfredModel
+           alfred_protected :a, :b
+         end
+         PAModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+       end
+
+       it "appends attr_protected to default role" do
+         class PBModel < AlfredModel
+           alfred_protected :a, :b
+           alfred_protected :c, :d
+         end
+         PBModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :c, :d].map(&:to_s)))
+       end
+
+       it "add's attr_protected with custom role" do
+         class PCModel < AlfredModel
+           alfred_protected :a, :b, as: :custom
+         end
+         PCModel.protected_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+       end
+
+       it "appends attr_protected to custom role" do
+         class PDModel < AlfredModel
+           alfred_protected :a, :b, as: :custom
+           alfred_protected :c, :d, as: :custom
+         end
+         PDModel.protected_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :c, :d].map(&:to_s)))
+       end
+
+       it "add's attr_protected to event" do
+         class PEModel < AlfredModel
+           alfred_protected :a, :b, on: :create
+         end
+         PEModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([].map(&:to_s)))
+         PEModel.before_create
+         PEModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+       end
+
+       it "appends attr_protected with custom role to event" do
+         class PFModel < AlfredModel
+           alfred_protected :a, :b, as: :custom, on: :create
+         end
+         PFModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([].map(&:to_s)))
+         PFModel.before_create
+         PFModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([].map(&:to_s)))
+         PFModel.protected_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+       end
+     end
+
+     describe "inheritance" do
+       it "inherits from default role" do
+         class PGModel < AlfredModel
+           alfred_protected :a, :b
+           alfred_protected :c, :d, as: :custom
+           alfred_protected :e, :f, as: :custom2
+         end
+         PGModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+         PGModel.protected_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :c, :d].map(&:to_s)))
+         PGModel.protected_attributes(:custom2).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :e, :f].map(&:to_s)))
+       end
+
+       it "inherits from custom role" do
+         class PHModel < AlfredModel
+           alfred_protected :a, :b
+           alfred_protected :c, :d, as: :custom
+           alfred_protected :e, :f, as: :custom2, inherit: :custom
+         end
+         PHModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b].map(&:to_s)))
+         PHModel.protected_attributes(:custom).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :c, :d].map(&:to_s)))
+         PHModel.protected_attributes(:custom2).should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:a, :b, :c, :d, :e, :f].map(&:to_s)))
+       end
+     end
+
+     describe "auto password confirmation" do
+       it "add's automatically password_confirmation if enabled" do
+         Alfred.auto_password_confirmation = true
+         class PIModel < AlfredModel
+           attr_accessor :password, :password_confirmation
+           alfred_protected :password
+         end
+         PIModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:password, :password_confirmation].map(&:to_s)))
+       end
+
+       it "not add's automatically password_confirmation if disabled" do
+         Alfred.auto_password_confirmation = false
+         class PJModel < AlfredModel
+           attr_accessor :password, :password_confirmation
+           alfred_protected :password
+         end
+         PJModel.protected_attributes.should eq(ActiveModel::MassAssignmentSecurity::BlackList.new([:password].map(&:to_s)))
+       end
+     end
+
+   end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'alfred'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: alfred
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Spangenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70320733483060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0.rc
+  type: :runtime
+  prerelease: false
+  version_requirements: *70320733483060
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70320733482640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70320733482640
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70320733482180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70320733482180
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70320733481760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70320733481760
+description: Alfred provides better attr_accessor handling on your application.
+email:
+- daniel.spangenberg@parcydo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Rakefile
+- alfred.gemspec
+- lib/alfred.rb
+- lib/alfred/engine.rb
+- lib/alfred/generators/alfred/install_generator.rb
+- lib/alfred/generators/templates/alfred.rb
+- lib/alfred/models.rb
+- lib/alfred/orm/active_record.rb
+- lib/alfred/version.rb
+- spec/models_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/alfred
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: alfred
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Alfred is the unobtrusive butler who takes care of the uninvited guests.
+test_files:
+- spec/models_spec.rb
+- spec/spec_helper.rb