rails_ops 1.0.0.beta1

data/lib/rails_ops/hookup/dsl.rb

@@ -0,0 +1,29 @@
+class RailsOps::Hookup::DSL
+  attr_reader :hooks
+
+  def initialize(&block)
+    @current_target            = nil
+    @validator                 = nil
+    @hooks                     = ActiveSupport::OrderedHash.new
+
+    RailsOps::ScopedEnv.new(self, [:run]).instance_exec(&block)
+  end
+
+  def run(target, &block)
+    @current_target = target
+    RailsOps::ScopedEnv.new(self, [:on]).instance_exec(&block)
+    @current_target = nil
+  end
+
+  def on(source, event = :after_run)
+    @hooks[source] ||= ActiveSupport::OrderedHash.new
+    @hooks[source][event] ||= []
+    @hooks[source][event] << RailsOps::Hookup::Hook.new(source, event, @current_target)
+  end
+
+  def validate!
+    @validator = RailsOps::Hookup::DSLValidator.new @hooks
+    @validator.validate!
+    @validator
+  end
+end

data/lib/rails_ops/hookup/dsl_validator.rb

@@ -0,0 +1,45 @@
+class RailsOps::Hookup::DSLValidator
+  attr_reader :error, :trace
+
+  def initialize(hooks)
+    @hooks = hooks
+    @trace = []
+  end
+
+  def validate!
+    # Check infinity loop
+    if target_hooks.any? { |name, targets| recursion?(targets, name) }
+      fail StandardError::SystemStackError.new, "Infinite loop detected in hooks configuration: #{inspect_trace}."
+    end
+  end
+
+  def target_hooks
+    @target_hooks ||= @hooks.map do |name, hash|
+      [name, drilldown(hash)]
+    end.to_h
+  end
+
+  private
+
+  def inspect_trace
+    @trace.map(&:to_s).join(' ~> ')
+  end
+
+  def recursion?(targets, name)
+    if targets.include? name
+      @trace << name.to_s
+      return true
+    end
+
+    return targets.any? do |target|
+      if @hooks[target]
+        @trace |= [name, target]
+        recursion? drilldown(@hooks[target]), name
+      end
+    end
+  end
+
+  def drilldown(hash)
+    hash.values.flatten.map(&:target_operation)
+  end
+end

data/lib/rails_ops/hookup/hook.rb

@@ -0,0 +1,11 @@
+class RailsOps::Hookup::Hook
+  attr_reader :on_operation
+  attr_reader :on_event
+  attr_reader :target_operation
+
+  def initialize(on_operation, on_event, target_operation)
+    @on_operation              = on_operation
+    @on_event                  = on_event
+    @target_operation          = target_operation
+  end
+end

data/lib/rails_ops/log_subscriber.rb

@@ -0,0 +1,24 @@
+module RailsOps
+  # This class subscribes to Rails Ops events via the ActiveSupport
+  # instrumentation API.
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    # This gets called whenever an operation has been performed and logs the
+    # operation via Rails' `debug` logging method.
+    def run(event)
+      op = event.payload[:operation]
+
+      return if op.class.logging_skipped?
+
+      message = 'OP'
+
+      profile = ::RailsOps::Profiler.node(op.object_id)
+      message += " (#{profile.t_self_ms.round(1)}ms / #{profile.t_kids_ms.round(1)}ms)"
+      profile.free
+
+      message = color(message, YELLOW, true)
+      message += color(" #{op.class.name}", YELLOW, false)
+
+      debug "  #{message}"
+    end
+  end
+end

data/lib/rails_ops/mixins.rb

@@ -0,0 +1,2 @@
+module RailsOps::Mixins
+end

data/lib/rails_ops/mixins/authorization.rb

@@ -0,0 +1,83 @@
+# Mixin for the {RailsOps::Operation} class that provides basic authorization
+# methods based on the cancan(can) ability that can be provided using an
+# operation's context.
+module RailsOps::Mixins::Authorization
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_authorization_disabled
+    class_attribute :_authorization_disabled_for_sub_ops
+
+    policy :after_perform do
+      ensure_authorize_called!
+    end
+  end
+
+  module ClassMethods
+    # Disables authorization (and authorization check) for this
+    # operation. If `include_sub_ops` is `true` (default `false`),
+    # this setting also applies to sub operations called by this
+    # operation (either via run_sub(!) or via a hook).
+    def without_authorization(include_sub_ops: false)
+      fail 'Option include_sub_ops is not yet supported.' if include_sub_ops
+
+      self._authorization_disabled = true
+      self._authorization_disabled_for_sub_ops = include_sub_ops
+    end
+  end
+
+  # Checks whether authorization is currently enabled and possible
+  # (an ability is present).
+  def authorization_enabled?
+    # Do not perform authorization if it is disabled globally
+    return false unless RailsOps.authorization_enabled?
+
+    # Do not perform authorization if it is disabled for this operation
+    return false if self.class._authorization_disabled
+
+    # Do not perform authorization if no ability is present
+    return false unless context.ability
+
+    # Perform authorization
+    return true
+  end
+
+  def authorization_enabled_for_sub_ops?
+    !@_authorization_disabled_for_sub_ops
+  end
+
+  def authorize_called?
+    @_authorize_called ||= false
+  end
+
+  # Operations within the given block will have disabled authorization.
+  # This only applies to the current thread.
+  def without_authorization(&block)
+    RailsOps.without_authorization(&block)
+  end
+
+  # Checks authorization against the configured authentication backend. Fails if
+  # authentication is not successfull or could not be performed. Does not
+  # perform anything if authorization is disabled.
+  def authorize!(action, *args)
+    authorize_only!(action, *args)
+    @_authorize_called = true
+  end
+
+  # Checks authorization against the configured authentication backend. Fails if
+  # authentication is not successfull or could not be performed. Does not
+  # perform anything if authorization is disabled. Calling authorize_only! does
+  # not count as authorized concerning ensure_authorize_called!.
+  def authorize_only!(*args)
+    return unless authorization_enabled?
+    RailsOps.authorization_backend.authorize!(self, *args)
+  end
+
+  # Checks if an authentication check has been performed if authorization is
+  # enabled.
+  def ensure_authorize_called!
+    return unless authorization_enabled?
+    return if authorize_called?
+    fail RailsOps::Exceptions::NoAuthorizationPerformed, "Operation #{self.class.name} has been performed without authorization."
+  end
+end

data/lib/rails_ops/mixins/log_settings.rb

@@ -0,0 +1,20 @@
+module RailsOps::Mixins::LogSettings
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_skip_logging
+    self._skip_logging = false
+  end
+
+  module ClassMethods
+    # Allows to skip logging for this operation via the
+    # {RailsOps::LogSubscriber}.
+    def skip_logging(skip = true)
+      self._skip_logging = skip
+    end
+
+    def logging_skipped?
+      _skip_logging
+    end
+  end
+end

data/lib/rails_ops/mixins/model.rb

@@ -0,0 +1,4 @@
+# Empty module used for namespacing mixins that are meant for
+# {RailsOps::Operations::Model} and it's subclasses.
+module RailsOps::Mixins::Model
+end

data/lib/rails_ops/mixins/model/authorization.rb

@@ -0,0 +1,64 @@
+# Mixin for the {RailsOps::Operation::Model} class that provides the method
+# {authorize_model!} which authorizes the operation's model class or instance
+# against the authorization methods of {RailsOps::Mixins::Authorization}.
+module RailsOps::Mixins::Model::Authorization
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_model_authorization_action
+  end
+
+  module ClassMethods
+    # Gets or sets the action verb used for authorizing models.
+    def model_authorization_action(*action)
+      if action.size == 1
+        self._model_authorization_action = action.first
+      elsif action.size > 1
+        fail ArgumentError, 'Too many arguments'
+      end
+
+      return _model_authorization_action
+    end
+  end
+
+  def model_authorization_action
+    self.class.model_authorization_action
+  end
+
+  # Performs authorization on the given model using the {authorize?} method.
+  # Models are casted using {cast_model_for_authorization} so that they can be
+  # used for authorization. If no `model_class_or_instance` is given, the
+  # {model} instance method will be used.
+  def authorize_model!(action, model_class_or_instance = model, *extra_args)
+    authorize! action, cast_model_for_authorization(model_class_or_instance), *extra_args
+  end
+
+  # Performs an authorization check like {authorize_model!}, but does not mark
+  # this operation instance as checked. This means that there must be at least
+  # one other authorization call within execution of this operation for the
+  # operation not to fail.
+  def authorize_model_with_authorize_only!(action, model_class_or_instance = model, *extra_args)
+    authorize_only! action, cast_model_for_authorization(model_class_or_instance), *extra_args
+  end
+
+  private
+
+  # Cast {ActiveType::Record} classes or instances to regular AR models in order
+  # for cancan(can) to work properly. Classes and instances that are no active
+  # type records will be returned as-is.
+  #
+  # TODO: Use ModelCasting module instead?
+  def cast_model_for_authorization(model_class_or_instance)
+    if model_class_or_instance.is_a?(Class)
+      if model_class_or_instance.respond_to?(:extended_record_base_class)
+        return model_class_or_instance.extended_record_base_class
+      else
+        return model_class_or_instance
+      end
+    elsif model_class_or_instance.class.respond_to?(:extended_record_base_class)
+      return ActiveType.cast(model_class_or_instance, model_class_or_instance.class.extended_record_base_class)
+    else
+      model_class_or_instance
+    end
+  end
+end

data/lib/rails_ops/mixins/model/nesting.rb

@@ -0,0 +1,180 @@
+module RailsOps::Mixins::Model::Nesting
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_nested_model_ops
+    self._nested_model_ops = {}.freeze
+
+    attr_reader :nested_model_ops
+  end
+
+  module ClassMethods
+    def nest_model_op(attribute, klass, lookup_via_id_on_update: true, &params_block)
+      # ---------------------------------------------------------------
+      # Make sure we're working with an extension /  copy
+      # of the given model class
+      # ---------------------------------------------------------------
+      unless always_extend_model_class?
+        fail 'This operation class must be configured to always extend the model class as `nest_model_op` modifies it.'
+      end
+
+      # ---------------------------------------------------------------
+      # Validate association (currently, we only support belongs_to)
+      # ---------------------------------------------------------------
+      reflection = model.reflect_on_association(attribute)
+
+      if reflection.nil?
+        fail "Association #{attribute} could not be found for #{model.model_name}."
+      elsif !reflection.belongs_to?
+        fail 'Method nest_model_op only supports :belongs_to associations, '\
+             "but association #{attribute} of model #{model.model_name} is a "\
+             "#{reflection.macro} association."
+      elsif reflection.options[:autosave] != false
+        fail "Association #{attribute} of #{model.model_name} has :autosave turned on. "\
+             'This is not supported by nest_model_op.'
+      elsif !reflection.options[:validate]
+        fail "Association #{attribute} of #{model.model_name} has :validate turned off. "\
+        'This is not supported by nest_model_op.'
+      end
+
+      # ---------------------------------------------------------------
+      # Define attributes setter on model.
+      #
+      # Model nesting is not compatible with accepts_nested_attributes_for
+      # as it automatically enables :autosave which is not supported.
+      # As we can't use accepts_nested_attributes_for, no nested attributes
+      # setter is generated. This also means that `fields_for` in form
+      # generation don't detect the attribute as nested and mistakenly omit the
+      # _attributes suffix. Therefore, we define this method but fail if it
+      # ever gets called.
+      # ---------------------------------------------------------------
+      model.send(:define_method, "#{attribute}_attributes=") do |_value|
+        fail 'This operation model does not allow receiving nested attributes' \
+             "for #{attribute}, as this is saved using a nested model operation."
+      end
+
+      # ---------------------------------------------------------------
+      # Validate inverse association reflection if given
+      # ---------------------------------------------------------------
+      if (inverse_reflection = reflection.inverse_of)
+        if inverse_reflection.options[:autosave] != false
+          fail "Association #{inverse_reflection.name} of #{inverse_reflection.active_record} has :autosave turned on. "\
+               'This is not supported by nest_model_op.'
+        end
+      end
+
+      # ---------------------------------------------------------------
+      # Store configuration
+      # ---------------------------------------------------------------
+      self._nested_model_ops = _nested_model_ops.merge(
+        attribute => {
+          klass: klass,
+          params_proc: params_block,
+          lookup_via_id_on_update: lookup_via_id_on_update
+        }
+      )
+    end
+
+    def nested_model_param_keys
+      _nested_model_ops.keys.collect do |attribute|
+        "#{attribute}_attributes"
+      end
+    end
+  end
+
+  def nested_model_ops_performed?
+    @nested_model_ops_performed || false
+  end
+
+  protected
+
+  def nested_model_op(attribute)
+    fail 'Nested model operations have not been built yet.' unless @nested_model_ops
+    return @nested_model_ops[attribute]
+  end
+
+  def build_nested_model_ops(action)
+    # Validate action
+    fail 'Unsupported action.' unless [:create, :update].include?(action)
+
+    # Make sure that this method can only be run once per operation
+    fail 'Nested model operations can only be built once.' if @nested_model_ops
+    @nested_model_ops = {}
+
+    self.class._nested_model_ops.each do |attribute, config|
+      op_params = extract_attributes_from_params["#{attribute}_attributes"] || {}
+
+      # Remove id field as this is commonly supplied by Rails' `fields_for` if
+      # the nested model is persisted. We don't usually need this.
+      op_params = op_params.except(:id)
+
+      # Apply custom params processing callback if given
+      if config[:params_proc]
+        op_params = instance_exec(op_params, &config[:params_proc])
+      end
+
+      # Wrap parameters for nested model operation
+      if action == :create
+        wrapped_params = {
+          attribute => op_params
+        }
+      elsif action == :update
+        if config[:lookup_via_id_on_update]
+          foreign_key = model.class.reflect_on_association(attribute).foreign_key
+          id = model.send(foreign_key)
+        else
+          id = model.send(attribute).id
+        end
+
+        wrapped_params = {
+          :id => id,
+          attribute => op_params
+        }
+      else
+        fail "Unsupported action #{action}."
+      end
+
+      # Instantiate nested operation
+      @nested_model_ops[attribute] = sub_op(config[:klass], wrapped_params)
+
+      # Inject model of nested operation to our own model
+      nested_model = @nested_model_ops[attribute].model
+      model.send("#{attribute}=", nested_model)
+
+      # Inject our own model to model of nested operation (if the inverse
+      # reflection can be resolved)
+      if (inverse_reflection = model.class.reflect_on_association(attribute).inverse_of)
+        nested_model.send("#{inverse_reflection.name}=", model)
+      end
+    end
+  end
+
+  # Tries to save nested models using their respective operations.
+  def perform_nested_model_ops!
+    fail 'Nested model operations can only be performed once.' if nested_model_ops_performed?
+
+    # Validate the whole model hierarchy. Since we're calling 'model' here, this
+    # line also makes sure a model is built.
+    model.validate!
+
+    # Make sure nested model operations are build
+    fail 'Nested model operations are not built yet. Make sure the model is built.' unless @nested_model_ops
+
+    @nested_model_ops.each do |attribute, op|
+      # Run the nested model operation and fail hard if a validation error
+      # arises. This should generally not happen as the whole hierarchy has been
+      # validated before. It is vital that the transaction gets rolled back if
+      # an exception happens here.
+      begin
+        op.run!
+      rescue op.validation_errors => e
+        fail RailsOps::Exceptions::SubOpValidationFailed, e
+      end
+
+      # Assign model again so that the ID gets updated
+      model.send("#{attribute}=", op.model)
+    end
+
+    @nested_model_ops_performed = true
+  end
+end