much-rails 0.1.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e37cec5104bf60569eb8a0310184ed80c9083fa3fa0f68fcd02d0ee1a25aee92
-  data.tar.gz: e2cffa2635a4fe025913d78ce78f81dcaba12b232129969ed0a3646a6d8c9928
+  metadata.gz: 8b0abf64ca287edfd1a6546db5766e878424a9165a661ef991ca7fda1dba6f78
+  data.tar.gz: 3aa006e90bb01924786952077cb5a72c595bb1c0fa28e4f32f3701063fc2ac06
 SHA512:
-  metadata.gz: cfd22f4cdd2dd60540e417606990bdcd13ac92cb1e83d6175462ac37aa066de6c478c0c06dcb27af6112ec35eb0fcd1c0828375cdbbc9e8e60e6f1d4a2249cce
-  data.tar.gz: e7c12b68abe00c404d4ab361ea1a5f49150a8877bf30619b7f01b478190cd14a027f3fec543c0d604339993a5803d9340251d53989d780d692015960e40cb075
+  metadata.gz: 92884c3070b8cbaf78ff384b7ea4bc12476ee175a56e73b4ea58431f84c3539c1d27d97e180b9ddcfbc16ba908127a6783c72f3716890ac5e879773dde7ff4e1
+  data.tar.gz: '0755183185e5f64a4c0e289e31d6bf0545438c96631847f306f83c0aa588308d215583ab2249e856c35592162438dc8cc4315ac959bb478a14baa9aa5c08584f'

data/lib/much-rails.rb

@@ -4,6 +4,7 @@ require "active_support"
 require "active_support/core_ext"
 
 require "much-rails/version"
+require "much-rails/abstract_class"
 require "much-rails/action"
 require "much-rails/boolean"
 require "much-rails/call_method"
@@ -46,6 +47,14 @@ module MuchRails
     add_instance_config :action, method_name: :action
     add_instance_config :layout, method_name: :layout
 
+    def add_save_service_validation_error(exception_class, &block)
+      MuchRails::SaveService::ValidationErrors.add(exception_class, &block)
+    end
+
+    def add_destroy_service_validation_error(exception_class, &block)
+      MuchRails::DestroyService::ValidationErrors.add(exception_class, &block)
+    end
+
     class ActionConfig
       attr_accessor :namespace
       attr_accessor :sanitized_exception_classes

data/lib/much-rails/abstract_class.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+
+# MuchRails::AbstractClass overrides the `new` class method to prevent a class
+# from being instantiated directly.
+module MuchRails::AbstractClass
+  include MuchRails::Mixin
+
+  after_mixin_included do
+    self.abstract_class = self
+
+    define_singleton_method(:new) do |*args, &block|
+      if abstract_class?
+        raise(
+          NotImplementedError,
+          "#{self} is an abstract class and cannot be instantiated.",
+        )
+      end
+
+      super(*args, &block)
+    end
+  end
+
+  mixin_class_methods do
+    def abstract_class
+      @abstract_class
+    end
+
+    def abstract_class=(value)
+      @abstract_class = value
+    end
+
+    def abstract_class?
+      !!(abstract_class == self)
+    end
+  end
+end

data/lib/much-rails/action/base_router.rb

@@ -70,8 +70,8 @@ class MuchRails::Action::BaseRouter
   #       url :users, "/users", "Users::Index"
   #     }
   #   AdminRouter.path_for(:users) # => "/admin/users"
-  def path_for(name, *args)
-    @url_set.path_for(name, *args)
+  def path_for(name, **kargs)
+    @url_set.path_for(name, **kargs)
   end
 
   # Example:
@@ -87,8 +87,8 @@ class MuchRails::Action::BaseRouter
   #       url :users, "/users", "Users::Index"
   #     }
   #   AdminRouter.url_for(:users) # => "http://example.org/admin/users"
-  def url_for(name, *args)
-    @url_set.url_for(name, *args)
+  def url_for(name, **kargs)
+    @url_set.url_for(name, **kargs)
   end
 
   # Example:
@@ -350,12 +350,12 @@ class MuchRails::Action::BaseRouter
       end
     end
 
-    def path_for(name, *args)
-      fetch(name).path_for(*args)
+    def path_for(name, **kargs)
+      fetch(name).path_for(**kargs)
     end
 
-    def url_for(name, *args)
-      fetch(name).url_for(*args)
+    def url_for(name, **kargs)
+      fetch(name).url_for(**kargs)
     end
   end
 
@@ -396,11 +396,11 @@ class MuchRails::Action::BaseRouter
       self.class.url_path(@router, @url_path)
     end
 
-    def path_for(*args)
+    def path_for(**kargs)
       raise NotImplementedError
     end
 
-    def url_for(*args)
+    def url_for(**kargs)
       raise NotImplementedError
     end
 

data/lib/much-rails/action/router.rb

@@ -90,12 +90,18 @@ class MuchRails::Action::Router < MuchRails::Action::BaseRouter
   alias_method :draw, :apply_to
 
   class URL < MuchRails::Action::BaseRouter::BaseURL
-    def path_for(*args)
-      MuchRails::RailsRoutes.instance.public_send("#{name}_path", *args)
+    def path_for(**kargs)
+      MuchRails::RailsRoutes.instance.public_send(
+        "#{name}_path",
+        **kargs.symbolize_keys,
+      )
     end
 
-    def url_for(*args)
-      MuchRails::RailsRoutes.instance.public_send("#{name}_url", *args)
+    def url_for(**kargs)
+      MuchRails::RailsRoutes.instance.public_send(
+        "#{name}_url",
+        **kargs.symbolize_keys,
+      )
     end
   end
 end

data/lib/much-rails/assets.rb

@@ -12,20 +12,16 @@ end
 module MuchRails::Assets
   def self.configure_for_rails(rails)
     MuchRails::Assets.configure do |config|
-      # Cache fingerprints in memory for performance gains.
-      config.fingerprint_cache MuchRails::Assets::MemCache.new
-
-      # Cache compiled content in memory in development/test for performance
-      # gains since we aren't caching to the file system. Otherwise, don't
-      # cache in memory as we are caching to the file system and won't benefit
-      # from the in memory cache.
-      much_rails_content_cache =
-        if rails.env.development? || rails.env.test?
-          MuchRails::Assets::MemCache.new
-        else
-          MuchRails::Assets::NoCache.new
-        end
-      config.content_cache much_rails_content_cache
+      # Cache fingerprints/content in memory in non-development for performance
+      # gains. Don't cache in memory in developlemnt so changes are reflected
+      # without restarting the server.
+      if !rails.env.development?
+        config.fingerprint_cache MuchRails::Assets::MemCache.new
+        config.content_cache MuchRails::Assets::MemCache.new
+      else
+        config.fingerprint_cache MuchRails::Assets::NoCache.new
+        config.content_cache MuchRails::Assets::NoCache.new
+      end
 
       # Cache out compiled file content to the public folder in non
       # development/test environments.
@@ -33,21 +29,40 @@ module MuchRails::Assets
         config.file_store rails.root.join("public")
       end
 
-      # Look for asset files in the app/assets folder. Support ERB processing
-      # on all .js and .scss files. Support compilation of .scss files.
-      config.source rails.root.join("app", "assets") do |s|
+      # Look for asset files in the app/assets/css folder. Support ERB
+      # on all .scss files. Support compilation of .scss files.
+      config.source rails.root.join("app", "assets", "css") do |s|
+        s.base_path "css"
+
         # Reject SCSS partials
         s.filter do |paths|
           paths.reject{ |p| File.basename(p) =~ /^_.*\.scss$/ }
         end
 
-        s.engine "js",   MuchRails::Assets::Erubi::Engine
         s.engine "scss", MuchRails::Assets::Erubi::Engine
         s.engine "scss", MuchRails::Assets::Sass::Engine, {
           syntax: "scss",
           output_style: "compressed",
         }
       end
+
+      # Look for asset files in the app/assets/img folder.
+      config.source rails.root.join("app", "assets", "img") do |s|
+        s.base_path "img"
+      end
+
+      # Look for asset files in the app/assets/js folder. Support ERB
+      # on all .js files.
+      config.source rails.root.join("app", "assets", "js") do |s|
+        s.base_path "js"
+
+        s.engine "js", MuchRails::Assets::Erubi::Engine
+      end
+
+      # Look for asset files in the app/assets/vendor folder
+      config.source rails.root.join("app", "assets", "vendor") do |s|
+        s.base_path "vendor"
+      end
     end
     MuchRails::Assets.init
   end

data/lib/much-rails/destroy_service.rb

@@ -18,12 +18,49 @@ module MuchRails::DestroyService
 
     around_call do |receiver|
       receiver.call
-    rescue MuchRails::Records::ValidateDestroy::DestructionInvalid => ex
+    rescue *MuchRails::DestroyService::ValidationErrors.exception_classes => ex
       set_the_return_value_for_the_call_method(
-        MuchRails::Result.failure(
-          exception: ex,
-          validation_errors: ex&.destruction_errors.to_h,
-        ),
+        MuchRails::DestroyService::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(MuchRails::Records::DestructionInvalid) do |ex|
+              MuchRails::DestroyService::FailureResult.new(
+                record: ex.record,
+                exception: ex,
+                validation_errors: ex.errors.to_h,
+                validation_error_messages: ex.error_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

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_model/error"
 require "much-rails/mixin"
 
 module MuchRails; end
@@ -33,7 +34,7 @@ module MuchRails::Records::ValidateDestroy
 
     def destroy!(as: :base, validate: true)
       if validate && !destroyable?
-        raise DestructionInvalid.new(self, field_name: as)
+        raise MuchRails::Records::DestructionInvalid.new(self, field_name: as)
       end
 
       # `_raise_record_not_destroyed` is from ActiveRecord. This logic was
@@ -61,22 +62,31 @@ module MuchRails::Records::ValidateDestroy
       raise NotImplementedError
     end
   end
+end
+
+class MuchRails::Records::DestructionInvalid < StandardError
+  attr_reader :record, :errors, :error_full_messages
 
-  class DestructionInvalid < StandardError
-    attr_reader :record, :destruction_errors
+  def initialize(record = nil, field_name: :base)
+    super(record&.destruction_error_messages.to_a.join("\n"))
 
-    def initialize(record = nil, field_name: :base)
-      super(record&.destruction_error_messages.to_a.join("\n"))
+    @record = record
 
-      @record = record
+    messages = record&.destruction_error_messages.to_a
+    @errors =
+      if messages.any?
+        { field_name.to_sym => messages }
+      else
+        {}
+      end
 
-      messages = record&.destruction_error_messages.to_a
-      @destruction_errors =
-        if messages.any?
-          { field_name.to_sym => messages }
-        else
-          {}
+    @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
 end

data/lib/much-rails/save_service.rb

@@ -4,6 +4,7 @@ require "active_record"
 require "much-rails/mixin"
 require "much-rails/result"
 require "much-rails/service"
+require "much-rails/service_validation_errors"
 
 module MuchRails; end
 
@@ -17,14 +18,50 @@ module MuchRails::SaveService
 
     around_call do |receiver|
       receiver.call
-    rescue ActiveRecord::RecordInvalid => ex
+    rescue *MuchRails::SaveService::ValidationErrors.exception_classes => ex
       set_the_return_value_for_the_call_method(
-        MuchRails::Result.failure(
-          record: ex.record,
-          exception: ex,
-          validation_errors: ex.record&.errors.to_h,
-          validation_error_messages: ex.record&.errors&.full_messages.to_a,
-        ),
+        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

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_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