wallaby-core 0.1.0

data/lib/services/wallaby/type_renderer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Type renderer
+  class TypeRenderer
+    class << self
+      # Render partial
+      # @param view [ActionView]
+      # @param options [Hash]
+      # @param locals [Hash]
+      # @return [String] HTML
+      def render(view, options = {}, locals = {}, &block)
+        locals[:object] ||= locals[:form].try :object
+        check locals
+        complete locals, view.params[:action]
+        view.render options, locals, &block
+      end
+
+      private
+
+      # @param locals [Hash]
+      # @raise [ArgumentError] if form is set but blank
+      # @raise [ArgumentError] if field_name is not provided
+      # @raise [ArgumentError] if object is not decorated
+      def check(locals)
+        raise ArgumentError, I18n.t('errors.required', subject: 'form') if locals.key?(:form) && locals[:form].blank?
+        raise ArgumentError, I18n.t('errors.required', subject: 'field_name') if locals[:field_name].blank?
+        raise ArgumentError, 'Object is not decorated.' unless locals[:object].is_a? ResourceDecorator
+      end
+
+      # @param locals [Hash]
+      # @param action [String]
+      def complete(locals, action)
+        action_name = CellUtils.to_action_prefix action
+        locals[:metadata] = locals[:object].public_send :"#{action_name}_metadata_of", locals[:field_name]
+        locals[:value] = locals[:object].public_send locals[:field_name]
+      end
+
+      # @param options [String]
+      # @param view [ActionView]
+      # @return [String] partial path string
+      # @return [String] blank string
+      def find_partial(options, view)
+        formats = [view.request.format.to_sym]
+        lookup = view.lookup_context
+        lookup.find_template options, lookup.prefixes, true, [], formats: formats
+      end
+    end
+  end
+end

data/lib/support/action_dispatch/routing/mapper.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Routing
+    # Re-open `ActionDispatch::Routing::Mapper` to add route helpers for Wallaby.
+    class Mapper
+      # Generate **resourceful** routes that works for Wallaby.
+      # @example To generate resourceful routes that works for Wallaby:
+      #   wresources :postcodes
+      #   # => same effect as
+      #   resources(
+      #     :postcodes,
+      #     path: ':resources',
+      #     defaults: { resources: :postcodes },
+      #     constraints: { resources: :postcodes }
+      #   )
+      # @param resource_names [Array<String, Symbol>]
+      # @see https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-resources
+      #   ActionDispatch::Routing::Mapper::Resources#resources
+      def wresources(*resource_names, &block)
+        options = resource_names.extract_options!.dup
+        resource_names.each do |resource_name|
+          new_options = wallaby_resources_options_for resource_name, options
+          resources resource_name, new_options, &block
+        end
+      end
+
+      # Generate **resourceful** routes that works for Wallaby.
+      # @example To generate resourceful routes that works for Wallaby:
+      #   wresource :profile
+      #   # => same effect as
+      #   resource(
+      #     :profile,
+      #     path: ':resource',
+      #     defaults: { resource: :profile, resources: :profiles },
+      #     constraints: { resource: :profile, resources: :profiles }
+      #   )
+      # @param resource_names [Array<String, Symbol>]
+      # @see https://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-resource
+      #   ActionDispatch::Routing::Mapper::Resources#resource
+      def wresource(*resource_names, &block)
+        options = resource_names.extract_options!.dup
+        resource_names.each do |resource_name|
+          new_options = wallaby_resource_options_for resource_name, options
+          resource resource_name, new_options, &block
+        end
+      end
+
+      protected
+
+      # Fill in the **resources** options required by Wallaby
+      # @param resources_name [String, Symbol]
+      # @param options [Hash]
+      def wallaby_resources_options_for(resources_name, options)
+        { path: ':resources' }.merge!(options).tap do |new_options|
+          %i(defaults constraints).each do |key|
+            new_options[key] = { resources: resources_name }.merge!(new_options[key] || {})
+          end
+        end
+      end
+
+      # Fill in the **resource** options required by Wallaby
+      # @param resource_name [String, Symbol]
+      # @param options [Hash]
+      def wallaby_resource_options_for(resource_name, options)
+        plural_resources = Wallaby::ModelUtils.to_resources_name resource_name
+        { path: ':resource' }.merge!(options).tap do |new_options|
+          %i(defaults constraints).each do |key|
+            new_options[key] = { resource: resource_name, resources: plural_resources }.merge!(new_options[key] || {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tree/wallaby/node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # To present classes in tree structure.
+  class Node
+    # @!attribute [r] klass
+    # Represent the current class
+    attr_reader :klass
+    # @!attribute parent
+    # Represent the parent class of current class
+    attr_accessor :parent
+
+    delegate :name, to: :klass
+
+    # @param klass [Class]
+    def initialize(klass)
+      @klass = klass
+    end
+
+    # @return [Array<Class>] a list of children classes
+    def children
+      @children ||= []
+    end
+  end
+end

data/lib/utils/wallaby/cell_utils.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Cell utils
+  module CellUtils
+    class << self
+      # Render a cell and produce output
+      # @param context [ActionView::Context]
+      # @param file_name [String]
+      # @param locals [Hash]
+      # @return [String] output
+      def render(context, file_name, locals = {}, &block)
+        snake_class = file_name[%r{(?<=app/).+(?=\.rb)}].split(SLASH, 2).last
+        cell_class = snake_class.camelize.constantize
+        Rails.logger.info "  Rendered [cell] #{file_name}"
+        cell_class.new(context, locals).render_complete(&block)
+      end
+
+      # Check if a partial is a cell or not
+      # @param partial_path [String]
+      # @return [true] if partial is a `rb` file
+      # @return [false] otherwise
+      def find_cell(*partials)
+        partials.find { |partial| partial.end_with? '.rb' }
+      end
+
+      # @param action_name [String, Symbol]
+      # @return [String, Symbol] action prefix
+      def to_action_prefix(action_name)
+        FORM_ACTIONS[action_name] || action_name
+      end
+    end
+  end
+end

data/lib/utils/wallaby/field_utils.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Field utils
+  module FieldUtils
+    class << self
+      # Find the first field that meets the first condition.
+      # @example to find the possible text field
+      #   Wallaby::FieldUtils.first_field_by({ name: /name|title/ }, { type: 'string' }, fields)
+      #   # => if any field name that has `name` or `title`, return this field
+      #   # => otherwise, find the first field that has type `string`
+      # @param conditions [Array<Hash>]
+      # @param fields [Hash] field metadata
+      # @return [String, Symbol] field name
+      def first_field_by(*conditions, fields)
+        return if [conditions, fields].any?(&:blank?)
+
+        conditions.each do |condition|
+          fields.each do |field_name, metadata|
+            return field_name if meet? field_name, metadata.with_indifferent_access, condition
+          end
+        end
+        nil
+      end
+
+      protected
+
+      # @param field_name [String]
+      # @param metadata [Hash]
+      # @param condition [Hash]
+      # @return [true] if field's metadata meets the condition
+      # @return [true] otherwise
+      def meet?(field_name, metadata, condition)
+        condition.all? do |key, requirement|
+          operator = requirement.is_a?(::Regexp) ? '=~' : '=='
+          value = metadata[key]
+          value ||= field_name.to_s if key.to_sym == :name
+          ModuleUtils.try_to value, operator, requirement
+        end
+      end
+    end
+  end
+end

data/lib/utils/wallaby/filter_utils.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Filter utils
+  module FilterUtils
+    # Find filter name in the following precedences from high to low:
+    #
+    # - `filter_name` argument
+    # - filters that has been marked as default
+    # - `:all`
+    # @param filter_name [String, Symbol] filter name
+    # @param filters [Hash] filter metadata
+    # @return [String, Symbol]
+    def self.filter_name_by(filter_name, filters)
+      filter = filter_name # from param
+      filter ||= filters.find { |_k, v| v[:default] }.try(:first) # from default value
+      filter || :all # last resort
+    end
+  end
+end

data/lib/utils/wallaby/model_utils.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Utils for model
+  module ModelUtils
+    class << self
+      # Convert model class (e.g. `Namespace::Product`) into resources name (e.g. `namespace::products`)
+      # @param model_class [Class, String] model class
+      # @return [String] resources name
+      def to_resources_name(model_class)
+        return EMPTY_STRING if model_class.blank?
+
+        model_class.to_s.underscore.gsub(SLASH, COLONS).pluralize
+      end
+
+      # Produce model label (e.g. `Namespace / Product`) for model class (e.g. `Namespace::Product`)
+      # @param model_class [Class, String] model class
+      # @return [String] model label
+      def to_model_label(model_class)
+        # TODO: change to use i18n translation
+        return EMPTY_STRING if model_class.blank?
+
+        model_class_name = to_model_name model_class
+        model_class_name.titleize.gsub(SLASH, SPACE + SLASH + SPACE)
+      end
+
+      # Convert resources name (e.g. `namespace::products`) into model class (e.g. `Namespace::Product`)
+      # @param resources_name [String] resources name
+      # @return [Class] model class
+      # @return [nil] when not found
+      def to_model_class(resources_name)
+        return if resources_name.blank?
+
+        class_name = to_model_name resources_name
+        class_name.constantize
+      rescue NameError
+        Rails.logger.warn I18n.t('errors.not_found.model', model: class_name)
+        nil
+      end
+
+      # Convert resources name (e.g. `namespace::products`) into model name (e.g. `Namespace::Product`)
+      # @param resources_name [String] resources name
+      # @return [String] model name
+      def to_model_name(resources_name)
+        return EMPTY_STRING if resources_name.blank?
+
+        resources_name.to_s.singularize.gsub(COLONS, SLASH).camelize
+      end
+    end
+  end
+end

data/lib/utils/wallaby/module_utils.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Utils for module and class
+  module ModuleUtils
+    class << self
+      # A helper method to check if subject responds to given method and to return the result if so
+      # @param subject [Object]
+      # @param method_id [String, Symbol]
+      # @param args [Array] a list of arguments
+      # @return [Object] result from executing given method on subject
+      # @return [nil] if subject doesn't respond to given method
+      def try_to(subject, method_id, *args, &block)
+        return if method_id.blank?
+
+        subject.respond_to?(method_id) && subject.public_send(method_id, *args, &block) || nil
+      end
+
+      # Check whether a class is anonymous or not
+      # @param klass [Class]
+      # @return [true] if a class is anonymous
+      # @return [false] otherwise
+      def anonymous_class?(klass)
+        klass.name.blank? || klass.to_s.start_with?('#<Class')
+      end
+
+      # Check if a child class inherits from parent class
+      # @param child [Class] child class
+      # @param parent [Class] parent class
+      # @raise [ArgumentError] if given class is not a child of the other class
+      def inheritance_check(child, parent)
+        return unless child && parent
+        return if child < parent
+
+        raise ::ArgumentError, I18n.t('errors.invalid.inheritance', klass: child, parent: parent)
+      end
+
+      # If block is given, run the block. Otherwise, return subject
+      # @param subject [Object]
+      # @yield [subject]
+      def yield_for(subject)
+        block_given? ? yield(subject) : subject
+      end
+    end
+  end
+end

data/lib/utils/wallaby/params_utils.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Hash utils
+  module ParamsUtils
+    class << self
+      # @param params [Array<Hash>]
+      # @return [Hash] combined hash that removes empty values
+      def presence(*params)
+        params.reduce({}, :merge).delete_if { |_, v| v.nil? || v == '' }
+      end
+    end
+  end
+end

data/lib/utils/wallaby/preload_utils.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Preload utils
+  module PreloadUtils
+    class << self
+      # Preload all files under app folder
+      def require_all
+        eager_load_paths.map(&method(:require_one))
+      end
+
+      # Require files under a load path
+      # @param load_path [String, Pathname]
+      # @see https://api.rubyonrails.org/classes/Rails/Engine.html#method-i-eager_load-21 Rails::Engine#eager_load!
+      def require_one(load_path)
+        Dir.glob("#{load_path}/**/*.rb").sort.each(&method(:load_class_for))
+      end
+
+      protected
+
+      # @return [Array<String, Pathname>] a list of sorted eager load paths which lists `app/models`
+      #   at highest precedence
+      def eager_load_paths
+        Rails.configuration.eager_load_paths.sort_by do |path|
+          - path.index(%r{/models$}).to_i
+        end
+      end
+
+      # `constantize` is used to make Rails to handle all sort of load errors
+      #
+      # NOTE: don't try to use `ActiveSupport::Dependencies::Loadable.require_dependency`.
+      # As `require_dependency` does not take care all errors raised when class/module is loaded.
+      # @param file_path [Pathname, String]
+      def load_class_for(file_path)
+        module_name = file_path[%r{app/[^/]+/(.+)\.rb}, 1].gsub('/concerns/', '/')
+        class_name = module_name.camelize
+        class_name.constantize unless Module.const_defined? class_name
+      rescue NameError, LoadError => e
+        Rails.logger.debug "  [WALLABY] Preload warning: #{e.message} from #{file_path}"
+        Rails.logger.debug e.backtrace.slice(0, 5)
+      end
+    end
+  end
+end

data/lib/utils/wallaby/test_utils.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Utils for test
+  module TestUtils
+    class << self
+      # @param context
+      # @param controller_class [Class]
+      def around_crud(context, controller_class = nil)
+        context.before do
+          controller_class ||= described_class
+          controller_path = controller_class.controller_path
+          Wallaby::TestUtils.draw(routes, controller_path)
+        end
+
+        context.after { Rails.application.reload_routes! }
+      end
+
+      # @param routes
+      # @param controller_path [String]
+      def draw(routes, controller_path)
+        routes.draw do
+          get ':resources', to: "#{controller_path}#index", as: :resources
+          get ':resources/:id', to: "#{controller_path}#show", as: :resource
+          get ':resources/new', to: "#{controller_path}#new"
+          get ':resources/:id/edit', to: "#{controller_path}#edit"
+          post ':resources', to: "#{controller_path}#create"
+          patch ':resources/:id', to: "#{controller_path}#update"
+          delete ':resources/:id', to: "#{controller_path}#destroy"
+        end
+      end
+    end
+  end
+end