better_record 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d29d2bc0753e584821d26b2fab8982433e35804b987d12f4b0dd041b0aacfa74
-  data.tar.gz: 1c2f52a0da7eaf5006bc5f7c37cb8d88a76c8f0b36f5f871e8e718cc09359062
+  metadata.gz: 15065e4dbf375d7777148aa24e0a36afde1c7db1ddb458c133fb38cac4b8cb7e
+  data.tar.gz: af39d1a5bf2bfeb0d16feb26bca64f2d6d2ddd0006d63317d764eb163e650c45
 SHA512:
-  metadata.gz: 9f665aa3dd58974cc2923d0a0f68115dc7060d7e6875e6babcbeefc2d8a6c6606074bbf895c0ef21b377560adaf8ffdf935e1e90707c194ce6293dc946047969
-  data.tar.gz: c4bd9c386f1072514d7bc63034fc29615e4263f5cc51315681997ea9c0be8833d4428fa39d60718ffb45bdd924762612120c84f01b10e2a3fe8416b2e76f75d5
+  metadata.gz: 20f71fc1960ba2478f065cd8d9d67b3c8cc9123e000c7c4648b7e77c5fccc54e54226e131bf63fb42a6096e7476571c6e73c2c7d307ccc625580b412a3d722ee
+  data.tar.gz: fd5479dce949e8e0cc5934319244dc4abac74a5945f7e29d1faa751afc1bd14400123fcc307051b8879c999be84eb535317820604871bbabbf3661af2aa20226

data/app/models/better_record/current.rb

@@ -9,11 +9,13 @@ module BetterRecord
     def self.set(user, ip)
       self.user = user.presence || nil
       self.ip_address = ip.presence || nil
+      self
     end
 
     def self.drop_values
       self.user = nil
       self.ip_address = nil
+      self
     end
   end
 end

data/config/initializers/core_ext/integer.rb

@@ -1,5 +1,43 @@
 class Integer
+  def self.models
+    @@record_models ||= Hash[*Dir[Rails.root.join('app', 'models', '**.rb')].map do |file|
+      @str_idx ||= Rails.root.join('app', 'models').to_s.size + 1
+      str = file[@str_idx..-4]
+      [str, str]
+    end.flatten]
+  end
+
+  def self.add_lookup_method(method_name, klass)
+    self.__send__ :define_method, method_name.to_sym do
+      klass.find_by(id: self)
+    end
+  end
+
   def cents
     StoreAsInt.money(self)
   end
+
+  def percentage
+    StoreAsInt.exchange_rate(self)
+  end
+
+  def method_missing(method, *args)
+    begin
+      if m = is_model_lookup?(method)
+        m = m.classify.constantize
+        Integer.add_lookup_method method, m
+        m.find_by(id: self)
+      else
+        raise NoMethodError
+      end
+    rescue NoMethodError
+      super(method, *args)
+    end
+  end
+
+  private
+    def is_model_lookup?(method = nil)
+      (method.to_s =~ /^to\_[a-zA-Z\_0-9]+$/) &&
+      (Integer.models[method.to_s.sub("to_", '')])
+    end
 end

data/config/initializers/core_ext/string.rb

@@ -0,0 +1,11 @@
+class String
+  def self.clean_certificate(str)
+    CGI.unescape(str).gsub(/(\n|-----(BEGIN|END) CERTIFICATE-----)/, '').strip
+  end
+
+  def clean_certificate
+    clean_certificate(self)
+  end
+
+  alias_method :clean_cert, :clean_certificate
+end

data/config/initializers/inflections.rb

@@ -18,4 +18,6 @@ ActiveSupport::Inflector.inflections(:en) do |inflect|
   inflect.acronym 'DBs'
   inflect.acronym 'GNU'
   inflect.acronym 'GNUs'
+  inflect.acronym 'JWT'
+  inflect.acronym 'JWTs'
 end

data/config/routes.rb

@@ -1,4 +1,10 @@
 BetterRecord::Engine.routes.draw do
   root to: 'table_sizes#index'
-  resources :table_sizes, only: [ :index, :show ]
+
+  resources :table_sizes, only: %i[ index show ]
+
+  namespace :api do
+    resources :sessions, only: %i[ new create destroy ]
+    get :sessions, to: 'sessions#new'
+  end
 end

data/lib/better_record.rb

@@ -1,25 +1,53 @@
-require "active_support"
-require "active_record"
+require 'active_support'
+require 'active_record'
+require 'csv'
 
 Dir.glob("#{File.expand_path(__dir__)}/core_ext/*.rb").each do |d|
   require d
 end
 
 module BetterRecord
+  ATTRIBUTE_METHODS = [
+    :default_polymorphic_method,
+    :db_audit_schema,
+    :has_auditing_relation_by_default,
+    :audit_relation_name,
+    :layout_template,
+    :app_domain_name,
+    :after_login_path,
+    :session_class,
+    :session_column,
+    :session_data,
+    :session_authenticate_method,
+    :certificate_session_class,
+    :certificate_session_column,
+    :certificate_session_user_method,
+  ].freeze
+
   class << self
-    attr_accessor :default_polymorphic_method,
-                  :db_audit_schema,
-                  :has_auditing_relation_by_default,
-                  :audit_relation_name,
-                  :layout_template,
-                  :app_domain_name
+    def attributes
+      attrs_hash.dup
+    end
+
+    attr_accessor *ATTRIBUTE_METHODS
+
+    private
+      def attrs_hash
+        @attrs ||= ATTRIBUTE_METHODS.map {|k| [k, true]}.to_h.with_indifferent_access.freeze
+      end
   end
+
   self.default_polymorphic_method = (ENV.fetch('BR_DEFAULT_POLYMORPHIC_METHOD') { :polymorphic_name }).to_sym
   self.db_audit_schema = ENV.fetch('BR_DB_AUDIT_SCHEMA') { 'auditing' }
   self.has_auditing_relation_by_default = ActiveRecord::Type::Boolean.new.cast(ENV.fetch('BR_ADD_HAS_MANY') { true })
   self.audit_relation_name = (ENV.fetch('BR_AUDIT_RELATION_NAME') { 'logged_actions' }).to_sym
   self.layout_template = (ENV.fetch('BR_LAYOUT_TEMPLATE') { 'better_record/layout' }).to_s
   self.app_domain_name = (ENV.fetch('APP_DOMAIN_NAME') { 'non_existant_domain.com' }).to_s
+  self.after_login_path = (ENV.fetch('BR_AFTER_LOGIN_PATH') { nil })
+  self.session_column = (ENV.fetch('BR_SESSION_COLUMN') { :id }).to_sym
+  self.session_authenticate_method = (ENV.fetch('BR_SESSION_AUTHENTICATE_METHOD') { :authenticate }).to_sym
+  self.certificate_session_column = (ENV.fetch('BR_CERTIFICATE_SESSION_COLUMN') { :certificate }).to_sym
+  self.certificate_session_user_method = (ENV.fetch('BR_CERTIFICATE_SESSION_USER_METHOD') { :user }).to_sym
 end
 
 Dir.glob("#{File.expand_path(__dir__)}/better_record/*.rb").each do |d|

data/lib/better_record/concerns/controllers/authenticatable.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module BetterRecord
+  module Authenticatable
+    extend ActiveSupport::Concern
+    include BetterRecord::JWT::ControllerMethods
+
+    included do
+      before_action :check_user
+    end
+
+    def method_missing(method, *args)
+      begin
+        if BetterRecord.attributes[method.to_sym]
+          m = method.to_sym
+          self.class.define_method m do
+            BetterRecord.__send__ m
+          end
+          BetterRecord.__send__ m
+        else
+          raise NoMethodError
+        end
+      rescue NoMethodError
+        super(method, *args)
+      end
+    end
+
+
+  end
+end

data/lib/better_record/concerns/controllers/sessionable.rb

@@ -0,0 +1,33 @@
+require 'active_support/concern'
+
+module BetterRecord
+  module Sessionable
+    extend ActiveSupport::Concern
+    include BetterRecord::JWT::ControllerMethods
+
+    included do
+      skip_before_action :check_user, raise: false
+    end
+
+    def new
+      session[:referrer] ||= request.referrer
+      p session[:referrer], request.referrer
+      if (header_hash = request.headers.to_h.deep_symbolize_keys)[:HTTP_X_SSL_CERT].present?
+        create_session_from_certificate(header_hash[:HTTP_X_SSL_CERT])
+        redirect_to (session.delete(:referrer) || __send__(after_login_path) || root_path)
+      end
+    end
+
+    def create
+      if(user = session_class.__send__(session_authenticate_method, params))
+        session[:better_record] = create_jwt(user)
+      end
+      respond_to do |format|
+        format.json
+        format.html do
+          return redirect_to (session.delete(:referrer) || __send__(after_login_path) || root_path)
+        end
+      end
+    end
+  end
+end

data/lib/better_record/concerns/controllers/uploadable.rb

@@ -0,0 +1,66 @@
+module Uploadable
+  extend ActiveSupport::Concern
+
+  def whitelisted_upload_params
+    params.require(:upload).permit(:file, :staff_id)
+  end
+
+  def csv_upload(job, whitelisted_params, upload_key, prefix, job_sym = :staff_id, redirecting = false)
+    p whitelisted_params
+    uploaded = whitelisted_params[upload_key]
+    job_id = whitelisted_params[job_sym]
+    @file_stats = {
+      name: uploaded.original_filename,
+      "mime-type" => uploaded.content_type,
+      size: view_context.number_to_human_size(uploaded.size)
+    }
+    if verify_file(whitelisted_params, upload_key)
+      File.open(Rails.root.join('public', 'import_csv', "#{prefix}_#{Time.now.to_i}#{rand(1000..100000)}.csv"), 'wb') do |file|
+        uploaded = BetterRecord::Encoder.new(uploaded.read).to_utf8
+        file.write(uploaded)
+        job.perform_later file.path, job_id, @file_stats[:name]
+      end
+      if redirecting
+        flash[:success] ||= []
+        flash[:success] << 'File Uploaded'
+      else
+        flash.now[:success] ||= []
+        flash.now[:success] << 'File Uploaded'
+      end
+      return true
+    else
+      msg = [
+        'something went wrong',
+        'Only csv files with the correct headers are supported',
+        "content type: #{whitelisted_params[upload_key].content_type}", "file name: #{whitelisted_params[upload_key].original_filename}"
+      ]
+
+      if redirecting
+        flash[:danger] = msg
+      else
+        flash.now[:danger] = msg
+
+        render :show
+      end
+    end
+  end
+
+  private
+    def verify_file(whitelisted_params, upload_key)
+      correct_mime_type(whitelisted_params, upload_key) && /\.csv/ =~ whitelisted_params[upload_key].original_filename
+    end
+
+    def correct_mime_type(whitelisted_params, upload_key)
+      [
+        "text/csv",
+        "text/plain",
+        "application/vnd.ms-excel",
+        "text/x-csv",
+        "application/csv",
+        "application/x-csv",
+        "text/csv",
+        "text/comma-separated-values",
+        "text/x-comma-separated-values"
+      ].any? {|mime| mime == whitelisted_params[upload_key].content_type}
+    end
+end

data/lib/better_record/encoder.rb

@@ -0,0 +1,46 @@
+module BetterRecord
+  class Encoder
+    def initialize(str)
+      @str = str
+    end
+
+    def to_utf8
+      return @str if is_utf8?
+      encoding = find_encoding
+      @str.force_encoding(encoding).encode('utf-8', invalid: :replace, undef: :replace)
+    end
+
+    def find_encoding
+      puts 'utf-8' if is_utf8?
+      return 'utf-8' if is_utf8?
+      puts 'iso-8859-1' if is_iso8859?
+      return 'iso-8859-1' if is_iso8859?
+      puts 'Windows-1252' if is_windows?
+      return 'Windows-1252' if is_windows?
+      raise ArgumentError.new "Invalid Encoding"
+    end
+
+    def is_utf8?
+      is_encoding?(Encoding::UTF_8)
+    end
+
+    def is_iso8859?
+      is_encoding?(Encoding::ISO_8859_1)
+    end
+
+    def is_windows?(str)
+      is_encoding?(Encoding::Windows_1252)
+    end
+
+    def is_encoding?(encoding_check)
+      case @str.encoding
+      when encoding_check
+        @str.valid_encoding?
+      when Encoding::ASCII_8BIT, Encoding::US_ASCII
+        @str.dup.force_encoding(encoding_check).valid_encoding?
+      else
+        false
+      end
+    end
+  end
+end

data/lib/better_record/jwt.rb

@@ -0,0 +1,127 @@
+require 'jwt'
+require 'jwe'
+require 'openssl'
+
+module BetterRecord
+  class JWT
+    CHARACTERS = [*('a'..'z'), *('A'..'Z'), *(0..9).map(&:to_s), *'!@#$%^&*()'.split('')]
+    DEFAULT_OPTIONS = { enc:  'A256GCM', alg: 'dir', zip: 'DEF' }
+
+    class << self
+      def gen_encryption_key
+        SecureRandom.random_bytes(32)
+      end
+
+      def encryption_key
+        @encryption_key ||= gen_encryption_key
+      end
+
+      def encryption_key=(key)
+        @encryption_key = key || gen_encryption_key
+      end
+
+      def gen_signing_key(length = 50)
+        (0...length).map { CHARACTERS[rand(CHARACTERS.length)] }.join
+      end
+
+      def signing_key
+        @signing_key ||= gen_signing_key
+      end
+
+      def signing_key=(key)
+        @signing_key = key || gen_signing_key
+      end
+
+      def encrypt_options
+        @encrypt_options ||= DEFAULT_OPTIONS
+      end
+
+      def encrypt_options=(options)
+        @encrypt_options = options || DEFAULT_OPTIONS
+      end
+
+      def encode(payload, sig_key = nil, enc_key = nil, options = nil)
+        ::JWE.encrypt ::JWT.encode(payload, (sig_key || signing_key), 'HS512'), (enc_key || encryption_key), (options || encrypt_options)
+      end
+
+      alias_method :create, :encode
+      alias_method :encrypt, :encode
+      alias_method :inflate, :encode
+
+      def decode(payload, sig_key = nil, enc_key = nil)
+        ::JWT.decode(::JWE.decrypt(payload, (enc_key || encryption_key)), (sig_key || signing_key), true, algorithm: 'HS512')[0]
+      end
+
+      alias_method :read, :decode
+      alias_method :decrypt, :decode
+      alias_method :deflate, :decode
+    end
+
+    module ControllerMethods
+      protected
+        def check_user
+          if logged_in?
+            begin
+              data = current_user_session_data
+              if  !data[:created_at] ||
+                  (data[:created_at].to_i > 14.days.ago.to_i)
+                if user = session_class.find_by(session_column => data[:user_id])
+                  session[:current_user] = create_jwt(user, data) if data[:created_at] < 1.hour.ago
+                  set_user(user)
+                else
+                  throw 'User Not Found'
+                end
+              else
+                throw 'Token Expired'
+              end
+            rescue
+              session.delete(:current_user)
+              BetterRecord::Current.drop_values
+            end
+          end
+
+          BetterRecord::Current.user || false
+        end
+
+        def create_jwt(user, additional_headers = {})
+          additional_headers = {} unless additional_headers && additional_headers.is_a?(Hash)
+          data = nil
+          data = session_data ? session_data.call(user) : {
+            user_id: user.__send__(session_column),
+            created_at: Time.now.to_i
+          }
+          BetterRecord::JWT.encode(data.merge(additional_headers.except(*data.keys)))
+        end
+
+        def create_session_from_certificate(cert)
+          user = (certificate_session_class || session_class).
+          find_by(certificate_session_column => cert.clean_certificate)
+
+          if user
+            if  certificate_session_user_method &&
+                user.respond_to?(certificate_session_user_method)
+              user = user.__send__(certificate_session_user_method)
+            end
+
+            session[:current_user] = create_jwt(user, { has_certificate: true })
+          end
+        end
+
+        def current_user
+          BetterRecord::Current.user || check_user
+        end
+
+        def current_user_session_data
+          logged_in? ? JWT.decode(session[:current_user]).deep_symbolize_keys : {}
+        end
+
+        def logged_in?
+          session[:current_user].present?
+        end
+
+        def set_user(user)
+          BetterRecord::Current.set(user, request.remote_ip)
+        end
+    end
+  end
+end

data/lib/better_record/rspec/expectations.rb

@@ -0,0 +1,3 @@
+Dir.glob("#{File.expand_path(__dir__)}/expectations/*").each do |d|
+  require d
+end

data/lib/better_record/rspec/expectations/write.rb

@@ -0,0 +1,75 @@
+require 'stringio'
+
+# Custom matcher to test text written to standard output and standard error
+#
+# @example
+#   expect { $stderr.puts "Some random error" }.to write(/Some.* error/).to(:stderr)
+#
+# @example
+#   expect { $stderr.puts "Some specific error" }.to write('Some specific error').to(:stderr)
+#
+RSpec::Matchers.define :write do |message|
+  chain(:to) do |io|
+    @io = io
+  end
+
+  match do |block|
+    output =
+      case io
+      when :stdout then fake_stdout(&block)
+      when :stderr  then fake_stderr(&block)
+      else fail("Allowed values for `to` are :stdout and :stderr, got `#{io.inspect}`")
+      end
+
+    case message
+    when String then output.include? message
+    when Regexp then output.match message
+    else fail("Allowed types for write `message` are String or Regexp, got `#{message.class}`")
+    end
+  end
+
+  def supports_block_expectations?
+    true # or some logic
+  end
+
+  description do
+    %Q[write #{message.inspect} to #{@io}]
+  end
+
+  def f_message(to = 'to')
+    %Q[expected #{to} #{description} but got #{@buffer.inspect}]
+  end
+
+  failure_message do
+    f_message 'to'
+  end
+
+  failure_message_when_negated do
+    f_message 'not to'
+  end
+
+  # Fake STDERR and return a string written to it.
+  def fake_stderr
+    original_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    @buffer = $stderr.string
+  ensure
+    $stderr = original_stderr
+  end
+
+  # Fake STDOUT and return a string written to it.
+  def fake_stdout
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+    @buffer = $stdout.string
+  ensure
+    $stdout = original_stdout
+  end
+
+  # default IO is standard output
+  def io
+    @io ||= :stdout
+  end
+end

data/lib/better_record/version.rb

@@ -1,3 +1,3 @@
 module BetterRecord
-  VERSION = '0.7.5'
+  VERSION = '0.8.0'
 end

data/lib/generators/better_record/setup/setup_generator.rb

@@ -7,7 +7,7 @@ class BetterRecord::SetupGenerator < ActiveRecord::Generators::Base
   class_option :eject, type: :boolean, default: false
 
   def run_generator
-    route 'mount BetterRecord::Engine => "/better_record"'
+    mount_engine
     copy_templates
     copy_migrations
     gsub_files
@@ -37,23 +37,6 @@ class BetterRecord::SetupGenerator < ActiveRecord::Generators::Base
       eject_files if !!options['eject']
     end
 
-    def gsub_files
-      eager_line = 'config.eager_load_paths += Dir["#{config.root}/lib/modules/**/"]'
-      structure_line = 'config.active_record.schema_format'
-
-      gsub_file 'config/application.rb', /([ \t]*?(#{Regexp.escape(eager_line)}|#{Regexp.escape(structure_line)})[ ='":]*?(rb|sql)?['"]?[ \t0-9\.]*?)\n/mi do |match|
-        ""
-      end
-
-      gsub_file 'config/application.rb', /#{Regexp.escape("config.load_defaults")}[ 0-9\.]+\n/mi do |match|
-        "#{match}    #{eager_line}\n    #{structure_line} = :sql\n"
-      end
-
-      gsub_file 'app/models/application_record.rb', /(#{Regexp.escape("class ApplicationRecord < ActiveRecord::Base")})/mi do |match|
-        "class ApplicationRecord < BetterRecord::Base"
-      end
-    end
-
     def eject_files
       template "#{BetterRecord::Engine.root}/db/postgres-audit-trigger.psql", 'db/postgres-audit-trigger.psql'
       template "#{BetterRecord::Engine.root}/lib/better_record.rb", 'lib/better_record.rb'
@@ -75,6 +58,32 @@ class BetterRecord::SetupGenerator < ActiveRecord::Generators::Base
       end
     end
 
+    def gsub_files
+      eager_line = 'config.eager_load_paths += Dir["#{config.root}/lib/modules/**/"]'
+      structure_line = 'config.active_record.schema_format'
+
+      gsub_file 'config/application.rb', /([ \t]*?(#{Regexp.escape(eager_line)}|#{Regexp.escape(structure_line)})[ ='":]*?(rb|sql)?['"]?[ \t0-9\.]*?)\n/mi do |match|
+        ""
+      end
+
+      gsub_file 'config/application.rb', /#{Regexp.escape("config.load_defaults")}[ 0-9\.]+\n/mi do |match|
+        "#{match}    #{eager_line}\n    #{structure_line} = :sql\n"
+      end
+
+      gsub_file 'app/models/application_record.rb', /(#{Regexp.escape("class ApplicationRecord < ActiveRecord::Base")})/mi do |match|
+        "class ApplicationRecord < BetterRecord::Base"
+      end
+    end
+
+    def mount_engine
+      in_root do
+        File.open('config/routes.rb', 'r') do |file|
+          return false if file.read =~ /mount\s+BetterRecord::Engine/
+        end
+      end
+      route 'mount BetterRecord::Engine => "/better_record"'
+    end
+
     def migration_path
       if Rails.version >= '5.0.3'
         db_migrate_path

data/lib/generators/better_record/setup/templates/initializer.rb

@@ -1,14 +1,19 @@
 module BetterRecord
-  ##################################################################
-  #   ALL SETTINGS HERE CAN BE SET THROUGH ENVIRONMENT VARIABLES   #
-  #                                                                #
-  #   default_polymorphic_method: BR_DEFAULT_POLYMORPHIC_METHOD    #
-  #              db_audit_schema: BR_DB_AUDIT_SCHEMA               #
-  #        has_auditing_relation_by_default: BR_ADD_HAS_MANY                  #
-  #          audit_relation_name: BR_AUDIT_RELATION_NAME           #
-  #              layout_template: BR_LAYOUT_TEMPLATE               #
-  #              app_domain_name: APP_DOMAIN_NAME                  #
-  ##################################################################
+  ##########################################################################
+  #   THE FOLLOWING SETTINGS CAN ALSO BE SET THROUGH ENVIRONMENT VARIABLES #
+  #                                                                        #
+  #       default_polymorphic_method: BR_DEFAULT_POLYMORPHIC_METHOD        #
+  #                  db_audit_schema: BR_DB_AUDIT_SCHEMA                   #
+  # has_auditing_relation_by_default: BR_ADD_HAS_MANY                      #
+  #              audit_relation_name: BR_AUDIT_RELATION_NAME               #
+  #                  layout_template: BR_LAYOUT_TEMPLATE                   #
+  #                  app_domain_name: APP_DOMAIN_NAME                      #
+  #                 after_login_path: BR_AFTER_LOGIN_PATH                  #
+  #                   session_column: BR_SESSION_COLUMN                    #
+  #      session_authenticate_method: BR_SESSION_AUTHENTICATE_METHOD       #
+  #       certificate_session_column: BR_CERTIFICATE_SESSION_COLUMN        #
+  #  certificate_session_user_method: BR_CERTIFICATE_SESSION_USER_METHOD   #
+  ##########################################################################
 
   # uncomment the following line to use table_names instead of model names
   # as the 'type' value in polymorphic relationships
@@ -39,4 +44,36 @@ module BetterRecord
   # runs under. Used in setting DKIM params. DEFAULT - 'non_existant_domain.com'
 
   # self.app_domain_name = 'default_app_name.com'
+
+  # uncomment and set the session_class to enable gem handled session management
+  # all other settings are optional
+
+  # self.session_class = User
+
+  # OPTIONAL #
+
+  # self.after_login_path = Rails.application.routes.url_helpers.root_path
+
+  # self.session_column = :uuid
+
+  # self.session_data = ->(user) do
+  #   {
+  #     user_id: user.uuid,
+  #     first_access: user.first_login_time,
+  #     created_at: Time.now
+  #   }
+  # end
+
+  # self.session_authenticate_method = :check_login
+
+  # self.certificate_session_class = Staff.includes(:user)
+
+  # self.certificate_session_column = :cert_str
+
+  # self.certificate_session_user_method = :user
 end
+
+# uncomment the following lines to set the keys needed for JWT token auth
+
+# BetterRecord::JWT.signing_key = ENV.fetch('JWT_SIGNING_KEY') { nil }
+# BetterRecord::JWT.encryption_key = ENV.fetch('JWT_ENCRYPTION_KEY') { nil }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_record
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors:
 - Sampson Crowley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-29 00:00:00.000000000 Z
+date: 2018-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -110,6 +110,66 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.6
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: jwe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -188,6 +248,7 @@ files:
 - config/initializers/core_ext/boolean.rb
 - config/initializers/core_ext/date.rb
 - config/initializers/core_ext/integer.rb
+- config/initializers/core_ext/string.rb
 - config/initializers/dkim.rb
 - config/initializers/filter_parameter_logging.rb
 - config/initializers/inflections.rb
@@ -205,13 +266,20 @@ files:
 - lib/better_record/concerns/active_record_extensions/associations_extensions/builder_extensions/association_extensions.rb
 - lib/better_record/concerns/active_record_extensions/base_extensions.rb
 - lib/better_record/concerns/active_record_extensions/reflection_extensions.rb
+- lib/better_record/concerns/controllers/authenticatable.rb
+- lib/better_record/concerns/controllers/sessionable.rb
+- lib/better_record/concerns/controllers/uploadable.rb
+- lib/better_record/encoder.rb
 - lib/better_record/engine.rb
 - lib/better_record/fake_redis.rb
+- lib/better_record/jwt.rb
 - lib/better_record/migration.rb
 - lib/better_record/nullify_blank_attributes.rb
 - lib/better_record/polymorphic_override.rb
 - lib/better_record/railtie.rb
 - lib/better_record/relation.rb
+- lib/better_record/rspec/expectations.rb
+- lib/better_record/rspec/expectations/write.rb
 - lib/better_record/rspec/extensions.rb
 - lib/better_record/rspec/extensions/boolean_column.rb
 - lib/better_record/rspec/extensions/has_valid_factory.rb
@@ -256,7 +324,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Fix functions that are lacking in Active record to be compatible with multi-app