wallaby-core 0.1.2 → 0.2.3

data/lib/renderers/wallaby/cell.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # In order to improve the rendering performance, cell is designed as simple partial component.
-  # @since 5.2.0
-  class Cell
-    # @!attribute [r] context
-    # @return [Object] view context
-    attr_reader :context
-
-    # @!attribute [r] local_assigns
-    # @return [Hash] a list of local_assigns containing {#object}, {#field_name}, {#value}, {#metadata} and {#form}
-    attr_reader :local_assigns
-
-    # @!attribute [r] buffer
-    # @return [String] output string buffer
-    attr_reader :buffer
-
-    delegate(*ERB::Util.singleton_methods, to: ERB::Util)
-
-    # @param context [ActionView::Context] view context
-    # @param local_assigns [Hash] local variables
-    def initialize(context, local_assigns)
-      @context = context
-      @local_assigns = local_assigns
-    end
-
-    # @!attribute [r] object
-    # @return [Object] object
-    def object
-      local_assigns[:object]
-    end
-
-    # @!attribute [w] object
-    def object=(object)
-      local_assigns[:object] = object
-    end
-
-    # @!attribute [r] field_name
-    # @return [String] field name
-    def field_name
-      local_assigns[:field_name]
-    end
-
-    # @!attribute [w] field_name
-    def field_name=(field_name)
-      local_assigns[:field_name] = field_name
-    end
-
-    # @!attribute [r] value
-    # @return [String] value
-    def value
-      local_assigns[:value]
-    end
-
-    # @!attribute [w] value
-    def value=(value)
-      local_assigns[:value] = value
-    end
-
-    # @!attribute [r] metadata
-    # @return [String] metadata
-    def metadata
-      local_assigns[:metadata]
-    end
-
-    # @!attribute [w] metadata
-    def metadata=(metadata)
-      local_assigns[:metadata] = metadata
-    end
-
-    # @!attribute [r] form
-    # @return [ActionView::Helpers::FormBuilder] form object
-    def form
-      local_assigns[:form]
-    end
-
-    # @!attribute [w] form
-    def form=(form)
-      local_assigns[:form] = form
-    end
-
-    # @note this is a template method that can be overridden by subclasses
-    # Produce output for this cell component.
-    #
-    # Please note that the output doesn't include the buffer produced by {#concat}.
-    # Therefore, use {#render_complete} method instead when the cell is rendered.
-    def render; end
-
-    # This method produces the complete rendered string including the buffer produced by {#concat}.
-    # @return [String] output of the cell
-    def render_complete(&block)
-      @buffer = EMPTY_STRING.dup # reset buffer before rendering
-      last_part = render(&block)
-      @buffer << last_part.to_s
-    end
-
-    # Append string to output buffer
-    # @param string [String] string to concat
-    def concat(string)
-      (@buffer ||= EMPTY_STRING.dup) << string
-    end
-
-    # @overload at(name)
-    #   Get view instance variable value
-    #   @example To get view instance variable value
-    #     at('name') # => get value of `@name` from the view
-    #   @param name [String, Symbol] view instance variable name without `@`
-    # @overload at(name, value)
-    #   Set view instance variable value
-    #   @example To set view instance variable value
-    #     at('name', value) # => set value of `@name` in the view
-    #   @param name [String, Symbol] view instance variable name without `@`
-    #   @param value [object] value
-    # @return [object] view instance variable value
-    def at(*args)
-      raise ArgumentError unless args.length.in? [1, 2]
-      return context.instance_variable_get :"@#{args.first}" if args.length == 1
-
-      context.instance_variable_set :"@#{args.first}", args.last
-    end
-
-    private
-
-    # Delegate missing method to {#context}
-    def method_missing(method_id, *args, &block)
-      return super unless context.respond_to? method_id
-
-      context.public_send method_id, *args, &block
-    end
-
-    # Delegate missing method check to {#context}
-    def respond_to_missing?(method_id, _include_private)
-      context.respond_to?(method_id) || super
-    end
-  end
-end

data/lib/renderers/wallaby/cell_resolver.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Resolver to provide support for cell and partial
-  # @since 5.2.0
-  class CellResolver < ActionView::OptimizedFileSystemResolver
-    # for Rails 5.2 and below
-    begin
-      # @note this method is only applicable to Rails 5.2 and below
-      # A cell query looks like:
-      #
-      # ```
-      # app/views/wallaby/resources/index/integer{_en,}{_html,}.rb
-      # ```
-      #
-      # Wallaby adds it to the front of the whole query as below:
-      #
-      # ```
-      # {app/views/wallaby/resources/index/integer{_en,}{_html,}.rb,
-      # app/views/wallaby/resources/index/_integer{.en,}{.html,}{.erb,}}
-      # ```
-      # @param path [String]
-      # @param details [Hash]
-      #   see {https://api.rubyonrails.org/classes/ActionView/LookupContext/ViewPaths.html#method-i-detail_args_for
-      #   Detials from ViewPaths}
-      # @return [String] a path query
-      def build_query(path, details)
-        # NOTE: super is impacted by {#escape_entry}
-        origin = super
-        file_name = origin[%r{(?<=/\{,_\})[^/\{]+}]
-        return origin unless file_name
-
-        base_dir = origin.gsub(%r{/[^/]*$}, '')
-        locales = convert details[:locale]
-        formats = convert details[:formats]
-        cell = "#{base_dir}/#{file_name}{#{locales}}{#{formats}}.rb"
-        "{#{cell},#{origin}}"
-      end
-    end
-
-    # for Rails 6 and above
-    begin
-      # @note this method is only applicable to Rails 6 and above
-      # This is to extend the origin functionality to enable to return cell file.
-      # at highest precedence.
-      # @param path [String]
-      # @param details [Hash]
-      # @return [ActionView::Template] found template
-      def find_template_paths_from_details(path, details)
-        details[:handlers].unshift(:rb) if details[:handlers].try(:first) != :rb
-        super
-      end
-
-      # @note this method is only applicable to Rails 6 and above
-      # This is to extend the origin functionality to enable to query cell files.
-      # @param path [String]
-      # @param details [Hash]
-      # @return [Regexp]
-      def build_regex(path, details)
-        origin = super.source
-        Regexp.new(
-          origin
-            .gsub(%r{/\{,_\}([^/]+)\z}, '/_?\\1')
-            .gsub('\\.', '[_\\.]')
-            .gsub('raw|', 'rb|raw|')
-        )
-      end
-    end
-
-    # This is to extend the origin funcationality to enable the query
-    # to look for cell files
-    # @example extend the query
-    #   escape_entry('integer') # => '/{,_}integer'
-    # @param entry [String]
-    # @return [String] an escaped and extended query
-    def escape_entry(entry)
-      super.gsub(%r{/_([^/]+)\z}, '/{,_}\1')
-    end
-
-    private
-
-    # @example concat a list of values into a string
-    #   convert(['html', 'csv']) # => '_html,_cvs,'
-    # @param values [Array<String>]
-    def convert(values)
-      (values.map { |v| "_#{v}" } << '').join ','
-    end
-  end
-end

data/lib/renderers/wallaby/custom_lookup_context.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # A custom lookup context that uses {Wallaby::CellResolver} to find cell/partial
-  class CustomLookupContext < ::ActionView::LookupContext
-    def self.normalize(lookup, details: nil, prefixes: nil)
-      return lookup if lookup.is_a? self
-
-      CustomLookupContext.new(
-        lookup.view_paths,
-        details || lookup.instance_variable_get('@details'),
-        prefixes || lookup.prefixes
-      )
-    end
-
-    # @note for Rails 6 and above
-    # It overrides the origin method to convert paths to {Wallaby::CellResolver}
-    # @param paths [Array]
-    # @return [ActionView::PathSet]
-    def build_view_paths(paths)
-      ActionView::PathSet.new Array(paths).map(&method(:convert))
-    end
-
-    # @note for Rails 5.2 and below
-    # It overrides the origin method to convert paths to {Wallaby::CellResolver}
-    # @param paths [Array]
-    # @return [ActionView::PathSet]
-    def view_paths=(paths)
-      @view_paths = build_view_paths paths
-    end
-
-    # It overrides the oirgin method to call the origin `find_template` and cache the result during a request.
-    # @param name [String]
-    # @param prefixes [Array<String>]
-    # @param partial [Boolean]
-    # @param keys [Array<String>] keys of local variables
-    # @param options [Hash]
-    def find_template(name, prefixes = [], partial = false, keys = [], options = {})
-      prefixes = [] if partial && name.include?(SLASH) # reset the prefixes if `/` is detected
-      key = [name, prefixes, partial, keys, options].map(&:inspect).join(SLASH)
-      cached_lookup[key] ||= super
-    end
-
-    protected
-
-    # @!attribute [r] cached_lookup
-    # Cached lookup result
-    def cached_lookup
-      @cached_lookup ||= {}
-    end
-
-    # Convert path to {Wallaby::CellResolver}
-    # @param path [Object]
-    # @return [Wallaby::CellResolver]
-    def convert(path)
-      case path
-      when ActionView::OptimizedFileSystemResolver, Pathname, String
-        CellResolver.new path.to_s
-      else
-        path
-      end
-    end
-  end
-end

data/lib/renderers/wallaby/custom_partial_renderer.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Custom partial renderer to provide support for cell rendering
-  class CustomPartialRenderer < ::ActionView::PartialRenderer
-    # When a type partial is found, it works as usual.
-    #
-    # But when a cell is found, there is an exception {Wallaby::CellHandling} raised. This error will be captured,
-    # and the cell will be rendered.
-    # @param context [ActionView::Context]
-    # @param options [Hash]
-    # @param block [Proc]
-    # @return [String] HTML output
-    def render(context, options, block)
-      super.try do |rendered|
-        ModuleUtils.try_to(rendered, :body) || # Rails 6 and above
-          rendered # Rails 5.2 and below
-      end
-    rescue CellHandling => e
-      CellUtils.render context, e.message, options[:locals], &block
-    end
-
-    # Override origin method to stop rendering when a cell is found.
-    # @return [ActionView::Template] partial template
-    # @raise [Wallaby:::CellHandling] when a cell is found
-    def find_partial(*)
-      super.tap do |partial|
-        cell = CellUtils.find_cell(partial.identifier, partial.inspect)
-        raise CellHandling, cell if cell
-      end
-    end
-  end
-end

data/lib/renderers/wallaby/custom_renderer.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Wallaby
-  # Custom view renderer to provide support for cell rendering
-  class CustomRenderer < ::ActionView::Renderer
-    def initialize(lookup_context)
-      super CustomLookupContext.normalize(lookup_context)
-    end
-
-    # @return [String] HTML output
-    # @see Wallaby::CustomPartialRenderer
-    def render_partial(context, options, &block) #:nodoc:
-      CustomPartialRenderer.new(lookup_context).render(context, options, block)
-    end
-  end
-end

data/lib/utils/wallaby/cell_utils.rb

@@ -1,34 +0,0 @@
-# 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/views/).+(?=\.rb)}]
-        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/preload_utils.rb

@@ -1,44 +0,0 @@
-# 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