throttling 0.3.1 → 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ed71179ebb7b627ce788a1ced69b28bba67f9d983614724390a95d6df97f2d1
+  data.tar.gz: cafd2ed60cf1758b5527d40d864aa8892d638631a9a95e977161227f34328eb0
+SHA512:
+  metadata.gz: 3d98584e62d6d179e4f358946f7d4f179e56df6c4a30e338e0bcd8b65a59a2ff9d0cccc9ca392306f3412dab4b5c94d7b64225c949fd31626d8ba45ac8181455
+  data.tar.gz: 7bd43a024a5bfca1a9dcf4d05cf70a255233dd87382b9229f63d04c5ab06c081cd83a8d20b5be0586b5fb42d8293387ff3e41cbb03c8f137be6246fe946c2c11

checksums.yaml.gz.sig

@@ -0,0 +1,4 @@
+u�wn臙K�l�Rա����J-cƬ|�2ݯm.D�M=h܂i�*j���y!��R3��H�M���Z!˥}
e�aM]
͢S�	�&�
+�M����e���no�!G0�e&?���oN��N�.��)�-�4������F5_���&`�zg�6F�c`����4)��um���Ŕ���NW�΁�j�ޛ�Q���G克�`J[	
+,,�c�4S9��
+�0!�<[K�ayjQ��>���[��x�Fn<�

data/CHANGELOG.md

@@ -1,30 +1,42 @@
+# Changelog
+
+## 0.4.1 (September 19, 2025)
+
+- Multiple rexml fixes ([6](https://github.com/kpumuk/throttling/pull/6), [7](https://github.com/kpumuk/throttling/pull/7), [8](https://github.com/kpumuk/throttling/pull/8), [9](https://github.com/kpumuk/throttling/pull/9), [11](https://github.com/kpumuk/throttling/pull/11/))
+- Use GitHub actions to build, sign and publish the gem ([11](https://github.com/kpumuk/throttling/pull/11/))
+
+## 0.4.0 (July 6, 2023)
+
+- Bump minimum Ruby requirement to 2.7.0
+- Updated codebase to match StandardRB style guide
+
 ## 0.3.1 (April 13, 2012)
 
 Features:
 
-  - When limit is omitted, no limits will be enforced (`check` always returns true)
+- When limit is omitted, no limits will be enforced (`check` always returns true)
 
 Bugfixes:
 
-  - Fixed bug when action was allowed `limit + 1` times
-  - When limit is 0, `check` should always return `false`
+- Fixed bug when action was allowed `limit + 1` times
+- When limit is 0, `check` should always return `false`
 
 ## 0.3.0 (April 13, 2012)
 
 Features:
 
-  - Added ability to retrieve custom value based on number of actions performed in a period of time
+- Added ability to retrieve custom value based on number of actions performed in a period of time
 
 ## 0.2.0 (April 12, 2012)
 
 Bugfixes:
 
-  - Fixed bug when occurrences where increased for larger periods, when smaller ones did not pass
+- Fixed bug when occurrences where increased for larger periods, when smaller ones did not pass
 
 ## 0.1.0 (April 12, 2012)
 
 Features:
 
-  - Allows to throttle actions occurred in period of time
-  - Allows to specify limits inline or in external configuration file
-  - 100% test coverage
+- Allows to throttle actions occurred in period of time
+- Allows to specify limits inline or in external configuration file
+- 100% test coverage

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,88 @@
+PATH
+  remote: .
+  specs:
+    throttling (0.4.1)
+      logger
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.3)
+    diff-lcs (1.6.2)
+    json (2.15.0)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.5.1)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.0)
+    regexp_parser (2.11.3)
+    rspec (3.13.1)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.5)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    rubocop (1.80.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.47.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-performance (1.25.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    standard (1.51.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.80.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.8.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.25.0)
+    timecop (0.9.10)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+
+PLATFORMS
+  arm64-darwin
+  arm64-linux
+  x86_64-darwin
+  x86_64-linux
+
+DEPENDENCIES
+  rake (~> 13.0)
+  rspec (~> 3.13.0)
+  standard (~> 1.51.0)
+  throttling!
+  timecop (~> 0.9.6)
+
+BUNDLED WITH
+   2.3.26

data/README.md

@@ -1,74 +1,79 @@
 # Throttling
 
-[![Travis-CI build status](https://secure.travis-ci.org/kpumuk/throttling.png)](http://travis-ci.org/kpumuk/throttling)
+[![Tests](https://github.com/kpumuk/throttling/actions/workflows/tests.yml/badge.svg)](https://github.com/kpumuk/throttling/actions/workflows/tests.yml)
+[![Gem Version](https://badge.fury.io/rb/throttling.svg)](https://badge.fury.io/rb/throttling)
+[![Gem Downloads](https://img.shields.io/gem/dt/throttling.svg)](https://badge.fury.io/rb/throttling)
+[![Changelog](https://img.shields.io/badge/Changelog-latest-blue.svg)](https://github.com/kpumuk/throttling/blob/main/CHANGELOG.md)
 
 Throttling gem provides basic, but very powerful way to throttle various user actions in your application. Basically you can specify how many times some action could be performed over a specified period(s) of time.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
-    gem 'throttling'
+```ruby
+gem "throttling"
+```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install throttling
+And run `bundle install` command.
 
 ## Configuration
 
-You can configure Throttling parameters by accessing attributes of `Throttling` module. Currently it supports only Memcached through `Rails.cache`.
+You can configure Throttling parameters by accessing attributes of `Throttling` module. Currently it supports only Memcached and Redis through `Rails.cache`.
 
-    Throttling.storage = Rails.cache
-    Throttling.logger = Rails.logger
+```ruby
+Throttling.storage = Rails.cache
+Throttling.logger = Rails.logger
+```
 
 Throttling limits could be stored in a configuration file in `config/throttling.yml`. You can also specify another file to read limits from:
 
-    Throttling.limits_config = "#{Rails.root}/config/throttling.yml"
+```ruby
+Throttling.limits_config = "#{Rails.root}/config/throttling.yml"
+```
 
 The basic structure of the file is:
 
-    user_signup:
-      limit: 20
-      period: 3600
-
-    search_requests:
-      minutely:
-        limit: 300
-        period: 600
-      hourly:
-        limit: 1000
-        period: 3600
-      daily:
-        limit: 10000
-        period: 86400
-
-    request_priority:
-      period: 86400
-      default_value: 25
-      values:
-        high_priority:
-          limit: 5
-          value: 10
-        medium_priority:
-          limit: 15
-          value: 15
-        low_priority:
-          limit: 100
-          value: 20
+```yaml
+user_signup:
+  limit: 20
+  period: 3600
+
+search_requests:
+  minutely:
+    limit: 300
+    period: 600
+  hourly:
+    limit: 1000
+    period: 3600
+  daily:
+    limit: 10000
+    period: 86400
+
+request_priority:
+  period: 86400
+  default_value: 25
+  values:
+    high_priority:
+      limit: 5
+      value: 10
+    medium_priority:
+      limit: 15
+      value: 15
+    low_priority:
+      limit: 100
+      value: 20
+```
 
 This example covers three different scenarios:
 
-1. Single period. In this case only 20 actions will be allowed in a period of
+1. **Single period**. In this case only 20 actions will be allowed in a period of
    one hour (3600 seconds).
 
-2. Multiple periods. Action will be allowed to perform 300 times in 10 minutes,
+2. **Multiple periods**. Action will be allowed to perform 300 times in 10 minutes,
    1000 times an hour, and 10000 times a day.
 
-3. This special case covers following scenario: based on the number of actions,
+3. **Complex scenario**. This special case covers following scenario: based on the number of actions,
    it returns a value, or default value when largest limit is reached. In this
    case it will return 10, when there were 5 or less requests (including current one),
    15 for up to 15 requests, 20 for up to 100 requests, and 25 when there were
@@ -76,110 +81,132 @@ This example covers three different scenarios:
 
 You can also specify limits as a Hash:
 
-    Throttling.limits = {
-      :user_signup => {
-        :limit  => 20,
-        :period => 3600
-      },
-      :search_requests => {
-        :minutely => {
-          :limit  => 20,
-          :period => 3600
-        },
-        :hourly => {
-          :limit  => 1000,
-          :period => 3600
-        },
-        :daily =>
-          :limit  => 10000,
-          :period => 86400
-        }
-      }
+```ruby
+Throttling.limits = {
+  user_signup: {
+    limit: 20,
+    period: 3600
+  },
+  search_requests: {
+    minutely: {
+      limit: 20,
+      period: 3600
+    },
+    hourly: {
+      limit: 1000,
+      period: 3600
+    },
+    daily: {
+      limit: 10000,
+      period: 86400
     }
+  }
+}
+```
 
 You can completely disable throttling by setting `enabled` to `false`:
 
-    Throttling.enabled = false
+```ruby
+Throttling.enabled = false
+```
 
 ## Usage
 
 The basic usage of Throttling gem is following:
 
-    Throttling.for(:user_signup).check(:user_id, current_user.id) do
-      # Do your stuff here
-    end
+```ruby
+Throttling.for(:user_signup).check(:user_id, current_user.id) do
+  # Do your stuff here
+end
 
-    if Throttling.for(:user_signup).check(:user_id, current_user.id)
-      # Action allowed
-    else
-      # Action denied
-    end
+if Throttling.for(:user_signup).check(:user_id, current_user.id)
+  # Action allowed
+else
+  # Action denied
+end
+```
 
 For convenience, there are some simplified methods:
 
-    Throttling.for(:user_signup).check_ip(request.remote_ip)
-    Throttling.for(:user_signup).check_user_id(current_user.id)
+```ruby
+Throttling.for(:user_signup).check_ip(request.remote_ip)
+Throttling.for(:user_signup).check_user_id(current_user.id)
+```
 
 You can add more helpers like this:
 
-    Throttling::Base.class_eval do
-      def check_user_id_and_document_id(user_id, doc_id)
-        check("user_id:doc_id", "#{user_id}:#{doc_id}")
-      end
-    end
+```ruby
+Throttling::Base.class_eval do
+  def check_user_id_and_document_id(user_id, doc_id)
+    check("user_id:doc_id", "#{user_id}:#{doc_id}")
+  end
+end
+```
 
 ## Use cases
 
 ### Limiting number of sign-ups
 
-    user_signup:
-      limit: 20
-      period: 3600
+```yaml
+user_signup:
+  limit: 20
+  period: 3600
+```
 
 Limit the number of sign-ups to 20 per hour per IP address:
 
-    Throttling.for('user_signup').check_ip(request.remote_ip)
+```ruby
+Throttling.for("user_signup").check_ip(request.remote_ip)
+```
 
 ### Limiting number of document uploads
 
-    document_uploads:
-      minutely:
-        limit: 5
-        period: 600
-      hourly:
-        limit: 10
-        period: 3600
-      daily:
-        limit: 50
-        period: 86400
+```yaml
+document_uploads:
+  minutely:
+    limit: 5
+    period: 600
+  hourly:
+    limit: 10
+    period: 3600
+  daily:
+    limit: 50
+    period: 86400
+```
 
 In this case user will be allowed to upload 5 documents in 10 minutes, 10 documents
 in an hour, or 50 documents a day:
 
-    Throttling.for('document_uploads').check_user_id(current_user.id)
+```ruby
+Throttling.for("document_uploads").check_user_id(current_user.id)
+```
 
 ### Prioritizing uploads based on number of uploads
 
-    document_priorities:
-      period: 86400
-      default_value: 25
-      values:
-        high_priority:
-          limit: 5
-          value: 10
-        medium_priority:
-          limit: 15
-          value: 15
-        low_priority:
-          limit: 100
-          value: 20
+```yaml
+document_priorities:
+  period: 86400
+  default_value: 25
+  values:
+    high_priority:
+      limit: 5
+      value: 10
+    medium_priority:
+      limit: 15
+      value: 15
+    low_priority:
+      limit: 100
+      value: 20
+```
 
 All documents could be prioritized based on the number of uploads: if user uploads
 less than 5 documents a day, they all will have priority 10. Next 10 documents
 (first five keep their original priority) will receive priority 15. Documents
 16 to 100 will get priority 20, and everything else will get priority 25.
 
-    Throttling.for('document_priorities').check_user_id(current_user.id)
+```ruby
+Throttling.for("document_priorities").check_user_id(current_user.id)
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,8 +1,8 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
-task :test => :spec
-task :default => :spec
+task test: :spec
+task default: :spec

data/certs/kpumuk.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MQ8wDQYDVQQDDAZrcHVt
+dWsxFjAUBgoJkiaJk/IsZAEZFgZrcHVtdWsxFDASBgoJkiaJk/IsZAEZFgRpbmZv
+MB4XDTI1MDkyOTE1MDM1M1oXDTI2MDkyOTE1MDM1M1owPzEPMA0GA1UEAwwGa3B1
+bXVrMRYwFAYKCZImiZPyLGQBGRYGa3B1bXVrMRQwEgYKCZImiZPyLGQBGRYEaW5m
+bzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALw2YroZc+IT+rs8NuPu
+c13DelrxrpAgPEu1zuRb3l7WaHRNWA4TyS8Z6Aa1G2O+FdUZNMW1n7IwP/QMJ9Mz
+ahRBiTmhik5kasJ9s0h1lq5/hZiycm0o5OtGioUzCkvk+UEMpzMHbLmVSZCzYciy
+NDRDbXB0rLLu1eJk+gKgn6Qf5vj93h1w28BdWdaA7YegtbmipZ+pjmzCQAfPActT
+6uXHG4dSo7Lz9jiFRI5dUizFbGXcRqkQ2b5AB8FFmfcvbqERvzQKBICnybjsKP0N
+pJ3vGgO2sh5GvJFOPk1Vlur2nX9ZFznPEP1CEAQ+NFrmKRt355Z5sgOkAojSGnIL
+/1sCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFPa4
+VFc1YOlV1u/7EGTwMCAk8YE9MB0GA1UdEQQWMBSBEmtwdW11a0BrcHVtdWsuaW5m
+bzAdBgNVHRIEFjAUgRJrcHVtdWtAa3B1bXVrLmluZm8wDQYJKoZIhvcNAQELBQAD
+ggEBAFz/6+efHFEomTCA8V/eMpzaMkbj04cTmFxm28KiUO1F4vgbSIBx0bsMoJkH
+KI956sPVVJMykwOdDUhRWBrHOVTBCGdkYWdb38KQKfwtkdGd8b/Afrxs5GuPME9r
+TdfDc1aXCAPdLCajhpmuzfa1g8/W7ORdxwNQidYSSPJ5OvcAGSfxTHJsFseHjrBK
+9hdoXZgqc4a5defxoOZFD9Im9AUwFqwR8njCBST6FbCGmHIYNHj2hxbwrU/1I2Kg
+pPzkBOwQl2p1ykAEUe7cwoqJcO+1rPeTHjudNqhOfc3VnMA8A7uXOkTtYNVhvApn
+oW4hE/8SnZkQm8jzdi0iX9nWxo8=
+-----END CERTIFICATE-----

data/lib/throttling/base.rb

@@ -15,7 +15,7 @@ module Throttling
         if @limits[:values]
           @limits[:values] = @limits[:values].sort_by { |name, params| params && params[:limit] }
         end
-        @limits = [[ 'global', @limits ]]
+        @limits = [["global", @limits]]
       else
         @limits = @limits.sort_by { |name, params| params && params[:period] }
       end
@@ -35,7 +35,7 @@ module Throttling
 
       limits.each do |period_name, params|
         period = params[:period].to_i
-        limit  = params[:limit].nil? ? nil : params[:limit].to_i
+        limit = params[:limit]&.to_i
         values = params[:values]
 
         raise ArgumentError, "Invalid or no 'period' parameter in the limits[#{action}][#{period_name}] config: #{limit.inspect}" if period < 1
@@ -44,7 +44,7 @@ module Throttling
         key = hits_store_key(check_type, check_value, period_name, period)
 
         # Retrieve current value
-        hits = Throttling.storage.fetch(key, :expires_in => hits_store_ttl(period), :raw => true) { '0' }.to_i
+        hits = Throttling.storage.fetch(key, expires_in: hits_store_ttl(period), raw: true) { "0" }.to_i
 
         if values
           value = params[:default_value] || false
@@ -54,16 +54,16 @@ module Throttling
               break
             end
           end
-        else
+        elsif !limit.nil? && hits >= limit
           # Over limit?
-          return false if !limit.nil? && hits >= limit
+          return false
         end
 
         Throttling.storage.increment(key) if auto_increment
         return value if values
       end
 
-      return true
+      true
     end
 
     private

data/lib/throttling/indifferent_access.rb

@@ -15,7 +15,7 @@ module Throttling
           super()
           update(constructor)
         else
-          super(constructor)
+          super
         end
       end
 
@@ -84,7 +84,7 @@ module Throttling
       #   hash.values_at("a", "b") # => ["x", "y"]
       #
       def values_at(*indices)
-        indices.collect {|key| self[convert_key(key)]}
+        indices.collect { |key| self[convert_key(key)] }
       end
 
       # Returns an exact copy of the hash.
@@ -95,13 +95,13 @@ module Throttling
       # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
       # Does not overwrite the existing hash.
       def merge(hash)
-        self.dup.update(hash)
+        dup.update(hash)
       end
 
       # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
       # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
       def reverse_merge(other_hash)
-        super other_hash.with_indifferent_access
+        super(other_hash.with_indifferent_access)
       end
 
       # Removes a specified key from the hash.
@@ -109,9 +109,17 @@ module Throttling
         super(convert_key(key))
       end
 
-      def stringify_keys!; self end
-      def symbolize_keys!; self end
-      def to_options!; self end
+      def stringify_keys!
+        self
+      end
+
+      def symbolize_keys!
+        self
+      end
+
+      def to_options!
+        self
+      end
 
       # Convert to a Hash with String keys.
       def to_hash
@@ -119,31 +127,32 @@ module Throttling
       end
 
       protected
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
 
-        def convert_value(value)
-          case value
-          when Hash
-            value.with_indifferent_access
-          when Array
-            value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
-          else
-            value
-          end
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          value.with_indifferent_access
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+        else
+          value
         end
+      end
     end
 
-    module HashIndifferentAccess #:nodoc:
+    module HashIndifferentAccess # :nodoc:
       def with_indifferent_access
         hash = HashWithIndifferentAccess.new(self)
-        hash.default = self.default
+        hash.default = default
         hash
       end
     end
 
-    class ::Hash #:nodoc:
+    class ::Hash # :nodoc:
       unless respond_to?(:with_indifferent_access)
         include Throttling::HashIndifferentAccess
       end

data/lib/throttling/version.rb

@@ -1,3 +1,3 @@
 module Throttling
-  VERSION = '0.3.1'
+  VERSION = "0.4.1"
 end