much-rails 0.0.1 → 0.2.0

data/lib/much-rails/change_action.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "much-rails/action"
+require "much-rails/change_action_result"
+require "much-rails/config"
+require "much-rails/mixin"
+
+module MuchRails; end
+
+module MuchRails::ChangeAction
+  Error = Class.new(StandardError)
+
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Config
+    include MuchRails::Action
+
+    add_config :much_rails_change_action
+
+    on_after_call do
+      if any_unextracted_change_result_validation_errors?
+        raise(
+          MuchRails::Action::ActionError,
+          unhandled_change_result_action_error_message,
+          unhandled_change_result_action_error_backtrace,
+        )
+      end
+    end
+  end
+
+  mixin_class_methods do
+    def change_result(&block)
+      much_rails_change_action_config.change_result_block = block
+    end
+  end
+
+  mixin_instance_methods do
+    def change_result
+      @change_result ||=
+        begin
+          unless (
+            self.class.much_rails_change_action_config.change_result_block
+          )
+            raise(Error, undefined_change_result_block_error_message)
+          end
+
+          MuchRails::ChangeActionResult.new(
+            instance_exec(
+              &self.class.much_rails_change_action_config.change_result_block
+            ),
+          )
+        end
+    end
+
+    # Check the instance variable directly to make sure the main `on_call`
+    # block actually called the `change_result` method and memoized a Result.
+    # If no Result memoized, there are implicitly no unhandled errors.
+    def any_unextracted_change_result_validation_errors?
+      !!@change_result&.any_unextracted_validation_errors?
+    end
+
+    private
+
+    def unhandled_change_result_action_error_message
+      change_result.exception&.message ||
+        "#{change_result.inspect} has validation errors that were not handled "\
+        "by the Action: #{change_result.validation_errors.inspect}."
+    end
+
+    def unhandled_change_result_action_error_backtrace
+      change_result.exception&.backtrace || caller
+    end
+
+    def undefined_change_result_block_error_message
+      raise NotImplementedError
+    end
+  end
+
+  class MuchRailsChangeActionConfig
+    attr_accessor :change_result_block
+  end
+end

data/lib/much-rails/change_action_result.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "much-rails/result"
+
+module MuchRails; end
+
+# MuchRails::ChangeActionResult is a Result object intended to wrap and
+# compose a MuchRails::Result.
+class MuchRails::ChangeActionResult
+  def self.success(**kargs)
+    new(MuchRails::Result.success(**kargs))
+  end
+
+  def self.failure(**kargs)
+    new(MuchRails::Result.failure(**kargs))
+  end
+
+  attr_reader :service_result
+
+  def initialize(save_service_result)
+    unless save_service_result.is_a?(MuchRails::Result)
+      raise(
+        TypeError,
+        "MuchRails::Result expected, got #{save_service_result.class}",
+      )
+    end
+
+    @service_result = save_service_result
+
+    @service_result.validation_errors ||= {}
+  end
+
+  def validation_errors
+    @validation_errors ||=
+      service_result.get_for_all_results(:validation_errors).to_h
+  end
+
+  def validation_error_messages
+    validation_errors.values.flatten.compact
+  end
+
+  def extract_validation_error(field_name)
+    validation_errors.delete(field_name)
+  end
+
+  def any_unextracted_validation_errors?
+    !!(failure? && validation_errors.any?)
+  end
+
+  private
+
+  def method_missing(name, *args, &block)
+    service_result&.__send__(name, *args, &block)
+  end
+
+  def respond_to_missing?(*args)
+    service_result.respond_to?(*args) || super
+  end
+end

data/lib/much-rails/config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+
+module MuchRails; end
+
+# MuchRails::Config is a mix-in to implement object DSL configuration.
+module MuchRails::Config
+  include MuchRails::Mixin
+
+  mixin_class_methods do
+    def add_config(name = nil, method_name: nil)
+      config_method_name, config_class_name, configure_method_name =
+        much_rails_config_names(name, method_name)
+
+      instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{config_method_name}
+          @#{config_method_name} ||= self::#{config_class_name}.new
+        end
+
+        def #{configure_method_name}
+          yield(#{config_method_name}) if block_given?
+        end
+      RUBY
+    end
+
+    def add_instance_config(name = nil, method_name: nil)
+      config_method_name, config_class_name, configure_method_name =
+        much_rails_config_names(name, method_name)
+
+      instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        define_method(:#{config_method_name}) do
+          @#{config_method_name} ||= self.class::#{config_class_name}.new
+        end
+
+        define_method(:#{configure_method_name}) do |&block|
+          block.call(#{config_method_name}) if block
+        end
+      RUBY
+    end
+
+    private
+
+    def much_rails_config_names(name, method_name)
+      name_prefix = name.nil? ? "" : "#{name.to_s.underscore}_"
+      config_method_name = (method_name || "#{name_prefix}config").to_s
+      config_class_name = "#{name_prefix.classify}Config"
+
+      name_suffix = name.nil? ? "" : "_#{name.to_s.underscore}"
+      configure_method_name = "configure#{name_suffix}"
+
+      [config_method_name, config_class_name, configure_method_name]
+    end
+  end
+end

data/lib/much-rails/date.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+module MuchRails::Date
+  InvalidError = Class.new(TypeError)
+
+  # @example
+  #   MuchRails::Date.for(nil) # => nil
+  #   MuchRails::Date.for(" ") # => nil
+  #   MuchRails::Date.for(Time.zone.today) # => Date
+  #   MuchRails::Date.for(Time.current) # => Date
+  #   MuchRails::Date.for(DateTime.current) # => Date
+  #   MuchRails::Date.for("07/04/2020") # => Date
+  #   MuchRails::Date.for("2020.07.04") # => Date
+  #   MuchRails::Date.for("2020-07-04T08:15:00Z") # => Date
+  def self.for(value)
+    return if value.blank?
+
+    if value.respond_to?(:to_date) && !value.is_a?(::String)
+      value.to_date
+    else
+      parse(value)
+    end
+  rescue
+    raise MuchRails::Date::InvalidError, "Invalid Date: #{value.inspect}."
+  end
+
+  def self.parse(value)
+    parse_united_states(value)
+  rescue ArgumentError
+    parse8601(value)
+  end
+
+  def self.parse_united_states(value)
+    formatted_value = value.to_s.gsub(/[^\w\s:]/, "-")
+
+    ::Date.strptime(formatted_value, "%m-%d-%Y")
+  rescue ArgumentError
+    ::Date.strptime(formatted_value, "%Y-%m-%d")
+  end
+
+  def self.parse8601(value)
+    formatted_value = value.to_s.gsub(/[^\w\s:]/, "-")
+
+    ::Date.iso8601(formatted_value)
+  rescue ArgumentError
+    ::Time.iso8601(formatted_value).utc.to_date
+  end
+end

data/lib/much-rails/decimal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-decimal"
+
+module MuchRails
+  Decimal = MuchDecimal
+end

data/lib/much-rails/destroy_action.rb

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

data/lib/much-rails/destroy_service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+require "much-rails/records"
+require "much-rails/records/validate_destroy"
+require "much-rails/result"
+require "much-rails/service"
+
+module MuchRails; end
+
+# MuchRails::DestroyService is a common mix-in for all service objects that
+# destroy records.
+module MuchRails::DestroyService
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Service
+
+    around_call do |receiver|
+      receiver.call
+    rescue *MuchRails::DestroyService::ValidationErrors.exception_classes => ex
+      set_the_return_value_for_the_call_method(
+        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
+end

data/lib/much-rails/has_slug.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "much-slug"
+
+module MuchRails
+  HasSlug = MuchSlug
+end

data/lib/much-rails/input_value.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+# MuchRails::InputValue is a utility module for dealing with input field values.
+module MuchRails::InputValue
+  def self.strip(value)
+    return if value.blank?
+
+    value.to_s.strip
+  end
+
+  def self.strip_all(values)
+    Array
+      .wrap(values)
+      .map{ |value| strip(value) }
+      .compact
+  end
+end

data/lib/much-rails/json.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "oj"
+
+module MuchRails; end
+
+# MuchRails::JSON is an adapter for encoding and decoding JSON values.
+# It uses Oj to do the work: https://github.com/ohler55/oj#-gem
+module MuchRails::JSON
+  InvalidError = Class.new(TypeError)
+
+  def self.default_mode
+    :strict
+  end
+
+  def self.encode(obj, **options)
+    options[:mode] ||= default_mode
+    ::Oj.dump(obj, options)
+  end
+
+  def self.decode(json, **options)
+    options[:mode] ||= default_mode
+    ::Oj.load(json, options)
+  rescue ::Oj::ParseError => ex
+    error = InvalidError.new("Oj::ParseError: #{ex.message}")
+    error.set_backtrace(ex.backtrace)
+    raise error
+  end
+end

data/lib/much-rails/layout.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "much-rails/layout/helper"
+require "much-rails/mixin"
+require "much-rails/view_models/breadcrumb"
+
+module MuchRails; end
+
+# MuchRails::Layout is a mix-in for view models that represent HTML rendered
+# in a layout. It adds a DSL for accumulating page titles, stylesheets and
+# javascripts.
+module MuchRails::Layout
+  include MuchRails::Mixin
+
+  mixin_class_methods do
+    def page_title(&block)
+      page_titles << block
+    end
+
+    def page_titles
+      @page_titles ||= []
+    end
+
+    def application_page_title(&block)
+      @application_page_title = block if block
+      @application_page_title
+    end
+
+    def breadcrumb(&block)
+      breadcrumbs << block
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||= []
+    end
+
+    def stylesheet(value = nil, &block)
+      stylesheets << (block || ->{ value })
+    end
+
+    def stylesheets
+      @stylesheets ||= []
+    end
+
+    def javascript(value = nil, &block)
+      javascripts << (block || ->{ value })
+    end
+
+    def javascripts
+      @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
+
+    def layouts
+      @layouts ||= []
+    end
+  end
+
+  mixin_instance_methods do
+    def page_title
+      @page_title ||= instance_eval(&(self.class.page_titles.last || ->(_){}))
+    end
+
+    def application_page_title
+      @application_page_title ||=
+        instance_eval(&(self.class.application_page_title || ->(_){}))
+    end
+
+    def full_page_title
+      @full_page_title ||=
+        [
+          self
+            .class
+            .page_titles
+            .reverse
+            .map!{ |segment| instance_eval(&segment) }
+            .join(MuchRails.config.layout.full_page_title_segment_separator),
+          application_page_title,
+        ]
+          .map(&:presence)
+          .compact
+          .join(MuchRails.config.layout.full_page_title_application_separator)
+          .presence
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||=
+        self
+          .class
+          .breadcrumbs
+          .map do |block|
+            MuchRails::ViewModels::Breadcrumb.new(*instance_eval(&block))
+          end
+    end
+
+    def stylesheets
+      @stylesheets ||= self.class.stylesheets.map(&:call)
+    end
+
+    def javascripts
+      @javascripts ||= self.class.javascripts.map(&:call)
+    end
+
+    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