much-rails 0.0.1 → 0.2.0

data/lib/much-rails/layout/helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+module MuchRails::Layout; end
+
+module MuchRails::Layout::Helper
+  # This is used to render layouts. It is designed to be used in
+  # the Rails layout template to render the nested layouts.
+  def much_rails_render_layouts(view_model, &content)
+    unless view_model.is_a?(MuchRails::Layout)
+      raise(
+        TypeError,
+        "A View Model that mixes in MuchRails::Layout expected; "\
+        "got #{view_model.class}.",
+      )
+    end
+    view_model
+      .layouts
+      .reverse
+      .reduce(content){ |render_proc, template_path|
+        ->{ render(File.join("layouts", template_path), &render_proc) }
+      }
+      .call
+  end
+end

data/lib/much-rails/mixin.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-mixin"
+
+module MuchRails
+  Mixin = MuchMixin
+end

data/lib/much-rails/not_given.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-not-given"
+
+module MuchRails
+  NotGiven = MuchNotGiven
+end

data/lib/much-rails/rails_routes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module MuchRails; end
+
+# MuchRails::RailsRoutes is a Singleton object that provides Rails' URL helpers
+# and path/URL generation.
+class MuchRails::RailsRoutes
+  include Singleton
+  include ::Rails.application.routes.url_helpers
+
+  # These methods support stubbing #method_missing in tests but have no real
+  # effect or behavior.
+
+  def method_missing(name, *args, &block)
+    super
+  end
+
+  def respond_to_missing?(*args)
+    super
+  end
+
+  private
+
+  def default_url_options
+    ::Rails.application.config.action_mailer.default_url_options
+  end
+end

data/lib/much-rails/railtie.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+class MuchRails::Railtie < Rails::Railtie
+  config.action_mailer.default_url_options ||= {}
+
+  initializer "much-rails-gem" do |app|
+    require "much-rails/rails_routes"
+
+    # Helpers
+    ActionView::Base.include(MuchRails::Layout::Helper)
+
+    require "much-rails/assets"
+    MuchRails::Assets.configure_for_rails(::Rails)
+    app.middleware.use MuchRails::Assets::Server
+
+    # See https://github.com/ohler55/oj/blob/master/pages/Rails.md.
+    Oj.optimize_rails
+
+    MuchResult.default_transaction_receiver = ActiveRecord::Base
+
+    MuchRails.configure do |config|
+      # This should be `true` in development so things fail fast and give the
+      # developers rich error information for debugging purposes.
+      #
+      # This should be `false` in all other envs so proper HTTP response
+      # statuses are returned.
+      config.action.raise_response_exceptions = Rails.env.development?
+
+      config.save_service_validation_error_exception_classes = [
+        ActiveRecord::RecordInvalid,
+      ]
+      config.destroy_service_validation_error_exception_classes = [
+        MuchRails::Records::DestructionInvalid,
+      ]
+    end
+  end
+end

data/lib/much-rails/records.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "much-rails/records/always_destroyable"
+require "much-rails/records/not_destroyable"
+require "much-rails/records/validate_destroy"

data/lib/much-rails/records/always_destroyable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+require "much-rails/records/validate_destroy"
+
+module MuchRails; end
+module MuchRails::Records; end
+
+# MuchRails::Records::AlwaysDestroyable is a mix-in to always enable destroying
+# a record. It mixes-in MuchRails::Records::ValidateDestroy and hard-codes
+# never adding destruction error messages.
+module MuchRails::Records::AlwaysDestroyable
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Records::ValidateDestroy
+  end
+
+  mixin_instance_methods do
+    def destruction_error_messages
+      []
+    end
+
+    private
+
+    def validate_destroy
+      # Do nothing on purpose.
+    end
+  end
+end

data/lib/much-rails/records/not_destroyable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+require "much-rails/records/validate_destroy"
+
+module MuchRails; end
+module MuchRails::Records; end
+
+# MuchRails::Records::NotDestroyable is a mix-in to disable destroying a
+# record. It mixes-in MuchRails::Records::ValidateDestroy and hard-codes
+# a permanent destruction error message.
+module MuchRails::Records::NotDestroyable
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Records::ValidateDestroy
+  end
+
+  mixin_instance_methods do
+    def destruction_error_messages
+      ["#{self.class.name} records can't be deleted."]
+    end
+
+    private
+
+    def validate_destroy
+      # Do nothing on purpose.
+    end
+  end
+end

data/lib/much-rails/records/validate_destroy.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_model/error"
+require "much-rails/mixin"
+
+module MuchRails; end
+module MuchRails::Records; end
+
+# MuchRails::Records::ValidateDestroy is used to mix in custom validation
+# logic and handling in destroying records.
+#
+# Include this module and define the #validate_destroy private method. Any
+# calls to #destroy or #destroy! will first check if the record is
+# #destroyable?. This check runs the custom #validate_destroy logic. If the
+# record is not destroyable, the #validate_destroy method should add
+# #destruction_error_messages.
+module MuchRails::Records::ValidateDestroy
+  include MuchRails::Mixin
+
+  mixin_instance_methods do
+    def destruction_error_messages
+      @destruction_error_messages ||= []
+    end
+
+    def destroy(validate: true)
+      return false if validate && !destroyable?
+
+      super()
+    end
+
+    def destroy_without_validation
+      destroy(validate: false)
+    end
+
+    def destroy!(as: :base, validate: true)
+      if validate && !destroyable?
+        raise MuchRails::Records::DestructionInvalid.new(self, field_name: as)
+      end
+
+      # `_raise_record_not_destroyed` is from ActiveRecord. This logic was
+      # copied from Rails `destroy!` implementation.
+      destroy(validate: validate) || _raise_record_not_destroyed
+    end
+
+    def destroy_without_validation!(as: :base)
+      destroy!(as: as, validate: false)
+    end
+
+    def destroyable?
+      destruction_error_messages.clear
+      validate_destroy
+      destruction_error_messages.none?
+    end
+
+    def not_destroyable?
+      !destroyable?
+    end
+
+    private
+
+    def validate_destroy
+      raise NotImplementedError
+    end
+  end
+end
+
+class MuchRails::Records::DestructionInvalid < StandardError
+  attr_reader :record, :errors, :error_full_messages
+
+  def initialize(record = nil, field_name: :base)
+    super(record&.destruction_error_messages.to_a.join("\n"))
+
+    @record = record
+
+    messages = record&.destruction_error_messages.to_a
+    @errors =
+      if messages.any?
+        { field_name.to_sym => messages }
+      else
+        {}
+      end
+
+    @error_full_messages =
+      if field_name == :base
+        messages
+      else
+        messages.map do |m|
+          ActiveModel::Error.new(@record, field_name, m).full_message
+        end
+      end
+  end
+end

data/lib/much-rails/result.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-result"
+
+module MuchRails
+  Result = MuchResult
+end

data/lib/much-rails/save_action.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+require "much-rails/change_action"
+
+module MuchRails; end
+
+module MuchRails::SaveAction
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::ChangeAction
+  end
+
+  mixin_class_methods do
+    def save_result(&block)
+      change_result(&block)
+    end
+  end
+
+  mixin_instance_methods do
+    def save_result
+      change_result
+    end
+
+    private
+
+    def undefined_change_result_block_error_message
+      "A `save_result` block must be defined."
+    end
+  end
+end

data/lib/much-rails/save_service.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "much-rails/mixin"
+require "much-rails/result"
+require "much-rails/service"
+require "much-rails/service_validation_errors"
+
+module MuchRails; end
+
+# MuchRails::SaveService is a common mix-in for all service objects that
+# save (e.g. create/update) records.
+module MuchRails::SaveService
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Service
+
+    around_call do |receiver|
+      receiver.call
+    rescue *MuchRails::SaveService::ValidationErrors.exception_classes => ex
+      set_the_return_value_for_the_call_method(
+        MuchRails::SaveService::ValidationErrors.result_for(ex),
+      )
+    end
+  end
+
+  module ValidationErrors
+    def self.add(exception_class, &block)
+      service_validation_errors.add(exception_class, &block)
+    end
+
+    def self.exception_classes
+      service_validation_errors.exception_classes
+    end
+
+    def self.result_for(ex)
+      service_validation_errors.result_for(ex)
+    end
+
+    def self.service_validation_errors
+      @service_validation_errors ||=
+        MuchRails::ServiceValidationErrors
+          .new
+          .tap do |e|
+            e.add(ActiveRecord::RecordInvalid) do |ex|
+              MuchRails::SaveService::FailureResult.new(
+                record: ex.record,
+                exception: ex,
+                validation_errors: ex.record&.errors.to_h,
+                validation_error_messages:
+                  ex.record&.errors&.full_messages.to_a,
+              )
+            end
+          end
+    end
+  end
+
+  module FailureResult
+    def self.new(exception:, validation_errors:, **kargs)
+      MuchResult.failure(
+        exception: exception,
+        validation_errors: validation_errors,
+        **kargs,
+      )
+    end
+  end
+end

data/lib/much-rails/service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "much-rails/call_method_callbacks"
+require "much-rails/mixin"
+require "much-rails/wrap_and_call_method"
+
+module MuchRails; end
+
+# MuchRails::Service is a common mix-in for service objects. It supports
+# the single `.call` method API with before/after callback support.
+module MuchRails::Service
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::CallMethodCallbacks
+    include MuchRails::WrapAndCallMethod
+  end
+end

data/lib/much-rails/service_validation_errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+class MuchRails::ServiceValidationErrors
+  attr_reader :hash
+
+  def initialize
+    @hash = {}
+  end
+
+  def add(exception_class, &block)
+    unless exception_class < Exception
+      raise(ArgumentError, "#{exception_class} is not an Exception")
+    end
+
+    @hash[exception_class] = block
+  end
+
+  def exception_classes
+    @hash.keys
+  end
+
+  def result_for(ex)
+    result_proc = nil
+    exception_class = ex.class
+    loop do
+      result_proc = @hash[exception_class]
+      break unless result_proc.nil?
+
+      exception_class =
+        if exception_class.superclass.nil?
+          raise ArgumentError, "#{ex.class} hasn't been configured"
+        else
+          exception_class.superclass
+        end
+    end
+
+    result_proc.call(ex)
+  end
+end