sinatra-filtering_parameters 0.1.0 → 0.1.1

data/.gitignore

@@ -1,3 +1,5 @@
 html/
 pkg/
+tmp/
 Guardfile
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'sinatra', :git => 'git://github.com/sinatra/sinatra'
+gem 'sinatra-contrib', :git => 'git://github.com/sinatra/sinatra-contrib.git'
+
+group :development do
+  gem 'guard-rspec'
+  gem 'rb-fsevent', '~> 0.9.1'
+end

data/lib/sinatra/filtering_parameters.rb

@@ -6,13 +6,13 @@ module Sinatra
       def registered(app)
         app.set(:allow) do |*filters|
           condition do
-            _params = params.dup
-            params.clear
+            original = @params.dup
+            @params.clear
             %w[ splat captures ].each do |name|
-              params[name] = _params.delete(name) if _params.include?(name)
+              @params[name] = original.delete(name) if original.include?(name)
             end
-            hoge = Sinatra::FilteringParameters.allow(_params, filters)
-            params.merge! hoge
+            allow_params = Sinatra::FilteringParameters.allow(original, filters)
+            @params.merge! indifferent_params(allow_params)
           end
         end
       end

data/lib/sinatra/filtering_parameters/version.rb

@@ -1,6 +1,6 @@
 module Sinatra
   module FilteringParameters
     # sinatra-filtering_parameters version
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/spec/nested_parameters_spec.rb

@@ -2,202 +2,170 @@ require 'spec_helper'
 
 describe Sinatra::FilteringParameters do
 
-  def post_with_filter(args)
-    mock_app do
-      register Sinatra::FilteringParameters
-      post('/', allow: args[:allow]){ params.to_json }
-    end
-    post '/', args[:pass_params]
+  def expect_with(parameters, keys, &block)
+    mock_route '/', :allow => keys, &block
+    post '/', parameters
   end
 
   it "permitted nested parameters" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :title => "Romeo and Juliet",
-          :authors => [{
-            :name => "William Shakespeare",
-            :born => "1564-04-26"
-          }, {
-            :name => "Christopher Marlowe"
-          }],
-          :details => {
-            :pages => 200,
-            :genre => "Tragedy"
-          }
-        },
-        :magazine => "Mjallo!"
-      },
-      :allow => [
-        :book => [
-          :title,
-          :authors => :name,
-          :details => :pages
-        ]
-      ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "title" => "Romeo and Juliet",
-        "authors" => [{
-          "name" => "William Shakespeare"
-        },{
-          "name" => "Christopher Marlowe"
+    parameters = {
+      :book => {
+        :title => "Romeo and Juliet",
+        :authors => [{
+          :name => "William Shakespeare",
+          :born => "1564-04-26"
+        }, {
+          :name => "Christopher Marlowe"
         }],
-        "details" => {
-          "pages" => "200"
-        }
-      }
-    })
-  end
-  it "nested arrays with strings" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :genres => ["Tragedy"]
+        :details => {
+          :pages => 200,
+          :genre => "Tragedy"
         }
       },
-      :allow => [
-        :book => :genres
+      :magazine => "Mjallo!"
+    }
+    keys = {
+      :book => [
+        :title,
+        :authors => :name,
+        :details => :pages
       ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "genres" => ["Tragedy"]
+    }
+    expect_with parameters, keys do
+      params[:book][:title].should == 'Romeo and Juliet'
+      params[:book][:authors][0][:name].should == 'William Shakespeare'
+      params[:book][:authors][1][:name].should == 'Christopher Marlowe'
+      params[:book][:details][:pages].should == '200'
+      params[:book][:details][:genre].should be_nil
+      params[:book][:authors][1][:born].should be_nil
+      params[:magazine].should be_nil
+    end
+  end
+
+  it "nested arrays with strings" do
+    parameters = {
+      :book => {
+        :genres => ["Tragedy"]
       }
-    })
+    }
+    keys = {
+      :book => :genres
+    }
+    expect_with parameters, keys do
+      params[:book][:genres].should == ['Tragedy']
+    end
   end
 
   it "permit may specify symbols or strings" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :title => "Romeo and Juliet",
-          :author => "William Shakespeare"
-        },
-        :magazine => "Shakespeare Today"
+    parameters = {
+      :book => {
+        :title => "Romeo and Juliet",
+        :author => "William Shakespeare"
       },
-      :allow => [{
-        :book => [
-          "title",
-          :author
-        ]},
-        "magazine"
-      ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "title" => "Romeo and Juliet",
-        "author" => "William Shakespeare",
-      },
-      "magazine" => "Shakespeare Today"
-    })
+      :magazine => "Shakespeare Today"
+    }
+    keys = [{
+      :book => [
+        "title",
+        :author
+      ]},
+      "magazine"
+    ]
+    expect_with parameters, keys do
+      params[:book][:title].should == 'Romeo and Juliet'
+      params[:book][:author].should == 'William Shakespeare'
+      params[:magazine].should == 'Shakespeare Today'
+    end
   end
 
   it "nested array with strings that should be hashes" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :genres => ["Tragedy"]
-        }
-      },
-      :allow => [
-        :book => [
-          :genres => :type
-        ]
+    parameters = {
+      :book => {
+        :genres => ["Tragedy"]
+      }
+    }
+    keys = {
+      :book => [
+        :genres => :type
       ]
-    )
-    result_should_be_equal({})
+    }
+    expect_with parameters, keys do
+      params.should be_empty
+    end
   end
 
   it "nested array with strings that should be hashes and additional values" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :title => "Romeo and Juliet",
-          :genres => ["Tragedy"]
-        }
-      },
-      :allow => [
-        :book => [
-          :title,
-          :genres => :type
-        ]
-      ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "title" => "Romeo and Juliet"
+    parameters = {
+      :book => {
+        :title => "Romeo and Juliet",
+        :genres => ["Tragedy"]
       }
-    })
+    }
+    keys = [
+      :book => [
+        :title,
+        :genres => :type
+      ]
+    ]
+    expect_with parameters, keys do
+      params[:book][:title].should == 'Romeo and Juliet'
+    end
   end
 
   it "nested string that should be a hash" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :genre => "Tragedy"
-        }
-      },
-      :allow => [
-        :book => [
-          :genres => :type
-         ]
-      ]
-    )
-    result_should_be_equal({})
+    parameters = {
+      :book => {
+        :genre => "Tragedy"
+      }
+    }
+    keys = [
+      :book => [
+        :genres => :type
+       ]
+    ]
+    expect_with parameters, keys do
+      params.should be_empty
+    end
   end
 
   it "fields_for_style_nested_params" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :authors_attributes => {
-            :'0' => { :name => 'William Shakespeare', :age_of_death => '52' },
-            :'1' => { :name => 'Unattributed Assistant' }
-          }
-        }
-      },
-      :allow => [
-        :book => [
-          :authors_attributes => :name
-        ]
-      ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "authors_attributes" => {
-          "0" => { "name" => "William Shakespeare" },
-          "1" => { "name" => "Unattributed Assistant" }
+    parameters = {
+      :book => {
+        :authors_attributes => {
+          :'0' => { :name => 'William Shakespeare', :age_of_death => '52' },
+          :'1' => { :name => 'Unattributed Assistant' }
         }
       }
-    })
+    }
+    keys = [
+      :book => [
+        :authors_attributes => :name
+      ]
+    ]
+    expect_with parameters, keys do
+      params[:book][:authors_attributes]['0'][:name].should == 'William Shakespeare'
+      params[:book][:authors_attributes]['1'][:name].should == 'Unattributed Assistant'
+    end
   end
 
   it "fields_for_style_nested_params with negative numbers" do
-    post_with_filter(
-      :pass_params => {
-        :book => {
-          :authors_attributes => {
-            :'-1' => { :name => 'William Shakespeare', :age_of_death => '52' },
-            :'-2' => { :name => 'Unattributed Assistant' }
-          }
-        }
-      },
-      :allow => [
-        :book => [
-          :authors_attributes => :name
-        ]
-      ]
-    )
-    result_should_be_equal({
-      "book" => {
-        "authors_attributes" => {
-          "-1" => { "name" => "William Shakespeare" },
-          "-2" => { "name" => "Unattributed Assistant" }
+    parameters = {
+      :book => {
+        :authors_attributes => {
+          :'-1' => { :name => 'William Shakespeare', :age_of_death => '52' },
+          :'-2' => { :name => 'Unattributed Assistant' }
         }
       }
-    })
+    }
+    keys = [
+      :book => [
+        :authors_attributes => :name
+      ]
+    ]
+    expect_with parameters, keys do
+      params[:book][:authors_attributes]['-1'][:name].should == 'William Shakespeare'
+      params[:book][:authors_attributes]['-2'][:name].should == 'Unattributed Assistant'
+    end
   end
 
 end

data/spec/permitted_parameters_spec.rb

@@ -2,65 +2,83 @@ require 'spec_helper'
 
 describe Sinatra::FilteringParameters do
 
-  def post_with_filter(args)
-    mock_app do
-      register Sinatra::FilteringParameters
-      if args[:allow].nil?
-        post('/sample/:name'){ params.to_json }
-      else
-        post('/sample/:name', allow: args[:allow]){ params.to_json }
-      end
+  describe 'Enable string or symbol key access to the nested params hash' do
+    def expect_with(parameters, keys, &block)
+      mock_route '/', &block
+      post '/', parameters
     end
-    post '/sample/foo', args[:pass_params]
-  end
 
-  describe 'permitted parameters nothing' do
-    it "when success" do
-      post_with_filter(
-        :pass_params  =>  { :a => 1, :b => 2, :c => 3 }
-      )
-      result_should_be_equal({ "a"=>"1", "b"=>"2", "c"=>"3", "splat"=>[], "captures"=>["foo"], "name"=>"foo" })
+    it 'with filter of hash' do
+      parameters = {
+        :book => {
+          :title => "Romeo and Juliet"
+        }
+      }
+      expect_with parameters, :allow => { :book => :title } do
+        params['book']['title'].should == 'Romeo and Juliet'
+        params[:book]['title'].should  == 'Romeo and Juliet'
+        params[:book][:title].should  == 'Romeo and Juliet'
+        params['book'][:title].should  == 'Romeo and Juliet'
+      end
     end
   end
 
-  describe 'permitted parameters specified in' do
-    it 'symbol' do
-      post_with_filter(
-        :pass_params  =>  { :a => 1, :b => 2, :c => 3 },
-        :allow        =>  :name
-      )
-      result_should_be_equal({ "splat"=>[], "captures"=>["foo"], "name"=>"foo" })
+  describe 'support matching parameters' do
+    it 'for splat' do
+      mock_route '/say/*/to/*', :allow => :hoo do
+        params[:splat].should == ['hello','world']
+      end
+      get '/say/hello/to/world'
     end
-    it "string" do
-      post_with_filter(
-        :pass_params  =>  { :a => 1, :b => 2, :c => 3 },
-        :allow        =>  'name'
-      )
-      result_should_be_equal({ "splat"=>[], "captures"=>["foo"], "name"=>"foo" })
+
+    it 'for captures' do
+      mock_route %r{/hello/([\w]+)}, :allow => :hoo do
+        params[:captures].should == ['world']
+      end
+      get '/hello/world'
     end
-    it "array" do
-      post_with_filter(
-        :pass_params  =>  { :a => 1, :b => 2, :c => 3 },
-        :allow        =>  [:name, :a]
-      )
-      result_should_be_equal({ "splat"=>[], "captures"=>["foo"], "name"=>"foo", "a"=>"1" })
+  end
+
+  context 'do not specify ilter' do
+    it "does not remove anything from the parameter" do
+      mock_route '/pages/:id' do
+        params[:id].should == '1'
+        params[:foo].should == 'foo'
+        params[:bar].should == 'bar'
+        params[:baz].should == 'baz'
+        params[:captures].should == ['1']
+        params[:splat].should be_empty
+      end
+      post '/pages/1', :foo => 'foo', :bar => 'bar', :baz => 'baz'
     end
-    context "empty" do
-      it "string" do
-        post_with_filter(
-          :pass_params  =>  { :a => 1, :b => 2, :c => 3 },
-          :allow        =>  ''
-        )
-        result_should_be_equal({ "splat"=>[], "captures"=>["foo"] })
+  end
+
+  context 'will be only parameters that allowed in' do
+    def should_with(filter={})
+      mock_route '/pages', filter do
+        params.delete('foo').should == 'foo'
+        params.each { |param| param.should be_nil }
       end
-      it "array" do
-        post_with_filter(
-          :pass_params  =>  { :a => 1, :b => 2, :c => 3 },
-          :allow        =>  []
-        )
-        result_should_be_equal({ "splat"=>[], "captures"=>["foo"] })
+      post '/pages', :foo => 'foo', :bar => 'bar', :baz => 'baz'
+    end
+
+    it('symbol'){ should_with :allow => :foo }
+    it("string"){ should_with :allow => 'foo' }
+    it("array") { should_with :allow => [:foo] }
+  end
+
+  context 'parameter will be empty when specify in' do
+    def should_with(filter={})
+      mock_route '/pages', filter do
+        params.each { |param| param.should be_nil }
       end
+      post '/pages', :foo => 'foo', :bar => 'bar', :baz => 'baz'
     end
+
+    it("blank string"){ should_with :allow => '' }
+    it("empty array") { should_with :allow => [] }
+    it("empty hash")  { should_with :allow => {} }
+    it("nil")         { should_with :allow => nil }
   end
 
 end

data/spec/spec_helper.rb

@@ -5,14 +5,19 @@ require 'rack/test'
 require 'sinatra'
 require 'sinatra/contrib'
 require 'sinatra/filtering_parameters'
-require 'json'
 
 RSpec.configure do |config|
   config.include Rack::Test::Methods
   config.include Sinatra::TestHelpers
 end
 
-def result_should_be_equal(filterd_params)
-  last_response.body.should == filterd_params.to_json
+def mock_route(path, opts={}, &block)
+  mock_app do
+    include RSpec::Matchers
+    register Sinatra::FilteringParameters
+    %w(get post put delete head options patch).each do |verb|
+      send(verb.to_sym, path, opts, &block)
+    end
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-filtering_parameters
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-26 00:00:00.000000000 Z
+date: 2013-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -133,6 +133,7 @@ files:
 - .document
 - .gitignore
 - .rspec
+- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile