arcane 0.1.1 → 1.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c157016d7b457a09a15c6222079d7d96725d8381
+  data.tar.gz: 90e1df401507d8c4281cf709580b23aebc72f958
+SHA512:
+  metadata.gz: 75a7e859ce0552b16632bc9bc777cb3fcc621a7ef10403b6f9ceb24f91a39c96b7313c158908a28d8d8539c1556986c228f7b9c0dc817b26cd2a0c95a5559c91
+  data.tar.gz: d241c9243a4b3a194e92add373e31b56dd9a162f0631ad155ac287930a866e5abd7f1b8b63e8b8f5bb2c9203f5f21e31efbfceb8904d8566f6fd3845377e3abe

data/CHANGELOG.md

@@ -1,9 +1,22 @@
-### Arcane **0.1.1** [head] – 2013-07-11
+### Arcane **1.0.0.pre** [head] - 2013-07-12
+* **[deprecation]** The `refine` helper no longer
+  exist, as it's a proposed keyword for ruby 2.0 look
+  to the new features for how to access arcane.
+
+* **[feature]** Introducing chained methods on `params`
+  to specify for what, who and how you want arcane to
+  refine your parameters. Look in `README.md` for
+  detailed information.
+
+* **[bugfix]** You can now properly specify
+  `refinery_class` in your model.
+
+### Arcane **0.1.1** [current] – 2013-07-11
 * **[feature]** The `refine` helper no longer needs a
   refinery method, it will try and detect which one to
   use based on parameters.
 
-### Arcane **0.1.0** [current] – 2013-07-11
+### Arcane **0.1.0** [old] – 2013-07-11
 * **[bugfix]** Arcane should no longer error when there is
   no current_user present.
 * **[feature]** Added new query syntax for the `refine`

data/README.md

@@ -13,16 +13,28 @@ Inspired by [Pundit](https://github.com/elabs/pundit)
 
 ## Usage
 
-This is how easy it will be:
+This is how easy it is to use:
 
 ```ruby
-@article = Article.new refine(Article, :create)
+def create
+  @article = Article.new params.for(Article).refine
+end
+
+def update
+  @article.find(params[:id])
+  @article.update_attributes params.for(@article).as(current_user).refine
+end
+
+def destroy
+  @article.find(params[:id])
+  @article.update_attributes params.for(@article).on(:destroy).refine
+end
 ```
 
-### Include the Helper
+### Include the Arcane Module
 
 Though, we need to do a couple of things before we can get started. First of all include `Arcane` in your
-controller. This will give you access to the `refine` helper.
+controller. This will extend strong parameters with all the arcane methods you saw above in the example.
 
 ```ruby
 # app/controllers/application_controller.rb
@@ -33,7 +45,7 @@ end
 
 ### Create your first Refinery
 
-Before you can use the `refine` helper, you need a Refinery for the model you want to pass parameters to.
+Before you can use the parameter methods, you need a Refinery for the model you want to pass parameters to.
 Simply create the directory `/app/refineries` in your Rails project. Create a Refinery your model, in this
 case Article. `/app/refineries/article_refinery.rb`. Create a class in that file called `ArticleRefinery`.
 
@@ -41,9 +53,8 @@ Methods defined in the refinery should reflect the controller method for clarity
 want it to be. These methods must return an array containing the same parameters you would otherwise send
 to strong parameters.
 
-It can be initiated using a `Struct` which accepts an `object` and a `user`. The `refine` method will
-automatically send `current_user`, if present to the refinery as well as the object you want to apply
-the parameters on.
+It can be initiated using a `Struct` which accepts an `object` and a `user`. Arcane will automatically send
+`current_user`, if present to the refinery as well as the object you want to apply the parameters on.
 
 ```ruby
 # app/refineries/article_refinery.rb
@@ -66,60 +77,82 @@ class CommentRefinery < Arcane::Refinery; end
 
 ### Using Arcane in your controller
 
-Next up, using the `refine` helper. The helper can be called from anywhere in your controller and views
-and accepts one parameter, the object for which you want to *refine* the parameters, then followed by
-calling the method for what parameters you want.
+Next up, using the Arcane methods. There first three are; `for`, `as`, `on` and can all be called on
+an instance of rails params, chained, and in any order you want. The fourth one, `refine` you call to
+pull your parameters through a refinery.
+
+* `for` - The model or object you want to filter parameters
+* `as` - The user performing the action, by default `current_user`
+* `on` - The action or rather, refinery method that is called
+
+* `refine` - Wraps everything up and finds your desired filter.
 
 ```ruby
-refined_params = refine @article, :create
+refined_params = params.for(@article).as(current_user).on(:update).refine
 ```
 
-In context of the controller method it might look something like this:
+Here's an example of how a controller can look with Arcane paramters.
 
 ```ruby
-class ArticlesController < ApplicationController
-
+class GameController < ApplicationController
   def create
-    @article = Article.new(refine(Article,:create))
-    @article.save
+    @game = Game.create(params.for(Game).as(user_from_location).refine)
   end
 
   def update
-    @article = Article.find(params[:id])
-    @article.update_attributes(refine(@article,:update))
+    @article.find(params[:id])
+    @article.update_attributes params.for(@article).as(current_user).refine
   end
 
-end
+  def update_many
+    @games = Game.find(params[:ids])
+    @games.each do |game|
+      game.update_attributes(params.for(@game).on(:update).refine)
+    end
+  end
+
+private
 
+  def user_from_location
+    # ...
+  end
+end
 ```
 
 ## Features
 
-### Custom Parameters
-Arcane isn't all magic (though mostly). You can pass your own parameters to the `refine` method, without
-having to worry which order you put them in as long as the permit object is the first one.
+### Invokable anywhere.
+As arcane extends ActionController::Parameters you can invoke in anywhere and start toying around with
+the arcane methods. This is good if you have some other way of getting data in to your application outside
+the context of a controller.
 
 ```ruby
-  my_params = { article: { title: "Hello" } }
-  refine(@article,my_params,:create)
-  refine(@article,:update,my_params)
+  @user, @post = User.find(1), Post.find(24)
+
+  my_params = ActionController::Parameters.new({ post: { content: "Hello" } })
+  my_params.for(@post).as(@user).on(:create)
 ```
 
 ### Automatic Method Detection
-If you have specified no refinery method in your call to `refine`, Arcane tries to find out for itself
-what method to use. If you send the params in from a rails controller, Arcane will use the `action` key
-on the parameters and use your refinery. *If you want to know how to handle fallbacks, see next feature.*
+If you have specified no refinery action in your chain to params, Arcane tries to find out for itself
+what method to use. Arcane uses the action key in the rails parameters to determine the refinery method.
 
 ```ruby
 class CommentsController < ApplicationController
   def update
     @comment = Comment.find(params[:id])
-    @comment.update_attributes refine @comment
+    @comment.update_attributes params.for(@comment)
+  end
+end
+
+class CommentRefinery < Arcane::Refinery
+  def update
+    [:email,:name,:text]
   end
 end
 ```
 
-### Default Parameters
+### Default parameters
 You are able to specify a `default` method in your refinery which will be prioritized if no the method
 you call does not exist. If default is not specified it will be as the refinery returned an empty array.
 
@@ -131,7 +164,7 @@ class AmbiguityRefinery < Arcane::Refinery
 end
 ```
 
-### Root Requirement
+### Custom root requrement
 You are able to disable or change the root requirement. Let's say you have a sessions endpoint where
 you don't have your username and password parameters wrapped in a root. Now you can use the root class
 method and set it to nil or false and it will automatically not require it.
@@ -156,6 +189,33 @@ class MeRefinery < UserRefinery
 end
 ```
 
+### Refinery Inheritence
+Say you have quite similar needs between two different models, one of them might even have inherited
+from the other. As arcane's refineries are just regular ruby models you can easily inherit from one
+to another and it will just work.
+
+```ruby
+class Square
+  attr :height, :width
+end
+
+class Cube < Square
+  attr :depth
+end
+
+class SquareRefinery
+  def create
+    [:height,:width]
+  end
+end
+
+class CubeRefinery
+  def create
+    [:depth] + super
+  end
+end
+```
+
 ## Requirements
 
 Currently this gem is only supported for Rails and with any of these ruby versions:

data/lib/arcane.rb

@@ -1,49 +1,41 @@
-require "arcane/version"
-require "arcane/finder"
-require "arcane/chain"
-require "arcane/refinery"
-
 require 'active_support/concern'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/object/blank'
 require 'strong_parameters'
 
+require "arcane/version"
+require "arcane/finder"
+require "arcane/refinery"
+require "arcane/parameters"
+
 module Arcane
 
   extend ActiveSupport::Concern
 
   included do
+
     if respond_to?(:helper_method)
       helper_method :refine
+      helper_method :current_params_user
     end
+
     if respond_to?(:hide_action)
       hide_action :refine
+      hide_action :current_params_user
     end
-  end
-
-  def refine(object,*args)
-
-    current_user = nil unless respond_to?(:current_user)
 
-    opts = { }
+  end
 
-    args.each do |arg|
-      if [String,Symbol].any? { |c| arg.kind_of?(c) }
-        opts[:method] ||= arg
-      elsif [Hash,HashWithIndifferentAccess,ActionController::Parameters].any? { |c| arg.kind_of?(c) }
-        opts[:params] ||= arg
-      elsif current_user.nil?
-        opts[:user]   ||= arg
-      end
-    end
+  def current_params_user
+    respond_to?(:current_user) ? current_user : nil
+  end
 
-    opts[:method] ||= params[:action]
-    opts[:params] ||= params
-    opts[:user]   ||= current_user
-    opts[:object] ||= object.respond_to?(:new) ? object.new : object
+  def params
+    @_params ||= ActionController::Parameters.new(request.parameters).as(current_params_user)
+  end
 
-    chain = Arcane::Chain.new(opts[:params],opts[:object],opts[:user])
-    return opts[:method].present? ? chain.send(opts[:method]) : chain
+  def params=(val)
+    @_params = val.kind_of?(Hash) ? ActionController::Parameters.new(val).as(current_params_user) : val.as(current_params_user)
   end
 
 end

data/lib/arcane/finder.rb

@@ -8,7 +8,7 @@ module Arcane
       @object = object
     end
 
-    def arcane
+    def refinery
       klass = find
       klass = klass.constantize if klass.is_a?(String)
       klass
@@ -33,9 +33,9 @@ module Arcane
 
     def find
       if object.respond_to?(:arcane_class)
-        object.arcane_class
+        object.refinery_class
       elsif object.class.respond_to?(:arcane_class)
-        object.class.arcane_class
+        object.class.refinery_class
       else
         klass = self.class.object_name(object)
         "#{klass}Refinery"

data/lib/arcane/parameters.rb

@@ -0,0 +1,77 @@
+module Arcane
+
+  module Parameters
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      attr_accessor :user, :object, :action
+
+      def dup
+        self.class.new(self).tap do |duplicate|
+          duplicate.user    = user
+          duplicate.object  = object
+          duplicate.action  = action
+          duplicate.default = default
+          duplicate.instance_variable_set :@permitted, @permitted
+        end
+      end
+
+    end
+
+    def for(object)
+      params = self.dup
+      params.object = object
+      return params
+    end
+
+    def as(user)
+      params = self.dup
+      params.user = user
+      return params
+    end
+
+    def on(action)
+      params = self.dup
+      params.action = action
+      return params
+    end
+
+    def refine(opts={})
+      params = self.dup
+
+      params.action = opts[:action] || action || params[:action]
+      params.user   = opts[:user]   || user
+      params.object = opts[:object] || object
+
+      refinery = Arcane::Finder.new(params.object).refinery.new(params.object, params.user)
+
+      args = if params.action.nil?
+        []
+      elsif refinery.respond_to?(params.action)
+        refinery.public_send(params.action)
+      elsif refinery.respond_to?(:default)
+        refinery.default
+      else
+        []
+      end
+
+      root = if refinery.respond_to?(:root)
+        refinery.root
+      elsif refinery.class.respond_to?(:root)
+        refinery.class.root
+      else
+        Arcane::Finder.object_name(params.object)
+      end
+
+      return root.present? ? params.require(root.underscore).permit(*args) : params.permit(*args)
+
+    end
+
+  end
+
+
+end
+
+ActionController::Parameters.send :include, Arcane::Parameters

data/lib/arcane/version.rb

@@ -1,3 +1,3 @@
 module Arcane
-  VERSION = "0.1.1"
+  VERSION = "1.0.0.pre"
 end

data/spec/arcane/finder_spec.rb

@@ -2,34 +2,34 @@ require 'spec_helper'
 
 describe Arcane::Finder do
 
-  let(:object_with_arcane) { Task.new }
-  let(:object_without_arcane) { Shape.new }
+  let(:object_with_refinery) { Task.new }
+  let(:object_without_refinery) { Shape.new }
 
-  before(:each) { @arcane = Arcane::Finder.new(object_with_arcane) }
+  before(:each) { @refinery = Arcane::Finder.new(object_with_refinery) }
 
   describe '.new' do
     it 'sets the object' do
-      @arcane.object.should eq(object_with_arcane)
+      @refinery.object.should eq(object_with_refinery)
     end
   end
 
   describe '#find' do
 
-    it 'finds existing arcane' do
-      @arcane.send(:find).should eq "TaskRefinery"
+    it 'finds existing refinery' do
+      @refinery.send(:find).should eq "TaskRefinery"
     end
 
   end
 
-  describe '#arcane' do
+  describe '#refinery' do
 
-    it 'returns arcane' do
-      @arcane.arcane.should eq TaskRefinery
+    it 'returns refinery' do
+      @refinery.refinery.should eq TaskRefinery
     end
 
-    it 'returns base arcane class when no arcane exists' do
-      @arcane = Arcane::Finder.new(object_without_arcane)
-      @arcane.arcane.should eq Arcane::Refinery
+    it 'returns base refinery class when no refinery exists' do
+      @refinery = Arcane::Finder.new(object_without_refinery)
+      @refinery.refinery.should eq Arcane::Refinery
     end
 
   end

data/spec/arcane/parameters_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Arcane::Parameters do
+
+  let(:user)   { double }
+  let(:object) { NilModel.new }
+  let(:action) { :unknown }
+  let(:params) { nil_model_params }
+  let(:refinery) { NilModelRefinery }
+
+  let(:subject)       { subject_class.new(params).for(object).on(action).as(user) }
+  let(:subject_class) { ActionController::Parameters }
+
+  describe '#for' do
+    it { subject.for(object).should be_a ActionController::Parameters }
+    it { subject.for(object).object.should eq object }
+  end
+
+  describe '#as' do
+    it { subject.as(user).should be_a ActionController::Parameters }
+    it { subject.as(user).user.should eq user }
+  end
+
+  describe '#on' do
+    it { subject.on(action).should be_a ActionController::Parameters }
+    it { subject.on(action).action.should eq action }
+  end
+
+  describe '#refine' do
+
+    it { subject.refine.should be_a ActionController::Parameters }
+
+    context 'with exstensive parameters' do
+
+      let(:user)   { double }
+      let(:object) { Article.new }
+      let(:params) { article_params }
+
+      it 'filters correctly' do
+        subject.on(:update).refine.should eq expected_params(:article,:title,:content)
+      end
+
+      it 'filters nested object parameters correctly' do
+        subject.on(:create).refine.should eq expected_params(:article,:title,:content,:links)
+      end
+
+      it 'filters nested scalar parameters correctly' do
+        subject.on(:publish).refine.should eq expected_params(:article,:title,:content,:tags)
+      end
+
+    end
+
+    context 'action is not set' do
+
+      let(:params)  { nil_model_params action: 'create' }
+      let(:subject) { subject_class.new(params).for(object).as(user) }
+
+      it 'uses the params to determine refinery action' do
+        NilModelRefinery.any_instance.should_receive :create
+        subject.refine
+      end
+
+      it 'uses the options to determine refinery action' do
+        NilModelRefinery.any_instance.should_receive :create
+        subject.refine action: :create
+      end
+
+    end
+
+    context 'user is not set' do
+
+      let(:user)      { double(name: :test) }
+      let(:subject)   { subject_class.new(params).for(object).on(action) }
+
+      it 'uses user from options' do
+        expect(subject).to receive(:user).once
+        subject.refine(user: user)
+      end
+
+    end
+
+  end
+
+end

data/spec/arcane_spec.rb

@@ -2,99 +2,22 @@ require 'spec_helper'
 
 describe Arcane do
 
-  let(:user)    { double }
-  let(:article) { Article.new }
-  let(:comment) { Comment.new }
-  let(:controller) { double(:current_user => user, :params => params).tap { |c| c.extend(Arcane) } }
-  let(:params) do
-    HashWithIndifferentAccess.new({
-      article: {
-        title:   "hello",
-        content: "world",
-        links: [
-          { blog: "http://blog.example.com" },
-          { site: "http://www.example.com" },
-        ],
-        tags: ["test","greeting"]
-      }
-    })
-  end
-  let(:custom_params) do
-    HashWithIndifferentAccess.new({
-      article: {
-        tags: ["test","greeting"]
-      }
-    })
-  end
-
-  describe '#refine' do
-
-    it { controller.refine(article).should be_a Arcane::Chain }
-    it { controller.refine(article,:update).should be_a ActionController::Parameters }
-    it { controller.refine(article).update.should be_a ActionController::Parameters }
-    it { controller.refine(Article)._object.should be_a Article }
-
-    context 'without supplying a refinery method' do
-
-      let(:params) do
-        HashWithIndifferentAccess.new({
-          action: 'create',
-          comment: {
-           content: "Awesome!",
-           score: 5
-          }
-        })
-      end
-
-      it 'still returns a parameters hash' do
-        controller.refine(comment).should be_a ActionController::Parameters
-      end
-
-      it 'finds the right method' do
-        controller.refine(comment).should eq expected_params(:comment,:score,:content)
-      end
-
-      context 'using a missing refinery method' do
-
-        let(:params) do
-          HashWithIndifferentAccess.new({
-            action: 'update',
-            comment: {
-             content: "Awesome!",
-             score: 5
-            }
-          })
-        end
-
-        it 'falls back on default' do
-          controller.refine(comment).should eq expected_params(:comment,:score)
-        end
-
-      end
-
-    end
-
-    it 'filters parameters correctly' do
-      controller.refine(article).update.should eq expected_params(:article,:title,:content)
-    end
-
-    it 'filters nested object parameters correctly' do
-      controller.refine(article).create.should eq expected_params(:article,:title,:content,:links)
-    end
-
-    it 'filters nested scalar parameters correctly' do
-      controller.refine(article).publish.should eq expected_params(:article,:title,:content,:tags)
+  let(:user)       { double(name: :user) }
+  let(:parameters) { nil_model_params }
+  let(:controller) { double(request: request, current_user: user).tap { |c| c.extend(Arcane) } }
+  let(:request)    { double(parameters: parameters) }
+
+  describe '#params' do
+    it 'sets the user for parameters' do
+      controller.params.user.should eq user
     end
+  end
 
-    it 'filters custom parameters correctly' do
-      controller.refine(article,custom_params,:publish).should eq expected_params(:article,:tags)
-      controller.refine(article,:publish,custom_params).should eq expected_params(:article,:tags)
+  describe '#params=' do
+    it 'sets the user for parameters' do
+      controller.params = { foo: :bar }
+      controller.instance_variable_get(:@_params).user.should eq user
     end
-
   end
 
-end
-
-def expected_params(object_name,*includes)
-  params[object_name].reject { |k,_| !includes.include? k.to_sym }
 end

data/spec/spec_helper.rb

@@ -3,6 +3,19 @@ require "pry"
 require "active_support/core_ext"
 require "active_model/naming"
 
+class NilModel; end
+class NilModelRefinery < Struct.new(:object,:user)
+
+  def create
+    [:attribute]
+  end
+
+  def default
+    create
+  end
+
+end
+
 class Article; end
 class ArticleRefinery < Arcane::Refinery
 
@@ -46,4 +59,30 @@ class CommentRefinery < Arcane::Refinery
     [:score]
   end
 
+end
+
+def article_params
+  ActionController::Parameters.new({
+    action: 'create',
+    article: {
+      title:   "hello",
+      content: "world",
+      links: [
+        { blog: "http://blog.example.com" },
+        { site: "http://www.example.com" },
+      ],
+      tags: ["test","greeting"]
+    }
+  })
+end
+
+def nil_model_params(opts={})
+  ActionController::Parameters.new({
+    action: 'unknown',
+    nil_model: { attribute: :value }
+  }).merge(opts)
+end
+
+def expected_params(object_name,*includes)
+  params[object_name].reject { |k,_| !includes.include? k.to_sym }
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arcane
 version: !ruby/object:Gem::Version
-  version: 0.1.1
-  prerelease: 
+  version: 1.0.0.pre
 platform: ruby
 authors:
 - Philip Vieira
@@ -10,60 +9,53 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: strong_parameters
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -71,7 +63,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -79,33 +70,29 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
   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'
 - !ruby/object:Gem::Dependency
   name: rake
   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: Parameter filter done OO, extending strong parameters.
@@ -125,49 +112,42 @@ files:
 - Rakefile
 - arcane.gemspec
 - lib/arcane.rb
-- lib/arcane/chain.rb
 - lib/arcane/finder.rb
+- lib/arcane/parameters.rb
 - lib/arcane/refinery.rb
 - lib/arcane/version.rb
-- spec/arcane/chain_spec.rb
 - spec/arcane/finder_spec.rb
+- spec/arcane/parameters_spec.rb
 - spec/arcane/refinery_spec.rb
 - spec/arcane_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/cloudsdaleapp/arcane
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1025235848978620495
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 1025235848978620495
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Extension for strong_parameters.
 test_files:
-- spec/arcane/chain_spec.rb
 - spec/arcane/finder_spec.rb
+- spec/arcane/parameters_spec.rb
 - spec/arcane/refinery_spec.rb
 - spec/arcane_spec.rb
 - spec/spec_helper.rb

data/lib/arcane/chain.rb

@@ -1,43 +0,0 @@
-module Arcane
-
-  class Chain
-
-    attr_reader :_params, :_user, :_object, :_arcane, :_arcane_class
-
-    def initialize(_params,_object,_user)
-      @_user           = _user
-      @_object         = _object
-      @_params         = ActionController::Parameters.new(_params)
-      @_arcane_class = Arcane::Finder.new(_object).arcane
-      @_arcane       = @_arcane_class.new(_object,_user)
-    end
-
-    def method_missing(_arcane_method,*args)
-
-      if _arcane.respond_to?(_arcane_method)
-        _computed = _arcane.public_send(_arcane_method)
-      elsif _arcane.respond_to?(:default)
-        _computed = _arcane.default
-      else
-        _computed = []
-      end
-
-      if _arcane.respond_to?(:root)
-        _root = arcane.root
-      elsif _arcane_class.respond_to?(:root)
-        _root = _arcane_class.root
-      else
-        _root = Arcane::Finder.object_name(_object)
-      end
-
-      if _root.present?
-        _params.require(_root.parameterize).permit(*_computed)
-      else
-        _params.permit(*_computed)
-      end
-
-    end
-
-  end
-
-end

data/spec/arcane/chain_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Arcane::Chain do
-
-  let(:chain) { Arcane::Chain.new(params,object,user) }
-
-  let(:user)            { double }
-  let(:object)          { Article.new }
-  let(:arcane_class)  { ArticleRefinery }
-  let(:params)          { ActionController::Parameters.new(hash_params) }
-  let(:hash_params) do
-    {
-      article: {
-        title:   "hello",
-        content: "world",
-        links: [
-          { blog: "http://blog.example.com" },
-          { site: "http://www.example.com" },
-        ]
-      }
-    }
-  end
-
-  describe '.new' do
-
-    it 'sets attributes' do
-      chain._params.should         eq(params)
-      chain._object.should         eq(object)
-      chain._user.should           eq(user)
-      chain._arcane.should       be_a(arcane_class)
-      chain._arcane_class.should eq(arcane_class)
-    end
-
-    it 'converts the object to ActionController::Parameters' do
-      chain = Arcane::Chain.new(hash_params,object,user)
-      chain._params.should be_a ActionController::Parameters
-    end
-
-  end
-
-  describe '#method_missing' do
-
-    it 'returns the filtered parameters' do
-      chain.void_method.should be_a ActionController::Parameters
-    end
-
-    it 'filters the same as the default constraint' do
-      chain.void_method.should eq chain.default
-    end
-
-    context 'without root in params' do
-      let(:chain) { Arcane::Chain.new(params[:article],object,user) }
-      it 'raises an error' do
-        expect { chain.void_method }.to raise_error ActionController::ParameterMissing
-      end
-      it 'successds with nil root in arcane' do
-        arcane_class.stub(:root) { false }
-        expect { chain.void_method }.to_not raise_error
-        arcane_class.stub(:root) { nil }
-        expect { chain.void_method }.to_not raise_error
-      end
-    end
-
-  end
-
-end