tok_access 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6aec725ecefd64e58d1fafa64d9450372b0fb705
+  data.tar.gz: 2200ef5494e6da6552f6ff8469a0251ade70a559
+SHA512:
+  metadata.gz: 40ed63785ecef8c0b50810ee00729e9e856c9de2f67b9dac6e2dd327c1b7b1291bc73c5a82bab07dedd951840b265abe38fba4fd5349dcf41c1cc0021bdc6e9f
+  data.tar.gz: 8608c7e8ad2c4599ba9b410c3961cba4b7249d45bf3bd3b0eccc1fa3976e5dd77e20870afd9f7174dae4ab0ddb0c34e409794cf24129cfb7b8ef1da9c20fed6a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Yonga
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,167 @@
+# TokAccess
+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.
+
+You should use the devise_token to identify the user devices
+in which the user has logged in and the token to authenticate the
+user request.
+
+TokAccess use bcrypt has_secure_password and has_secure_token methods to handle the authentication process and tokens generation
+
+## Usage
+
+#### Imagine you have a User model and a mobile app in which a user want to sign up.
+
+```ruby
+  # somewhere in a controller that handle the users registration
+
+  def sign_up
+    user = User.new(user_params)
+    if user.save
+      # 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
+      #  return the tokens to the front-end.
+    else
+      # code if the user can't be saved
+    end
+  end
+```
+#### So, now the user is logged in one device and start browsing the app. How to identify the user that sign up previously?
+
+```ruby
+  # somewhere in your code, probably in you ApplicationController
+  # let's say that you are sending a token in a header named
+  # APP_TOKEN
+
+  def current_user
+    @current_user ||= User.validate_access(token: request.headers["HTTP_APP_TOKEN"])
+  end
+
+  def user_signed_in?
+    !current_user.nil?
+  end
+
+  def current_token
+    current_user ? current_user.get_token : nil
+  end
+
+  def current_devise_token
+    current_user ? current_user.get_devise_token : nil
+  end
+
+  # After 15 minutes, the next user request will refresh the tokens.
+  # it is necessary to send the tokens to the front-end again
+
+  def tokens_refreshed?
+    if current_user and current_user.refreshed?
+      # Some code that allows you to send the tokens to the front-end
+    end
+  end
+```
+
+
+#### Now the previous user wants to login in a new device
+
+```ruby
+  # somewhere in a controller that handle the users sign in
+
+  def sign_in
+    user = User.find_by(email: params[:email])
+    if user.tok_auth(params[:password])
+      # 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
+      # then you should return to the front-end the tokens.
+    else
+      # code if the user authentication fails
+    end
+  end
+```
+
+#### Now the previous user wants to login in an old device
+
+```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
+
+  def sign_in
+    user = User.find_by(email: params[:email])
+    if user.tok_auth(params[:password], request.headers["HTTP_APP_DEVISE_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
+      # 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
+      # methods.
+      token = user.get_token
+      devise_token = user.get_devise_token
+      # then you should return to the front-end the tokens.
+    else
+      # code if the user authentication fails
+    end
+  end
+```
+
+#### Accessing the toks from the user.
+```ruby
+
+  user = User.validate_access(token: request.headers["HTTP_APP_TOKEN"])
+  user.toks # UserTok collection.
+
+```
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tok_access'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+### Generating models
+
+Generating a User model.
+
+```bash
+$ rails g tok_access:model User email:string nickname:string
+```
+The above command will generate two models: User and UserTok
+
+The migration generated to create the User model will add a column named
+password_digest to store the password.
+
+#### IMPORTANT: If you already have a User model, the command will generate just the migration to add the password_digest column
+
+#### NOTE: You can generate any model to be 'tokified' just pass the name of the model
+
+```bash
+$ rails g tok_access:model Person email:string nickname:string
+```
+The above command will generate two models: Person and PersonTok
+
+#### IMPORTANT: If you use the tok_access:model generator to destroy the model, the Model and ModelTok will be destroyed. It's a better choice to do it manually
+
+```bash
+$ rails d model user
+$ rails d model user_tok
+```
+
+Also, remember to remove the migrations...
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TokAccess'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/generators/tok_access/USAGE

@@ -0,0 +1,33 @@
+Description:
+    Use this generator to create the models that you want give access through tokens
+    It will generate the a migration to add a password_digest attribute to the model.
+    If the model does not exist, will generate it.
+    Also generates a model to handle the related toks. If your model name
+    is User, the associated tok model name will be UserTok.
+
+Example:
+    rails generate tok_access:model User email:string nickname:string birth:date -f
+
+    This will be the output:
+      create  db/migrate/20170913173053_tok_access_create_users.rb
+      create  app/models/user.rb
+      invoke  test_unit
+      create    test/models/user_test.rb
+      create    test/fixtures/users.yml
+      create  db/migrate/20170913173054_create_user_toks.rb
+      create  app/models/user_tok.rb
+      invoke  test_unit
+      insert  app/models/user.rb
+      insert  app/models/user_tok.rb
+
+    If the model already exists, this will be the output:
+      create  db/migrate/20170913173229_add_tok_access_to_users.rb
+      identical  app/models/user.rb
+        invoke  test_unit
+      identical    test/models/user_test.rb
+         force    test/fixtures/users.yml
+        create  db/migrate/20170913173230_create_user_toks.rb
+        create  app/models/user_tok.rb
+        invoke  test_unit
+        insert  app/models/user.rb
+        insert  app/models/user_tok.rb

data/lib/generators/tok_access/model_generator.rb

@@ -0,0 +1,48 @@
+require 'generators/tok_access/orm_helper'
+require 'rails/generators/active_record/model/model_generator'
+
+module TokAccess
+  module Generators
+    class ModelGenerator < ActiveRecord::Generators::ModelGenerator
+      include TokAccess::Generators::OrmHelper
+      source_root File.join(File.dirname(ActiveRecord::Generators::ModelGenerator.instance_method(:create_migration_file).source_location.first), "templates")
+
+
+      def create_migration_file
+        return unless options[:migration] && options[:parent].nil?
+        attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
+        if behavior == :invoke
+          if model_exists? or migration_exists?(table_name)
+            migration_template "#{__FILE__}/../templates/migration_existing_for.rb", "db/migrate/add_tok_access_to_#{table_name}.rb", migration_version: migration_version
+          else
+            migration_template "#{__FILE__}/../templates/migration_for.rb", "db/migrate/tok_access_create_#{table_name}.rb", migration_version: migration_version
+          end
+        end
+        if behavior == :revoke
+          migration_template "#{__FILE__}/../templates/migration_existing_for.rb", "db/migrate/add_tok_access_to_#{table_name}.rb", migration_version: migration_version
+          migration_template "#{__FILE__}/../templates/migration_for.rb", "db/migrate/tok_access_create_#{table_name}.rb", migration_version: migration_version
+        end
+      end
+
+      def generate_tok_model
+        tok_model_table_name = "#{table_name.singularize}_tok"
+        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"]
+          end
+          inject_into_class(Rails.root.join("app", "models", "#{table_name.singularize}.rb"), Object.const_get(table_name.singularize.camelize)) do
+            %Q{\ttokify\n}
+          end
+          inject_into_class(Rails.root.join("app", "models", "#{tok_model_table_name}.rb"), Object.const_get(tok_model_class_name)) do
+            %Q{\tdefine_toks :#{table_name.singularize}\n}
+          end
+        end
+        if behavior == :revoke
+          system "rails d model #{table_name.singularize.camelize}"
+          system "rails d model #{tok_model_class_name}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/tok_access/orm_helper.rb

@@ -0,0 +1,35 @@
+module TokAccess
+  module Generators
+    module OrmHelper
+
+      private
+
+      def model_exists?
+        File.exist?(File.join(destination_root, model_path))
+      end
+
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_add_tok_access_to_#{table_name}.rb$/).first
+      end
+
+      def migration_path
+        @migration_path ||= File.join("db", "migrate")
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+
+      def migration_version
+         "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+
+      def migration_data
+        <<-RUBY.strip_heredoc
+        t.string :password_digest, null: false, default: ""
+        RUBY
+      end
+
+    end
+  end
+end

data/lib/generators/tok_access/templates/migration_existing_for.rb

@@ -0,0 +1,12 @@
+class AddTokAccessTo<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+
+    change_table :<%= table_name %> do |t|
+      <%= migration_data %>
+      <% attributes.each do |attribute| %>
+        t.<%= attribute.type %> :<%= attribute.name %>
+      <% end %>
+    end
+  end
+
+end

data/lib/generators/tok_access/templates/migration_for.rb

@@ -0,0 +1,12 @@
+class TokAccessCreate<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+
+    create_table :<%= table_name %> do |t|
+      <%= migration_data %>
+      <% attributes.each do |attribute| %>
+        t.<%= attribute.type %> :<%= attribute.name %>
+      <% end %>
+    end
+  end
+
+end

data/lib/generators/tok_access/tok_access_generator.rb

@@ -0,0 +1,7 @@
+module TokAccess
+  module Generators
+    class TokAccessGenerator < Rails::Generators::Base
+      #namespace "tok_access"
+    end
+  end
+end

data/lib/tasks/tok_access_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :tok_access do
+#   # Task goes here
+# end

data/lib/tok_access/tok_authenticable.rb

@@ -0,0 +1,135 @@
+module TokAccess
+
+  module TokAuthenticable
+    extend ActiveSupport::Concern
+
+    included do
+
+        # before create an tokified object, setup the toks
+        before_create :setup_access_tok
+
+        # 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 token attribute of one
+        # of the associated object toks.
+        def get_token
+          @_token
+        end
+
+        # 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
+        # of one of the associated object toks.
+        def get_devise_token
+          @_devise_token
+        end
+
+        # Return nil if you haven't use the method TokAccess.validate_access.
+        # After the TokAccess.validate_access method is called, if the access was validated
+        # successfuly, this method will return true if the token was regenerated, otherwise
+        # return nil
+        def refreshed?
+          @refreshed
+        end
+
+
+        # 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
+        # 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
+        # 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 )
+          if self.authenticate(password)
+            generate_access_toks(devise_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
+        # 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
+            return self
+          end
+          nil
+        end
+
+        private
+
+        def refresh(tok)
+          if tok.updated_at >= 15.minutes.ago
+            tok.touch
+            @refreshed = true
+          end
+        end
+
+        def set_token(token)
+          @_token = token
+        end
+
+        def set_devise_token(token)
+          @_devise_token = token
+        end
+
+        def setup_access_tok
+          self.toks.build()
+        end
+
+        def generate_access_toks(devise_token = nil)
+          if !devise_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.regenerate_token if tok
+            tok.regenerate_devise_token if tok
+          end
+          if tok
+            @refreshed = true
+            set_token tok.token
+            set_devise_token tok.devise_token
+          end
+        end
+
+    end
+
+    module ClassMethods
+
+      # 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
+      # => 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
+      # 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(token: tokens[:token]) if tokens[:token] and !tok
+        if tok
+          return tok._tok_object.provide_access(tok)
+        end
+        nil
+      end
+
+    end
+
+  end
+
+end

data/lib/tok_access/tok_config.rb

@@ -0,0 +1,52 @@
+module TokAccess
+
+  class TokConfig
+
+    attr_accessor :tokens_limit
+    @tokens_limit = nil
+
+    def initialize()
+      @tokens_limit = 10
+    end
+
+  end
+
+  @config =  TokConfig.new
+
+  def config
+    @config
+  end
+  module_function :config
+
+  def configure(&block)
+    if block_given?
+      yield @config
+    end
+  end
+  module_function :configure
+
+  Object.class_eval do
+    def tokify
+      class_eval do
+        include TokAccess::TokAuthenticable
+        has_secure_password
+        has_many :toks, class_name: "#{self}Tok", foreign_key: "object_id", autosave: true
+      end
+    end
+
+    def define_toks(association = nil)
+      class_eval do
+        belongs_to association,
+                   class_name: "#{self.to_s.gsub(/Tok\z/,'')}",
+                   foreign_key: "object_id" if association
+        belongs_to :_tok_object,
+                   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
+      end
+    end
+  end
+
+end

data/lib/tok_access/version.rb

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

data/lib/tok_access.rb

@@ -0,0 +1,7 @@
+require 'tok_access/tok_config'
+require 'tok_access/tok_authenticable'
+
+## TokAccess
+# The TokAcess module
+module TokAccess
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: tok_access
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yonga9121
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.7
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Handle authentication of your users using tokens.
+email:
+- jorgeggayon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/tok_access/USAGE
+- lib/generators/tok_access/model_generator.rb
+- lib/generators/tok_access/orm_helper.rb
+- lib/generators/tok_access/templates/migration_existing_for.rb
+- lib/generators/tok_access/templates/migration_for.rb
+- lib/generators/tok_access/tok_access_generator.rb
+- lib/tasks/tok_access_tasks.rake
+- lib/tok_access.rb
+- lib/tok_access/tok_authenticable.rb
+- lib/tok_access/tok_config.rb
+- lib/tok_access/version.rb
+homepage: https://yonga9121.github.io/tok_access/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Handle authentication of your users using tokens.
+test_files: []