object-filters 0.0.5

data/.gitignore

@@ -0,0 +1,4 @@
+/pkg
+.rvmrc
+.DS_Store
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gemspec
+
+group :development do
+  gem 'bundler'
+  gem 'rspec'
+end

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake/version_task'
+require 'rspec/core/rake_task'
+
+spec = Gem::Specification.new do |s|
+  s.name         = 'object-filters'
+  s.platform     = Gem::Platform::RUBY
+  s.author       = 'Ryan Scott Lewis'
+  s.email        = 'ryan@rynet.us'
+  s.homepage     = "http://rubygems.org/gems/#{s.name}"
+  s.summary      = 'Use before, after, and around filters with your objects!'
+  s.description  = 'This gem provides ActionController::Filters for your custom classes.'
+  s.require_path = 'lib'
+  s.post_install_message = "This is a placeholder gem... for now. Check back in a few versions!"
+  s.files        = `git ls-files`.lines.to_a.collect { |s| s.strip }
+  s.executables  = `git ls-files -- bin/*`.lines.to_a.collect { |s| File.basename(s.strip) }
+  
+  s.add_dependency 'version', '~> 1'
+  s.add_dependency 'active_support', '~> 3'
+end
+
+Rake::VersionTask.new do |t|
+  t.with_git_tag = true
+  t.with_gemspec = spec
+end
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/filters.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "object-filters"
+  s.version = "0.0.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Scott Lewis"]
+  s.date = "2012-10-08"
+  s.description = "This gem provides ActionController::Filters for normal applications."
+  s.email = ["ryan@rynet.us"]
+  s.files = [".gitignore", "Gemfile", "Rakefile", "VERSION", "filters.gemspec", "lib/filters.rb", "spec/filters_spec.rb", "spec/spec_helper.rb"]
+  s.homepage = "http://rubygems.org/gems/filters"
+  s.post_install_message = "This is a placeholder gem... for now. Check back in a few versions!"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Use before, after, and around filters with your objects!"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<version>, ["~> 1"])
+      s.add_runtime_dependency(%q<active_support>, ["~> 3"])
+    else
+      s.add_dependency(%q<version>, ["~> 1"])
+      s.add_dependency(%q<active_support>, ["~> 3"])
+    end
+  else
+    s.add_dependency(%q<version>, ["~> 1"])
+    s.add_dependency(%q<active_support>, ["~> 3"])
+  end
+end

data/lib/filters.rb

@@ -0,0 +1,203 @@
+require 'pathname'
+require 'bundler/setup'
+require 'version'
+require 'active_support/concern'
+require 'active_support/callbacks'
+
+__PATH__ = Pathname.new(__FILE__)
+$:.unshift(__PATH__.dirname.to_s) unless $:.include?(__PATH__.dirname.to_s)
+
+module AbstractController
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    # Uses ActiveSupport::Callbacks as the base functionality. For
+    # more details on the whole callback system, read the documentation
+    # for ActiveSupport::Callbacks.
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :process_action, :terminator => "response_body", :skip_after_callbacks_if_terminated => true
+    end
+
+    # Override AbstractController::Base's process_action to run the
+    # process_action callbacks around the normal behavior.
+    def process_action(*args)
+      run_callbacks(:process_action) do
+        super
+      end
+    end
+
+    module ClassMethods
+      # If :only or :except are used, convert the options into the
+      # :unless and :if options of ActiveSupport::Callbacks.
+      # The basic idea is that :only => :index gets converted to
+      # :if => proc {|c| c.action_name == "index" }.
+      #
+      # ==== Options
+      # * <tt>only</tt>   - The callback should be run only for this action
+      # * <tt>except</tt>  - The callback should be run for all actions except this action
+      def _normalize_callback_options(options)
+        if only = options[:only]
+          only = Array(only).map {|o| "action_name == '#{o}'"}.join(" || ")
+          options[:if] = Array(options[:if]) << only
+        end
+        if except = options[:except]
+          except = Array(except).map {|e| "action_name == '#{e}'"}.join(" || ")
+          options[:unless] = Array(options[:unless]) << except
+        end
+      end
+
+      # Skip before, after, and around filters matching any of the names
+      #
+      # ==== Parameters
+      # * <tt>names</tt> - A list of valid names that could be used for
+      #   callbacks. Note that skipping uses Ruby equality, so it's
+      #   impossible to skip a callback defined using an anonymous proc
+      #   using #skip_filter
+      def skip_filter(*names)
+        skip_before_filter(*names)
+        skip_after_filter(*names)
+        skip_around_filter(*names)
+      end
+
+      # Take callback names and an optional callback proc, normalize them,
+      # then call the block with each callback. This allows us to abstract
+      # the normalization across several methods that use it.
+      #
+      # ==== Parameters
+      # * <tt>callbacks</tt> - An array of callbacks, with an optional
+      #   options hash as the last parameter.
+      # * <tt>block</tt>    - A proc that should be added to the callbacks.
+      #
+      # ==== Block Parameters
+      # * <tt>name</tt>     - The callback to be added
+      # * <tt>options</tt>  - A hash of options to be used when adding the callback
+      def _insert_callbacks(callbacks, block = nil)
+        options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
+        _normalize_callback_options(options)
+        callbacks.push(block) if block
+        callbacks.each do |callback|
+          yield callback, options
+        end
+      end
+
+      ##
+      # :method: before_filter
+      #
+      # :call-seq: before_filter(names, block)
+      #
+      # Append a before filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: prepend_before_filter
+      #
+      # :call-seq: prepend_before_filter(names, block)
+      #
+      # Prepend a before filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: skip_before_filter
+      #
+      # :call-seq: skip_before_filter(names)
+      #
+      # Skip a before filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_before_filter
+      #
+      # :call-seq: append_before_filter(names, block)
+      #
+      # Append a before filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: after_filter
+      #
+      # :call-seq: after_filter(names, block)
+      #
+      # Append an after filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: prepend_after_filter
+      #
+      # :call-seq: prepend_after_filter(names, block)
+      #
+      # Prepend an after filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: skip_after_filter
+      #
+      # :call-seq: skip_after_filter(names)
+      #
+      # Skip an after filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_after_filter
+      #
+      # :call-seq: append_after_filter(names, block)
+      #
+      # Append an after filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: around_filter
+      #
+      # :call-seq: around_filter(names, block)
+      #
+      # Append an around filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: prepend_around_filter
+      #
+      # :call-seq: prepend_around_filter(names, block)
+      #
+      # Prepend an around filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: skip_around_filter
+      #
+      # :call-seq: skip_around_filter(names)
+      #
+      # Skip an around filter. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_around_filter
+      #
+      # :call-seq: append_around_filter(names, block)
+      #
+      # Append an around filter. See _insert_callbacks for parameter details.
+
+      # set up before_filter, prepend_before_filter, skip_before_filter, etc.
+      # for each of before, after, and around.
+      [:before, :after, :around].each do |filter|
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          # Append a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def #{filter}_filter(*names, &blk)                                                    # def before_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{filter}, name, options)                          #     set_callback(:process_action, :before, name, options)
+            end                                                                                 #   end
+          end                                                                                   # end
+
+          # Prepend a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def prepend_#{filter}_filter(*names, &blk)                                            # def prepend_before_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
+            end                                                                                 #   end
+          end                                                                                   # end
+
+          # Skip a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def skip_#{filter}_filter(*names)                                                     # def skip_before_filter(*names)
+            _insert_callbacks(names) do |name, options|                                         #   _insert_callbacks(names) do |name, options|
+              skip_callback(:process_action, :#{filter}, name, options)                         #     skip_callback(:process_action, :before, name, options)
+            end                                                                                 #   end
+          end                                                                                   # end
+
+          # *_filter is the same as append_*_filter
+          alias_method :append_#{filter}_filter, :#{filter}_filter  # alias_method :append_before_filter, :before_filter
+        RUBY_EVAL
+      end
+    end
+  end
+end

data/spec/filters_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+__END__
+
+module AbstractController
+  module Testing
+
+    class ControllerWithCallbacks < AbstractController::Base
+      include AbstractController::Callbacks
+    end
+
+    class Callback1 < ControllerWithCallbacks
+      set_callback :process_action, :before, :first
+
+      def first
+        @text = "Hello world"
+      end
+
+      def index
+        self.response_body = @text
+      end
+    end
+
+    class TestCallbacks1 < ActiveSupport::TestCase
+      test "basic callbacks work" do
+        controller = Callback1.new
+        controller.process(:index)
+        assert_equal "Hello world", controller.response_body
+      end
+    end
+
+    class Callback2 < ControllerWithCallbacks
+      before_filter :first
+      after_filter :second
+      around_filter :aroundz
+
+      def first
+        @text = "Hello world"
+      end
+
+      def second
+        @second = "Goodbye"
+      end
+
+      def aroundz
+        @aroundz = "FIRST"
+        yield
+        @aroundz << "SECOND"
+      end
+
+      def index
+        @text ||= nil
+        self.response_body = @text.to_s
+      end
+    end
+
+    class Callback2Overwrite < Callback2
+      before_filter :first, :except => :index
+    end
+
+    class TestCallbacks2 < ActiveSupport::TestCase
+      def setup
+        @controller = Callback2.new
+      end
+
+      test "before_filter works" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "after_filter works" do
+        @controller.process(:index)
+        assert_equal "Goodbye", @controller.instance_variable_get("@second")
+      end
+
+      test "around_filter works" do
+        @controller.process(:index)
+        assert_equal "FIRSTSECOND", @controller.instance_variable_get("@aroundz")
+      end
+
+      test "before_filter with overwritten condition" do
+        @controller = Callback2Overwrite.new
+        @controller.process(:index)
+        assert_equal "", @controller.response_body
+      end
+    end
+
+    class Callback3 < ControllerWithCallbacks
+      before_filter do |c|
+        c.instance_variable_set("@text", "Hello world")
+      end
+
+      after_filter do |c|
+        c.instance_variable_set("@second", "Goodbye")
+      end
+
+      def index
+        self.response_body = @text
+      end
+    end
+
+    class TestCallbacks3 < ActiveSupport::TestCase
+      def setup
+        @controller = Callback3.new
+      end
+
+      test "before_filter works with procs" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "after_filter works with procs" do
+        @controller.process(:index)
+        assert_equal "Goodbye", @controller.instance_variable_get("@second")
+      end
+    end
+
+    class CallbacksWithConditions < ControllerWithCallbacks
+      before_filter :list, :only => :index
+      before_filter :authenticate, :except => :index
+
+      def index
+        self.response_body = @list.join(", ")
+      end
+
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+
+      private
+      def list
+        @list = ["Hello", "World"]
+      end
+
+      def authenticate
+        @list ||= []
+        @authenticated = "true"
+      end
+    end
+
+    class TestCallbacksWithConditions < ActiveSupport::TestCase
+      def setup
+        @controller = CallbacksWithConditions.new
+      end
+
+      test "when :only is specified, a before filter is triggered on that action" do
+        @controller.process(:index)
+        assert_equal "Hello, World", @controller.response_body
+      end
+
+      test "when :only is specified, a before filter is not triggered on other actions" do
+        @controller.process(:sekrit_data)
+        assert_equal "true", @controller.response_body
+      end
+
+      test "when :except is specified, an after filter is not triggered on that action" do
+        @controller.process(:index)
+        assert !@controller.instance_variable_defined?("@authenticated")
+      end
+    end
+
+    class CallbacksWithArrayConditions < ControllerWithCallbacks
+      before_filter :list, :only => [:index, :listy]
+      before_filter :authenticate, :except => [:index, :listy]
+
+      def index
+        self.response_body = @list.join(", ")
+      end
+
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+
+      private
+      def list
+        @list = ["Hello", "World"]
+      end
+
+      def authenticate
+        @list = []
+        @authenticated = "true"
+      end
+    end
+
+    class TestCallbacksWithArrayConditions < ActiveSupport::TestCase
+      def setup
+        @controller = CallbacksWithArrayConditions.new
+      end
+
+      test "when :only is specified with an array, a before filter is triggered on that action" do
+        @controller.process(:index)
+        assert_equal "Hello, World", @controller.response_body
+      end
+
+      test "when :only is specified with an array, a before filter is not triggered on other actions" do
+        @controller.process(:sekrit_data)
+        assert_equal "true", @controller.response_body
+      end
+
+      test "when :except is specified with an array, an after filter is not triggered on that action" do
+        @controller.process(:index)
+        assert !@controller.instance_variable_defined?("@authenticated")
+      end
+    end
+
+    class ChangedConditions < Callback2
+      before_filter :first, :only => :index
+
+      def not_index
+        @text ||= nil
+        self.response_body = @text.to_s
+      end
+    end
+
+    class TestCallbacksWithChangedConditions < ActiveSupport::TestCase
+      def setup
+        @controller = ChangedConditions.new
+      end
+
+      test "when a callback is modified in a child with :only, it works for the :only action" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "when a callback is modified in a child with :only, it does not work for other actions" do
+        @controller.process(:not_index)
+        assert_equal "", @controller.response_body
+      end
+    end
+
+    class SetsResponseBody < ControllerWithCallbacks
+      before_filter :set_body
+
+      def index
+        self.response_body = "Fail"
+      end
+
+      def set_body
+        self.response_body = "Success"
+      end
+    end
+
+    class TestHalting < ActiveSupport::TestCase
+      test "when a callback sets the response body, the action should not be invoked" do
+        controller = SetsResponseBody.new
+        controller.process(:index)
+        assert_equal "Success", controller.response_body
+      end
+    end
+
+    class CallbacksWithArgs < ControllerWithCallbacks
+      set_callback :process_action, :before, :first
+
+      def first
+        @text = "Hello world"
+      end
+
+      def index(text)
+        self.response_body = @text + text
+      end
+    end
+
+    class TestCallbacksWithArgs < ActiveSupport::TestCase
+      test "callbacks still work when invoking process with multiple args" do
+        controller = CallbacksWithArgs.new
+        controller.process(:index, " Howdy!")
+        assert_equal "Hello world Howdy!", controller.response_body
+      end
+    end
+
+
+  end
+end
+
+__END__
+describe Filters do
+  
+  let(:dummy_class) { Class.new { include(Filters) } }
+  
+  describe 'ClassMethods' do
+    subject { dummy_class }
+    
+    describe '.some_class_method' do
+      it { should respond_to(:some_class_method) }
+    end
+    
+  end
+  
+  describe 'InstanceMethods' do
+    subject { dummy_class.new }
+    
+    describe '#some_instance_method' do
+      it { should respond_to(:some_instance_method) }
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: object-filters
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Scott Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: version
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+description: This gem provides ActionController::Filters for normal applications.
+email:
+- ryan@rynet.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- VERSION
+- filters.gemspec
+- lib/filters.rb
+- spec/filters_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/filters
+licenses: []
+post_install_message: This is a placeholder gem... for now. Check back in a few versions!
+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: Use before, after, and around filters with your objects!
+test_files: []