tok_access 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6aec725ecefd64e58d1fafa64d9450372b0fb705
-  data.tar.gz: 2200ef5494e6da6552f6ff8469a0251ade70a559
+  metadata.gz: fafa5abd9d9c931e83776fcfa62a40ee0ba2f038
+  data.tar.gz: 915d606a864bd9aa6448e8f61929903bc9c38dad
 SHA512:
-  metadata.gz: 40ed63785ecef8c0b50810ee00729e9e856c9de2f67b9dac6e2dd327c1b7b1291bc73c5a82bab07dedd951840b265abe38fba4fd5349dcf41c1cc0021bdc6e9f
-  data.tar.gz: 8608c7e8ad2c4599ba9b410c3961cba4b7249d45bf3bd3b0eccc1fa3976e5dd77e20870afd9f7174dae4ab0ddb0c34e409794cf24129cfb7b8ef1da9c20fed6a
+  metadata.gz: 93314be37f8cd700b7d6d105ee2299d062c667d94cae280bfe17533eae1afd5046779120beaea9f6553354eb3c47751d4a729d26ab1c3089d95cff26ef665217
+  data.tar.gz: 945908665bf875065a1d8f403e3ccb9f42ac504a899c296a921be287e7f9a460740214fe6ba24e21a6834595bdf1f6cb708bdf30046cada3c107f177da07bf79

data/README.md

@@ -3,9 +3,9 @@ Handle authentication of your users using tokens.
 Every 'tokified' user will have a association named
 toks.
 
-A tok is an object that consist of two attributes: token, devise_token.
+A tok is an object that consist of two attributes: token, device_token.
 
-You should use the devise_token to identify the user devices
+You should use the device_token to identify the user devices
 in which the user has logged in and the token to authenticate the
 user request.
 
@@ -24,7 +24,7 @@ TokAccess use bcrypt has_secure_password and has_secure_token methods to handle
       # if the user is saved, an associated tok is created
       # and you can access that tok using the following methods
       token = user.get_token
-      devise_token = user.get_devise_token
+      device_token = user.get_device_token
       #  return the tokens to the front-end.
     else
       # code if the user can't be saved
@@ -50,8 +50,8 @@ TokAccess use bcrypt has_secure_password and has_secure_token methods to handle
     current_user ? current_user.get_token : nil
   end
 
-  def current_devise_token
-    current_user ? current_user.get_devise_token : nil
+  def current_device_token
+    current_user ? current_user.get_device_token : nil
   end
 
   # After 15 minutes, the next user request will refresh the tokens.
@@ -76,7 +76,7 @@ TokAccess use bcrypt has_secure_password and has_secure_token methods to handle
       # if the user is authenticated successfully, a new tok is created
       # and you can access that tok using the following methods
       token = user.get_token
-      devise_token = user.get_devise_token
+      device_token = user.get_device_token
       # then you should return to the front-end the tokens.
     else
       # code if the user authentication fails
@@ -88,22 +88,22 @@ TokAccess use bcrypt has_secure_password and has_secure_token methods to handle
 
 ```ruby
   # somewhere in a controller that handle the users sign in
-  # let's say that you are sending a devise_token in a header named
-  # APP_DEVISE_TOKEN
+  # let's say that you are sending a device_token in a header named
+  # APP_device_TOKEN
 
   def sign_in
     user = User.find_by(email: params[:email])
-    if user.tok_auth(params[:password], request.headers["HTTP_APP_DEVISE_TOKEN"])
+    if user.tok_auth(params[:password], request.headers["HTTP_APP_device_TOKEN"])
       # if the user is authenticated successfully and the tok related to the
-      # given devise_token is found, the token and devise_token are regenerated
-      # and you can access that tok using the get_token and get_devise_token
+      # given device_token is found, the token and device_token are regenerated
+      # and you can access that tok using the get_token and get_device_token
       # methods.
       # if the user is authenticated successfully and the tok related to the
-      # given devise_token wasn't found, a new tok is created and you can access
-      # that tok using the get_token and get_devise_token
+      # given device_token wasn't found, a new tok is created and you can access
+      # that tok using the get_token and get_device_token
       # methods.
       token = user.get_token
-      devise_token = user.get_devise_token
+      device_token = user.get_device_token
       # then you should return to the front-end the tokens.
     else
       # code if the user authentication fails
@@ -124,7 +124,7 @@ TokAccess use bcrypt has_secure_password and has_secure_token methods to handle
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tok_access'
+gem 'tok_access', '~> 1.1.0'
 ```
 
 And then execute:

data/lib/generators/tok_access/model_generator.rb

@@ -29,7 +29,7 @@ module TokAccess
         tok_model_class_name = "#{table_name.singularize}_tok".camelize
         if behavior == :invoke
           if !File.exist?(Rails.root.join("app", "models", "#{tok_model_table_name}.rb"))
-            invoke "active_record:model", [tok_model_class_name, "token:string","devise_token:string", "object_id:integer"]
+            invoke "active_record:model", [tok_model_class_name, "token:string","device_token:string", "object_id:integer"]
           end
           inject_into_class(Rails.root.join("app", "models", "#{table_name.singularize}.rb"), Object.const_get(table_name.singularize.camelize)) do
             %Q{\ttokify\n}

data/lib/tok_access/tok_authenticable.rb

@@ -18,10 +18,10 @@ module TokAccess
 
         # Return nil if you haven't authenticated the object
         # using the method #tok_auth or the method #tok_auth failed the
-        # authentication process. Otherwise, return the devise_token attribute
+        # authentication process. Otherwise, return the device_token attribute
         # of one of the associated object toks.
-        def get_devise_token
-          @_devise_token
+        def get_device_token
+          @_device_token
         end
 
         # Return nil if you haven't use the method TokAccess.validate_access.
@@ -35,29 +35,29 @@ module TokAccess
 
         # Authenticate the object with the given password .
         # If the authentication process is successful return the object and the
-        # methods #get_tok and #get_devise_tok will return the tokens
+        # methods #get_tok and #get_device_tok will return the tokens
         # Return nil if the authentication process fails
-        # You can pass as a parameter a devise_token. If the object has a tok that
-        # match the devise_token given, will regenerate the tok. If you do not
-        # pass the devise_token parameter, the method will create a new tok
+        # You can pass as a parameter a device_token. If the object has a tok that
+        # match the device_token given, will regenerate the tok. If you do not
+        # pass the device_token parameter, the method will create a new tok
         # associated with the object. If the object.toks.size is equal to the
         # toks_limit, the method will destroy one of the toks and create a new one
-        def tok_auth(password, devise_token = nil )
+        def tok_auth(password, device_token = nil )
           if self.authenticate(password)
-            generate_access_toks(devise_token)
+            generate_access_toks(device_token)
             return self
           end
           nil
         end
 
         # If the object is associated to the tok given the method will return
-        # the object and the methods #get_tok and #get_devise_tok will
+        # the object and the methods #get_tok and #get_device_tok will
         # return the tokens. Otherwise return nil
         def provide_access(tok)
           if self.toks.find_by(id: tok.id)
             refresh tok
             set_token tok.token
-            set_devise_token tok.devise_token
+            set_device_token tok.device_token
             return self
           end
           nil
@@ -76,27 +76,27 @@ module TokAccess
           @_token = token
         end
 
-        def set_devise_token(token)
-          @_devise_token = token
+        def set_device_token(token)
+          @_device_token = token
         end
 
         def setup_access_tok
           self.toks.build()
         end
 
-        def generate_access_toks(devise_token = nil)
-          if !devise_token
+        def generate_access_toks(device_token = nil)
+          if !device_token
             self.toks.order(updated_at: :asc).first.destroy if self.toks.count == TokAccess.config.tokens_limit
             tok = self.toks.create
           else
-            tok = self.toks.find_by(devise_token: devise_token)
+            tok = self.toks.find_by(device_token: device_token)
             tok.regenerate_token if tok
-            tok.regenerate_devise_token if tok
+            tok.regenerate_device_token if tok
           end
           if tok
             @refreshed = true
             set_token tok.token
-            set_devise_token tok.devise_token
+            set_device_token tok.device_token
           end
         end
 
@@ -107,20 +107,20 @@ module TokAccess
       # object: The object to authenticate
       # password: The password to authenticate the object with
       # if the object is authenticatred successfully, returns the object with
-      # => the get_token and get_devise_token methods returning the access
+      # => the get_token and get_device_token methods returning the access
       # => tokens.
       # otherwise return nil
       def tok_authentication(object, password)
           return object.tok_auth(password)
       end
 
-      # tokens: hash with a devise_token key or token key
+      # tokens: hash with a device_token key or token key
       # if any of the tokens is found. Provide access to the related
       # object calling the method provide_access
       # otherwise return nil
       def validate_access(tokens = {})
         toks_class = Object.const_get("#{self.name.camelize}Tok")
-        tok = toks_class.find_by(devise_token: tokens[:devise_token]) if tokens[:devise_token]
+        tok = toks_class.find_by(device_token: tokens[:device_token]) if tokens[:device_token]
         tok = toks_class.find_by(token: tokens[:token]) if tokens[:token] and !tok
         if tok
           return tok._tok_object.provide_access(tok)

data/lib/tok_access/tok_config.rb

@@ -43,8 +43,8 @@ module TokAccess
                    class_name: "#{self.to_s.gsub(/Tok\z/,'')}",
                    foreign_key: "object_id" if association
         has_secure_token
-        has_secure_token :devise_token
-        validates :token, :devise_token, presence: true, on: :update
+        has_secure_token :device_token
+        validates :token, :device_token, presence: true, on: :update
       end
     end
   end

data/lib/tok_access/version.rb

@@ -1,3 +1,3 @@
 module TokAccess
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tok_access
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yonga9121
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-22 00:00:00.000000000 Z
+date: 2017-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Handle authentication of your users using tokens.