logux_rails 0.1.0 → 0.2.0

data/lib/logux/policy.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  class Policy
-    class UnauthorizedError < StandardError; end
-
-    attr_reader :action, :meta
-
-    def initialize(action:, meta:)
-      @action = action
-      @meta = meta
-    end
-  end
-end

data/lib/logux/policy_caller.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  class PolicyCaller
-    attr_reader :action, :meta
-
-    delegate :logger, :configuration, to: :Logux
-
-    def initialize(action:, meta:)
-      @action = action
-      @meta = meta
-    end
-
-    def call!
-      logger.debug('Searching policy for Logux action:' \
-                   " #{action}, meta: #{meta}")
-      policy.public_send("#{action.action_type}?")
-    rescue Logux::UnknownActionError, Logux::UnknownChannelError => e
-      raise e if configuration.verify_authorized
-
-      logger.warn(e)
-    end
-
-    private
-
-    def class_finder
-      @class_finder ||= Logux::ClassFinder.new(action: action, meta: meta)
-    end
-
-    def policy
-      class_finder.find_policy_class.new(action: action, meta: meta)
-    end
-  end
-end

data/lib/logux/process.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Process
-    autoload :Batch, 'logux/process/batch'
-    autoload :Auth,  'logux/process/auth'
-    autoload :Action, 'logux/process/action'
-  end
-end

data/lib/logux/process/action.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Process
-    class Action
-      attr_reader :stream, :chunk
-      attr_accessor :stop_process
-
-      def initialize(stream:, chunk:)
-        @stream = stream
-        @chunk = chunk
-      end
-
-      def call
-        process_authorization!
-        process_action!
-      end
-
-      def action_from_chunk
-        @action_from_chunk ||= chunk[:action]
-      end
-
-      def meta_from_chunk
-        @meta_from_chunk ||= chunk[:meta]
-      end
-
-      def stop_process?
-        @stop_process ||= false
-      end
-
-      def stop_process!
-        @stop_process = true
-      end
-
-      private
-
-      def process_action!
-        return if stop_process?
-
-        action_caller = Logux::ActionCaller.new(
-          action: action_from_chunk,
-          meta: meta_from_chunk
-        )
-
-        stream.write(action_caller.call!.format)
-      end
-
-      def process_authorization!
-        policy_caller = Logux::PolicyCaller.new(action: action_from_chunk,
-                                                meta: meta_from_chunk)
-        policy_check = policy_caller.call!
-        status = policy_check ? :approved : :forbidden
-        stream.write([status, meta_from_chunk.id])
-        return stream.write(',') if policy_check
-
-        stop_process!
-      end
-    end
-  end
-end

data/lib/logux/process/auth.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Process
-    class Auth
-      attr_reader :stream, :chunk
-
-      def initialize(stream:, chunk:)
-        @stream = stream
-        @chunk = chunk
-      end
-
-      def call
-        authed = Logux.configuration.auth_rule.call(user_id, chunk.credentials)
-        return stream.write(['authenticated', chunk.auth_id]) if authed
-
-        stream.write(['denied', chunk.auth_id])
-      end
-
-      private
-
-      def user_id
-        chunk.node_id.split(':').first
-      end
-    end
-  end
-end

data/lib/logux/process/batch.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Process
-    class Batch
-      attr_reader :stream, :batch
-
-      def initialize(stream:, batch:)
-        @stream = stream
-        @batch = batch
-      end
-
-      def call
-        last_chunk = batch.size - 1
-        preprocessed_batch.map.with_index do |chunk, index|
-          case chunk[:type]
-          when :action
-            process_action(chunk: chunk.slice(:action, :meta))
-          when :auth
-            process_auth(chunk: chunk[:auth])
-          end
-          stream.write(',') if index != last_chunk
-        end
-      end
-
-      def process_action(chunk:)
-        Logux::Process::Action.new(stream: stream, chunk: chunk).call
-      end
-
-      def process_auth(chunk:)
-        Logux::Process::Auth.new(stream: stream, chunk: chunk).call
-      end
-
-      def preprocessed_batch
-        @preprocessed_batch ||= batch.map do |chunk|
-          case chunk[0]
-          when 'action'
-            preprocess_action(chunk)
-          when 'auth'
-            preprocess_auth(chunk)
-          end
-        end
-      end
-
-      def preprocess_action(chunk)
-        { type: :action,
-          action: Logux::Actions.new(chunk[1]),
-          meta: Logux::Meta.new(chunk[2]) }
-      end
-
-      def preprocess_auth(chunk)
-        { type: :auth,
-          auth: Logux::Auth.new(node_id: chunk[1],
-                                credentials: chunk[2],
-                                auth_id: chunk[3]) }
-      end
-    end
-  end
-end

data/lib/logux/response.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  class Response
-    attr_reader :status, :action, :meta, :custom_data
-
-    def initialize(status, action:, meta:, custom_data: nil)
-      @status = status
-      @action = action
-      @meta = meta
-      @custom_data = custom_data
-    end
-
-    def format
-      [status, custom_data || meta.id]
-    end
-  end
-end

data/lib/logux/stream.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  class Stream
-    attr_reader :stream
-
-    delegate :close, to: :stream
-
-    def initialize(stream)
-      @stream = stream
-    end
-
-    def write(payload)
-      processed_payload = process(payload)
-      Logux.logger.debug("Write to Logux response: #{processed_payload}")
-      stream.write(processed_payload)
-    end
-
-    private
-
-    def process(payload)
-      payload.is_a?(::String) ? payload : payload.to_json
-    end
-  end
-end

data/lib/logux/test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Test
-    class << self
-      attr_accessor :http_requests_enabled
-
-      def enable_http_requests!
-        raise ArgumentError unless block_given?
-
-        begin
-          self.http_requests_enabled = true
-          yield
-        ensure
-          self.http_requests_enabled = false
-        end
-      end
-    end
-
-    module Client
-      def post(params)
-        if Logux::Test.http_requests_enabled
-          super(params)
-        else
-          Logux::Test::Store.instance.add(params.to_json)
-        end
-      end
-    end
-
-    autoload :Helpers, 'logux/test/helpers'
-    autoload :Store, 'logux/test/store'
-    autoload :Matchers, 'logux/test/matchers'
-  end
-end
-Logux::Client.prepend Logux::Test::Client

data/lib/logux/test/helpers.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Test
-    module Helpers
-      extend ActiveSupport::Concern
-
-      included do
-        before do
-          Logux::Test::Store.instance.reset!
-        end
-      end
-
-      def logux_store
-        Logux::Test::Store.instance.data
-      end
-
-      def send_to_logux(*commands)
-        Logux::Test::Matchers::SendToLogux.new(*commands)
-      end
-
-      def a_logux_meta_with(attributes = {})
-        RSpec::Matchers::BuiltIn::Include.new(attributes.stringify_keys)
-      end
-      alias a_logux_meta a_logux_meta_with
-
-      def a_logux_action_with(attributes = {})
-        RSpec::Matchers::BuiltIn::Include.new(attributes.stringify_keys)
-      end
-      alias a_logux_action a_logux_action_with
-
-      def logux_approved(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['approved'], excludes: %w[forbidden error]
-        )
-      end
-
-      def logux_processed(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['processed'], excludes: %w[forbidden error]
-        )
-      end
-
-      def logux_forbidden(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['forbidden']
-        )
-      end
-
-      def logux_errored(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['error']
-        )
-      end
-
-      def logux_authenticated(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['authenticated']
-        )
-      end
-
-      def logux_unauthorized(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['unauthorized']
-        )
-      end
-
-      def logux_denied(meta = nil)
-        Logux::Test::Matchers::ResponseChunks.new(
-          meta: meta, includes: ['denied']
-        )
-      end
-    end
-  end
-end

data/lib/logux/test/matchers.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Test
-    module Matchers
-      autoload :SendToLogux, 'logux/test/matchers/send_to_logux'
-      autoload :ResponseChunks, 'logux/test/matchers/response_chunks'
-    end
-  end
-end

data/lib/logux/test/matchers/base.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Logux
-  module Test
-    module Matchers
-      class Base
-        attr_reader :expected
-
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        def supports_block_expectations?
-          true
-        end
-
-        private
-
-        def pretty(obj)
-          JSON.pretty_generate(obj)
-        end
-      end
-    end
-  end
-end

data/lib/logux/test/matchers/response_chunks.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module Logux
-  module Test
-    module Matchers
-      class ResponseChunks < Base
-        attr_reader :includes, :excludes, :meta
-
-        def initialize(meta:, includes:, excludes: [])
-          @meta = meta
-          @includes = includes
-          @excludes = excludes
-        end
-
-        def matches?(actual)
-          @actual = JSON.parse(actual.body)
-
-          match_includes? && match_excludes?
-        end
-
-        def failure_message
-          data = "expected that #{pretty(@actual)} to has " \
-            "#{includes.join(', ')} chunks"
-          !excludes.empty? && data += " and doesn't" \
-            " has #{excludes.join(', ')} chunks"
-          data
-        end
-
-        private
-
-        def match_includes?
-          @actual.any? do |command|
-            command.first.in?(includes) &&
-              (meta.nil? || (meta.present? && command[1] == meta))
-          end
-        end
-
-        def match_excludes?
-          @actual.empty? || @actual.none? do |command|
-            command.first.in?(excludes)
-          end
-        end
-      end
-    end
-  end
-end