limited 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0c628b05e6dd3db011e8ae8aa7299da4ab0664a
-  data.tar.gz: c5185402f1a9f258c641276f36e640994b17c10e
+  metadata.gz: 4a28b517efc2c9c053d8fd054c5ee44620c42507
+  data.tar.gz: f6ec63d47da226112bb915aa4c881dd3c8205288
 SHA512:
-  metadata.gz: 8a5dce139e3e678c083855773ac616ee638124fdce8d07dfa3c00ba1f5c2b634adfaefa43e36ca99f646f83d24addea085a1095a08904c6449cc2eeca6dbc2b4
-  data.tar.gz: bdcee5091e679f9cdd3f12bb05f9bd3df953d8f929b0921405091b8538e35921cf897eb720473a36492d2e1fe1321e1c0e32c67016e9fcf63a7b692078339851
+  metadata.gz: 030ad2dcffe79f7294d4536c6dcc578e95aa6f38088acfae4b9ae05827935d428d0348e253a35962e2eb4eb07944c4ec93904f91ccc2086705d8986814c93ad1
+  data.tar.gz: 85033f466bf1893b485d82d3161b770e4bf126b1bba265f1a2fa9739706e73fd7c9386d23ba22db0d816208b2536f3b59f4b03c6cb6b176ab6a940f048619cf8

data/README.md

@@ -24,13 +24,19 @@ You need to define your actions somewhere in your application like this:
 
     Limited.configure do
       # this action should only be 1337 times at most 
-      action :name_of_action, 1337
+      action :name_of_action, amount: 1337
 
       # only 1 login all 10 seconds
-      action :login, 1, 10
+      action :login, amount: 1, every: 10
 
       # at maximum 123 contact emails a day
-      action :sending_contact_email, 123, :day
+      action :sending_contact_email, amount: 123, every: :day
+
+      # you can also define identifier, which can be used to distinguish counters
+      identifier :category, [:category_id]
+
+      # no more than 50 posts a day are allowed per category
+      action :post, amount: 50, every: :day, per: :category
     end
 
 The second parameter given to action defines how many times the action
@@ -42,6 +48,7 @@ module to access your Action like this:
     Limited.name_of_action 
     Limited.login
     Limited.sending_contact_email
+    Limited.post
 
 Here are a few commonly used methods which every Action provides:
 
@@ -56,6 +63,27 @@ Here are a few commonly used methods which every Action provides:
   </tr>
 </table>
 
+For example:
+
+    unless Limited.sending_contact_email.limit_reached
+
+      # code to send contact email
+
+      Limited.sending_contact_email.executed
+    end
+
+If the action uses an identifier (you used the `:per` option in the config file) you can pass
+a hash containing the values used to distingish counters.
+
+For example:
+
+    unless Limited.post.limit_reached({category_id: category.id})
+
+      # code to insert post into the category ...
+
+      Limited.post.executed({category_id: category.id})
+    end
+
 ## Contributing
 
 1. Fork it

data/lib/limited/action.rb

@@ -8,6 +8,11 @@ module Limited
     attr_reader :name
     # the amount of times the action can be executed
     attr_reader :limit
+    # an object used to distinguish users
+    attr_reader :identifier
+    # users which have already executed this action
+    # they are differenciated by the identifier object
+    attr_reader :actors
 
     ##
     # :call-seq:
@@ -18,7 +23,7 @@ module Limited
     # === Example
     #
     #   Limited::Action.new :do_stuff, 1000
-    def initialize(name, limit, interval = nil)
+    def initialize(name, limit, interval = nil, identifier = [])
       raise ArgumentError.new("Limited::Action::name needs to be a Symbol") unless name.is_a?(Symbol)
       raise ArgumentError.new("Limited::Action::limit needs to be an Integer") unless limit.is_a?(Integer)
       raise ArgumentError.new("Limited::Action::limit needs to be positive") if limit < 0
@@ -27,6 +32,9 @@ module Limited
       @limit = limit
       @num_executed = 0
       @interval = Interval.new(interval.nil? ? :endless : interval)
+      @identifier = identifier.is_a?(Limited::Actor::Identifier) ? identifier : Limited::Actor::Identifier.new(*identifier)
+
+      @actors = []
       check_new_interval
     end
 
@@ -40,34 +48,58 @@ module Limited
     ##
     # returns the amount of times the action already
     # has been executed
-    def num_executed
+    def num_executed(actor_attributes = nil)
       check_new_interval
-      @num_executed
+      return @num_executed unless actor_attributes.is_a?(Hash)
+      actor_num_executed(actor_attributes)
     end
 
     ##
     # returns how many times the action can be executed
     # until the given limit is reached
-    def num_left
+    def num_left(actor_attributes = nil)
       check_new_interval
-      @limit - @num_executed
+      return @limit - @num_executed unless actor_attributes.is_a?(Hash)
+      actor_num_left(actor_attributes)
     end
 
     ##
     # should be called everytime
     # the action gets executed
     # so the internal counter is always up-to-date
-    def executed
+    def executed(actor_attributes = nil)
       check_new_interval
-      @num_executed += 1
+      if actor_attributes.is_a?(Hash)
+        actor_executed(actor_attributes)
+      else
+        @num_executed += 1
+      end
     end
 
     ##
     # wheter the limit of executions
     # has been exceeded
-    def limit_reached
+    def limit_reached(actor_attributes = nil)
       check_new_interval
-      @limit <= @num_executed
+      return @limit <= @num_executed unless actor_attributes.is_a?(Hash)
+      actor_limit_reached(actor_attributes)
+    end
+
+    ##
+    # get a user which can execute this
+    # action by the attributes
+    #
+    # if the actor doesn't exist yet it is created
+    def actor(attributes)
+      actor = nil
+      @actors.each do |current_actor|
+        if current_actor.attributes == attributes
+          actor = current_actor
+        end
+      end
+
+      @actors << actor = Limited::Actor.new(@identifier, attributes) if actor.nil?
+      actor
     end
 
     private
@@ -81,7 +113,27 @@ module Limited
       if @interval.passed?
         @interval.reset_start
         @num_executed = 0
+        @actors.each do |current_actor|
+          current_actor.num_executed = 0
+        end
       end
     end
+
+    def actor_num_executed(attributes)
+      actor(attributes).num_executed + @num_executed
+    end
+
+    def actor_num_left(attributes)
+       @limit - actor_num_executed(attributes)
+    end
+
+    def actor_executed(attributes)
+      actor(attributes).execute
+    end
+
+    def actor_limit_reached(attributes)
+      @limit <= actor_num_executed(attributes)
+    end
+
   end
 end

data/lib/limited/actor.rb

@@ -0,0 +1,36 @@
+module Limited
+  class Actor
+    class Identifier
+
+      attr_reader :keys
+      attr_reader :hash_keys
+
+      def initialize(*symbols)
+        raise ArgumentError.new("The symbols passed need to be unique") unless symbols.uniq.size == symbols.uniq.size
+        @keys = symbols.sort
+        @hash_keys = {}
+        @keys.each do |k|
+          raise ArgumentError.new("You need to pass a list of symbols") unless k.is_a?(Symbol)
+          @hash_keys[k] = nil
+        end
+      end
+
+    end
+
+    attr_reader :attributes
+    attr_reader :num_executed
+
+    def initialize(identifier, values, num_executed = 0)
+      raise ArgumentError.new("first parameter needs to be an identifier") unless identifier.is_a?(Identifier)
+      raise ArgumentError.new("second parameter needs to be a hash of values") unless values.is_a?(Hash)
+      raise ArgumentError.new("the values given in the second parameter needs to match with the keys of the identifier") unless identifier.keys.sort == values.keys.sort
+
+      @attributes = values
+      @num_executed = num_executed
+    end
+
+    def execute
+      @num_executed += 1
+    end
+  end
+end

data/lib/limited/config.rb

@@ -11,11 +11,27 @@ module Limited
     #
     # raises an ArgumentError if the same name
     # for an action is not unique
-    def self.action(name, limit, interval_length = nil)
-      action = Limited::Action.new(name, limit, interval_length)
+    def self.action(name, options = {})
+      raise ArgumentError.new("the options parameter needs to be a hash") unless options.is_a?(Hash)
+      limit = options[:amount]
+      interval = options[:every] || :endless
+      identifier = options[:per].is_a?(Symbol) ? Limited::identifiers[options[:per]] : options[:per]
+      action = Limited::Action.new(name, limit, interval, identifier)
       raise ArgumentError.new("action with name :#{name.to_s} has already been added") if Limited.actions.has_key?(name)
       Limited.actions[name] = action
     end
+
+    ##
+    # adds a new identifier to the list of identifiers
+    # to be used by actions.
+    #
+    # raises an ArgumentError if the the name of an
+    # identifier has already been taken
+    def self.identifier(name, symbols)
+      identifier = Limited::Actor::Identifier.new *symbols
+      raise ArgumentError.new("identifier with name :#{name.to_s} has already been added") if Limited.identifiers.has_key?(name)
+      Limited.identifiers[name] = identifier
+    end
   end
 
   ##

data/lib/limited/version.rb

@@ -1,3 +1,3 @@
 module Limited
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/limited.rb

@@ -1,6 +1,7 @@
 require "limited/version"
 require "limited/action"
 require "limited/interval"
+require "limited/actor"
 
 module Limited
   # a hash containing all the 
@@ -15,6 +16,12 @@ module Limited
     @actions
   end
 
+  @identifiers = {}
+
+  def self.identifiers
+    @identifiers
+  end
+
 
   ##
   # :call-seq:

data/spec/limited_action_spec.rb

@@ -4,7 +4,7 @@ require 'limited'
 require 'limited/action'
 
 describe Limited::Action do
-  before { @action = Limited::Action.new :do_some_stuff, 1337 }
+  before { @action = Limited::Action.new :do_some_stuff, 1337, :endless, [:id] }
   subject { @action }
 
   it { should respond_to(:name) }
@@ -12,6 +12,7 @@ describe Limited::Action do
   it { should respond_to(:interval) }
   it { should respond_to(:num_executed) }
   it { should respond_to(:num_left) }
+  it { should respond_to(:identifier) }
 
   describe "constructor" do
     it "should take a name" do
@@ -23,6 +24,16 @@ describe Limited::Action do
       limit = Limited::Action.new(:do_stuff, 15).limit
       limit.should eq 15
     end
+
+    it "should take an interval" do
+      interval = Limited::Action.new(:do_stuff, 15, :minute).interval
+      interval.length.should eq 60
+    end
+
+    it "should take an identifier" do
+      identifier = Limited::Action.new(:do_stuff, 15, :minute, [:asd]).identifier
+      identifier.keys.should eq [:asd]
+    end
   end
 
   describe "name" do
@@ -50,13 +61,31 @@ describe Limited::Action do
   describe "num_executed" do
     it "should be initialized to 0" do
       @action.num_executed.should eq 0
+      @action.num_executed({id: 21304843}).should eq 0
     end
   end
 
   describe "executed" do
-    before { @action.executed }
-    it "should increase the num_executed counter" do
-      @action.num_executed.should eq 1
+    describe "without actors" do
+      before { @action.executed }
+      it "should increase the num_executed counter" do
+        @action.num_executed.should eq 1
+      end
+    end
+
+    describe "with actors" do
+      before do
+        @actor1 = {id: 3561}
+        @actor2 = {id: 5631}
+      end
+
+      it "should increase seperately" do
+        @action.executed(@actor1)
+        @action.executed(@actor1)
+        @action.executed(@actor2)
+        @action.num_executed(@actor1).should eq 2
+        @action.num_executed(@actor2).should eq 1
+      end
     end
   end
 
@@ -74,6 +103,30 @@ describe Limited::Action do
       @action.executed
       @action.limit_reached.should be_true
     end
+
+    describe "with actors" do
+      before do
+        @actor1 = {id: 356}
+        @actor2 = {id: 563}
+      end
+
+      it "should count seperately" do
+        @action.limit_reached(@actor1).should be_false
+        @action.limit_reached(@actor2).should be_false
+        1336.times { @action.executed(@actor1) }
+        @action.limit_reached(@actor1).should be_false
+        @action.limit_reached(@actor2).should be_false
+        1336.times { @action.executed(@actor2) }
+        @action.limit_reached(@actor1).should be_false
+        @action.limit_reached(@actor2).should be_false
+        @action.executed(@actor1)
+        @action.limit_reached(@actor1).should be_true
+        @action.limit_reached(@actor2).should be_false
+        @action.executed(@actor2)
+        @action.limit_reached(@actor1).should be_true
+        @action.limit_reached(@actor2).should be_true
+      end
+    end
   end
 
   describe "with an ending interval" do
@@ -97,4 +150,18 @@ describe Limited::Action do
       end
     end
   end
+
+  describe "actor" do
+    before do
+      @action.actor(id: 15)
+    end
+
+    it "should create an actor if it doesn't exist yet" do
+      expect { @action.actor(id: 1337) }.to change{@action.actors.count}.by(1)
+    end
+
+    it "should always return an Actor object" do
+      @action.actor(id: 15).attributes.should eq({id: 15})
+    end
+  end
 end

data/spec/limited_actor_identifier_spec.rb

@@ -0,0 +1,36 @@
+describe Limited::Actor::Identifier do
+  before(:all) do
+    @identifier = Limited::Actor::Identifier.new
+  end
+  describe "constructor" do
+    it "should take a series of symbols used as keys for identification of the actor" do
+      expect do
+        Limited::Actor::Identifier.new :id
+        Limited::Actor::Identifier.new :id, :ip
+        Limited::Actor::Identifier.new :id, :ip, :page
+      end.not_to raise_error
+    end
+
+    it "should not allow two symbols with the same name" do
+      expect { Limited::Actor.new :id, :id }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "keys" do
+    it { @identifier.should respond_to(:keys) }
+    it "should return all the symbols given in the connstructor as an array" do
+      Limited::Actor::Identifier.new(:id).keys.should eq [:id]
+      Limited::Actor::Identifier.new(:id, :ip).keys.should eq [:id, :ip]
+      Limited::Actor::Identifier.new(:id, :ip, :page).keys.should eq [:id, :ip, :page]
+    end
+  end
+
+  describe "empty_hash" do
+    it { @identifier.should respond_to(:hash_keys) }
+    it "should return all the symbols given in the connstructor used as key in a hash" do
+      Limited::Actor::Identifier.new(:id).hash_keys.should eq({ id: nil })
+      Limited::Actor::Identifier.new(:id, :ip).hash_keys.should eq({ id: nil, ip: nil })
+      Limited::Actor::Identifier.new(:id, :ip, :page).hash_keys.should eq({ id: nil, ip: nil, page: nil })
+    end
+  end
+end

data/spec/limited_actor_spec.rb

@@ -0,0 +1,53 @@
+describe Limited::Actor do
+  before do
+    @identifier = Limited::Actor::Identifier.new :ip, :user_agent
+    @actor = Limited::Actor.new @identifier, { ip: '1.3.3.7', user_agent: 'void browser' }
+  end
+
+  describe "constructor" do
+    it "should take an identifier, the the values for identifying the actor" do
+      expect do
+        Limited::Actor.new @identifier, { ip: '1.3.3.7', user_agent: 'void browser' }
+        Limited::Actor.new @identifier, { ip: '1.3.3.7', user_agent: '1337 browser' }
+      end.not_to raise_error
+    end
+
+    it "should throw an execption if the values for identifying the actor don't match" do
+      expect do
+        Limited::Actor.new @identifier, { ip: '1.3.3.7' }
+      end.to raise_error(ArgumentError)
+
+      expect do
+        Limited::Actor.new @identifier, { ip: '1.3.3.7', user_agent: '123123', stuff: 'asdasd' }
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "attributes" do
+    it { @actor.should respond_to(:attributes) }
+
+    it "should return a hash containing the data to identify this actor" do
+      @actor.attributes.should eq({ ip: '1.3.3.7', user_agent: 'void browser' })
+    end
+  end
+
+  describe "num_executed" do
+    before do
+      @actor_with_num_executed = Limited::Actor.new @identifier, { ip: '', user_agent: ''  }, 15
+    end
+
+    it "should initialize it with 0" do
+      @actor.num_executed.should eq 0
+    end
+
+    it "should be settable using the constructor" do
+      @actor_with_num_executed .num_executed.should eq 15
+    end
+  end
+
+  describe "execute" do
+    it "should increase num_executed by 1" do
+      expect { @actor.execute }.to change(@actor, :num_executed).by(1)
+    end
+  end
+end

data/spec/limited_config_spec.rb

@@ -7,14 +7,15 @@ describe Limited::Config do
 
   it "should add an Limited::Action to Limited::actions when calling Limited::Config::action" do
     expect do
-      Limited::Config.action :new, 123, :day
+      Limited::Config.action :new, amount: 123, every: :day
     end.to change(Limited, :actions)
   end
 
   describe "the Action objects in the Limited::actions array" do
     before(:all) do
-      Limited::Config.action :value_check, 123, :day
-      Limited::Config.action :value_check1, 3
+      Limited::Config.identifier :category, [:id]
+      Limited::Config.action :value_check, amount: 123, every: :day
+      Limited::Config.action :value_check1, amount: 3, per: :category
     end
 
     it "should have the correct name" do
@@ -31,6 +32,29 @@ describe Limited::Config do
       Limited.actions[:value_check].interval.length.should eq 24 * 60 * 60
       Limited.actions[:value_check1].interval.length.should eq 1.0/0.0
     end
+
+    it "should have the correct identifier" do
+      Limited.actions[:value_check].identifier.keys.should eq []
+      Limited.actions[:value_check1].identifier.keys.should eq [:id]
+    end
+  end
+
+  describe "the identifier objects in the Limited::identifiers array" do
+    before(:all) do
+      Limited.configure do
+        identifier :section, [:id]
+        action :do_some_task, amount: 2, per: :section
+      end
+    end
+
+    it "should use the name to store the object" do
+      Limited.identifiers[:section].should be_a(Limited::Actor::Identifier)
+    end
+
+
+    it "should contain the symbols passed with the Limited::Config.identifier method" do
+      Limited.identifiers[:section].keys.should eq [:id]
+    end
   end
 
   it "should not be possible to add an action with the same name twice" do
@@ -44,9 +68,17 @@ describe Limited::Config do
     it "should be possible to add actions via the Limited::configure method" do
       expect do
         Limited.configure do
-          action :some_action, 123
+          action :some_action, amount: 123
         end
       end.to change(Limited, :actions)
     end
+
+    it "should be possible to add identifiers via the Limited::configure method" do
+      expect do
+        Limited.configure do
+          identifier :user, [:user_id]
+        end
+      end.to change(Limited, :identifiers)
+    end
   end
 end

data/spec/limited_spec.rb

@@ -1,5 +1,5 @@
 Limited.configure do
-  action :missing_method_test, 13
+  action :missing_method_test, amount: 13
 end
 
 describe Limited do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: limited
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Moritz Küttel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,11 +80,14 @@ files:
 - Rakefile
 - lib/limited.rb
 - lib/limited/action.rb
+- lib/limited/actor.rb
 - lib/limited/config.rb
 - lib/limited/interval.rb
 - lib/limited/version.rb
 - limited.gemspec
 - spec/limited_action_spec.rb
+- spec/limited_actor_identifier_spec.rb
+- spec/limited_actor_spec.rb
 - spec/limited_config_spec.rb
 - spec/limited_interval_spec.rb
 - spec/limited_spec.rb
@@ -117,6 +120,8 @@ summary: Some utility functions to help you limit some actions in your applicati
   your services.
 test_files:
 - spec/limited_action_spec.rb
+- spec/limited_actor_identifier_spec.rb
+- spec/limited_actor_spec.rb
 - spec/limited_config_spec.rb
 - spec/limited_interval_spec.rb
 - spec/limited_spec.rb