token_attr 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2b3cdab36a03426a385de026e0b16b271e94b79
-  data.tar.gz: 39bbbec8a942559030535a44f3b0ead803550177
+  metadata.gz: 8883c5c7026e366c148643bd1e4bd13dc57feba4
+  data.tar.gz: 7f661a16d09ab1e9368680efff5b940e20c51f05
 SHA512:
-  metadata.gz: d6f07c48755e3b73c7f07741fcce0a17f0a58fd113d2c87a6edcf873c31b9f5041f629409e60ee2a4bcd2bef53737e194421ad3e71137df6ce6d46c5075e6706
-  data.tar.gz: 6d7668305f5a4868b1ac2a1b460a24b9b8f5bf520367bea6ce560aca5033bcd641aa23cac3954c2e5e03f6342d6ff4c47e8e72d21c6d3abcbc1b11683d2793a6
+  metadata.gz: a01317959dd57120d37231389020af8e9ea669596788aad13b50c60b1f170f3cf3155ba20e640bbdd2e1076657bb08e8c218b592c4c19c33f98fada74accb73f
+  data.tar.gz: 404e200b4bfe0c10ddeee8cf1b9970cc39c0ee572815e7c3c5ba11c3737ffc47f9f82521faefb043120d21dbbcf4ebdd4ac415cbd1c8e56a4e57023317c4a970

data/README.md

@@ -6,13 +6,13 @@ Unique random token generator for ActiveRecord.
 
 Add `token_attr` to your Gemfile:
 
-    gem 'token_attr', '~> 0.1.0'
+    gem 'token_attr', '~> 0.2.0'
 
 ## Usage
 
 ```
 class User < ActiveRecord::Base
-  include TokenAttr
+  include TokenAttr::Concern
   token_attr :token
 end
 
@@ -21,7 +21,7 @@ user.valid?
 user.token # => "b8bd30ff"
 ```
 
-The token is generated in a `before_validation` callback.
+The token is generated in a `before_validation` callback only if the it's `nil`.
 
 ### Options
 
@@ -48,10 +48,10 @@ Accepted values:
 - a string - a string of your choice of the characters you want to use
 
 ```
-token_attr :token, alphabet: :numeric # => "82051173"
-token_attr :token, alphabet: :alphabetic # => "xqnInSJa"
+token_attr :token, alphabet: :numeric      # => "82051173"
+token_attr :token, alphabet: :alphabetic   # => "xqnInSJa"
 token_attr :token, alphabet: :alphanumeric # => "61nD0lUo"
-token_attr :token, alphabet: "token" # => "ktnekoet"
+token_attr :token, alphabet: "token"       # => "ktnekoet"
 ```
 
 ## Contributing

data/lib/token_attr.rb

@@ -1,88 +1,3 @@
 require 'token_attr/version'
-require 'active_record'
-require 'active_support/concern'
-
-module TokenAttr
-  extend ActiveSupport::Concern
-
-  DEFAULT_TOKEN_LENGTH  = 8.freeze
-  ALPHABETIC_ALPHABET   = [('a'..'z'),('A'..'Z')].map(&:to_a).flatten.freeze
-  NUMERIC_ALPHABET      = [(0..9)].map(&:to_a).flatten.freeze
-  ALPHANUMERIC_ALPHABET = [ALPHABETIC_ALPHABET, NUMERIC_ALPHABET].flatten.freeze
-
-  class TooManyAttemptsError < StandardError
-    attr_reader :attribute, :token
-
-    def initialize(attr_name, token, message = nil)
-      @attribute = attr_name
-      @token = token
-      message ||= "Can't generate unique token for \"#{attr_name}\". Last attempt with \"#{token}\"."
-      super(message)
-    end
-  end
-
-  included do
-    before_validation :generate_tokens
-  end
-
-  module ClassMethods
-    def token_attr(attr_name, options = {})
-      token_attributes << attr_name
-
-      define_method "should_generate_new_#{attr_name}_token?" do
-        send(attr_name).blank?
-      end
-
-      define_method "generate_new_#{attr_name}_token" do
-        token_length = options.fetch(:length, DEFAULT_TOKEN_LENGTH)
-
-        if alphabet = options[:alphabet]
-          alphabet_array = case alphabet
-          when :alphanumeric
-            ALPHANUMERIC_ALPHABET
-          when :alphabetic
-            ALPHABETIC_ALPHABET
-          when :numeric
-            NUMERIC_ALPHABET
-          else
-            alphabet.split('')
-          end
-          (0...token_length).map{ alphabet_array.sample }.join
-        else
-          hex_length = (token_length / 2.0).ceil # 2 characters per length
-          SecureRandom.hex(hex_length).slice(0...token_length)
-        end
-      end
-    end
-
-    def token_attributes
-      @token_attributes ||= []
-    end
-  end
-
-  def generate_tokens
-    self.class.token_attributes.each do |attr_name|
-      if send("should_generate_new_#{attr_name}_token?")
-        new_token = nil
-        try_count = 0
-        begin
-          raise TooManyAttemptsError.new(attr_name, new_token) if try_count == 5
-          new_token = send("generate_new_#{attr_name}_token")
-          try_count += 1
-        end until token_is_unique?(attr_name, new_token)
-
-        send "#{attr_name}=", new_token
-      end
-    end
-  end
-
-  def token_is_unique?(attr_name, token)
-    scope = self.class.where(attr_name => token)
-    scope = scope.where(id != self.id) if self.persisted?
-    !scope.exists?
-  end
-
-end
-
-# Uncomment to auto-extend ActiveRecord, probably not a good idea
-# ActiveRecord::Base.send(:extend, TokenAttr)
+require 'token_attr/concern'
+require 'token_attr/errors'

data/lib/token_attr/concern.rb

@@ -0,0 +1,84 @@
+require 'active_record'
+require 'active_support/concern'
+
+module TokenAttr
+  DEFAULT_TOKEN_LENGTH  = 8.freeze
+  ALPHABETIC_ALPHABET   = [('a'..'z'),('A'..'Z')].map(&:to_a).flatten.freeze
+  NUMERIC_ALPHABET      = [(0..9)].map(&:to_a).flatten.freeze
+  ALPHANUMERIC_ALPHABET = [ALPHABETIC_ALPHABET, NUMERIC_ALPHABET].flatten.freeze
+
+  TokenDefinition = Struct.new(:attr_name, :scope_attr)
+
+  module Concern
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :generate_tokens
+    end
+
+    module ClassMethods
+      def token_attr(attr_name, options = {})
+        token_definitions << TokenDefinition.new(attr_name, options[:scope])
+
+        define_method "should_generate_new_#{attr_name}?" do
+          send(attr_name).blank?
+        end
+
+        define_method "generate_new_#{attr_name}" do
+          token_length = options.fetch(:length, DEFAULT_TOKEN_LENGTH)
+
+          if alphabet = options[:alphabet]
+            alphabet_array = case alphabet
+            when :alphanumeric
+              ALPHANUMERIC_ALPHABET
+            when :alphabetic
+              ALPHABETIC_ALPHABET
+            when :numeric
+              NUMERIC_ALPHABET
+            else
+              alphabet.split('')
+            end
+            (0...token_length).map{ alphabet_array.sample }.join
+          else
+            hex_length = (token_length / 2.0).ceil # 2 characters per length
+            SecureRandom.hex(hex_length).slice(0...token_length)
+          end
+        end
+      end
+
+      def token_definitions
+        @token_definitions ||= []
+      end
+    end
+
+    def generate_tokens
+      self.class.token_definitions.each do |td|
+        if send("should_generate_new_#{td.attr_name}?")
+          new_token = nil
+          try_count = 0
+          begin
+            raise TooManyAttemptsError.new(td.attr_name, new_token) if try_count == 5
+            new_token = send("generate_new_#{td.attr_name}")
+            try_count += 1
+          end until token_is_unique?(td, new_token)
+
+          send "#{td.attr_name}=", new_token
+        end
+      end
+    end
+
+    def token_is_unique?(token_definition, token)
+      attr_name  = token_definition.attr_name
+      scope_attr = token_definition.scope_attr
+
+      scope = self.class.where(attr_name => token)
+      scope = scope.where.not(id: self.id) if self.persisted?
+      scope = scope.where(scope_attr => read_attribute(scope_attr)) if scope_attr
+      !scope.exists?
+    end
+
+  end
+end
+
+# Uncomment to auto-extend ActiveRecord, probably not a good idea
+# ActiveRecord::Base.send(:extend, TokenAttr)

data/lib/token_attr/errors.rb

@@ -0,0 +1,14 @@
+module TokenAttr
+
+  class TooManyAttemptsError < StandardError
+    attr_reader :attribute, :token
+
+    def initialize(attr_name, token, message = nil)
+      @attribute = attr_name
+      @token = token
+      message ||= "Can't generate unique token for \"#{attr_name}\". Last attempt with \"#{token}\"."
+      super(message)
+    end
+  end
+
+end

data/lib/token_attr/version.rb

@@ -1,3 +1,3 @@
 module TokenAttr
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/spec/spec_helper.rb

@@ -20,6 +20,12 @@ ActiveRecord::Schema.define do
   create_table :models, force: true do |t|
     t.string :token
     t.string :private_token
+    t.integer :scope_id
   end
 
 end
+
+class BaseModel < ActiveRecord::Base
+  self.table_name = 'models'
+  include TokenAttr::Concern
+end

data/spec/{token_attr_spec.rb → token_attr/concern_spec.rb}

@@ -2,48 +2,47 @@ require 'spec_helper'
 
 describe TokenAttr do
 
-  class Model < ActiveRecord::Base
-    include TokenAttr
+  class Model < BaseModel
     token_attr :token
   end
 
-  class ModelWithLength < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithLength < BaseModel
     token_attr :token, length: 13
   end
 
-  class ModelWithAlphabet < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithAlphabet < BaseModel
     token_attr :token, alphabet: 'abc123'
   end
 
-  class ModelWithAlphanumericAlphabet < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithAlphanumericAlphabet < BaseModel
     token_attr :token, alphabet: :alphanumeric
   end
 
-  class ModelWithAlphabeticAlphabet < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithAlphabeticAlphabet < BaseModel
     token_attr :token, alphabet: :alphabetic
   end
 
-  class ModelWithNumericAlphabet < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithNumericAlphabet < BaseModel
     token_attr :token, alphabet: :numeric
   end
 
-  class ModelWithMultipleTokens < ActiveRecord::Base
-    self.table_name = 'models'
-    include TokenAttr
+  class ModelWithMultipleTokens < BaseModel
     token_attr :token
     token_attr :private_token
   end
 
+  class ModelWithOverride < BaseModel
+    token_attr :token
+
+    def should_generate_new_token?
+      token == '1234'
+    end
+  end
+
+  class ModelWithScope < BaseModel
+    token_attr :token, scope: :scope_id
+  end
+
   describe ".token_attr" do
     let(:model) { Model.new }
 
@@ -136,6 +135,47 @@ describe TokenAttr do
       end
     end
 
+    context "when the should_generate_new_[attr_name]? method is overridden" do
+      let(:model) { ModelWithOverride.new }
+
+      it "generates a token when the condition is satisfied" do
+        SecureRandom.should_receive(:hex).with(4).and_return('newtoken')
+        model.token = '1234'
+        model.valid?
+        model.token.should == 'newtoken'
+      end
+
+      it "does not generate a new token when the condition is not satisfied" do
+        model.valid?
+        model.token.should be_nil
+      end
+    end
+
+    context "with scope" do
+      let(:model) { ModelWithScope.new }
+
+      context "when the scope attributes are different" do
+        it "allows duplicate tokens" do
+          SecureRandom.should_receive(:hex).twice.with(4).and_return('12345678')
+          ModelWithScope.create(scope_id: 1)
+          model.scope_id = 2
+          model.valid?
+          model.token.should == '12345678'
+        end
+      end
+
+      context "when the scope attributes are the same" do
+        it "regenerates a duplicate token" do
+          SecureRandom.should_receive(:hex).twice.with(4).and_return('12345678')
+          SecureRandom.should_receive(:hex).once.with(4).and_return('asdfghjk')
+          ModelWithScope.create(scope_id: 1)
+          model.scope_id = 1
+          model.valid?
+          model.token.should == 'asdfghjk'
+        end
+      end
+    end
+
     context "when token is not blank" do
       before { model.token = 'not blank' }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: token_attr
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Michel Billard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -109,9 +109,11 @@ files:
 - README.md
 - Rakefile
 - lib/token_attr.rb
+- lib/token_attr/concern.rb
+- lib/token_attr/errors.rb
 - lib/token_attr/version.rb
 - spec/spec_helper.rb
-- spec/token_attr_spec.rb
+- spec/token_attr/concern_spec.rb
 - token_attr.gemspec
 homepage: http://github.com/mbillard/token_attr
 licenses:
@@ -139,4 +141,4 @@ specification_version: 4
 summary: Unique random token generator for ActiveRecord
 test_files:
 - spec/spec_helper.rb
-- spec/token_attr_spec.rb
+- spec/token_attr/concern_spec.rb