provision 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Chen Fisher
+
+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.md

@@ -0,0 +1,157 @@
+# Provision
+
+The provision gem lets you hook a provision filter to a method. **ANY method**.
+
+For example, 
+Lets say we have an article website, where users can post articles.
+
+We want to limit the number of articles a user can post to our website, based on a primium account. For example, if the user is using the free version he can post up to 5 articles, when a user that has paid and is using the pro account, can post up to 20 articles.
+
+This is where 'provision' comes in. It makes it easy and dry to do provisions on your website.
+
+The great thing about **provision** is that it can act on any level - model, controller or any other class you have.
+Think of it as ActiveRecord's **validate** and Controller's **before_filter** combined and available on any class and method. 
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'provision'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install provision
+
+## Usage
+When a method is provisioned, whenever it is called, the provision method comes into action.
+If the provision method returns true then the original method will be called. If the provision returns false
+then the method won't be called (and false will be returned)
+
+### Provision using a method
+	class SomeClass
+		def a_method
+			# do something
+		end
+		provision :a_method, :with => :provision_method
+
+		private
+			def provision_method
+				# some condition (returns true or false)
+			end
+	end
+
+**provision_method** can take optional ***args** which are the arguments passed to the original method:
+
+	def provision_method(*args)
+		# some condition using args
+	end
+
+
+### Provision using a proc (lambda)
+	class SomeClass
+		def a_method
+			# do something
+		end
+		provision :a_method, :with => lambda{ [some condition] }
+	end
+
+**lambda** can take arguments like so:
+
+	provision :a_method, :with => lambda{ |sender, *args| [some condition] }
+where **sender** is the instance of SomeClass and ***args** are the arguments passed to the original method
+
+
+### Provision using a class name
+	class SomeClass
+		def a_method
+			# do something
+		end
+		provision :a_method, :with => ProvisionClass
+	end
+
+**NOTE**: provision will try to call `ProvisionClass.provision!` (a class method); if the class does not respond to provision! then
+it will create an instance of ProvisionClass and then call `provision!` (mind the bang!)
+
+	class ProvisionClass
+		def self.provision!(sender, *args)
+			# some condition using sender and *args
+		end
+	end
+
+**sender** is the instance of SomeClass and ***args** are the arguments passed to the original method
+
+### Provision using an instance of a class
+when the **lambda** block return something other than *true* or *false* then provision assumes it returns an instance
+of a class that responds to **provision!**
+
+	provision :a_method, :with => lambda{ |sender, *args| ProvisionClass.new(sender, *args) }
+
+**sender** and ***args** are optional
+
+### Add a block to do something
+You can add a block which will be called when the provision returns false.
+
+	provision :a_method, :with => lambda{ some_condition } do |sender, *args|
+		# do something for when the provision fails
+		# for example: send a notification email to the user you just provisioned
+	end
+
+**sender** and ***args** are optional
+
+### Provision more than one method at a time
+You can pass any number of methods to be provisioned
+
+	provision :a_method, :another_method, :with => lambda{ some_condition } do
+		# do something
+	end
+
+### Use it in your controllers and models
+You can use it in your controllers and models like you use before_filter and validations.
+Lets provision a user on the number of posts they can post. We can do this on the controller level or on the model level:
+
+#### Controller level example:
+	class PostsController < ApplicationController
+		include provision
+
+		def create
+			# create the post
+		end
+
+		provision :create, :with => UserProvision do |controller|
+			controller.flash[:error] = "You have maxed out your posts"
+			redirect_to some_url
+		end
+	end
+
+	class UserProvision
+		def self.provision!(controller)
+			controller.current_user.post_count < MAX_POSTS
+		end
+	end
+
+#### Model level example:
+	class Post < ActiveRecord::Base
+		include provision
+
+		provision :save, :valid?, :with => lambda{ |post| post.user.post_count < MAX_COUNT } do |post|
+			post.errors[:count] = "you have maxed out you post count"
+			false
+		end
+	end
+
+## GOTCHA!
+`provision` call **must** come **after** your provisioned method definitions
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/provision/version.rb

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

data/lib/provision.rb

@@ -0,0 +1,94 @@
+require "provision/version"
+
+module Provision
+	module ClassMethods
+
+		##
+		# 
+		def provision(*args, &block)
+			options = args.last.is_a?(::Hash) ? args.pop : {}
+
+			hook(*args, :before => options[:with], &block)
+		end
+
+		##
+		# hooks the specified array of methods to a method specified with the :before hook
+		# calls the original method only if the hooked method returns true
+		# usage:
+		# 	hook :method1, :method2, :before => :method_name
+		def hook(*args, &block)
+			hooks = args.last.is_a?(::Hash) ? args.pop : {}
+
+			args.each do |method|
+				original_method = self.instance_method(method)
+
+				self.send(:define_method, method) do |*a|
+					return original_method.bind(self).call(*a) if 
+						case
+						when hooks[:before].is_a?(Symbol)
+							hook_method(hooks[:before], *a)
+						when hooks[:before].is_a?(Class)
+							hook_class(hooks[:before], *a)
+						when hooks[:before].is_a?(Proc)
+							hook_proc(hooks[:before], *a)
+						when hooks[:before].instance_of?(hooks[:before].class)
+							hook_instance(hooks[:before], *a)
+						end
+
+ 					if block_given?
+						if block.arity == 0
+							return yield
+						else
+							return yield(self, *a)
+						end
+					end
+
+					false
+				end
+			end
+		end
+
+		private :hook
+	end
+	
+	module InstanceMethods
+		def hook_method(h, *a)
+			self.send(h, *a)
+		end
+
+		def hook_class(h, *a)
+			if h.respond_to? :provision!
+				h.provision!(self, *a)
+			else
+				h.new.provision!(self, *a)
+			end
+		end
+
+		def hook_instance(h, *a)
+			h.provision!(self, *a)
+		end
+
+		def hook_proc(h, *a)
+			# call the proc
+			if h.arity == 0
+				result = h.call
+			else
+				result = h.call(self, *a)
+			end
+
+			# if proc returns true or false then return the result
+			return result if result == true || result == false
+			
+			# if proc returns an instance of an object then call provision! on it
+			result.provision!(*a)
+		end
+
+		private :hook_method, :hook_class, :hook_instance, :hook_proc
+		
+	end
+	
+	def self.included(receiver)
+		receiver.extend         ClassMethods
+		receiver.send :include, InstanceMethods
+	end
+end

data/provision.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'provision/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "provision"
+  gem.version       = Provision::VERSION
+  gem.authors       = ["Chen Fisher"]
+  gem.email         = ["chen.fisher@gmail.com"]
+  gem.description   = %q{Lets one hook a provision for a method}
+  gem.summary       = %q{When a method is provisioned, any call to that method is passed through a provision filter that can stop the method execution and perform some actions}
+  gem.homepage      = "https://github.com/chenfisher/provision"
+
+  gem.add_development_dependency "rspec"
+
+  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)/})
+  gem.require_paths = ["lib"]
+end

data/spec/provision/sample.rb

@@ -0,0 +1,3 @@
+class	Sample
+	include Provision
+end

data/spec/provision_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'provision/sample'
+
+describe Provision do
+
+	before :each do
+		@sample = Sample.new
+		@sample.stub(:a_method).and_return('hello')
+		@meta = class << @sample; self; end
+	end
+
+	it "should call the method if provision returns true" do
+		@sample.stub(:this_method).and_return(true)
+		@meta.provision :a_method, :with => :this_method
+
+		@sample.a_method.should eq 'hello'
+	end
+
+	it "should provision a method using a method name" do
+		@sample.stub(:this_method).and_return(false)
+		@meta.provision :a_method, :with => :this_method
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should provision a method using a class name" do
+		class ThisClass; 
+			def provision!(sender)
+				false
+			end
+		end
+		
+		@meta.provision :a_method, :with => ThisClass
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should provision a method using a class name with class method provision!" do
+		class ThisClass; 
+			def self.provision!(sender)
+				false
+			end
+		end
+		
+		@meta.provision :a_method, :with => ThisClass
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should provision a method using an instance of a class" do
+		class ThisClass; end
+		@instance = ThisClass.new
+		@instance.stub(:provision!).and_return false
+		@instance.should_receive(:provision!)
+		
+		@meta.provision :a_method, :with => @instance
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should provision a method using an instance of a class (from a proc)" do
+		class ThisClass; end
+		ThisClass.any_instance.stub(:provision!).and_return false
+		ThisClass.any_instance.should_receive(:provision!)
+		
+		@meta.provision :a_method, :with => lambda{ ThisClass.new }
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should provision a method using a proc" do
+		@meta.provision :a_method, :with => lambda{ false }
+
+		@sample.a_method.should_not eq 'hello'
+	end
+
+	it "should takea proc with arguments" do
+		@meta.provision :a_method, :with => lambda{ |sender, p| sender === @sample && p == 'p' }
+
+		@sample.a_method('p').should eq 'hello'
+	end
+
+	it "should take an array of methods to provision" do
+		@sample.stub(:b_method).and_return('hello')
+		@meta.provision :a_method, :b_method, :with => lambda{ false }
+
+		@sample.a_method.should_not eq 'hello'
+		@sample.b_method.should_not eq 'hello'
+	end
+
+	it "should take a block as an action when provision fails" do
+		@meta.provision :a_method, :with => lambda{ false } do
+			'hi there'
+		end
+
+		@sample.a_method.should eq 'hi there'
+	end
+
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: provision
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chen Fisher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Lets one hook a provision for a method
+email:
+- chen.fisher@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/provision.rb
+- lib/provision/version.rb
+- provision.gemspec
+- spec/provision/sample.rb
+- spec/provision_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/chenfisher/provision
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: When a method is provisioned, any call to that method is passed through a
+  provision filter that can stop the method execution and perform some actions
+test_files:
+- spec/provision/sample.rb
+- spec/provision_spec.rb
+- spec/spec_helper.rb