rails_ops 1.0.0.beta1

data/RUBY_VERSION

@@ -0,0 +1 @@
+ruby-2.3.1-p112

data/Rakefile

@@ -0,0 +1,39 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task default: :test
+
+task :gemspec do
+  gemspec = Gem::Specification.new do |spec|
+    spec.name          = 'rails_ops'
+    spec.version       = IO.read('VERSION').chomp
+    spec.authors       = ['Sitrox']
+    spec.summary       = 'A skeleton that allows extracting queries into atomic, reusable classes.'
+    spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+    spec.executables   = []
+    spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+    spec.require_paths = ['lib']
+
+    spec.add_development_dependency 'bundler', '~> 1.3'
+    spec.add_development_dependency 'rake'
+    spec.add_development_dependency 'sqlite3'
+    spec.add_development_dependency 'yard'
+    spec.add_development_dependency 'rubocop', '0.47.1'
+    spec.add_development_dependency 'redcarpet'
+    spec.add_dependency 'active_type', '~> 0.7.1'
+    spec.add_dependency 'minitest'
+    spec.add_dependency 'activesupport'
+    spec.add_dependency 'activerecord'
+    spec.add_dependency 'schemacop', '~> 2.0'
+  end
+
+  File.open('rails_ops.gemspec', 'w') { |f| f.write(gemspec.to_ruby.strip) }
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/rails_ops/**/*_test.rb'
+  t.verbose = false
+  t.libs << 'test'
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0.beta1

data/lib/rails_ops.rb

@@ -0,0 +1,96 @@
+module RailsOps
+  AUTH_THREAD_STORAGE_KEY = :rails_ops_authorization_enabled
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure(&_block)
+    yield(config)
+  end
+
+  def self.authorization_backend
+    return nil unless config.authorization_backend
+    return @authorization_backend ||= config.authorization_backend.constantize.new
+  end
+
+  # Returns an instance of the {RailsOps::Hookup} class. This instance is
+  # cached depending on the application environment.
+  def self.hookup
+    Hookup.instance
+  end
+
+  def self.authorization_enabled?
+    fail 'No authorization backend is configured.' unless authorization_backend
+
+    return false unless authorization_backend
+
+    if Thread.current[AUTH_THREAD_STORAGE_KEY].nil?
+      return true
+    else
+      return Thread.current[AUTH_THREAD_STORAGE_KEY]
+    end
+  end
+
+  # Operations within the given block will have disabled authorization.
+  # This only applies to the current thread.
+  def self.without_authorization(&_block)
+    previous_value = Thread.current[AUTH_THREAD_STORAGE_KEY]
+    Thread.current[AUTH_THREAD_STORAGE_KEY] = false
+    yield
+    Thread.current[AUTH_THREAD_STORAGE_KEY] = previous_value
+  end
+end
+
+# ---------------------------------------------------------------
+# Require Gem active_type and monkey patch
+# ---------------------------------------------------------------
+require 'active_type'
+require 'active_type/type_caster'
+require 'rails_ops/patches/active_type_patch'
+
+# ---------------------------------------------------------------
+# Require RailsOps
+# ---------------------------------------------------------------
+require 'rails_ops/authorization_backend/abstract.rb'
+require 'rails_ops/authorization_backend/can_can_can.rb'
+require 'rails_ops/configuration.rb'
+require 'rails_ops/context.rb'
+require 'rails_ops/controller_mixin.rb'
+require 'rails_ops/exceptions.rb'
+require 'rails_ops/hooked_job.rb'
+require 'rails_ops/hookup.rb'
+require 'rails_ops/hookup/dsl.rb'
+require 'rails_ops/hookup/dsl_validator.rb'
+require 'rails_ops/hookup/hook.rb'
+require 'rails_ops/log_subscriber.rb'
+require 'rails_ops/mixins.rb'
+require 'rails_ops/mixins/authorization.rb'
+require 'rails_ops/mixins/log_settings.rb'
+require 'rails_ops/mixins/model.rb'
+require 'rails_ops/mixins/model/authorization.rb'
+require 'rails_ops/mixins/model/nesting.rb'
+require 'rails_ops/mixins/policies.rb'
+require 'rails_ops/mixins/require_context.rb'
+require 'rails_ops/mixins/routes.rb'
+require 'rails_ops/mixins/schema_validation.rb'
+require 'rails_ops/mixins/sub_ops.rb'
+require 'rails_ops/model_casting.rb'
+require 'rails_ops/model_mixins.rb'
+require 'rails_ops/model_mixins/ar_extension.rb'
+require 'rails_ops/model_mixins/parent_op.rb'
+require 'rails_ops/model_mixins/protected_attributes.rb'
+require 'rails_ops/model_mixins/virtual_attributes.rb'
+require 'rails_ops/model_mixins/virtual_attributes/virtual_column_wrapper.rb'
+require 'rails_ops/model_mixins/virtual_has_one.rb'
+require 'rails_ops/operation.rb'
+require 'rails_ops/operation/model.rb'
+require 'rails_ops/operation/model/load.rb'
+require 'rails_ops/operation/model/create.rb'
+require 'rails_ops/operation/model/destroy.rb'
+require 'rails_ops/operation/model/update.rb'
+require 'rails_ops/profiler.rb'
+require 'rails_ops/profiler/node.rb'
+require 'rails_ops/railtie.rb'
+require 'rails_ops/scoped_env.rb'
+require 'rails_ops/virtual_model.rb'

data/lib/rails_ops/authorization_backend/abstract.rb

@@ -0,0 +1,7 @@
+module RailsOps::AuthorizationBackend
+  class Abstract
+    def authorize!(_operation, *_args)
+      fail NotImplementedError
+    end
+  end
+end

data/lib/rails_ops/authorization_backend/can_can_can.rb

@@ -0,0 +1,14 @@
+module RailsOps::AuthorizationBackend
+  class CanCanCan < Abstract
+    def initialize
+      unless defined?(CanCanCan)
+        fail "RailsOps is configured to use CanCanCan authorization backend, but the Gem 'cancancan' does not appear to be installed."
+      end
+    end
+
+    def authorize!(operation, *args)
+      ability = operation.context.try(:ability) || fail(RailsOps::Exceptions::AuthorizationNotPerformable)
+      ability.authorize!(*args)
+    end
+  end
+end

data/lib/rails_ops/configuration.rb

@@ -0,0 +1,4 @@
+class RailsOps::Configuration < ActiveType::Object
+  attribute :lock_models_at_build, :boolean, default: true
+  attribute :authorization_backend, :string, default: nil
+end

data/lib/rails_ops/context.rb

@@ -0,0 +1,35 @@
+module RailsOps
+  class Context < ActiveType::Object
+    attribute :user
+    attribute :ability
+    attribute :op_chain, default: []
+    attribute :session
+    attribute :called_via_hook
+    attribute :url_options
+
+    # Returns a copy of the context with the given operation added to the
+    # contexts operation chain.
+    def spawn(op)
+      return Context.new(
+        user:            user,
+        ability:         ability,
+        session:         session,
+        op_chain:        op_chain + [op],
+        called_via_hook: false,
+        url_options:     url_options
+      )
+    end
+
+    # Runs the given operation in this particular context with the given args
+    # using the non-bang `run` method.
+    def run(op, *args)
+      op.run(self, *args)
+    end
+
+    # Runs the given operation in this particular context with the given args
+    # using the bang `run!` method.
+    def run!(op, *args)
+      op.run!(self, *args)
+    end
+  end
+end

data/lib/rails_ops/controller_mixin.rb

@@ -0,0 +1,105 @@
+module RailsOps
+  module ControllerMixin
+    extend ActiveSupport::Concern
+
+    # TODO: A similar thing is already done in the operation
+    #   initializer. Are both necessary? This one here contains
+    #   more exceptions though.
+    EXCEPT_PARAMS = [
+      :controller,
+      :action,
+      :utf8,
+      :authenticity_token,
+      :_referer_depth,
+      :_referer,
+      :_method
+    ].freeze
+
+    included do
+      if defined?(helper_method)
+        helper_method :model
+        helper_method :op
+        helper_method :op?
+
+        after_action :ensure_operation_authorize_called!
+      end
+    end
+
+    # Instantiates and returns a new operation with the given class. If no class
+    # is given, it just returns the previously assigned operation or raises if
+    # none has been given.
+    def op(op_class = nil, custom_params = nil)
+      set_op_class(op_class, custom_params) if op_class
+      fail 'Operation is not set.' unless @op
+      return @op
+    end
+
+    def op?
+      !!@op
+    end
+
+    # If there is a current operation set, it is made sure that authorization
+    # has been performed within the operation. This only applies if
+    # authorization is not disabled.
+    def ensure_operation_authorize_called!
+      return unless op?
+      op.ensure_authorize_called!
+    end
+
+    # Runs an operation and fails on validation errors using an exception. If
+    # no operation class is given, it takes the operation previosly set by {op}
+    # or fails if no operation has been set. If an op_class is given, it will be
+    # set using the {op} method.
+    def run!(op_class = nil, custom_params = nil)
+      op(op_class, custom_params) if op_class
+      op.run!
+    end
+
+    # Runs an operation and returns `true` for success and `false` for any
+    # validation errors. The supplied block is yielded only on success.
+    # See {run!} for more information.
+    def run(op_class = nil, custom_params = nil, &_block)
+      op(op_class, custom_params) if op_class
+      success = op.run
+      yield if success && block_given?
+      return success
+    end
+
+    def model
+      return @model if @model
+      fail 'Current operation does not support `model` method.' unless op.respond_to?(:model)
+      return op.model
+    end
+
+    def filter_op_params(params)
+      (params || {}).except(*EXCEPT_PARAMS)
+    end
+
+    def op_params
+      filter_op_params(params.permit!).to_h
+    end
+
+    def op_context
+      @op_context ||= begin
+        context = RailsOps::Context.new
+        context.user = current_user if defined?(:current_user)
+        context.ability = current_ability if defined?(:current_ability)
+        context.session = session
+        context.url_options = url_options
+        context
+      end
+    end
+
+    protected
+
+    def set_op_class(op_class, custom_params = nil)
+      fail 'Operation class is already set.' if @op_class
+      @op_class = op_class
+      @op = instantiate_op(custom_params)
+    end
+
+    def instantiate_op(custom_params = nil)
+      return @op_class.new(op_context, custom_params || op_params)
+    end
+  end
+end

data/lib/rails_ops/exceptions.rb

@@ -0,0 +1,19 @@
+module RailsOps::Exceptions
+  class Base < StandardError; end
+  class ValidationFailed < Base; end
+  class ModelNotDeleteable < Base; end
+  class AuthorizationNotPerformable < Base; end
+  class NoAuthorizationPerformed < Base; end
+  class MissingContextAttribute < Base; end
+  class RoutingNotAvailable < Base; end
+  class RollbackRequired < Base; end
+
+  class SubOpValidationFailed < Base
+    attr_reader :original_exception
+
+    def initialize(original_exception)
+      @original_exception = original_exception
+      super original_exception.message
+    end
+  end
+end

data/lib/rails_ops/hooked_job.rb

@@ -0,0 +1,25 @@
+module RailsOps
+  # This class extends ActiveJob::Job and, when subclassed, allows to link
+  # common job classes to operations. When defining a Job, just extend this
+  # class and use the static `op` method in order to hook it to a specific
+  # operation. The `perform` method will then automatically run the operation
+  # via its `run!` method and with the given params.
+  class HookedJob < ActiveJob::Base
+    class_attribute :operation_class
+
+    # Set an operation class this job shall be hooked with. This is mandatory
+    # unless you override the `perform` method (which would be an abuse of this
+    # class anyways).
+    def self.op(klass)
+      self.operation_class = klass
+    end
+
+    # This method is called by the ActiveJob framework and solely executes the
+    # hooked operation's `run!` method. If no operation has been hooked (use the
+    # static method `op` for that), it will raise an exception.
+    def perform(params = {})
+      fail 'This job is not hooked to any operation.' unless operation_class
+      operation_class.run!(params)
+    end
+  end
+end

data/lib/rails_ops/hookup.rb

@@ -0,0 +1,80 @@
+class RailsOps::Hookup
+  REQUEST_STORE_KEY = 'RailsOps::Hookup'.freeze
+  CONFIG_PATH = 'config/hookup.rb'.freeze
+
+  attr_reader :hooks
+
+  def self.instance
+    if defined?(Rails) && Rails.env.development?
+      return RequestStore.store[REQUEST_STORE_KEY] ||= new
+    else
+      @instance ||= new
+      return @instance
+    end
+  end
+
+  def initialize
+    @hooks = nil
+    @drawn = false
+    @config_loaded = false
+  end
+
+  def load_config
+    unless @config_loaded
+      @config_loaded = true
+      load Rails.root.join(CONFIG_PATH)
+    end
+
+    unless @drawn
+      fail 'Hooks are not drawn.'
+    end
+  end
+
+  def draw(&block)
+    if @drawn
+      fail "Hooks can't be drawn twice."
+    end
+
+    dsl = DSL.new(&block)
+    dsl.validate!
+
+    @hooks = dsl.hooks
+    @drawn = true
+  end
+
+  def hooks_for(operation, event)
+    load_config
+
+    hooks = []
+
+    @hooks.slice('*', operation.class.name).values.each do |hooks_by_event|
+      hooks += hooks_by_event.slice('*', event).values.flatten || []
+    end
+
+    return hooks
+  end
+
+  def trigger_params
+    {}
+  end
+
+  def trigger(operation, event, params)
+    context = operation.context.spawn(operation)
+    context.called_via_hook = true
+
+    hooks_for(operation, event).each do |hook|
+      if context.op_chain.collect(&:class).collect(&:to_s).include?(hook.target_operation)
+        next
+      end
+
+      begin
+        op_class = hook.target_operation.constantize
+      rescue NameError
+        fail "Could not find hook target operation #{hook.target_operation}."
+      end
+
+      op = op_class.new(context, params)
+      op.run!
+    end
+  end
+end