fresh_jwt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3db90e474ada5fe77cce913c8cfeab01a059f22859b83d743dcf1ca9254d7fbc
+  data.tar.gz: fb524e5cbe83e56733e8294741c9f104a9535fa710a8dfed4af761db0334420d
+SHA512:
+  metadata.gz: e3aa6737e66e4ce4f6c721a8a72c1ef2aa428026cba551edb792e1ba43463b3b2bed5b743678293e06c3eddcc198ef23c364ed17ff5e5b66f7e37a2f33a2c3fd
+  data.tar.gz: 387704eb2eefb1c2cce0b88d1c82fd152d5e6faef365b43cf8788d67d44294c9f98ed49c12e7f7b75d4b447f53137d68831dd02ee2f854502e2b160d7d4f15bf

data/.gitignore

@@ -0,0 +1,57 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*
+tmp.rb

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# A sample Gemfile
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+ruby "2.7.3"
+
+gem 'jwt'
+gem 'dry-initializer'
+gem 'dry-validation'
+gem 'dry-monads'
+gem 'rspec'
+# https://github.com/garyf/jwt_claims
+# gem 'jwt_claims'
+
+gem 'pry'
+gem 'timecop'

data/Gemfile.lock

@@ -0,0 +1,81 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    dry-configurable (0.12.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5.0)
+    dry-container (0.8.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.6.0)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.3.0)
+    dry-inflector (0.2.0)
+    dry-initializer (3.0.4)
+    dry-logic (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-monads (1.3.5)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.4, >= 0.4.4)
+      dry-equalizer
+    dry-schema (1.6.2)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.8, >= 0.8.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-initializer (~> 3.0)
+      dry-logic (~> 1.0)
+      dry-types (~> 1.5)
+    dry-types (1.5.1)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 1.0, >= 1.0.2)
+    dry-validation (1.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.7, >= 0.7.1)
+      dry-core (~> 0.4)
+      dry-equalizer (~> 0.2)
+      dry-initializer (~> 3.0)
+      dry-schema (~> 1.5, >= 1.5.2)
+    jwt (2.2.3)
+    method_source (1.0.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    timecop (0.9.4)
+
+PLATFORMS
+  x86_64-darwin-20
+
+DEPENDENCIES
+  dry-initializer
+  dry-monads
+  dry-validation
+  jwt
+  pry
+  rspec
+  timecop
+
+RUBY VERSION
+   ruby 2.7.3p183
+
+BUNDLED WITH
+   2.2.17

data/README.md

@@ -0,0 +1 @@
+# fresh_jwt

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/fresh_jwt'
+
+require 'pry'
+Pry.start

data/lib/contracts/issuer_contract.rb

@@ -0,0 +1,18 @@
+module FreshJwt
+  class ContractError < StandardError
+    DEFAULT_MESSAGE = 'something wrong with Contract'
+    def initialize(msg = DEFAULT_MESSAGE, exception_type='custom')
+      @exception_type = exception_type
+      super(msg) 
+    end
+    def message
+      super
+    end
+  end
+end
+
+class IssuerContract < Dry::Validation::Contract
+  params do
+    required(:algorithm).filled(:string)
+  end
+end

data/lib/fresh_jwt.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'dry/validation'
+require 'jwt'
+require 'securerandom' 
+
+require_relative 'fresh_jwt/contract_validator'
+require_relative 'fresh_jwt/expiration'
+require_relative 'contracts/issuer_contract'
+require_relative 'fresh_jwt/payload'
+require_relative 'fresh_jwt/store'
+require_relative 'fresh_jwt/version'
+require_relative 'fresh_jwt/validator'
+require_relative 'fresh_jwt/entity/access_token'
+require_relative 'fresh_jwt/issuer'
+
+
+# require 'dry/monads'
+# TODO payload as dry entity
+
+
+module FreshJwt  
+
+
+  class Decoder
+    extend Dry::Initializer
+
+    option :algorithm, default: -> { 'HS256' }
+    option :secret, default: -> { 'SECRET' }
+
+    def decode(token:)
+      JWT.decode(token, secret, algorithm)
+    end
+  end
+
+
+end

data/lib/fresh_jwt/contract_validator.rb

@@ -0,0 +1,24 @@
+require 'dry/monads'
+#это штука типа оборачивает монады...
+require 'dry/monads/do'
+module FreshJwt
+  class ContractValidator
+    include Dry::Monads[:result]
+    include Dry::Monads::Do.for(:call)
+  
+    def call(contract, params)
+      result = contract.new.call(params)
+      if result.success?
+        Success(result)
+      else
+        Failure(result.errors.to_h)
+      end  
+    
+    end
+  end
+end
+
+
+  #def validate
+  #  return Success(data) || Failure(:not_valid)
+  #end

data/lib/fresh_jwt/entity/access_token.rb

@@ -0,0 +1,25 @@
+module FreshJwt
+  module Entity
+
+    class Token
+      extend Dry::Initializer
+      option :name, proc(&:to_s), default: -> { self.class.to_s.split('::').last }
+      option :token, proc(&:to_s)
+      option :issued_at, proc(&:to_i), default: -> { Time.now.to_i }
+      
+    end
+
+    class AccessToken < Token
+      option :payload, Payload, optional: true
+      option :expired_at, proc(&:to_i), default: -> { issued_at + FreshJwt::Expiration::ACCESS }
+    end
+
+    class RefreshToken < Token
+      option :expired_at, proc(&:to_i), default: -> { issued_at + FreshJwt::Expiration::REFRESH }
+      #https://auth0.com/docs/tokens/refresh-tokens/disable-refresh-token-rotation
+      option :behavior_type, proc(&:to_s), default: -> {'non-rotation'} #or rotation
+    end
+
+
+  end
+end

data/lib/fresh_jwt/expiration.rb

@@ -0,0 +1,9 @@
+module FreshJwt
+  module Expiration
+    def self.minutes v
+      v * 60
+    end
+    ACCESS = Expiration.minutes(5) 
+    REFRESH = Expiration.minutes(60)
+  end
+end

data/lib/fresh_jwt/issuer.rb

@@ -0,0 +1,53 @@
+module FreshJwt
+
+  class Issuer
+    extend Dry::Initializer
+    include Dry::Monads[:result, :do]
+    REFRESH_EXPIRATION = 60*60*24
+
+    #Payload.new(extend: val )
+    option :payload, ->(hash){ Payload.new(exp: FreshJwt::Expiration::ACCESS, extend: hash) }, default: -> { Payload.new } #why we need new i do not understand, coz class is callable
+    # TODO: describe enum type for 2 algo
+    option :algorithm, default: -> { 'HS256' } #RS256 
+    option :secret, default: -> { 'SECRET' }
+    option :refresh_token, proc(&:to_s), default: -> { SecureRandom.hex }
+    option :tokens_repo, default: -> { Store }
+
+    def call
+      validate_params params
+      token = JWT.encode(payload.to_hash, secret, algorithm)
+      access_token = Entity::AccessToken.new(token: token)
+      refresh_token = Entity::RefreshToken.new(token: refresh_token)
+      
+      yield tokens_repo.single_transaction access_token
+      yield tokens_repo.single_transaction refresh_token
+      
+      #result = tokens_repo.transaction do
+      #  tokens_repo.save access_token
+      #  tokens_repo.save refresh_token
+      #end
+      #return result unless result.success?
+
+      #tokens_repo.save Entity::AccessToken.new(
+      #  token: token
+      #)
+      #tokens_repo.save Entity::RefreshToken.new(
+      #  token: refresh_token
+      #)
+      return access_token, refresh_token
+    end
+
+    def params
+      @params ||= self.class.dry_initializer.attributes(self)
+    end
+
+    def validate_params params
+      result = IssuerContract.new.call(params)
+      unless result.success?
+        raise ContractError.new(result.errors.to_h)  
+      end
+    end
+
+    
+  end
+end

data/lib/fresh_jwt/payload.rb

@@ -0,0 +1,49 @@
+
+
+
+module FreshJwt
+
+  module Entity
+    module Callable
+      def call(*args)
+        new(*args)
+      end
+  
+      alias [] call
+    end
+  end
+
+  class Payload
+    extend Dry::Initializer
+    extend Entity::Callable
+  
+    option :jti, default: proc { SecureRandom.hex }
+    option :iat, proc(&:to_i), default: proc { Time.now }
+    option :exp, ->(val){ (Time.now + val).to_i }, default: -> { 10 * 60 } #default: ->(val) { iat + 10*60 }
+    option :extend, proc(&:to_h), default: proc{ {} }
+    
+    def default_payload
+      @default_payload ||= self.class.dry_initializer.attributes(self).slice(:jti, :iat, :exp)
+    end
+
+    def to_hash
+      @params ||= default_payload.merge(extend)
+    end
+
+  end
+end
+
+=begin
+def registered_claim(sym)
+  case sym
+  when :aud then Claim::Aud
+  when :exp then Claim::Exp
+  when :iat then Claim::Iat
+  when :iss then Claim::Iss
+  when :jti then Claim::Jti
+  when :nbf then Claim::Nbf
+  when :sub then Claim::Sub
+  else nil # custom claim
+  end
+end
+=end

data/lib/fresh_jwt/store.rb

@@ -0,0 +1,49 @@
+module FreshJwt  
+  class Store
+    extend Dry::Monads[:result]
+    @@store = []
+    #{
+    #  "token_value": {
+    #    jti: 1,
+    #    exp: 2,
+    #    type: :access
+    #  }
+    #}
+
+    def self.save token
+      
+      @@store << token
+    end
+    def self.get token
+      @@store.find{ |t| t == token }
+    end
+    def self.all
+      @@store
+    end
+
+    def self.find_by_token token
+      @@store.find{ |t| t.token == token }
+    end
+
+    def self.single_transaction token
+      begin
+        save token
+        return Success()
+      rescue Exception => error
+        #puts error
+        return Failure(error: error.message)
+      end      
+    end
+
+    def self.transaction &block
+      begin
+        block.call
+        return Success()
+      rescue Exception => error
+
+        puts error
+        return Failure(error: error.message)
+      end
+    end
+  end
+end

data/lib/fresh_jwt/validator.rb

@@ -0,0 +1,43 @@
+module FreshJwt
+  class Validator
+    extend Dry::Initializer
+    include Dry::Monads[:result, :do]
+
+    option :algorithm, default: -> { 'HS256' }
+    option :secret, default: -> { 'SECRET' }
+    option :token_repo, default: -> { Store }
+
+    def call(token)
+      yield valid_by_store? token
+      payload, _ = yield decode token
+      valid_payload? payload  
+    end
+
+    def valid_by_store? token
+      #access_token = token_repo.find_by_token(token)
+      #if access_token.expired_at > Time.now.to_i      
+      if true 
+        return Success()
+      else
+        return Failure(validator: :invalid_by_store)
+      end
+    end
+
+    def decode token
+      begin 
+        result = JWT.decode(token, secret, true, {algorithm: algorithm})
+        Success(result)
+      rescue JWT::VerificationError, JWT::DecodeError => e
+        Failure(decode_error: ["Cannot validate", e.message])
+      end
+    end
+
+    def valid_payload? payload
+      if payload["exp"] > Time.now.to_i
+        Success()
+      else
+        Failure(valid_payload: false)
+      end      
+    end
+  end
+end

data/lib/fresh_jwt/version.rb

@@ -0,0 +1,3 @@
+module FreshJwt
+  VERSION = '0.0.1'
+end

data/main.rb

@@ -0,0 +1,67 @@
+require_relative 'lib/fresh_jwt'
+
+#payload = FreshJwt::Payload.new(extend:{
+#  user_id: rand(1000),
+#  rating: 99.4
+#})
+
+payload = {
+  user_id: rand(1000),
+  rating: 99.4
+}
+
+issuer = FreshJwt::Issuer.new(algorithm: 'HS256', payload:{
+  user_id: rand(1000),
+  rating: 99.4  
+})
+
+access_token, refresh_token = begin
+  issuer.call
+rescue FreshJwt::ContractError => e
+  p e.message
+  nil
+end
+token = access_token.token
+
+exit(0) unless token
+p token 
+p "decoded " << FreshJwt::Decoder.new().decode(token:token).to_s 
+#p JWT.decode(token, issuer.secret, 'HS256')
+p "valid? " << FreshJwt::Validator.new().call(token).to_s
+payload = FreshJwt::Payload.new({})
+p "store: #{FreshJwt::Store.all}"
+
+
+########################################
+##### HOW TO COMFORTABLE WORK WITH #####
+########################################
+=begin
+issuer = FreshJwt::Issuer.new(algorithm: 'HS256')
+#OR
+issuer = FreshJwt::Issuer.new
+access, refresh = issuer.call(payload: {
+  user_id: 1
+})
+
+authenticator = FreshJwt::Authenticator.new
+authenticator.call(access_token: token)
+# Success or 403 failure with errors describe
+
+refresher = FreshJwt::Refresher.new
+access, refresh = refresher.call(
+  refresh_token: token,
+  payload: {
+    user_id: 1
+  }
+)
+=end
+#FreshJwt::Revoker
+
+
+
+
+
+
+
+
+

data/refresher_draft.rb

@@ -0,0 +1,51 @@
+require 'dry/monads'
+require 'dry/monads/do'
+require 'securerandom'
+
+#extend Dry::Monads[:maybe, :result]
+#p None().to_result( {error: :some} )
+
+class Refresher
+  include Dry::Monads[:result, :do]
+
+  def initialize(token:)
+    @token = token
+  end
+  
+  def call
+    token = yield validate_token @token
+    new_token = yield create_new_token token#.value!
+    store_token new_token#.value!
+  end
+
+  def validate_token token
+    if true
+      Success(token)
+    else
+      Failure(:token_not_valid)
+    end
+  end
+
+  def create_new_token token
+    if true
+      Success(SecureRandom.hex<< ' ' << token)
+    else
+      Failure(:cannot_create_token)
+    end
+  end
+
+  def store_token token
+    if true
+      $db << token
+      Success(token)
+    else
+      Failure(:some_errors_when_store)
+    end
+  end
+
+end
+
+$db = []
+token = Refresher.new(token: '1').call
+#p token.failure?
+p token.value_or{ |err| err }

data/spec/fresh_jwt/issuer_spec.rb

@@ -0,0 +1,37 @@
+#require 'dry/monads/result'
+
+include Dry::Monads[:result]
+RSpec.describe FreshJwt::Issuer do
+  
+  let(:jwt_regexp) { /^[\w-]*\.[\w-]*\.[\w-]*$/ }
+  let(:plain_token) { 'Token' }
+  let(:secret) { SecureRandom.hex }
+  let(:user_id) { rand(1000) }
+  let(:payload) { {user_id:user_id} }
+  let(:issuer) { described_class.new(payload: payload) }
+  before do
+    allow(SecureRandom).to receive(:hex).and_return(plain_token)
+  end
+  it 'should be kind of string' do
+    expect(issuer.call).to be_kind_of Array
+  end
+  it 'return AccessToken as first value' do
+    expect(issuer.call.first).to be_kind_of FreshJwt::Entity::AccessToken
+  end
+  it 'return RefreshToken as first value' do
+    expect(issuer.call.last).to be_kind_of FreshJwt::Entity::RefreshToken
+  end    
+  it 'match jwt_regexp' do
+    expect(issuer.call.first.token).to match jwt_regexp
+  end 
+  #let(:store) { class_double(FreshJwt::Store)}
+  context 'store transaction is failed' do
+    before do
+      allow(FreshJwt::Store).to receive(:save).and_raise(StandardError)
+    end
+    it 'return empty array' do
+      expect(issuer.call).to be_kind_of(Failure)
+    end
+  end
+
+end

data/spec/fresh_jwt/store_spec.rb

@@ -0,0 +1,16 @@
+Struct.new('AccessToken', :token)
+
+RSpec.describe FreshJwt::Store do
+  let(:token) { SecureRandom.hex }
+  let(:unknown_token) { SecureRandom.hex }
+  let(:token_obj) { Struct::AccessToken.new(token) }
+  before do 
+    described_class.save token_obj 
+  end
+  it 'should contant token' do
+    expect(described_class.find_by_token(token)).to eq(token_obj)
+  end
+  it 'should not contant token' do
+    expect(described_class.find_by_token(unknown_token)).to be_nil
+  end  
+end

data/spec/fresh_jwt/token_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+RSpec.describe FreshJwt::Entity::AccessToken do
+    let(:token) { SecureRandom.hex }
+    let(:access_token) { FreshJwt::Entity::AccessToken.new(token: token) }
+    before do
+      
+    end
+    it 'create access token klass' do
+      expect(access_token.name).to eq('AccessToken')
+    end
+  end

data/spec/fresh_jwt/validator_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+include Dry::Monads[:result]
+RSpec.describe FreshJwt::Validator do
+  #let(:token) { SecureRandom.hex }
+  #let(:access_token) { FreshJwt::Entity::AccessToken.new(token: token) }
+  let(:random_token) { SecureRandom.hex }
+  before do
+    @access_token, @refresh_token = FreshJwt::Issuer.new(payload: {}).call()
+    #FreshJwt::Store.save access_token
+  end
+  it 'can validate coz knwon token' do
+    expect(described_class.new.call(@access_token.token)).to eq(Success())
+  end
+
+  it 'con not validate coz unknwon token' do
+    expect(described_class.new.call(random_token)).to be_kind_of(Failure)
+  end
+  context 'too late for validate' do
+    before do
+      @access_token, @refresh_token = FreshJwt::Issuer.new(payload: {}).call()
+      t = Time.at( Time.now.to_i + FreshJwt::Expiration::ACCESS + 1 )
+      Timecop.travel(t)   
+    end
+    it 'can not validate coz expire token' do
+      expect(described_class.new.call(@access_token.token)).to eq(
+        Failure({:decode_error=>["Cannot validate", "Signature has expired"]})
+      )
+    end
+  end
+end
+
+# Добавить кейсы с разными фейлами
+# -Failure({:decode_error=>"Signature has expired"})
+# +Failure({:decode_error=>"Signature verification raised"})

data/spec/fresh_jwt_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe FreshJwt do 
+  it 'has a version number' do
+    expect(described_class::VERSION).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require_relative '../lib/fresh_jwt'
+require 'timecop'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: fresh_jwt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrei Mosin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-19 00:00:00.000000000 Z
+dependencies: []
+description: Issue access JWT & secure with refresh token
+email: otmosina@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/console
+- lib/contracts/issuer_contract.rb
+- lib/fresh_jwt.rb
+- lib/fresh_jwt/contract_validator.rb
+- lib/fresh_jwt/entity/access_token.rb
+- lib/fresh_jwt/expiration.rb
+- lib/fresh_jwt/issuer.rb
+- lib/fresh_jwt/payload.rb
+- lib/fresh_jwt/store.rb
+- lib/fresh_jwt/validator.rb
+- lib/fresh_jwt/version.rb
+- main.rb
+- refresher_draft.rb
+- spec/fresh_jwt/issuer_spec.rb
+- spec/fresh_jwt/store_spec.rb
+- spec/fresh_jwt/token_spec.rb
+- spec/fresh_jwt/validator_spec.rb
+- spec/fresh_jwt_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/hola
+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: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Fresh JWT token!
+test_files:
+- spec/fresh_jwt/issuer_spec.rb
+- spec/fresh_jwt/store_spec.rb
+- spec/fresh_jwt/token_spec.rb
+- spec/fresh_jwt/validator_spec.rb
+- spec/fresh_jwt_spec.rb
+- spec/spec_helper.rb