hola_dmleobit 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bacab45470fdf4298f45f3398971182ff8a3dc415bbda98e9e7132c44e18f09c
-  data.tar.gz: 82e3fdd78814fb17045ff2a83e9274ddab88bc7c56ba90592ff2342b2d91fec8
+  metadata.gz: b1eb7847183ec4abaa2225794008dd89c712a50d1f12c81fce975f68c481060a
+  data.tar.gz: ed59804cb8dd17c36044cf9e4a958daee9f0e713d49497190dbfa6a276dbe3bd
 SHA512:
-  metadata.gz: abd873b2c39063346d482a5a641bfdcb99788463f32864e461bee9d2a12833f62e3e24e2bd0c05fc26a941be5bfedf3852017704f9c29bb68589b3e07e22f88d
-  data.tar.gz: 9ed1436c5a992ebf296c81ff0d646bff8280ae78cfba052fa012a6ff5db173b41501a89b57c1343a92491483ccf17bb7a6dfb53989b83401a83e1bba01c4d009
+  metadata.gz: f616f4a105afdcae870aab97cca71f7caec6327b200a0c6f66ce381047c3a2597fb9f9a6fff0b649c2da87684a425a45348ac3ad1c274ad21282409f8b8d9364
+  data.tar.gz: c40eb1baa298de4b3cbfda9db63145b70de6908fc1a69ac1291e1b0dbe1491406251a5ba2a0f3c0e1c20c027375901486a98f2b208ca0f3da78c4e279e73ca88

data/lib/findable/definition.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'findable/finder'
+
+
+module Findable
+  class Definition
+    ONLY_KEYWORD   = 'only'
+    EXCEPT_KEYWORD = 'except'
+
+    attr_reader :resource_name, :params
+
+    def initialize(controller:, resource_name:, **params)
+      @controller    = controller
+      @resource_name = resource_name
+      @params        = params
+      @only          = params.delete(:only)
+      @except        = params.delete(:except)
+    end
+
+    def call
+      this = self
+
+      controller.define_method(finder_name) do
+        resource = ::Findable::Finder.new(controller: self,
+                                          resource_name: this.resource_name,
+                                          **this.params).call
+        instance_variable_set("@#{this.resource_name}", resource)
+      end
+
+      controller.before_action(finder_name, action_params)
+    end
+
+    private
+
+    attr_reader :controller, :only, :except
+
+    def finder_name
+      @finder_name ||=
+        "find_#{resource_name}#{only_suffix}#{except_suffix}!".to_sym
+    end
+
+    def only_suffix
+      return if only.blank?
+
+      "_#{ONLY_KEYWORD}_#{Array(only).join('_')}"
+    end
+
+    def except_suffix
+      return if except.blank?
+
+      "_#{EXCEPT_KEYWORD}_#{Array(except).join('_')}"
+    end
+
+    def action_params
+      { only: only, except: except }.compact
+    end
+  end
+end

data/lib/findable/find.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'findable/strategies/friendly_id'
+
+module Findable
+  class Find
+    include Strategies::FriendlyId
+
+    def initialize(resource_class:, **params)
+      @resource_class = resource_class
+      @value          = params[:value]
+      @attribute      = params.fetch(:attribute, :id)
+      @strict         = params.fetch(:strict, true)
+      @eager_load     = params[:eager_load]
+      @preload        = params[:preload]
+      @joins          = params[:joins]
+      @friendly       = params[:friendly]
+    end
+
+    def call
+      constantize_resource_class!
+      verify_strategies!
+      find_resource!
+    end
+
+    private
+
+    attr_reader :resource_class, :value, :attribute, :strict,
+                :eager_load, :preload, :joins, :friendly,
+                :constantized_resource_class
+
+    def constantize_resource_class!
+      @constantized_resource_class = resource_class.to_s.constantize
+    rescue NameError
+      raise NameError, invalid_resource_class_message
+    end
+
+    def invalid_resource_class_message
+      "You haven't defined such resource class: `#{resource_class}`."
+    end
+
+    def verify_strategies!
+      verify_friendly_id_strategy!
+    end
+
+    def find_resource!
+      constantized_resource_class
+        .eager_load(eager_load)
+        .preload(preload)
+        .joins(joins)
+        .yield_self(&method(:apply_search_strategy!))
+    end
+
+    def apply_search_strategy!(scope)
+      return apply_friendly_id_strategy!(scope) if friendly
+
+      constantized_resource_class.send(finder_method, attribute => value)
+    end
+
+    def finder_method
+      strict ? :find_by! : :find_by
+    end
+  end
+end

data/lib/findable/finder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'findable/find'
+
+module Findable
+  class Finder
+
+    def initialize(controller:, resource_name:, **params)
+      @controller = controller
+      @resource_name = resource_name
+      @resource_class = params.fetch(:class) { default_resource_class }
+      @by = params.fetch(:by, :id)
+      @attribute = params.fetch(:attribute, :id)
+      @strict = params.fetch(:strict, true)
+      @decorate = params.fetch(:decorate, false)
+      @friendly = params[:friendly]
+      @fallback_parameter = params[:fallback]
+      @fallback_value_parameter = params[:fallback_value]
+      @options = params
+    end
+
+    def call
+      return fallback(fallback_parameter) unless resource
+
+      decorate? ? resource.decorate : resource
+    end
+
+    private
+
+    attr_reader :controller, :resource_name, :resource_class,
+                :by, :attribute, :strict, :fallback_parameter,
+                :fallback_value_parameter, :options, :decorate,
+                :friendly
+    alias_method :decorate?, :decorate
+
+    def eager_load
+      @eager_load ||= options[:eager_load]
+    end
+
+    def preload
+      @preload ||= options[:preload]
+    end
+
+    def joins
+      @joins ||= options[:joins]
+    end
+
+    def default_resource_class
+      resource_name.to_s.camelcase
+    end
+
+    def resource
+      ::Findable::Find.new(
+        resource_class: resource_class,
+        value: value,
+        attribute: attribute,
+        strict: strict?,
+        eager_load: eager_load,
+        preload: preload,
+        joins: joins,
+        friendly: friendly
+      ).call
+    end
+
+    def value
+      controller.params.dig(*by) || fallback(fallback_value_parameter)
+    end
+
+    def fallback(parameter)
+      case parameter
+      when Symbol then controller.send(parameter)
+      when Proc   then controller.instance_exec(&parameter)
+      else             parameter
+      end
+    end
+
+    def strict?
+      fallback_parameter.blank? && strict.present?
+    end
+  end
+end

data/lib/findable/strategies/friendly_id.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Findable
+  module Strategies
+    module FriendlyId
+      protected
+
+      def strict
+        raise "##{__method__} should be defined!"
+      end
+
+      def value
+        raise "##{__method__} should be defined!"
+      end
+
+      def friendly
+        raise "##{__method__} should be defined!"
+      end
+
+      def constantized_resource_class
+        raise "##{__method__} should be defined!"
+      end
+
+      def verify_friendly_id_strategy!
+        return unless friendly
+        return no_friendly_id_gem! unless defined?(::FriendlyId)
+
+        no_friendly_id_model! unless friendly_id_model?
+      end
+
+      def apply_friendly_id_strategy!(scope)
+        scope.friendly.find(value)
+      rescue ActiveRecord::RecordNotFound => e
+        raise e if strict
+
+        nil
+      end
+
+      private
+
+      def no_friendly_id_gem!
+        raise 'Add FriendlyId gem to your bundle to use `friendly` option!'
+      end
+
+      def friendly_id_model?
+        constantized_resource_class.method_defined?(:friendly_id)
+      end
+
+      def no_friendly_id_model!
+        raise 'Enable FriendlyId to your model to use `friendly` option!'
+      end
+    end
+  end
+end

data/lib/hola_dmleobit.rb

@@ -3,3 +3,39 @@ class HolaDmleobit
     puts "Hello world!"
   end
 end
+
+require 'findable'
+require 'findable/definition'
+
+
+# module Findable
+#   extend ActiveSupport::Concern
+
+#   class_methods do
+#     # resource_name - name of instance variable where found resource will be placed
+#     # options includes:
+#     #   - class          - name of resource class (default: taken from resource_name)
+#     #   - by             - how value is named in params (default: :id)
+#     #   - attribute      - name of resource attribute (default: :id)
+#     #   - strict         - raise error if resource hasn't been found (default: true)
+#     #   - fallback       - method name/proc which we call if resource hasn't been found
+#     #   - fallback_value - method name/proc which we call if value can't be found in params
+#     #   - only           - list of controller actions on which it is triggered
+#     #   - except         - list of controller actions on which it isn't triggered
+#     #   - eager_load     - list of eager loaded entries to avoid N+1 problem
+#     #   - preload        - list of preloaded entries to avoid N+1 problem
+#     #   - joins          - list of joined entries to avoid N+1 problem
+#     #   - decorate       - shows if we should decorate found resource.
+#     #                      Can be used only with respective Drapper decorator
+#     #   - friendly       - shows if we should find resource also by slug field.
+#     #                      Can be used only for FriendlyId models.
+#     #
+#     def find(resource_name, **options)
+#       ::Findable::Definition.call(
+#         controller: self,
+#         resource_name: resource_name,
+#         **options
+#       )
+#     end
+#   end
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hola_dmleobit
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Nick Quaranto
@@ -16,6 +16,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/findable/definition.rb
+- lib/findable/find.rb
+- lib/findable/finder.rb
+- lib/findable/strategies/friendly_id.rb
 - lib/hola_dmleobit.rb
 homepage: https://rubygems.org/gems/hola
 licenses: