rails_ops 1.0.0.beta1

data/lib/rails_ops/operation/model.rb

@@ -0,0 +1,168 @@
+class RailsOps::Operation::Model < RailsOps::Operation
+  include RailsOps::Mixins::Model::Authorization
+  include RailsOps::Mixins::Model::Nesting
+
+  class_attribute :_model_class
+
+  # Allows to set or get a model class associated with this operation.
+  #
+  # To get the model class, call this method without any parameters. Note that
+  # this will result in an exception if the model class has not been previously
+  # set.
+  #
+  # To set the model class, there are 3 ways:
+  #
+  # - You only specify an existing class as `model_class`.
+  # - You only specify a block of code. This will result in a dynamically
+  #   created class using the provided code block. The base class that is
+  #   extended by this block is determined by the method
+  #   {default_model_class}. Check this method to determine the used base class
+  #   or overwrite it. This only makes sense for inheritance as there is the
+  #   parameter `model_class` (see next point).
+  # - You specify a `model_class` as well as a block of code. In this case, the
+  #   supplied class will be dynamically extended with the code block provided.
+  #
+  # This is a DSL method. Do not call it at runtime (i.e. after bootup) as it
+  # is not thread-safe and may generate anonymous classes.
+  #
+  # @param model_class [Class] The model class to take or extend
+  # @param name [String,Symbol] A custom name that will be used for generating
+  #   the anonymous class
+  # @yield [] This optional block is executed in context of the newly generated,
+  #   anonymous class and allows you to extend it
+  def self.model(model_class = nil, name = nil, &block)
+    if model_class || block_given?
+      fail 'Model class can only be set once.' if _model_class
+
+      model_class ||= default_model_class
+
+      # ---------------------------------------------------------------
+      # If we're given a block or we're configured to always extend the
+      # given model class, create a new model class inheriting from the
+      # given one and mix in required modules.
+      # ---------------------------------------------------------------
+      if block_given? || always_extend_model_class?
+        self._model_class = Class.new(model_class)
+
+        # Include operation mixins that provide various functionality needed for
+        # operation-specific models. We can safely include this even if it has
+        # already been included, as module includes only happen once.
+        _model_class.send(:include, RailsOps::ModelMixins)
+
+        # Apply the given block to the newly created class.
+        _model_class.class_eval(&block) if block_given?
+
+        # Set virtual model name if given.
+        if name && _model_class.respond_to?(:virtual_model_name=)
+          _model_class.virtual_model_name = ActiveModel::Name.new(_model_class, nil, name.to_s)
+        end
+
+      # ---------------------------------------------------------------
+      # We just use the given model class without any adaptions
+      # ---------------------------------------------------------------
+      else
+        self._model_class = model_class
+      end
+    elsif _model_class.nil?
+      fail 'No model class has been set.'
+    end
+
+    return _model_class
+  end
+
+  # This method determines whether the given model class (specified using the
+  # static `model` method) is always extended with an anonymous class. This can
+  # be required if the operation modifies the model class.
+  def self.always_extend_model_class?
+    false
+  end
+
+  # Returns the class used for extension when defining a model using the {model}
+  # method.
+  def self.default_model_class
+    ActiveType::Object
+  end
+
+  # Returns an instance of the operation model class. The instance is obtained
+  # using {build_model} and cached for the lifespan of the operation instance.
+  def model
+    unless @model
+      build_model
+    end
+
+    return @model
+  end
+
+  # Assigns attributes to a model. If no arguments are given, it extracts the
+  # attributes from the {params} hash and assigns them to the {model}.
+  #
+  # @param attributes [Hash] The attributes hash to assign. If not given,
+  #   attributes will be obtained from the {params} hash using
+  #   {extract_attributes_from_params}.
+  # @param without_protection [Boolean] If `true`, attributes wil be assigned without
+  #   mass assignment protection.
+  # @param model [ActiveRecord::Base] Allows to manually specify a model the attributes
+  #   will be assigned to. If not given, the model will be obtained from the
+  #   {model} method.
+  # @param without_nested_models [Boolean] Per default, attribute params that
+  #   are meant for nested models (registered via `nested_model_op`) will not
+  #   be assigned. You can turn this filtering off by passing `false`.
+  def assign_attributes(attributes = nil, model: nil, without_protection: false, without_nested_models: true)
+    model ||= self.model
+
+    unless attributes
+      # Extract attributes from params hash
+      attributes = extract_attributes_from_params(model)
+    end
+
+    if without_nested_models
+      # Remove parameters that will be passed to nested model operations
+      # such as `post_attributes: {}`.
+      attributes = attributes.except(*self.class.nested_model_param_keys)
+    end
+
+    # Do nothing if there are no attributes to assign
+    return if attributes.nil? || attributes.empty?
+
+    # Assign attributes, either with or without protection
+    if !without_protection && model.respond_to?(:assign_attributes_with_protection)
+      model.assign_attributes_with_protection(attributes)
+    else
+      model.assign_attributes(attributes)
+    end
+  end
+
+  # Extracts model attributes from the {params} hash using
+  # `model.model_name.param_key`. If no model is given, the model will be
+  # obtained from the {model} method.
+  # @param model [ActiveRecord::Base] An optional model for determining the
+  #   param key name
+  def extract_attributes_from_params(model = nil)
+    model ||= self.model
+    return params[model.model_name.param_key] || {}
+  end
+
+  protected
+
+  # Performs nested model operations and then saves the model. If you have
+  # nested model operations, you should call this method instead of calling
+  # `model.save!` directly.
+  def save!
+    perform_nested_model_ops!
+    model.save!
+  end
+
+  # Override of the base classes method to provide the model under key `model`
+  # to operations called via the `after_run` hook. You can still override this
+  # to suit your own operation's needs.
+  def after_run_trigger_params
+    { model: model }
+  end
+
+  # This method must be implemented on superclasses in order to return an
+  # instance of the operation model class. This can be a new or existing record,
+  # depending on the respective operation's needs.
+  def build_model
+    fail NotImplementedError, 'Method `build_model` must be implemented.'
+  end
+end

data/lib/rails_ops/operation/model/create.rb

@@ -0,0 +1,35 @@
+class RailsOps::Operation::Model::Create < RailsOps::Operation::Model
+  model_authorization_action :create
+
+  policy :on_init do
+    model_authorization
+  end
+
+  # As this operation might extend the model class, we need to make sure that
+  # the operation works using an extended 'copy' of the given model class.
+  def self.always_extend_model_class?
+    true
+  end
+
+  def model_authorization
+    return unless authorization_enabled?
+
+    unless model_authorization_action.nil?
+      authorize_model! model_authorization_action, model
+    end
+  end
+
+  def build_model
+    fail 'Model can only be built once.' if @model
+    @model = self.class.model.new
+    if @model.respond_to?(:parent_op=)
+      @model.parent_op = self
+    end
+    build_nested_model_ops :create
+    assign_attributes
+  end
+
+  def perform
+    save!
+  end
+end

data/lib/rails_ops/operation/model/destroy.rb

@@ -0,0 +1,26 @@
+class RailsOps::Operation::Model::Destroy < RailsOps::Operation::Model::Load
+  model_authorization_action :destroy
+
+  def model_authorization
+    return unless authorization_enabled?
+
+    unless load_model_authorization_action.nil?
+      authorize_model_with_authorize_only! load_model_authorization_action, model
+    end
+
+    unless model_authorization_action.nil?
+      authorize_model! model_authorization_action, model
+    end
+  end
+
+  policy do
+    if model.respond_to?(:deleteable?) && !model.deleteable?
+      fail RailsOps::Exceptions::ModelNotDeleteable
+    end
+  end
+
+  def perform
+    trigger :before_destroy, model: model
+    model.destroy!
+  end
+end

data/lib/rails_ops/operation/model/load.rb

@@ -0,0 +1,72 @@
+class RailsOps::Operation::Model::Load < RailsOps::Operation::Model
+  class_attribute :_lock_model_at_build
+  class_attribute :_load_model_authorization_action
+
+  policy :on_init do
+    model_authorization
+  end
+
+  # Gets or sets the action verb used for authorizing models on load.
+  def self.load_model_authorization_action(*action)
+    if action.size == 1
+      self._load_model_authorization_action = action.first
+    elsif action.size > 1
+      fail ArgumentError, 'Too many arguments'
+    end
+
+    return _load_model_authorization_action
+  end
+
+  def model_authorization
+    return unless authorization_enabled?
+
+    unless load_model_authorization_action.nil?
+      authorize_model! load_model_authorization_action, model
+    end
+  end
+
+  def load_model_authorization_action
+    self.class.load_model_authorization_action
+  end
+
+  load_model_authorization_action :read
+
+  def self.lock_model_at_build(enabled = true)
+    self._lock_model_at_build = enabled
+  end
+
+  def self.lock_model_at_build?
+    _lock_model_at_build.nil? ? RailsOps.config.lock_models_at_build? : _lock_model_at_build
+  end
+
+  def model_id_field
+    :id
+  end
+
+  def find_model
+    unless params[model_id_field]
+      fail "Param #{model_id_field.inspect} must be given."
+    end
+
+    # Get model class
+    relation = self.class.model
+
+    # Express intention to lock if required
+    relation = relation.lock if self.class.lock_model_at_build?
+
+    # Fetch (and possibly lock) model
+    return relation.find_by!(model_id_field => params[model_id_field])
+  end
+
+  def build_model
+    @model = find_model
+
+    if @model.respond_to?(:parent_op=)
+      @model.parent_op = self
+    end
+  end
+
+  def extract_id_from_params
+    params[model_id_field]
+  end
+end

data/lib/rails_ops/operation/model/update.rb

@@ -0,0 +1,31 @@
+class RailsOps::Operation::Model::Update < RailsOps::Operation::Model::Load
+  model_authorization_action :update
+
+  # As this operation might extend the model class, we need to make sure that
+  # the operation works using an extended 'copy' of the given model class.
+  def self.always_extend_model_class?
+    true
+  end
+
+  def model_authorization
+    return unless authorization_enabled?
+
+    unless load_model_authorization_action.nil?
+      authorize_model_with_authorize_only! load_model_authorization_action, model
+    end
+
+    unless model_authorization_action.nil?
+      authorize_model! model_authorization_action, model
+    end
+  end
+
+  def build_model
+    super
+    build_nested_model_ops :update
+    assign_attributes
+  end
+
+  def perform
+    save!
+  end
+end

data/lib/rails_ops/patches/active_type_patch.rb

@@ -0,0 +1,52 @@
+# Internal reference: #25564
+module ActiveType
+  class TypeCaster
+    def type_cast_from_user(value)
+      # For some reason, Rails defines additional type casting logic
+      # outside the classes that have that responsibility.
+      case @type
+      when :integer
+        if value == ''
+          nil
+        else
+          native_type_cast_from_user(value)
+        end
+      when :timestamp, :datetime
+        time = native_type_cast_from_user(value)
+        if time && ActiveRecord::Base.time_zone_aware_attributes
+          time = ActiveSupport::TimeWithZone.new(nil, Time.zone, time)
+        end
+        time
+      when Integer.class
+        if value == ''
+          nil
+        else
+          value.to_i
+        end
+      else
+        native_type_cast_from_user(value)
+      end
+    end
+
+    module NativeCasters
+      class DelegateToType
+        def initialize(type, connection)
+          # The specified type (e.g. "string") may not necessary match the
+          # native type ("varchar") expected by the connection adapter.
+          # PostgreSQL is one of these. Perform a translation if the adapter
+          # supports it (but don't turn a mysql boolean into a tinyint).
+          if !type.nil? && !(type == :boolean) && type.respond_to?(:to_sym) && connection.respond_to?(:native_database_types)
+            native_type = connection.native_database_types[type.try(:to_sym)]
+            if native_type && native_type[:name]
+              type = native_type[:name]
+            else
+              # unknown type, we just dont cast
+              type = nil
+            end
+          end
+          @active_record_type = connection.lookup_cast_type(type)
+        end
+      end
+    end
+  end
+end

data/lib/rails_ops/profiler.rb

@@ -0,0 +1,47 @@
+module RailsOps
+  class Profiler
+    def self.profile(object_id, description = nil, &_block)
+      node = tstore_nodes[object_id] = ::RailsOps::Profiler::Node.new(object_id, description, tstore_current_parent)
+      self.tstore_current_parent = node
+      res = yield
+      self.tstore_current_parent = node.parent
+      node.finish_measure
+      res
+    end
+
+    def self.time(descr = nil, &_block)
+      descr += ' - ' if descr
+      start = Time.now
+      res = yield
+      puts "#{descr}#{((Time.now - start).to_f * 1000).round(1)}ms elapsed.".magenta
+      res
+    end
+
+    def self.forget_all
+      Thread.current[:rails_ops_profiler][:nodes] = {}
+    end
+
+    def self.forget(object_id)
+      tstore_nodes.delete(object_id)
+    end
+
+    def self.node(object_id)
+      tstore_nodes[object_id] || fail("Unkown object_id #{object_id}.")
+    end
+
+    def self.tstore_current_parent
+      Thread.current[:rails_ops_profiler] ||= {}
+      Thread.current[:rails_ops_profiler][:current_parent]
+    end
+
+    def self.tstore_current_parent=(parent)
+      Thread.current[:rails_ops_profiler] ||= {}
+      Thread.current[:rails_ops_profiler][:current_parent] = parent
+    end
+
+    def self.tstore_nodes
+      Thread.current[:rails_ops_profiler] ||= {}
+      Thread.current[:rails_ops_profiler][:nodes] ||= {}
+    end
+  end
+end

data/lib/rails_ops/profiler/node.rb

@@ -0,0 +1,64 @@
+module RailsOps
+  class Profiler::Node
+    def initialize(object_id, description = nil, parent = nil)
+      @object_id = object_id
+      @description = description
+      @parent = parent
+      parent&.add_child(self)
+      @children = []
+      @t_start = Time.now
+    end
+
+    attr_reader :parent
+    attr_reader :description
+
+    def finish_measure
+      @t_stop = Time.now
+    end
+
+    def t_self
+      t_total - t_kids
+    end
+
+    def t_kids
+      @children.map(&:t_total).inject(:+) || 0
+    end
+
+    def t_total
+      fail "Measure for object_id #{@object_id} (#{@description}) is not finished." unless @t_stop
+      (@t_stop - @t_start).to_f
+    end
+
+    def t_self_s
+      t_self
+    end
+
+    def t_kids_s
+      t_kids
+    end
+
+    def t_total_s
+      t_total
+    end
+
+    def t_self_ms
+      t_self * 1000
+    end
+
+    def t_kids_ms
+      t_kids * 1000
+    end
+
+    def t_total_ms
+      t_total * 1000
+    end
+
+    def free
+      ::RailsOps::Profiler.forget(@object_id) unless parent
+    end
+
+    def add_child(child)
+      @children << child
+    end
+  end
+end