tarquinn 0.1.0 → 0.3.0

data/lib/tarquinn/redirection_config.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  # @api private
+  #
+  # Redirection configuration
+  #
+  # @see Tarquinn::RequestHandler
+  class RedirectionConfig
+    attr_reader :redirect
+
+    # @param redirect [Symbol] redirection name and redirection method
+    def initialize(redirect)
+      @redirect = redirect
+    end
+
+    # Adds conditions to the rule
+    #
+    # The rule name defines which method will be called when checking the path of redirection
+    #
+    # @param methods [Array<Symbol>] Methods that tell that a redirection should be applied
+    # @param block [Proc] block that tells if a the redirection should be applied
+    #
+    # @return [Array<Tarquinn::Condition>] Current registered conditions
+    def add_redirection_rules(*methods, &block)
+      redirect_on method_caller(methods)
+      redirect_on proc_runner(&block)
+    end
+
+    # Add rule for skipping on some actions / routes
+    #
+    # @param actions [Array<Symbol>] actions / routes to be skipped by redirection rule
+    #
+    # @return [Array<Tarquinn::Condition>]
+    def add_skip_action(*actions)
+      skip action_checker(actions)
+    end
+
+    # Attaches conditions to skip a redirection
+    #
+    # Methods and blocks are ran and if any returns true, the redirec is skipped
+    #
+    # @param methods [Array<Symbol>] Methods that tell that a redirection should be skipped
+    # @param block [Proc] block that tells if a the redirection should be skipped
+    #
+    # @return [Array] Current registered conditions
+    def add_skip_rules(*methods, &block)
+      skip method_caller(methods)
+      skip proc_runner(&block)
+    end
+
+    # All blocks that indicate a redirection
+    #
+    # @return [Array<Tarquinn::Condition>]
+    def redirection_blocks
+      @redirection_blocks ||= []
+    end
+
+    # All blocks that indicate a redirection should be skipped
+    #
+    # @return [Array<Tarquinn::Condition>]
+    def skip_blocks
+      @skip_blocks ||= []
+    end
+
+    private
+
+    delegate :method_caller, :action_checker, :proc_runner, to: Tarquinn::Condition
+
+    # @private
+    #
+    # Adds a condition to skip a redirection
+    #
+    # @return (see #skip_blocks)
+    def skip(condition)
+      return skip_blocks unless condition
+
+      skip_blocks << condition
+    end
+
+    # @private
+    #
+    # Adds a condition to a redirection
+    #
+    # @return (see #redirection_blocks)
+    def redirect_on(condition)
+      return redirection_blocks unless condition
+
+      redirection_blocks << condition
+    end
+  end
+end

data/lib/tarquinn/redirection_handler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  # @api private
+  #
+  # Redirect config handler
+  #
+  # Checks if one redirection rule should or should not be applied
+  class RedirectionHandler
+    # @param config [Tarquinn::RedirectionConfig] redirection configuration
+    # @param controller [Tarquinn::Controller] controller interface
+    def initialize(config, controller)
+      @config = config
+      @controller = controller
+    end
+
+    # Checks if redirection should be performd
+    #
+    # @return [TrueClass] when redirection should be performed
+    # @return [FalseClass] when redirection should not be performed
+    def perform_redirect?
+      return perform_redirect if instance_variable_defined?(:@perform_redirect)
+
+      @perform_redirect = redirect?
+    end
+
+    # Performs redirction to a new route
+    #
+    # @return [String] redirection body
+    def redirect
+      controller.call(:redirect_to, redirect_path)
+    end
+
+    private
+
+    attr_reader :config, :controller, :perform_redirect
+
+    delegate :redirection_blocks, :skip_blocks, to: :config
+
+    # Returns method in the controller that returns the redirection path
+    #
+    # @return [Symbol] method name
+    def redirect_method
+      config.redirect
+    end
+
+    # Returns the redirection path
+    #
+    # when redirection path method does not exist, then then
+    # the redirection name is used
+    #
+    # @return [String]
+    def redirect_path
+      return redirect_method unless controller.method?(redirect_method)
+
+      controller.call redirect_method
+    end
+
+    # Checks if a redirection should be performd
+    #
+    # @return [TrueClass]
+    # @return [FalseClass]
+    def redirect?
+      return false if blocks_skip_redirect?
+
+      blocks_require_redirect?
+    end
+
+    # Checks if redirection should be skipped
+    #
+    # @return [TrueClass]
+    # @return [FalseClass]
+    def blocks_skip_redirect?
+      check_blocks(skip_blocks)
+    end
+
+    # Checks if redirection should be applied (not concerning the skip blocks)
+    #
+    # @return [TrueClass]
+    # @return [FalseClass]
+    def blocks_require_redirect?
+      return true if redirection_blocks.empty?
+
+      check_blocks(redirection_blocks)
+    end
+
+    # Check if any condition  returns positive
+    #
+    # @return [TrueClass]
+    # @return [FalseClass]
+    def check_blocks(blocks)
+      blocks.any? do |block|
+        block.check?(controller)
+      end
+    end
+  end
+end

data/lib/tarquinn/request_handler.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  # @api private
+  #
+  # RequestHandler processing a request defining the flow
+  class RequestHandler
+    # @method configs
+    # @api private
+    #
+    # All redirect configs
+    #
+    # @return [Hash<Symbol,Tarquinn::RedirectionConfig>]
+
+    # @method controller
+    #
+    # Controller interface
+    #
+    # @return [Tarquinn::Controller]
+
+    # @param configs [Hash<Symbol,Tarquinn::RedirectionConfig>] All redirect configs
+    # @param controller [Tarquinn::Controller] Controller interface
+    def initialize(configs, controller)
+      @configs = configs
+      @controller = controller
+    end
+
+    # Performs redirection if enabled / needed
+    #
+    # The rules / configuratons are processed in order
+    # and if any is positive, it will be processed
+    #
+    # @return [NilClass] Nothing when no redirection is performed
+    # @return [String] The result of the redirection
+    def perform_redirect
+      return unless perform_redirect?
+
+      handler_redirector.redirect
+    end
+
+    private
+
+    attr_reader :configs, :controller
+
+    def perform_redirect?
+      handler_redirector.present?
+    end
+
+    def handler_redirector
+      @handler_redirector ||= handlers.find(&:perform_redirect?)
+    end
+
+    def handlers
+      @handlers ||= build_handlers
+    end
+
+    def build_handlers
+      configs.values.map { |config| Tarquinn::RedirectionHandler.new(config, controller) }
+    end
+  end
+end

data/lib/tarquinn/request_handler_builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  # @api private
+  #
+  # Redirections rules builder
+  #
+  # @see Tarquinn::RedirectionConfig
+  # @see Tarquinn::RequestHandler
+  # @see Tarquinn::Controller
+  class RequestHandlerBuilder
+    # Creates a redirection rule
+    #
+    # The rule name defines which method will be called when checking the path of redirection
+    #
+    # @param redirection [Symbol] Rule name and method with redirection path
+    # @param (see Tarquinn::RedirectionConfig#add_redirection_rules)
+    #
+    # @return (see Tarquinn::RedirectionConfig#add_redirection_rules)
+    def add_redirection_config(redirection, *methods, &block)
+      config_for(redirection).add_redirection_rules(*methods, &block)
+    end
+
+    # Attaches a condition to skip a redirection based on route (controller action)
+    #
+    # When any of the skip rules is met the redirection is skipped
+    #
+    # @param redirection [Symbol] Rule name to attach the skip condition
+    # @param (see Tarquinn::RedirectionConfig#add_skip_action)
+    #
+    # @return (see Tarquinn::RedirectionConfig#add_skip_action)
+    def add_skip_action(redirection, *actions)
+      config_for(redirection).add_skip_action(*actions)
+    end
+
+    # Attaches conditions to skip a redirection
+    #
+    # Methods and blocks are ran and if any returns true, the redirec is skipped
+    #
+    # @param redirection [Symbol] Rule name to attach the skip condition
+    # @param (see Tarquinn::RedirectionConfig#add_skip_rules)
+    #
+    # @return (see Tarquinn::RedirectionConfig#add_skip_rules)
+    def add_skip_config(redirection, *methods, block)
+      config_for(redirection).add_skip_rules(*methods, &block)
+    end
+
+    # Builds a new engine to process a request
+    #
+    # @param controller [ActionController::Base] Controller handling the request
+    #
+    # @return [Tarquinn::RequestHandler]
+    def build(controller)
+      controller = Tarquinn::Controller.new(controller)
+      Tarquinn::RequestHandler.new(configs, controller)
+    end
+
+    private
+
+    # @api private
+    # @private
+    #
+    # Returns the configuration for one redirection
+    #
+    # When none is configured, a new one is created
+    #
+    # @param redirection [Symbol] redirection_name
+    #
+    # @return [Tarquinn::RedirectionConfig]
+    def config_for(redirection)
+      configs[redirection.to_sym] ||= Tarquinn::RedirectionConfig.new(redirection)
+    end
+
+    # @api private
+    # @private
+    #
+    # Returns all configurations for all redirections for the controller
+    #
+    # @return [Hash<Symbol,Tarquinn::RedirectionConfig>]
+    def configs
+      @configs ||= {}
+    end
+  end
+end

data/lib/tarquinn/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tarquinn
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/lib/tarquinn.rb

@@ -1,14 +1,80 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext'
 
+# @api public
+#
+# Concern adding methods for easy redirection controll
 module Tarquinn
-  require 'tarquinn/version'
-  require 'tarquinn/handler'
-  require 'tarquinn/controller'
-  require 'tarquinn/condition'
-  require 'tarquinn/config'
-  require 'tarquinn/engine'
-  require 'tarquinn/builder'
+  extend ActiveSupport::Concern
+
+  autoload :Version,               'tarquinn/version'
+  autoload :RedirectionHandler,    'tarquinn/redirection_handler'
+  autoload :Controller,            'tarquinn/controller'
+  autoload :Condition,             'tarquinn/condition'
+  autoload :RedirectionConfig,     'tarquinn/redirection_config'
+  autoload :RequestHandler,        'tarquinn/request_handler'
+  autoload :RequestHandlerBuilder, 'tarquinn/request_handler_builder'
+
   require 'tarquinn/class_methods'
-  require 'tarquinn/concern'
+
+  # @method self.redirection_rule(redirection, *methods, &block)
+  #
+  # Creates a redirection rule
+  #
+  # The rule name defines which method will be called when checking the path of redirection
+  #
+  # @param (see Tarquinn::ClassMethods#redirection_rule)
+  # @return (see Tarquinn::ClassMethods#redirection_rule)
+
+  # @method self.skip_redirection(redirection, *actions)
+  #
+  # Attaches a condition to skip a redirection based on route (controller action)
+  #
+  # When any of the skip rules is met the redirection is skipped
+  #
+  # @param (see Tarquinn::ClassMethods#skip_redirection)
+  # @return (see Tarquinn::ClassMethods#skip_redirection)
+
+  # @method self.skip_redirection_rule(redirection, *methods, &block)
+  #
+  # Attaches conditions to skip a redirection
+  #
+  # Methods and blocks are ran and if any returns true, the redirec is skipped
+  #
+  # @param (see Tarquinn::ClassMethods#skip_redirection)
+  # @return (see Tarquinn::ClassMethods#skip_redirection)
+
+  # @method self.redirector_builder
+  #
+  # Retruns the RequestHandlerBuilder
+  #
+  # RequestHandlerBuilder will Carry all the configurations and will create
+  # one {RequestHandler} for each request
+  #
+  # @return (see Tarquinn::ClassMethods#redirector_builder)
+  included do
+    before_action :perform_redirection
+  end
+
+  private
+
+  # @api private
+  # private
+  #
+  # @return [Tarquinn::RequestHandler] an engine for the controller
+  def redirector_engine
+    self.class.redirector_builder.build(self)
+  end
+
+  # Performs redirection if enabled / needed
+  #
+  # The rules / configuratons are processed in order
+  # and if any is positive, it will be processed
+  #
+  # @return (see Tarquinn::RequestHandler#perform_redirect)
+  def perform_redirection
+    redirector_engine.perform_redirect
+  end
 end

data/spec/dummy/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1 @@
+/* Application styles */

data/spec/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/spec/dummy/app/channels/application_cable/connection.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ApplicationController < ActionController::Base
+end

data/spec/dummy/app/controllers/tarquinn/dummy_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  class DummyController < ApplicationController
+    include Tarquinn
+
+    skip_redirection :redirection_path, :route_method
+    redirection_rule :redirection_path, :should_redirect?
+    skip_redirection_rule :redirection_path, :should_skip_redirect?
+
+    def parse_request
+      perform_redirection
+    end
+
+    private
+
+    def params
+      ActionController::Parameters.new({ action: 'show' })
+    end
+
+    def true
+      true
+    end
+
+    def false
+      false
+    end
+
+    def redirection_path
+      '/path'
+    end
+
+    def redirect_to(_); end
+
+    def should_redirect?
+      true
+    end
+
+    def should_skip_redirect?
+      false
+    end
+  end
+end

data/spec/dummy/app/controllers/tarquinn/dummy_route_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Tarquinn
+  class DummyRouteController < ApplicationController
+    include Tarquinn
+
+    def index; end
+
+    def new; end
+
+    private
+
+    def redirection
+      '/path'
+    end
+
+    def should_redirect?
+      params[:should_redirect]
+    end
+
+    def condition2
+      params[:redirect]
+    end
+
+    def should_skip?
+      params[:should_skip]
+    end
+
+    def do_skip?
+      params[:skip]
+    end
+
+    def always_redirect
+      true
+    end
+  end
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ApplicationHelper
+end

data/spec/dummy/app/jobs/application_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/spec/dummy/app/mailers/application_mailer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.text.erb

@@ -0,0 +1 @@
+<%= yield %>

data/spec/dummy/bin/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# path to your application root.
+APP_ROOT = File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:prepare'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end