endpoint-flux2 1.1.6

data/Rakefile

@@ -0,0 +1 @@
+

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-slate

data/circle.yml

@@ -0,0 +1,14 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.5.3-node
+    steps:
+      - checkout
+      - run: gem install bundle
+      - run:
+          name: Bundle Install
+          command: bundle check || bundle install
+      - run:
+          name: Run Specs
+          command: bundle exec rspec --format progress

data/endpoint_flux.gemspec

@@ -0,0 +1,20 @@
+require_relative 'lib/endpoint_flux/version' # frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name          = 'endpoint-flux2'
+  s.version       = EndpointFlux::VERSION
+  s.summary       = 'EndpointFlux!'
+  s.description   = 'A simple way to organise API endpoints'
+  s.authors       = ['Original creator Arturs Kreipans https://github.com/fragallia Forked by Pavel Kvasnikov https://github.com/pavelkvasnikov']
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.homepage      = 'https://github.com/pavelkvasnikov/endpoint-flux'
+  s.license       = 'MIT'
+  s.required_ruby_version = '>= 2.5.3'
+
+  s.add_development_dependency 'byebug', '>= 9.0'
+  s.add_development_dependency 'rspec', '>= 3.5.0'
+  s.add_development_dependency 'codecov'
+
+end

data/lib/endpoint_flux.rb

@@ -0,0 +1,22 @@
+require 'endpoint_flux/class_loader'
+
+require 'endpoint_flux/config'
+require 'endpoint_flux/endpoint'
+require 'endpoint_flux/exceptions'
+require 'endpoint_flux/middlewares'
+
+require "endpoint_flux/railtie" if defined?(Rails)
+
+module EndpointFlux
+  module_function
+
+  def config(handler = nil)
+    @config = handler if handler
+
+    @config ||= EndpointFlux::Config.new
+  end
+
+  def clear
+    @config = nil
+  end
+end

data/lib/endpoint_flux/class_loader.rb

@@ -0,0 +1,58 @@
+module EndpointFlux
+  module ClassLoader
+    module_function
+
+    def load_class(klass_name)
+      return klass_name if klass_name.is_a?(Class)
+
+      constantize "::#{string_to_class_name(klass_name.to_s)}"
+    rescue NameError
+      nil
+    end
+
+    def load_class!(klass_name)
+      load_class(klass_name) ||
+        raise("The [#{klass_name}] should be a string representing a class")
+    end
+
+    def string_to_class_name(klass_name)
+      klass_name
+        .sub(%r{^[a-z\d]*}) { $&.capitalize }
+        .gsub(%r{(?:_|(\/))([a-z\d]*)}) do
+          "#{Regexp.last_match[1]}#{Regexp.last_match[2].capitalize}"
+        end
+        .gsub('/', '::')
+    end
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split("::".freeze)
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject(constant) do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/config.rb

@@ -0,0 +1,85 @@
+module EndpointFlux
+  class Config
+    require 'endpoint_flux/config/interceptor'
+    require 'endpoint_flux/config/middleware'
+    require 'endpoint_flux/config/rescue_from'
+
+    attr_accessor :middlewares_namespaces
+
+    def initialize
+      @flow                   = %i[authenticator authorizator validator policy process decorator]
+      @default_middlewares    = {}
+      @rescue_from            = EndpointFlux::Config::RescueFrom.new
+      @endpoints_namespace    = 'endpoints'
+      @middlewares_namespaces = ['endpoint_flux/middlewares']
+    end
+
+    def interceptor(&block)
+      @interceptor ||= EndpointFlux::Config::Interceptor.new
+      @interceptor.add(&block) if block_given?
+      @interceptor
+    end
+
+    def flow(new_flow = nil)
+      @flow = new_flow if new_flow
+
+      @flow
+    end
+
+    def default_middlewares(name = nil, klass_name = nil)
+      if name
+        @default_middlewares[name] ||= []
+
+        if klass_name
+          klass = fetch_middleware_class!(name.to_s, klass_name.to_s)
+          @default_middlewares[name] << EndpointFlux::Config::Middleware.new(klass)
+        end
+
+        return @default_middlewares[name]
+      end
+
+      @default_middlewares
+    end
+
+    def rescue_from(klass_names = nil, &block)
+      if klass_names
+        if klass_names.respond_to?(:to_ary)
+          klass_names.to_ary || [klass_names]
+        else
+          [klass_names]
+        end.each do |klass_name|
+          klass = EndpointFlux::ClassLoader.load_class!(klass_name)
+          @rescue_from.add(klass, &block)
+        end
+      end
+
+      @rescue_from
+    end
+
+    def endpoints_namespace(name = nil)
+      @endpoints_namespace = name if name
+
+      @endpoints_namespace
+    end
+
+    def fetch_middleware_class!(name, klass_name)
+      klass = fetch_middleware_class(name, klass_name)
+
+      raise "The [#{name}][#{klass_name}] should be a string representing a class" unless klass
+
+      klass
+    end
+
+    def fetch_middleware_class(name, klass_name)
+      middlewares_namespaces.each do |namespace|
+        klass = EndpointFlux::ClassLoader.load_class(
+          [namespace, name.to_s, klass_name.to_s].compact.join('/')
+        )
+
+        return klass if klass
+      end
+
+      nil
+    end
+  end
+end

data/lib/endpoint_flux/config/interceptor.rb

@@ -0,0 +1,23 @@
+module EndpointFlux
+  class Config
+    class Interceptor
+      attr_accessor :handlers
+
+      def initialize
+        @handlers = []
+      end
+
+      def run(attrs)
+        handlers.each { |handler| handler.call(attrs) }
+
+        attrs
+      end
+
+      def add(&block)
+        raise 'Block not given' unless block_given?
+
+        handlers << block
+      end
+    end
+  end
+end

data/lib/endpoint_flux/config/middleware.rb

@@ -0,0 +1,38 @@
+module EndpointFlux
+  class Config
+    class Middleware
+      attr_accessor :klass, :options, :handler
+
+      def initialize(klass = nil, options = {}, &block)
+        if klass
+          unless klass.methods.include?(:perform)
+            raise "The [#{klass}] class should define perform class method"
+          end
+        else
+          raise 'You must provide block or existing klass' unless block_given?
+        end
+
+        @klass   = klass
+        @options = options
+        @handler = block
+      end
+
+      def run(attrs)
+        if klass
+          klass.perform(*attrs, options, &handler)
+        elsif handler
+          handler.call(*attrs, options)
+        else
+          raise "Unknown middleware type [#{inspect}]"
+        end
+      end
+
+      def ==(other)
+        return true if klass && klass == other.klass
+        return true if handler && handler == other.handler
+
+        false
+      end
+    end
+  end
+end

data/lib/endpoint_flux/config/rescue_from.rb

@@ -0,0 +1,28 @@
+module EndpointFlux
+  class Config
+    class RescueFrom
+      attr_accessor :handlers, :exceptions
+
+      def initialize
+        @handlers   = {}
+        @exceptions = []
+      end
+
+      def run(name, attrs, e)
+        raise 'No handler given' unless exceptions.include?(e.class)
+
+        handlers[e.class.name].call(name, attrs, e)
+      end
+
+      def add(klass, &block)
+        raise 'Block not given' unless block_given?
+
+        handlers[klass.to_s] = block
+
+        exceptions << klass unless exceptions.include?(klass)
+
+        nil
+      end
+    end
+  end
+end

data/lib/endpoint_flux/endpoint.rb

@@ -0,0 +1,81 @@
+require 'endpoint_flux/config'
+require 'endpoint_flux/request'
+require 'endpoint_flux/response'
+
+module EndpointFlux
+  module Endpoint
+    def self.included(includer)
+      includer.extend self
+      includer.class_eval %( @middlewares ||= {} )
+    end
+
+    def perform(request)
+      attrs = [request, EndpointFlux::Response.new]
+      attrs = EndpointFlux.config.interceptor.run(attrs)
+
+      request.endpoint = to_s
+
+      flow.inject(attrs) do |res, middleware_name|
+        fetch_middleware(middleware_name).inject(res) do |middleware_res, middleware|
+          middleware.run(middleware_res)
+        end
+      end
+    rescue *EndpointFlux.config.rescue_from.exceptions => e
+      EndpointFlux.config.rescue_from.run(name, attrs, e)
+    end
+
+    def flow(array = nil)
+      @flow = array.map(&:to_sym) if array
+      @flow || EndpointFlux.config.flow
+    end
+
+    def method_missing(method_id, *attrs, &block)
+      method_sym = method_id.to_sym
+      if flow.include?(method_sym)
+        configure_middleware(method_sym, attrs, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name)
+      flow.include?(method_name.to_sym)
+    end
+
+    private
+
+    def configure_middleware(middleware_name, attrs, &block)
+      @middlewares[middleware_name] ||= []
+
+      middleware = build_middleware(middleware_name, *attrs, &block)
+      @middlewares[middleware_name] << middleware if middleware
+
+      @middlewares[middleware_name]
+    end
+
+    def fetch_middleware(name)
+      @middlewares[name] ||
+        EndpointFlux.config.default_middlewares[name] ||
+        raise("No middleware registred for [#{name.inspect}]")
+    end
+
+    def build_middleware(middleware_name, *options, &block)
+      attrs = []
+      unless options.empty?
+        klass = EndpointFlux.config.fetch_middleware_class(middleware_name, options.first)
+
+        if klass
+          attrs << klass
+          attrs << options[1..-1]
+        else
+          attrs << nil
+          attrs << options
+        end
+      end
+
+      return if attrs.empty? && !block_given?
+
+      EndpointFlux::Config::Middleware.new(*attrs.flatten, &block)
+    end
+  end
+end

data/lib/endpoint_flux/exceptions.rb

@@ -0,0 +1,10 @@
+module EndpointFlux
+  module Exceptions
+    require 'endpoint_flux/exceptions/base'
+    require 'endpoint_flux/exceptions/forbidden'
+    require 'endpoint_flux/exceptions/not_found'
+    require 'endpoint_flux/exceptions/service_unavailable'
+    require 'endpoint_flux/exceptions/unauthorized'
+    require 'endpoint_flux/exceptions/validation'
+  end
+end

data/lib/endpoint_flux/exceptions/base.rb

@@ -0,0 +1,21 @@
+module EndpointFlux
+  module Exceptions
+    class Base < StandardError
+      attr_accessor :messages
+
+      def initialize(messages = nil)
+        @messages = messages
+
+        super("#{self.class.name}: [ #{messages.inspect}]")
+      end
+
+      def to_hash
+        raise NotImplementedError
+      end
+
+      def inspect
+        "#{self.class.name}: [ #{to_hash.inspect} ]"
+      end
+    end
+  end
+end

data/lib/endpoint_flux/exceptions/forbidden.rb

@@ -0,0 +1,12 @@
+module EndpointFlux
+  module Exceptions
+    class Forbidden < EndpointFlux::Exceptions::Base
+      def to_hash
+        {
+          status: 403,
+          message: 'Forbidden'
+        }
+      end
+    end
+  end
+end

data/lib/endpoint_flux/exceptions/not_found.rb

@@ -0,0 +1,12 @@
+module EndpointFlux
+  module Exceptions
+    class NotFound < EndpointFlux::Exceptions::Base
+      def to_hash
+        {
+          status: 404,
+          message: 'not found'
+        }
+      end
+    end
+  end
+end