isomorfeus-empowerment 2.5.5 → 22.9.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88c17eb965b536d101ebbbf74331d9c79caafb9906e9a35bd0f3697696241004
-  data.tar.gz: 7f39c6c6fa6e06ffe0ec342293d14122153db174597c1d295c3ccb03fea23dbc
+  metadata.gz: e771b58cef0a5856ce230b553e27de84b168c44d48087619de02ae73ed6c7a67
+  data.tar.gz: 0cdfe9141e3e81264e756629e1f177adc943dfecc6890a9e5ac5227a9637afe6
 SHA512:
-  metadata.gz: ace9f66f471232ed1aa00589ef32fa7d637dea2defc8ee5e7b7a0fc281e9b70c8516aeea88532dddef9d45b942430f7ba4225346a92686ba95eaea6f79443281
-  data.tar.gz: 9a861899220dc5b0e5d7fde846bd2cfb976685a870a34a0bcd0c597f8794314161e879ffeb8b9eea12b424d2742579d4254a9a0cb801adc62a055b0233c5a5fc
+  metadata.gz: 0b08887cab6471b2e0b169c2c964a4b0d244068414e31bd8e6270eedc81a846ef9b4fab60690bc4bfba0db9366cc9af846f62a42c70aefea990268fdf2f5c2ff
+  data.tar.gz: 74fc2aa0e03a0ebd1cdda94d42a6588900583e87d61dfded31a9abf2314e1a4c2312ae25925b0b4c78e7c1f10a55c50020d7b6e2c6e0913e87187d2544a66b98

data/lib/isomorfeus/empowerment/anonymous.rb

@@ -1,5 +1,16 @@
-class Anonymous
-  include LucidUser::Authorization
+class Anonymous < LucidUser
+  class << self
+    undef_method :load
+    undef_method :load!
+    undef_method :destroy
+    undef_method :create
+    undef_method :search
+  end
+
+  undef_method :create
+  undef_method :save
+  undef_method :destroy
+  undef_method :reload
 
   def anonymous?
     true

data/lib/isomorfeus/empowerment/authentication_handler.rb

@@ -0,0 +1,60 @@
+module Isomorfeus
+  module Empowerment
+    class AuthenticationHandler < LucidHandler
+      TIMEOUT = 30
+
+      def process_request(response_agent)
+        # promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'login', user_class_name, user_identifier, user_password)
+        response_agent.agent_result = { error: 'Authentication failed' }
+        tries = pub_sub_client.instance_variable_get(:@isomorfeus_authentication_tries)
+        tries = 0 unless tries
+        tries += 1
+        sleep(5) if tries > 3 # TODO, this needs a better solution (store data in user/session)
+        Isomorfeus.pub_sub_client.instance_variable_set(:@isomorfeus_authentication_tries, tries)
+        user_class_name = response_agent.request['login']&.keys&.first
+        invalid_data_error! unless user_class_name && user_class_name.is_a?(String)
+        user = nil
+        invalid_data_error! unless Isomorfeus.valid_user_class_name?(user_class_name)
+        user_class = Isomorfeus.cached_user_class(user_class_name)
+        user_hash = response_agent.request.dig('login', user_class_name)
+        invalid_data_error! unless user_hash && user_hash.is_a?(Hash)
+        user_str = user_hash.keys.first
+        promise = user_class.promise_login(user: user_str , pass: user_hash[user_str])
+        unless promise.realized?
+          start = Time.now
+          until promise.realized?
+            break if (Time.now - start) > TIMEOUT
+            sleep 0.01
+          end
+        end
+        key = promise.value
+        authentication_error! unless key.is_a?(String)
+        cu = Thread.current[:isomorfeus_user]
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+        begin
+          user = user_class.load(key: key)
+        ensure
+          Thread.current[:isomorfeus_user] = cu
+        end
+        authentication_error! unless user
+        session_id = SecureRandom.uuid
+        session_cookie = "session=#{session_id}; SameSite=Strict; HttpOnly; Path=/; Max-Age=2592000#{'; Secure' if Isomorfeus.production?}"
+        session_cookie_accessor = SecureRandom.uuid
+        Isomorfeus.pub_sub_client.instance_variable_set(:@isomorfeus_authentication_tries, nil)
+        Isomorfeus.session_class.add(session_id: session_id, cookie: session_cookie, user: user, accessor: session_cookie_accessor)
+        response_agent.agent_result = { success: 'ok', state: { data_state: { user_class_name => { user.key => Isomorfeus.store.dig(:data_state, user_class_name, user.key) }}}, session_cookie_accessor: session_cookie_accessor }
+      rescue Exception => e
+        STDERR.puts "Isomorfeus::Empowerment::AuthenticationHandler: #{e.message}\n#{e.backtrace&.join("\n")}" if Isomorfeus.development?
+        response_agent.agent_result = { error: 'Authentication failed' }
+      end
+
+      def invalid_data_error!
+        raise 'Received invalid data!'
+      end
+
+      def authentication_error!
+        raise 'Authentication failed!'
+      end
+    end
+  end
+end

data/lib/isomorfeus/empowerment/config.rb

@@ -7,8 +7,8 @@ module Isomorfeus
       end
 
       def init_current_user
-        if Isomorfeus.current_user_sid
-          Isomorfeus.instance_from_sid(Isomorfeus.current_user_sid)
+        if Isomorfeus.current_user_sid_s
+          LucidObject.instance_from_sid_s(Isomorfeus.current_user_sid_s)
         else
           Anonymous.new
         end
@@ -17,10 +17,10 @@ module Isomorfeus
       def set_current_user(user)
         if user
           @current_user = user
-          Isomorfeus.current_user_sid = user.sid
+          Isomorfeus.current_user_sid_s = user.sid.to_s
         else
           @current_user = Anonymous.new
-          Isomorfeus.current_user_sid = nil
+          Isomorfeus.current_user_sid_s = nil
         end
       end
     else

data/lib/isomorfeus/empowerment/local_system.rb

@@ -1,5 +1,16 @@
-class LocalSystem
-  include LucidUser::Authorization
+class LocalSystem < LucidUser
+  class << self
+    undef_method :load
+    undef_method :load!
+    undef_method :destroy
+    undef_method :create
+    undef_method :search
+  end
+
+  undef_method :create
+  undef_method :save
+  undef_method :destroy
+  undef_method :reload
 
   def anonymous?
     false

data/lib/isomorfeus/empowerment/local_system_policy.rb

@@ -1,3 +1,3 @@
-class LocalSystemPolicy < LucidPolicy::Base
+class LocalSystemPolicy < LucidPolicy
   allow all
 end

data/lib/isomorfeus/empowerment/session.rb

@@ -1,6 +1,6 @@
 module Isomorfeus
   module Empowerment
-    class Session  < LucidObject::Base
+    class Session  < LucidObject
       # :key is the session_id
       attribute :user_class_name, required: true
       attribute :user_key, required: true
@@ -9,53 +9,95 @@ module Isomorfeus
       attribute :ctime, required: true
       attribute :atime, required: true # only updated when the last access is more than 10 minutes ago
 
+      query :accessor, "accessor:\"%{accessor}\""
+
       class << self
         def add(session_id:, cookie:, user:, accessor:)
-          t = Time.now
-          self.create(key: session_id, attributes: { user_class_name: user.class.name, user_key: user.key, cookie: cookie, accessor: accessor, ctime: t, atime: t })
+          t = Time.now.to_s
+          cu = Thread.current[:isomorfeus_user]
+          begin
+            Thread.current[:isomorfeus_user] = LocalSystem.new
+            self.create(key: session_id, attributes: { user_class_name: user.class.name, user_key: user.key, cookie: cookie, accessor: accessor, ctime: t, atime: t })
+          ensure
+            Thread.current[:isomorfeus_user] = cu
+          end
+          nil
         end
 
         def take_cookie(accessor:)
-          s = self.search(:accessor, accessor).first
-          if s
-            cookie = s.cookie
-            if cookie
-              session_info = cookie.split('; ').first
-              session_id = session_info.split('=').last.strip
-              s.cookie = nil
-              s.save
-              cookie
-            else
-              # asked for the same cookie a second time
-              # can probably only be due to session hijacking
-              # so delete session associated with that accessor
-              s.destroy
-              nil
+          res = nil
+          cu = Thread.current[:isomorfeus_user]
+          begin
+            Thread.current[:isomorfeus_user] = LocalSystem.new
+            s = self.search(:accessor, { accessor: accessor }).first
+            if s
+              cookie = s[:cookie]
+              if cookie
+                session_info = cookie.split('; ').first
+                session_id = session_info.split('=').last.strip
+                s[:cookie] = nil
+                s.save
+                res = cookie
+              else
+                # asked for the same cookie a second time
+                # can probably only be due to session hijacking
+                # so delete session associated with that accessor
+                s.destroy
+              end
             end
+          ensure
+            Thread.current[:isomorfeus_user] = cu
           end
+          res
         end
 
         def get_user(session_id:)
+          res = nil
           s = touch(session_id: session_id)
-          s.user_class_name.constantize.load(key: s.user_key) if s
-        rescue
-          nil
+          cu = Thread.current[:isomorfeus_user]
+          begin
+            Thread.current[:isomorfeus_user] = LocalSystem.new
+            res = s[:user_class_name].constantize.load(key: s[:user_key]) if s
+          rescue
+            nil
+          ensure
+            Thread.current[:isomorfeus_user] = cu
+          end
+          res
         end
 
         def touch(session_id:)
-          s = self.load(key: session_id)
+          cu = Thread.current[:isomorfeus_user]
+          ls = LocalSystem.new
+          begin
+            Thread.current[:isomorfeus_user] = ls
+            s = self.load(key: session_id)
+          ensure
+            Thread.current[:isomorfeus_user] = cu
+          end
           return nil unless s
           t = Time.now
-          if (t - s.atime) > 600
-            s.atime = t
-            s.save
+          a = s[:atime] ? Time.parse(s[:atime]) : Time.at(0)
+          if (t - a) > 600
+            s[:atime] = t.to_s
+            begin
+              Thread.current[:isomorfeus_user] = ls
+              s.save
+            ensure
+              Thread.current[:isomorfeus_user] = cu
+            end
           end
           s
         end
-        alias_method :get_session, :touch
 
         def remove(session_id:)
-          self.destroy(key: session_id)
+          cu = Thread.current[:isomorfeus_user]
+          begin
+            Thread.current[:isomorfeus_user] = LocalSystem.new
+            self.destroy(key: session_id)
+          ensure
+            Thread.current[:isomorfeus_user] = cu
+          end
         end
       end
     end

data/lib/isomorfeus/empowerment/session_cleanup.rb

@@ -1,6 +1,6 @@
 module Isomorfeus
   module Empowerment
-    class SessionCleanup < LucidSimpleOperation::Base
+    class SessionCleanup < LucidSimpleOperation
       def self.sessions_cleaned
         @sessions_cleaned
       end
@@ -31,7 +31,8 @@ module Isomorfeus
         Isomorfeus::Empowerment::Session.each do |session|
           # cleanup sessions that have last been accessed more than 20 minutes ago
           self.class.sessions_counted += 1
-          if (t - session.atime) > 1200
+          st = Time.parse(session[:atime])
+          if (t - st) > 1200
             sessions_to_cleanup << session.key
           end
         end

data/lib/isomorfeus/empowerment/session_task.rb

@@ -1,7 +1,13 @@
 module Isomorfeus
   module Empowerment
-    class SessionTask < LucidObject::Base
+    class SessionTask < LucidObject
       STATES = %w[ready running failed]
+
+      query :ready, 'state:"ready"'
+      query :running, 'state:"running"'
+      query :failed, 'state:"failed"'
+      query :all, 'state:*'
+
       # when the task is added to the queue its added as ready
       # when its running, its running
       # when it failes, it failed, the exception attribute is filled

data/lib/isomorfeus/empowerment/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Empowerment
-    VERSION = '2.5.5'
+    VERSION = '22.9.0.rc1'
   end
 end

data/lib/isomorfeus-empowerment.rb

@@ -1,13 +1,13 @@
-require 'isomorfeus-policy'
+
 require 'isomorfeus-transport'
+require 'isomorfeus-redux'
+require 'isomorfeus-i18n'
+require 'isomorfeus-policy'
 require 'isomorfeus-data'
 require 'isomorfeus-operation'
-require 'lucid_user/authentication'
-require 'lucid_user/authorization'
-require 'lucid_user/mixin'
-require 'lucid_user/base'
-require 'isomorfeus/empowerment/anonymous'
 require 'isomorfeus/empowerment/config'
+require 'lucid_user'
+require 'isomorfeus/empowerment/anonymous'
 
 if RUBY_ENGINE != 'opal'
   require 'active_support'
@@ -17,11 +17,12 @@ if RUBY_ENGINE != 'opal'
   require 'isomorfeus/empowerment/local_system_policy'
   require 'isomorfeus/empowerment/session_task'
   require 'isomorfeus/empowerment/init_timer_task'
+  require 'isomorfeus/empowerment/authentication_handler'
 
   # register daily session cleanup task
-  Isomorfeus::Empowerment::SessionTask.create(key: 'isomorfeus_empowerment_session_cleanup',
-    fields: { operation_class_name: 'Isomorfeus::Empowerment::SessionCleanup',
-      props: {}, user_class_name: 'LocalSystem', user_key: 'local_system', state: 'ready', fail: false })
+  # Isomorfeus::Empowerment::SessionTask.create(key: 'isomorfeus_empowerment_session_cleanup',
+  #   fields: { operation_class_name: 'Isomorfeus::Empowerment::SessionCleanup',
+  #     props: {}, user_class_name: 'LocalSystem', user_key: 'local_system', state: 'ready', fail: false })
 
   require 'iso_opal'
   Opal.append_path(__dir__.untaint) unless IsoOpal.paths_include?(__dir__.untaint)

data/lib/lucid_user.rb

@@ -0,0 +1,153 @@
+class LucidUser < LucidObject
+  if RUBY_ENGINE == 'opal'
+    class << self
+      def execute_login(&block)
+      end
+
+      def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
+        send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
+      end
+
+      def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
+        user_class = self
+        class_name = self.name
+        if Isomorfeus.production?
+          Isomorfeus.raise_error(message: "Connection not secure, can't login!") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
+        else
+          `console.warn("Connection not secure, ensure a secure connection in production, otherwise login will fail!")` unless Isomorfeus::Transport.socket.url.start_with?('wss:')
+        end
+        Isomorfeus::Transport.promise_send_path('Isomorfeus::Empowerment::AuthenticationHandler', 'login', self.name, { user => pass }).then do |agent|
+          if agent.processed
+            agent.result
+          else
+            agent.processed = true
+            if agent.response.key?(:success)
+              Isomorfeus.store.dispatch(type: 'REDUX_MERGE', state: agent.response[:state])
+              key = agent.response.dig(:state, :data_state, class_name).keys.first
+              logged_in_user = user_class.new(key: key)
+              cookie_accessor = agent.response[:session_cookie_accessor]
+              begin
+                target = if block_given?
+                          block.call(logged_in_user)
+                        else
+                          `window.location.pathname`
+                        end
+                unless target.class == String && target.start_with?('/')
+                  Isomorfeus.raise_error(message: "A path must be returned as string starting with '/', returned was #{target}!")
+                end
+              rescue
+                target = `window.location.pathname`
+              end
+              cookie_query = "#{Isomorfeus.cookie_eater_path}?#{cookie_accessor}=#{target}"
+              `window.location = cookie_query` # doing page load and redirect
+              nil
+            else
+              Isomorfeus.raise_error(message: "Login failed with '#{agent.response[:error]}'!") # triggers .fail
+            end
+          end
+        end
+      end
+    end
+
+    def promise_logout(scheme: :isomorfeus)
+      send("promise_deauthentication_with_#{scheme}")
+    end
+
+    def promise_deauthentication_with_isomorfeus
+      p = Promise.new
+      begin
+        `window.location = #{Isomorfeus.api_logout_path}`
+      rescue
+        p.reject
+      end
+    end
+  else
+    class << self
+      def inherited(base)
+        Isomorfeus.add_valid_data_class(base)
+        Isomorfeus.add_valid_user_class(base)
+      end
+
+      def passwords_match?(encrypted_password, given_password)
+        bcrypt_pass = BCrypt::Password.new(encrypted_password)
+        bcrypt_pass == given_password
+      end
+
+      def execute_login(&block)
+        @execute_login_block = block
+      end
+
+      def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
+        send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
+      end
+
+      def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
+        key = @execute_login_block.call(user: user, pass: pass)
+        if key.is_a?(String)
+          block.call(key) if block_given?
+          Promise.new.resolve(key)
+        else
+          Promise.new.resolve(nil)
+        end
+      end
+    end
+
+    def encrypt_password(password, password_confirmation)
+      raise "Password and confirmation don't match!" unless password == password_confirmation
+      BCrypt::Password.create(password).to_s
+    end
+
+    def promise_logout(scheme: :isomorfeus)
+      send("promise_deauthentication_with_#{scheme}")
+    end
+
+    def promise_deauthentication_with_isomorfeus
+      Promise.new.resolve(true)
+    end
+  end
+
+  def anonymous?
+    self.class == Anonymous
+  end
+
+  # authorization
+
+  def record_authorization_reason
+    @_isomorfeus_record_authorization_reason = true
+  end
+
+  def stop_to_record_authorization_reason
+    @_isomorfeus_record_authorization_reason = false
+    @_isomorfeus_authorization_reason = nil
+  end
+
+  def authorization_reason
+    @_isomorfeus_authorization_reason
+  end
+
+  def authorized?(target_class, target_method = nil, props = nil)
+    begin
+      class_name = self.class.name
+      class_name = class_name.split('>::').last if class_name.start_with?('#<')
+      policy_class = Isomorfeus.cached_policy_class("#{class_name}Policy")
+    rescue ::NameError
+      policy_class = nil
+    end
+    return false unless policy_class
+    policy_instance = policy_class.new(self, @_isomorfeus_record_authorization_reason)
+    result = policy_instance.authorized?(target_class, target_method, props)
+    @_isomorfeus_authorization_reason = policy_instance.reason
+    result
+  end
+
+  def authorized!(target_class, target_method = nil, props = nil)
+    class_name = self.class.name
+    class_name = class_name.split('>::').last if class_name.start_with?('#<')
+    policy_class = Isomorfeus.cached_policy_class("#{class_name}Policy")
+    Isomorfeus.raise_error(error_class: LucidPolicy::Exception, message: "#{self}: policy class #{class_name}Policy not found!") unless policy_class
+    policy_instance = policy_class.new(self, @_isomorfeus_record_authorization_reason)
+    result = policy_instance.authorized!(target_class, target_method, props)
+    @_isomorfeus_authorization_reason = policy_instance.reason
+    result
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-empowerment
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 22.9.0.rc1
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,98 +16,98 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: 7.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: 7.0.3
 - !ruby/object:Gem::Dependency
   name: isomorfeus-asset-manager
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.24
+        version: 0.15.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.24
+        version: 0.15.1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-data
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-transport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
 - !ruby/object:Gem::Dependency
   name: isomorfeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +146,7 @@ files:
 - README.md
 - lib/isomorfeus-empowerment.rb
 - lib/isomorfeus/empowerment/anonymous.rb
+- lib/isomorfeus/empowerment/authentication_handler.rb
 - lib/isomorfeus/empowerment/config.rb
 - lib/isomorfeus/empowerment/init_timer_task.rb
 - lib/isomorfeus/empowerment/local_system.rb
@@ -154,10 +155,7 @@ files:
 - lib/isomorfeus/empowerment/session_cleanup.rb
 - lib/isomorfeus/empowerment/session_task.rb
 - lib/isomorfeus/empowerment/version.rb
-- lib/lucid_user/authentication.rb
-- lib/lucid_user/authorization.rb
-- lib/lucid_user/base.rb
-- lib/lucid_user/mixin.rb
+- lib/lucid_user.rb
 homepage: https://isomorfeus.com
 licenses:
 - MIT
@@ -175,9 +173,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/lucid_user/authentication.rb

@@ -1,123 +0,0 @@
-module LucidUser
-  module Authentication
-    def anonymous?
-      self.class == Anonymous
-    end
-
-    if RUBY_ENGINE == 'opal'
-      def self.included(base)
-        base.instance_exec do
-          def execute_login(&block)
-          end
-
-          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
-            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
-          end
-
-          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
-            if Isomorfeus.production?
-              Isomorfeus.raise_error(message: "Connection not secure, can't login!") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
-            else
-              `console.warn("Connection not secure, ensure a secure connection in production, otherwise login will fail!")` unless Isomorfeus::Transport.socket.url.start_with?('wss:')
-            end
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'login', self.name, user, pass).then do |agent|
-              if agent.processed
-                agent.result
-              else
-                agent.processed = true
-                if agent.response.key?(:success)
-                  Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
-                  class_name = agent.response[:data].keys.first
-                  key = agent.response[:data][class_name].keys.first
-                  logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
-                  cookie_accessor = agent.response[:session_cookie_accessor]
-                  begin
-                    target = if block_given?
-                               block.call(logged_in_user)
-                             else
-                               `window.location.pathname`
-                             end
-                    unless target.class == String && target.start_with?('/')
-                      Isomorfeus.raise_error(message: "A path must be returned as string starting with '/', returned was #{target}!")
-                    end
-                  rescue
-                    target = `window.location.pathname`
-                  end
-                  cookie_query = "#{Isomorfeus.cookie_eater_path}?#{cookie_accessor}=#{target}"
-                  `window.location = cookie_query` # doing page load and redirect
-                  nil
-                else
-                  Isomorfeus.raise_error(message: "Login failed with '#{agent.response[:error]}'!") # triggers .fail
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def promise_logout(scheme: :isomorfeus)
-        send("promise_deauthentication_with_#{scheme}")
-      end
-
-      def promise_deauthentication_with_isomorfeus
-        cookie = `document.cookie`
-        p = Promise.new
-        begin
-          logout_query = Isomorfeus.api_logout_path
-          `window.location = logout_query`
-        rescue
-          p.reject
-        end
-      end
-    else
-      def self.included(base)
-        Isomorfeus.add_valid_user_class(base)
-
-        base.instance_exec do
-          def execute_login(&block)
-            @execute_login_block = block
-          end
-
-          def promise_login(user: nil, pass: nil, scheme: :isomorfeus, &block)
-            send("promise_authentication_with_#{scheme}", user: user, pass: pass, &block)
-          end
-
-          def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
-            promise_or_user = @execute_login_block.call(user: user, pass: pass)
-            if promise_or_user.class == Promise
-              if block_given?
-                promise_or_user.then do |user|
-                  block.call(user)
-                  user
-                end
-              else
-                promise_or_user
-              end
-            else
-              block.call(user) if block_given?
-              Promise.new.resolve(promise_or_user)
-            end
-          end
-        end
-      end
-
-      def encrypt_password(password, password_confirmation)
-        raise "Password and confirmation don't match!" unless password == password_confirmation
-        BCrypt::Password.create(password).to_s
-      end
-
-      def passwords_match?(encrypted_password, given_password)
-        bcrypt_pass = BCrypt::Password.new(encrypted_password)
-        bcrypt_pass == given_password
-      end
-
-      def promise_logout(scheme: :isomorfeus)
-        send("promise_deauthentication_with_#{scheme}")
-      end
-
-      def promise_deauthentication_with_isomorfeus
-        Promise.new.resolve(true)
-      end
-    end
-  end
-end

data/lib/lucid_user/authorization.rb

@@ -1,42 +0,0 @@
-module LucidUser
-  module Authorization
-    def record_authorization_reason
-      @_isomorfeus_record_authorization_reason = true
-    end
-
-    def stop_to_record_authorization_reason
-      @_isomorfeus_record_authorization_reason = false
-      @_isomorfeus_authorization_reason = nil
-    end
-
-    def authorization_reason
-      @_isomorfeus_authorization_reason
-    end
-
-    def authorized?(target_class, target_method = nil, props = nil)
-      begin
-        class_name = self.class.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        policy_class = Isomorfeus.cached_policy_class("#{class_name}Policy")
-      rescue ::NameError
-        policy_class = nil
-      end
-      return false unless policy_class
-      policy_instance = policy_class.new(self, @_isomorfeus_record_authorization_reason)
-      result = policy_instance.authorized?(target_class, target_method, props)
-      @_isomorfeus_authorization_reason = policy_instance.reason
-      result
-    end
-
-    def authorized!(target_class, target_method = nil, props = nil)
-      class_name = self.class.name
-      class_name = class_name.split('>::').last if class_name.start_with?('#<')
-      policy_class = Isomorfeus.cached_policy_class("#{class_name}Policy")
-      Isomorfeus.raise_error(error_class: LucidPolicy::Exception, message: "#{self}: policy class #{class_name}Policy not found!") unless policy_class
-      policy_instance = policy_class.new(self, @_isomorfeus_record_authorization_reason)
-      result = policy_instance.authorized!(target_class, target_method, props)
-      @_isomorfeus_authorization_reason = policy_instance.reason
-      result
-    end
-  end
-end

data/lib/lucid_user/base.rb

@@ -1,10 +0,0 @@
-module LucidUser
-  class Base
-    def self.inherited(base)
-      base.include LucidUser::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_data_class(base)
-      end
-    end
-  end
-end

data/lib/lucid_user/mixin.rb

@@ -1,9 +0,0 @@
-module LucidUser
-  module Mixin
-    def self.included(base)
-      base.include(LucidObject::Mixin)
-      base.include(LucidUser::Authentication)
-      base.include(LucidUser::Authorization)
-    end
-  end
-end