scoped_from 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60b1498cb3cb9245b530983e03de6747afc745ae
-  data.tar.gz: de5a35a889949ab68cab01190a2621e2eb1617b9
+  metadata.gz: 4289bd8c3bbfa67e32434e234a812d6c7355722d
+  data.tar.gz: f8f519eba2ed19382bd26dac18ed29235b2f2f36
 SHA512:
-  metadata.gz: 23769faa9d0b74681da6d8be60a0c9768519c3a08871a68f73725f4b18763b292471669022b2be4e6001d73e106c47d9a1ea88b7e69cb089413a14aa74c31e1a
-  data.tar.gz: 204779901e30475f4dfc0adc59f5ec4eb7719944d5aff87aeca19b92ec6a602c84643145d3b2d6b2ee470ab2bf15fa9f2ac72034bbc77da36117fdac203a4d3c
+  metadata.gz: d8b4baaf4d2624f44422b79bf2fe124e7f8f21dcfd9d097638f97e7b4832135eef8bcdf70d803317acb3a5f59dffc7de73f05747718d161473e3e7853f524afd
+  data.tar.gz: 5921566963a8c2e17538acd47b5a91f1fe4007405f0297f2310d67341c2a361fa0d4a7f550f35434fe9f1d2b4e7148ba60b135dcb9c9fb17aa78f114b2872233

data/Gemfile.lock

@@ -1,35 +1,36 @@
 PATH
   remote: .
   specs:
-    scoped_from (0.7.0)
-      activerecord (~> 3.2.0)
-      activesupport (~> 3.2.0)
+    scoped_from (0.8.0)
+      activerecord (~> 4.0.0)
+      activesupport (~> 4.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (3.2.13)
-      activesupport (= 3.2.13)
-      builder (~> 3.0.0)
-    activerecord (3.2.13)
-      activemodel (= 3.2.13)
-      activesupport (= 3.2.13)
-      arel (~> 3.0.2)
-      tzinfo (~> 0.3.29)
-    activesupport (3.2.13)
-      i18n (= 0.6.1)
-      multi_json (~> 1.0)
-    arel (3.0.2)
-    builder (3.0.4)
-    byebug (1.6.1)
-      columnize (~> 0.3.6)
-      debugger-linecache (~> 1.2.0)
-    columnize (0.3.6)
-    debugger-linecache (1.2.0)
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.0)
+    atomic (1.1.10)
+    builder (3.1.4)
     diff-lcs (1.2.4)
-    i18n (0.6.1)
+    i18n (0.6.4)
+    minitest (4.7.5)
     multi_json (1.7.7)
-    rake (10.0.4)
+    rake (10.1.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
@@ -41,14 +42,15 @@ GEM
     sqlite3 (1.3.7)
     sqlite3-ruby (1.3.3)
       sqlite3 (>= 1.3.3)
+    thread_safe (0.1.0)
+      atomic
     tzinfo (0.3.37)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  byebug (~> 1.6.0)
-  rake (~> 10.0.0)
+  rake (~> 10.1.0)
   rspec (~> 2.14.0)
   scoped_from!
   sqlite3-ruby (~> 1.3.0)

data/README.mdown

@@ -64,21 +64,21 @@ Columns are also automatically scoped.
 
 You can restrict mapping to some scopes with `:only` option:
 
-    @posts = Post.scoped_from(params, :only => ['commented', 'search'])
+    @posts = Post.scoped_from(params, only: ['commented', 'search'])
 
 You can also exclude some scopes from mapping with `:except` option:
 
-    @posts = Post.scoped_from(params, :except => 'commented')
+    @posts = Post.scoped_from(params, except: 'commented')
 
 ## Mapping order
 
 If you need to map an SQL order, just pass `order` parameter:
 
-    @posts = Post.scoped_from(:order => 'created_at')
+    @posts = Post.scoped_from(order: 'created_at')
 
 Order direction can be specified using a dot, space or `:` as delimiter:
     
-    @posts = Post.scoped_from(:order => 'created_at.desc')
+    @posts = Post.scoped_from(order: 'created_at.desc')
 
 Note that order is SQL safe with `scoped_from` method (columns names are
 checked).
@@ -88,7 +88,7 @@ checked).
 If your provide an array as parameter value, scope is invoked with each item
 of the array:
 
-    @posts = Post.scoped_from(:search => ['bar', 'foo'])
+    @posts = Post.scoped_from(search: ['bar', 'foo'])
     
 is equivalent to
     
@@ -97,7 +97,7 @@ is equivalent to
 You may also not want to filter on columns, just specify `:exclude_columns`
 option:
 
-    @posts = Post.scoped_from(params, :exclude_columns => true)
+    @posts = Post.scoped_from(params, exclude_columns: true)
 
 A query string can also be given to `scoped_from` method:
 

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.8.0

data/lib/scoped_from/active_record.rb

@@ -21,13 +21,13 @@ module ScopedFrom
       end
 
       def scope_without_argument?(name)
-        [-1, 0].include?(scope_arities[name])
+        scope_arities[name] == 0
       end
 
       def scoped_from(params, options = {})
         query_class = "#{name}Query".safe_constantize
         query_class = Query unless query_class.is_a?(Class) && query_class.ancestors.include?(Query)
-        query_class.new(self, params, options).scope
+        query_class.new(self, params, options).relation
       end
 
     end

data/lib/scoped_from/query.rb

@@ -10,9 +10,9 @@ module ScopedFrom
 
     # Available options are: - :only : to restrict to specified keys.
     #                        - :except : to ignore specified keys.
-    def initialize(scope, params, options = {})
-      @scope = scope.scoped
-      @options = options
+    def initialize(relation, params, options = {})
+      self.relation = relation
+      self.options = options
       self.params = params
     end
 
@@ -24,34 +24,52 @@ module ScopedFrom
       parse_order(params['order'])[:direction]
     end
 
-    def scope
-      scope = @scope
+    def relation
+      relation = @relation
       params.each do |name, value|
         [value].flatten.each do |value|
-          scope = scoped(scope, name, value)
+          relation = invoke_param(relation, name, value)
         end
       end
-      decorate_scope(scope)
+      decorate_relation(relation)
     end
 
     protected
 
-    def decorate_scope(scope)
-      return scope if scope.respond_to?(:query)
-      def scope.query
+    def decorate_relation(relation)
+      return relation if relation.respond_to?(:query)
+      def relation.query
         @__query
       end
-      scope.instance_variable_set('@__query', self)
-      scope
+      relation.instance_variable_set('@__query', self)
+      relation
+    end
+
+    def invoke_param(relation, name, value)
+      if name.to_s == 'order'
+        relation.order(order_to_hash(value))
+      elsif relation.scope_with_one_argument?(name)
+        relation.send(name, value)
+      elsif relation.scope_without_argument?(name)
+        relation.send(name)
+      elsif relation.column_names.include?(name.to_s)
+        relation.where(name => value)
+      else
+        relation
+      end
     end
 
     def false?(value)
       FALSE_VALUES.include?(value.to_s.strip.downcase)
     end
 
-    def order_to_sql(value)
+    def options=(options)
+      @options = options.symbolize_keys
+    end
+
+    def order_to_hash(value)
       order = parse_order(value)
-      "#{order[:column]} #{order[:direction].upcase}" if order.present?
+      order.present? ? { order[:column] => order[:direction].downcase.to_sym } : {}
     end
 
     def params=(params)
@@ -64,13 +82,13 @@ module ScopedFrom
         if name.to_s == 'order'
           orders = parse_orders(values).map { |order| "#{order[:column]}.#{order[:direction]}" }
           @params[name] = (orders.many? ? orders : orders.first) if orders.any?
-        elsif @scope.scope_without_argument?(name)
+        elsif @relation.scope_without_argument?(name)
           @params[name] = true if values.all? { |value| true?(value) }
-        elsif @scope.scope_with_one_argument?(name)
+        elsif @relation.scope_with_one_argument?(name)
           value = values.many? ? values : values.first
           @params[name] = @params[name] ? [@params[name], value].flatten : value
-        elsif @options[:exclude_columns].blank? && @scope.column_names.include?(name.to_s)
-          if @scope.columns_hash[name.to_s].type == :boolean
+        elsif @options[:exclude_columns].blank? && @relation.column_names.include?(name.to_s)
+          if @relation.columns_hash[name.to_s].type == :boolean
             @params[name] = true if values.all? { |value| true?(value) }
             @params[name] = false if values.all? { |value| false?(value) }
           else
@@ -87,30 +105,20 @@ module ScopedFrom
       column, direction = value.to_s.split(/[\.:\s]+/, 2)
       direction = direction.to_s.downcase
       direction = ORDER_DIRECTIONS.first unless ORDER_DIRECTIONS.include?(direction)
-      @scope.column_names.include?(column) ? { column: column, direction: direction } : {}
+      @relation.column_names.include?(column) ? { column: column, direction: direction } : {}
     end
 
     def parse_orders(values)
       [].tap do |orders|
-        values.each do |value|
+        values.reverse.each do |value|
           order = parse_order(value)
           orders << order if order.present? && !orders.any? { |o| o[:column] == order[:column] }
         end
       end
     end
 
-    def scoped(scope, name, value)
-      if name.to_s == 'order'
-        scope.order(order_to_sql(value))
-      elsif scope.scope_with_one_argument?(name)
-        scope.send(name, value)
-      elsif scope.scope_without_argument?(name)
-        scope.send(name)
-      elsif scope.column_names.include?(name.to_s)
-        scope.scoped(conditions: { name => value })
-      else
-        scope
-      end
+    def relation=(relation)
+      @relation = relation.is_a?(Class) ? relation.all : relation
     end
 
     def true?(value)

data/scoped_from.gemspec

@@ -1,12 +1,13 @@
 Gem::Specification.new do |s|
   s.name = 'scoped_from'
-  s.version = File.read(File.expand_path(File.dirname(__FILE__) + '/VERSION')).strip
+  s.version = File.read("#{File.dirname(__FILE__)}/VERSION").strip
   s.platform = Gem::Platform::RUBY
   s.author = 'Alexis Toulotte'
   s.email = 'al@alweb.org'
   s.homepage = 'https://github.com/alexistoulotte/scoped_from'
   s.summary = 'Mapping between scopes and parameters for Rails'
   s.description = 'Provides a simple mapping between Active Record scopes and controller parameters for Ruby On Rails 3'
+  s.license = 'MIT'
 
   s.rubyforge_project = 'scoped_from'
 
@@ -15,11 +16,10 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
-  s.add_dependency 'activerecord', '~> 3.2.0'
-  s.add_dependency 'activesupport', '~> 3.2.0'
+  s.add_dependency 'activerecord', '~> 4.0.0'
+  s.add_dependency 'activesupport', '~> 4.0.0'
 
-  s.add_development_dependency 'byebug', '~> 1.6.0'
-  s.add_development_dependency 'rake', '~> 10.0.0'
+  s.add_development_dependency 'rake', '~> 10.1.0'
   s.add_development_dependency 'rspec', '~> 2.14.0'
   s.add_development_dependency 'sqlite3-ruby', '~> 1.3.0'
 end

data/spec/mocks/user.rb

@@ -1,14 +1,8 @@
 class User < ActiveRecord::Base
 
-  scope :enabled, where(enabled: true)
-  scope :search, lambda { |pattern|
-    where('firstname LIKE ? OR lastname LIKE ?', "%#{pattern}%", "%#{pattern}%")
-  }
-  scope :created_between, lambda { |after, before|
-    where('created_at >= ? AND created_at <= ?', after, before)
-  }
-  scope :latest, lambda {
-    where('created_at >= ?', 1.week.ago)
-  }
+  scope :enabled, -> { where(enabled: true) }
+  scope :search, -> (pattern) { where('firstname LIKE ? OR lastname LIKE ?', "%#{pattern}%", "%#{pattern}%") }
+  scope :created_between, -> (after, before) { where('created_at >= ? AND created_at <= ?', after, before) }
+  scope :latest, -> { where('created_at >= ?', 1.week.ago) }
 
 end

data/spec/scoped_from/active_record_spec.rb

@@ -64,7 +64,7 @@ describe ScopedFrom::ActiveRecord do
 
     it 'just build a new query and return its scope' do
       query = double(:query)
-      query.should_receive(:scope).and_return(42)
+      query.should_receive(:relation).and_return(42)
       ScopedFrom::Query.should_receive(:new).with(User, 'foo', except: 'bam').and_return(query)
       User.scoped_from('foo', except: 'bam').should == 42
     end

data/spec/scoped_from/query_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe ScopedFrom::Query do
 
-  def query(scope = User, params = {}, options = {})
-    ScopedFrom::Query.new(scope, params, options)
+  def query(relation = User, params = {}, options = {})
+    ScopedFrom::Query.new(relation, params, options)
   end
 
   describe '#false?' do
@@ -63,11 +63,62 @@ describe ScopedFrom::Query do
 
   describe '#initialize' do
 
-    it 'invokes #scoped method on specified scope' do
-      User.should_receive(:scoped)
+    it 'invokes .all method on given class' do
+      User.should_receive(:all)
       ScopedFrom::Query.new(User, {})
     end
 
+    it 'does not invokes .all method on given relation' do
+      relation = User.all
+      relation.should_not_receive(:all)
+      ScopedFrom::Query.new(relation, {})
+    end
+
+  end
+
+  describe '#invoke_param' do
+
+    it 'returns given scope if it has no scope with specified name' do
+      query.send(:invoke_param, User, :foo, true).should == User
+    end
+
+    it 'returns given scope if scope takes more than 1 argument' do
+      query.send(:invoke_param, User, :created_between, true).should == User
+    end
+
+    it 'invokes scope without arguments if scope takes no arguments' do
+      query.send(:invoke_param, User.all, :enabled, true).should == [users(:john)]
+      query.send(:invoke_param, User.all, :enabled, ' 1 ').should == [users(:john)]
+      query.send(:invoke_param, User.all, :enabled, 'off').should == [users(:john)]
+    end
+
+    it 'invokes scope with value has argument if scope takes one argument' do
+      query.send(:invoke_param, User.all, :search, 'doe').should == [users(:john), users(:jane)]
+      query.send(:invoke_param, User.all, :search, 'john').should == [users(:john)]
+      query.send(:invoke_param, User.all, :search, 'jane').should == [users(:jane)]
+    end
+
+    it 'scope on column conditions' do
+      query.send(:invoke_param, User.all, :firstname, 'Jane').should == [users(:jane)]
+    end
+
+    it 'invokes "order"' do
+      query.send(:invoke_param, User.all, :order, 'firstname.asc').should == [users(:jane), users(:john)]
+      query.send(:invoke_param, User.all, :order, 'firstname.desc').should == [users(:john), users(:jane)]
+    end
+
+  end
+
+  describe '#options' do
+
+    it 'is set at initialization' do
+      ScopedFrom::Query.new(User, {}, bar: 'foo').instance_variable_get(:@options).should == { bar: 'foo' }
+    end
+
+    it 'keys are symbolized' do
+      ScopedFrom::Query.new(User, {}, 'bar' => 'foo').instance_variable_get(:@options).should == { bar: 'foo' }
+    end
+
   end
 
   describe '#order_column' do
@@ -288,10 +339,10 @@ describe ScopedFrom::Query do
     end
 
     it 'many order can be specified' do
-      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC'] }).params.should == { 'order' => ['firstname.asc', 'lastname.desc'] }
-      query(User, { 'order' => ['firstname.Asc', 'firstname.desc'] }).params.should == { 'order' => 'firstname.asc' }
-      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.asc', 'lastname.desc'] }
-      query(User, { 'order' => ['firstname.Asc', 'foo', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.asc', 'lastname.desc'] }
+      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC'] }).params.should == { 'order' => ['lastname.desc', 'firstname.asc'] }
+      query(User, { 'order' => ['firstname.Asc', 'firstname.desc'] }).params.should == { 'order' => 'firstname.desc' }
+      query(User, { 'order' => ['firstname.Asc', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.desc', 'lastname.desc'] }
+      query(User, { 'order' => ['firstname.Asc', 'foo', 'lastname.DESC', 'firstname.desc'] }).params.should == { 'order' => ['firstname.desc', 'lastname.desc'] }
     end
 
     it 'order can be delimited by a space' do
@@ -313,41 +364,41 @@ describe ScopedFrom::Query do
 
   end
 
-  describe '#scope' do
+  describe '#relation' do
 
     it 'does not execute any query' do
       User.should_not_receive(:connection)
-      query(User, :enabled => true).scope
+      query(User, :enabled => true).relation
     end
 
     it 'works with scopes with a lambda without arguments' do
       users(:jane).update_attribute(:created_at, 10.days.ago)
-      query(User, :latest => true).scope.should == [users(:john)]
-      query(User, :latest => false).scope.should == [users(:john), users(:jane)]
+      query(User, :latest => true).relation.should == [users(:john)]
+      query(User, :latest => false).relation.should == [users(:john), users(:jane)]
     end
 
-    it 'does not modify scope specified at initialization' do
-      scope = User.search('foo')
-      q = query(scope, :enabled => true)
+    it 'does not modify relation specified at initialization' do
+      relation = User.search('foo')
+      q = query(relation, :enabled => true)
       expect {
         expect {
-          q.scope
-        }.to_not change { q.instance_variable_get('@scope') }
-      }.to_not change { scope }
+          q.relation
+        }.to_not change { q.instance_variable_get('@relation') }
+      }.to_not change { relation }
     end
 
-    it 'returns scope (#scoped) specified at construction if params are empty' do
-      query.scope.should_not == User
-      query.scope.should == User.scoped
+    it 'returns relation specified at construction if params are empty' do
+      query.relation.should_not == User
+      query.relation.should == User.all
     end
 
-    it 'invokes many times scope if an array is given' do
-      query(User, :search => ['John', 'Doe']).scope.should == [users(:john)]
-      query(User, :search => ['John', 'Done']).scope.should == []
+    it 'invokes many times relation if an array is given' do
+      query(User, :search => ['John', 'Doe']).relation.should == [users(:john)]
+      query(User, :search => ['John', 'Done']).relation.should == []
       query(User, :search => ['John', 'Doe']).params.should == { 'search' => ['John', 'Doe'] }
     end
 
-    it 'invokes many times scope if given twice (as string & symbol)' do
+    it 'invokes many times relation if given twice (as string & symbol)' do
       query(User, :search => 'John', 'search' => 'Done').params['search'].size.should be(2)
       query(User, :search => 'John', 'search' => 'Done').params['search'].should include('John', 'Done')
 
@@ -357,59 +408,29 @@ describe ScopedFrom::Query do
     end
 
     it 'invokes last order if an array is given' do
-      query(User, :order => ['lastname', 'firstname']).scope.should == [users(:jane), users(:john)]
-      query(User, :order => ['lastname', 'firstname.desc']).scope.should == [users(:john), users(:jane)]
-      query(User, :order => ['firstname.desc', 'lastname']).scope.order_values.should == ['firstname DESC', 'lastname ASC']
+      create_user(:jane2, firstname: 'Jane', lastname: 'Zoe')
+
+      query(User, :order => ['lastname', 'firstname']).relation.should == [users(:jane), users(:john), users(:jane2)]
+      query(User, :order => ['lastname', 'firstname.desc']).relation.should == [users(:john), users(:jane), users(:jane2)]
+      query(User, :order => ['firstname', 'lastname.desc']).relation.should == [users(:jane2), users(:jane), users(:john)]
+      query(User, :order => ['firstname.desc', 'lastname']).relation.order_values.should == [{ 'firstname' => :desc }, { 'lastname' => :asc }]
     end
 
-    it 'defines #query method on returned scoped' do
-      query(User).scope.should respond_to(:query)
+    it 'defines #query method on returned relation' do
+      query(User).relation.should respond_to(:query)
     end
 
-    it 'does not define #query method for future scopes' do
-      query(User).scope.query.should be_present
+    it 'does not define #query method for future relations' do
+      query(User).relation.query.should be_present
       User.should_not respond_to(:query)
-      User.scoped.should_not respond_to(:query)
+      User.all.should_not respond_to(:query)
       User.enabled.should_not respond_to(:query)
     end
 
     it 'defined #query method returns query' do
       q = query(User)
-      q.scope.query.should be_a(ScopedFrom::Query)
-      q.scope.query.should be(q)
-    end
-
-  end
-
-  describe '#scoped' do
-
-    it 'returns given scope if it has no scope with specified name' do
-      query.send(:scoped, User, :foo, true).should == User
-    end
-
-    it 'returns given scope if scope takes more than 1 argument' do
-      query.send(:scoped, User, :created_between, true).should == User
-    end
-
-    it 'invokes scope without arguments if scope takes no arguments' do
-      query.send(:scoped, User.scoped, :enabled, true).should == [users(:john)]
-      query.send(:scoped, User.scoped, :enabled, ' 1 ').should == [users(:john)]
-      query.send(:scoped, User.scoped, :enabled, 'off').should == [users(:john)]
-    end
-
-    it 'invokes scope with value has argument if scope takes one argument' do
-      query.send(:scoped, User.scoped, :search, 'doe').should == [users(:john), users(:jane)]
-      query.send(:scoped, User.scoped, :search, 'john').should == [users(:john)]
-      query.send(:scoped, User.scoped, :search, 'jane').should == [users(:jane)]
-    end
-
-    it 'scope on column conditions' do
-      query.send(:scoped, User.scoped, :firstname, 'Jane').should == [users(:jane)]
-    end
-
-    it 'invokes "order"' do
-      query.send(:scoped, User.scoped, :order, 'firstname.asc').should == [users(:jane), users(:john)]
-      query.send(:scoped, User.scoped, :order, 'firstname.desc').should == [users(:john), users(:jane)]
+      q.relation.query.should be_a(ScopedFrom::Query)
+      q.relation.query.should be(q)
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoped_from
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-15 00:00:00.000000000 Z
+date: 2013-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,56 +16,42 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.6.0
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 10.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 10.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -127,7 +113,8 @@ files:
 - spec/support/bootsrap/database.rb
 - spec/support/macros/user_macro.rb
 homepage: https://github.com/alexistoulotte/scoped_from
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []