much-rails 0.1.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08eb433f0b2e7fa04acaa6aec285a57d6c2988dc34067cb0ef401992a02125c4'
-  data.tar.gz: dc1a2ddf9997e2aa2577a1100efedb52e4a3d89b2abc5ee6a8150626a5b42129
+  metadata.gz: f4834b7655c265c28bb9f46729491681daa8003dd99615c2074f27a010f22e10
+  data.tar.gz: 70603cc1bd5717a2edf35ff23cf2fa50ae35dc494431e2fbc476388af8c3d6a1
 SHA512:
-  metadata.gz: d5178f432b4f6fd2712036e951742301b52565161e4d1387915315ea5a661beaa5b8d11935ae8eb7f761c76430f7afd1ba2243a0178d5fa7f155ac5a0751a934
-  data.tar.gz: 7aa259619b17110e7ce6ec81defa760b2ae6494b2e4e1eb6677f9ba003d4ad4312f046ff806680c8bbed11b2af92a09d86640cec904be20627fec52870a2ae3b
+  metadata.gz: d3e614697001a8f9dd5d09a78dcfa3c5e4f6fb458406a7af6c018d7a829687b74c1a98c673ef3e62ec8f7a28f85e4a59f4b3bd7c01ccb95b4ff0d661f569cb61
+  data.tar.gz: dcd670e7ca04b1394a92a8a9a7a55b31fd825f5f99bf0282a18d4907e7f614536f30195756ceda6b4320a2fec0d073caf96ab5b74aa57428e4331a1c73381cd7

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/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/layout.rb

@@ -50,6 +50,14 @@ module MuchRails::Layout
       @javascripts ||= []
     end
 
+    def head_link(url, **attributes)
+      head_links << HeadLink.new(url, **attributes)
+    end
+
+    def head_links
+      @head_links ||= []
+    end
+
     def layout(value)
       layouts << value
     end
@@ -104,12 +112,31 @@ module MuchRails::Layout
       @javascripts ||= self.class.javascripts.map(&:call)
     end
 
-    def any_breadcrumbs?
-      breadcrumbs.any?
+    def head_links
+      @head_links ||= self.class.head_links
     end
 
     def layouts
       self.class.layouts
     end
+
+    def any_breadcrumbs?
+      breadcrumbs.any?
+    end
+  end
+
+  class HeadLink
+    attr_reader :href, :attributes
+
+    def initialize(href, **attributes)
+      @href = href
+      @attributes = attributes
+    end
+
+    def ==(other)
+      super unless other.is_a?(self.class)
+
+      href == other.href && attributes == other.attributes
+    end
   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

data/lib/much-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MuchRails
-  VERSION = "0.1.2"
+  VERSION = "0.2.3"
 end

data/much-rails.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("activerecord",   ["> 5.0", "< 7.0"])
   gem.add_dependency("activesupport",  ["> 5.0", "< 7.0"])
-  gem.add_dependency("dassets",        ["~> 0.15.1"])
+  gem.add_dependency("dassets",        ["~> 0.15.2"])
   gem.add_dependency("dassets-erubi",  ["~> 0.1.1"])
   gem.add_dependency("dassets-sass",   ["~> 0.5.1"])
   gem.add_dependency("much-boolean",   ["~> 0.2.1"])

data/test/unit/abstract_class_tests.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/abstract_class"
+
+module MuchRails::AbstractClassTest
+  class UnitTests < Assert::Context
+    desc "MuchRails::AbstractClass"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::AbstractClass }
+
+    should "include MuchRails::Mixin" do
+      assert_that(subject).includes(MuchRails::Mixin)
+    end
+  end
+
+  class ReceiverTests < UnitTests
+    desc "receiver"
+    subject{ receiver_class }
+
+    let(:receiver_class) do
+      Class.new.tap{ |c| c.include unit_class }
+    end
+    let(:receiver_subclass) do
+      Class.new(receiver_class)
+    end
+
+    should have_accessor :abstract_class
+    should have_imeths :new, :abstract_class?
+
+    should "know if it is an abstract class or not" do
+      assert_that(subject.abstract_class?).equals(true)
+      assert_that(receiver_subclass.abstract_class?).equals(false)
+    end
+
+    should "prevent calling .new on the receiver" do
+      assert_that{ subject.new }.raises(NotImplementedError)
+    end
+
+    should "allow calling .new on subclasses of the receiver" do
+      assert_that(receiver_subclass.new).is_a?(subject)
+    end
+  end
+end