hanami-view 1.3.3 → 2.0.0.alpha6

data/lib/hanami/view/exposure.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Hanami
+  class View
+    # An exposure defined on a view
+    #
+    # @api private
+    class Exposure
+      include Dry::Equalizer(:name, :proc, :object, :options)
+
+      EXPOSURE_DEPENDENCY_PARAMETER_TYPES = %i[req opt].freeze
+      INPUT_PARAMETER_TYPES = %i[key keyreq keyrest].freeze
+
+      attr_reader :name
+      attr_reader :proc
+      attr_reader :object
+      attr_reader :options
+
+      def initialize(name, proc = nil, object = nil, **options)
+        @name = name
+        @proc = prepare_proc(proc, object)
+        @object = object
+        @options = options
+      end
+
+      def bind(obj)
+        self.class.new(name, proc, obj, **options)
+      end
+
+      def dependency_names
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), names|
+            names << name if EXPOSURE_DEPENDENCY_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
+      end
+
+      def input_keys
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), keys|
+            keys << name if INPUT_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
+      end
+
+      def for_layout?
+        options.fetch(:layout) { false }
+      end
+
+      def decorate?
+        options.fetch(:decorate) { true }
+      end
+
+      def private?
+        options.fetch(:private) { false }
+      end
+
+      def default_value
+        options[:default]
+      end
+
+      def call(input, locals = {})
+        if proc
+          call_proc(input, locals)
+        else
+          input.fetch(name) { default_value }
+        end
+      end
+
+      private
+
+      def call_proc(input, locals)
+        args, keywords = proc_args(input, locals)
+
+        if keywords.empty?
+          if proc.is_a?(Method)
+            proc.(*args)
+          else
+            object.instance_exec(*args, &proc)
+          end
+        else
+          if proc.is_a?(Method)
+            proc.(*args, **keywords)
+          else
+            object.instance_exec(*args, **keywords, &proc)
+          end
+        end
+      end
+
+      def proc_args(input, locals)
+        dependency_args = proc_dependency_args(locals)
+        keywords = proc_input_args(input)
+
+        if keywords.empty?
+          [dependency_args, {}]
+        else
+          [dependency_args, keywords]
+        end
+      end
+
+      def proc_dependency_args(locals)
+        dependency_names.map { |name| locals.fetch(name) }
+      end
+
+      def proc_input_args(input)
+        input_keys.each_with_object({}) { |key, args|
+          args[key] = input[key] if input.key?(key)
+        }
+      end
+
+      def prepare_proc(proc, object)
+        if proc
+          proc
+        elsif object.respond_to?(name, _include_private = true)
+          object.method(name)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/exposures.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "tsort"
+require "dry/core/equalizer"
+require_relative "exposure"
+
+module Hanami
+  class View
+    # @api private
+    class Exposures
+      include Dry::Equalizer(:exposures)
+      include TSort
+
+      attr_reader :exposures
+
+      def initialize(exposures = {})
+        @exposures = exposures
+      end
+
+      def key?(name)
+        exposures.key?(name)
+      end
+
+      def [](name)
+        exposures[name]
+      end
+
+      def each(&block)
+        exposures.each(&block)
+      end
+
+      def add(name, proc = nil, **options)
+        exposures[name] = Exposure.new(name, proc, **options)
+      end
+
+      def import(name, exposure)
+        exposures[name] = exposure.dup
+      end
+
+      def bind(obj)
+        bound_exposures = exposures.each_with_object({}) { |(name, exposure), memo|
+          memo[name] = exposure.bind(obj)
+        }
+
+        self.class.new(bound_exposures)
+      end
+
+      def call(input)
+        # rubocop:disable Style/MultilineBlockChain
+        tsort.each_with_object({}) { |name, memo|
+          next unless (exposure = self[name])
+
+          value = exposure.(input, memo)
+          value = yield(value, exposure) if block_given?
+
+          memo[name] = value
+        }.each_with_object({}) { |(name, value), memo|
+          memo[name] = value unless self[name].private?
+        }
+        # rubocop:enable Style/MultilineBlockChain
+      end
+
+      private
+
+      def tsort_each_node(&block)
+        exposures.each_key(&block)
+      end
+
+      def tsort_each_child(name, &block)
+        self[name].dependency_names.each(&block) if exposures.key?(name)
+      end
+    end
+  end
+end

data/lib/hanami/view/part.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require_relative "decorated_attributes"
+require_relative "render_environment_missing"
+
+module Hanami
+  class View
+    # Decorates an exposure value and provides a place to encapsulate
+    # view-specific behavior alongside your application's domain objects.
+    #
+    # @abstract Subclass this and provide your own methods adding view-specific
+    #   behavior. You should not override `#initialize`.
+    #
+    # @see https://dry-rb.org/gems/dry-view/parts/
+    #
+    # @api public
+    class Part
+      # @api private
+      CONVENIENCE_METHODS = %i[
+        format
+        context
+        render
+        scope
+        value
+      ].freeze
+
+      include Dry::Equalizer(:_name, :_value, :_render_env)
+      include DecoratedAttributes
+
+      # The part's name. This comes from the exposure supplying the value.
+      #
+      # @return [Symbol] name
+      #
+      # @api public
+      attr_reader :_name
+
+      # The decorated value. This is the value returned from the exposure.
+      #
+      # @overload _value
+      #   Returns the value.
+      # @overload value
+      #   A convenience alias for `_value`. Is available unless the value itself
+      #   responds to `#value`.
+      #
+      # @return [Object] value
+      #
+      # @api public
+      attr_reader :_value
+
+      # The current render environment
+      #
+      # @return [RenderEnvironment] render environment
+      #
+      # @api private
+      attr_reader :_render_env
+
+      # Determins a part name (when initialized without one). Intended for use
+      # only while unit testing Parts.
+      #
+      # @api private
+      def self.part_name(inflector)
+        name ? inflector.underscore(inflector.demodulize(name)) : "part"
+      end
+
+      # Returns a new Part instance
+      #
+      # @param name [Symbol] part name
+      # @param value [Object] the value to decorate
+      # @param render_env [RenderEnvironment] render environment
+      #
+      # @api public
+      def initialize(
+        render_env: RenderEnvironmentMissing.new,
+        name: self.class.part_name(render_env.inflector),
+        value:
+      )
+        @_name = name
+        @_value = value
+        @_render_env = render_env
+      end
+
+      # The template format for the current render environment.
+      #
+      # @overload _format
+      #   Returns the format.
+      # @overload format
+      #   A convenience alias for `#_format.` Is available unless the value
+      #   itself responds to `#format`.
+      #
+      # @return [Symbol] format
+      #
+      # @api public
+      def _format
+        _render_env.format
+      end
+
+      # The context object for the current render environment
+      #
+      # @overload _context
+      #   Returns the context.
+      # @overload context
+      #   A convenience alias for `#_context`. Is available unless the value
+      #   itself responds to `#context`.
+      #
+      # @return [Context] context
+      #
+      # @api public
+      def _context
+        _render_env.context
+      end
+
+      # Renders a new partial with the part included in its locals.
+      #
+      # @overload _render(partial_name, as: _name, **locals, &block)
+      #   Renders the partial.
+      # @overload render(partial_name, as: _name, **locals, &block)
+      #   A convenience alias for `#_render`. Is available unless the value
+      #   itself responds to `#render`.
+      #
+      # @param partial_name [Symbol, String] partial name
+      # @param as [Symbol] the name for the Part to assume in the partial's locals. Defaults to
+      #   the Part's `_name`.
+      # @param locals [Hash<Symbol, Object>] other locals to provide the partial
+      #
+      # @return [String] rendered partial
+      #
+      # @api public
+      # rubocop:disable Naming/UncommunicativeMethodParamName
+      def _render(partial_name, as: _name, **locals, &block)
+        _render_env.partial(partial_name, _render_env.scope({as => self}.merge(locals)), &block)
+      end
+      # rubocop:enable Naming/UncommunicativeMethodParamName
+
+      # Builds a new scope with the part included in its locals.
+      #
+      # @overload _scope(scope_name = nil, **locals)
+      #   Builds the scope.
+      # @overload scope(scope_name = nil, **locals)
+      #   A convenience alias for `#_scope`. Is available unless the value
+      #   itself responds to `#scope`.
+      #
+      # @param scope_name [Symbol, nil] scope name, used by the scope builder to determine the
+      #   scope class
+      # @param locals [Hash<Symbol, Object>] other locals to provide the partial
+      #
+      # @return [Hanami::View::Scope] scope
+      #
+      # @api public
+      def _scope(scope_name = nil, **locals)
+        _render_env.scope(scope_name, {_name => self}.merge(locals))
+      end
+
+      # Returns a string representation of the value
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        _value.to_s
+      end
+
+      # Builds a new a part with the given parameters
+      #
+      # This is helpful for manually constructing a new part object that
+      # maintains the current render environment.
+      #
+      # However, using `.decorate` is preferred for declaring attributes that
+      # should also be decorated as parts.
+      #
+      # @see DecoratedAttributes::ClassInterface#decorate
+      #
+      # @param klass [Class] part class to use (defaults to the part's class)
+      # @param name [Symbol] part name (defaults to the part's name)
+      # @param value [Object] value to decorate (defaults to the part's value)
+      # @param options[Hash<Symbol, Object>] other options to provide when initializing the new part
+      #
+      # @api public
+      def new(klass = self.class, name: _name, value: _value, **options)
+        klass.new(
+          name: name,
+          value: value,
+          render_env: _render_env,
+          **options
+        )
+      end
+
+      # Returns a string representation of the part
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        %(#<#{self.class.name} name=#{_name.inspect} value=#{_value.inspect}>)
+      end
+
+      private
+
+      # Handles missing methods. If the `_value` responds to the method, then
+      # the method will be sent to the value.
+      def method_missing(name, *args, &block)
+        if _value.respond_to?(name)
+          _value.public_send(name, *args, &block)
+        elsif CONVENIENCE_METHODS.include?(name)
+          __send__(:"_#{name}", *args, &block)
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(name, include_private = false)
+        CONVENIENCE_METHODS.include?(name) || _value.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/hanami/view/part_builder.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+require_relative "part"
+
+module Hanami
+  class View
+    # Decorates exposure values with matching parts
+    #
+    # @api private
+    class PartBuilder
+      extend Dry::Core::Cache
+      include Dry::Equalizer(:namespace)
+
+      attr_reader :namespace
+      attr_reader :render_env
+
+      # Returns a new instance of PartBuilder
+      #
+      # @api private
+      def initialize(namespace: nil, render_env: nil)
+        @namespace = namespace
+        @render_env = render_env
+      end
+
+      # @api private
+      def for_render_env(render_env)
+        return self if render_env == self.render_env
+
+        self.class.new(namespace: namespace, render_env: render_env)
+      end
+
+      # Decorates an exposure value
+      #
+      # @param name [Symbol] exposure name
+      # @param value [Object] exposure value
+      # @param options [Hash] exposure options
+      #
+      # @return [Hanami::View::Part] decorated value
+      #
+      # @api private
+      def call(name, value, **options)
+        builder = value.respond_to?(:to_ary) ? :build_collection_part : :build_part
+
+        send(builder, name, value, **options)
+      end
+
+      private
+
+      def build_part(name, value, **options)
+        klass = part_class(name: name, **options)
+
+        klass.new(
+          name: name,
+          value: value,
+          render_env: render_env
+        )
+      end
+
+      def build_collection_part(name, value, **options)
+        collection_as = collection_options(name: name, **options)[:as]
+        item_name, item_as = collection_item_options(name: name, **options).values_at(:name, :as)
+
+        arr = value.to_ary.map { |obj|
+          build_part(item_name, obj, **options.merge(as: item_as))
+        }
+
+        build_part(name, arr, **options.merge(as: collection_as))
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def collection_options(name:, **options)
+        collection_as = options[:as].is_a?(Array) ? options[:as].first : nil
+
+        options.merge(as: collection_as)
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      def collection_item_options(name:, **options)
+        singular_name = inflector.singularize(name).to_sym
+        singular_as =
+          if options[:as].is_a?(Array)
+            options[:as].last if options[:as].length > 1
+          else
+            options[:as]
+          end
+
+        if singular_as && !singular_as.is_a?(Class)
+          singular_as = inflector.singularize(singular_as.to_s)
+        end
+
+        options.merge(
+          name: singular_name,
+          as: singular_as
+        )
+      end
+
+      def part_class(name:, fallback_class: Part, **options)
+        name = options[:as] || name
+
+        if name.is_a?(Class)
+          name
+        else
+          fetch_or_store(namespace, name, fallback_class) do
+            resolve_part_class(name: name, fallback_class: fallback_class)
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      def resolve_part_class(name:, fallback_class:)
+        return fallback_class unless namespace
+
+        name = inflector.camelize(name.to_s)
+
+        # Give autoloaders a chance to act
+        begin
+          klass = namespace.const_get(name)
+        rescue NameError # rubocop:disable Lint/HandleExceptions
+        end
+
+        if !klass && namespace.const_defined?(name, false)
+          klass = namespace.const_get(name)
+        end
+
+        if klass && klass < Part
+          klass
+        else
+          fallback_class
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def inflector
+        render_env.inflector
+      end
+    end
+  end
+end

data/lib/hanami/view/path.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/core/cache"
+
+module Hanami
+  class View
+    # @api private
+    class Path
+      extend Dry::Core::Cache
+      include Dry::Equalizer(:dir, :root)
+
+      attr_reader :dir, :root
+
+      def self.[](path)
+        if path.is_a?(self)
+          path
+        else
+          new(path)
+        end
+      end
+
+      def initialize(dir, root: dir)
+        @dir = Pathname(dir)
+        @root = Pathname(root)
+      end
+
+      def lookup(name, format, child_dirs: [], parent_dir: false)
+        fetch_or_store(dir, root, name, format, child_dirs, parent_dir) do
+          lookup_template(name, format) ||
+            lookup_in_child_dirs(name, format, child_dirs: child_dirs) ||
+            parent_dir && lookup_in_parent_dir(name, format, child_dirs: child_dirs)
+        end
+      end
+
+      def chdir(dirname)
+        self.class.new(dir.join(dirname), root: root)
+      end
+
+      def to_s
+        dir.to_s
+      end
+
+      private
+
+      def root?
+        dir == root
+      end
+
+      # Search for a template using a wildcard for the engine extension
+      def lookup_template(name, format)
+        glob = dir.join("#{name}.#{format}.*")
+        Dir[glob].first
+      end
+
+      def lookup_in_child_dirs(name, format, child_dirs:)
+        child_dirs.reduce(nil) { |_, dir|
+          template = chdir(dir).lookup(name, format)
+          break template if template
+        }
+      end
+
+      def lookup_in_parent_dir(name, format, child_dirs:)
+        !root? && chdir("..").lookup(name, format, child_dirs: child_dirs, parent_dir: true)
+      end
+    end
+  end
+end

data/lib/hanami/view/render_environment.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Hanami
+  class View
+    # @api private
+    class RenderEnvironment
+      def self.prepare(renderer, config, context)
+        new(
+          renderer: renderer,
+          inflector: config.inflector,
+          context: context,
+          scope_builder: config.scope_builder.new(namespace: config.scope_namespace),
+          part_builder: config.part_builder.new(namespace: config.part_namespace)
+        )
+      end
+
+      include Dry::Equalizer(:renderer, :inflector, :context, :scope_builder, :part_builder)
+
+      attr_reader :renderer, :inflector, :context, :scope_builder, :part_builder
+
+      def initialize(renderer:, inflector:, context:, scope_builder:, part_builder:)
+        @renderer = renderer
+        @inflector = inflector
+        @context = context.for_render_env(self)
+        @scope_builder = scope_builder.for_render_env(self)
+        @part_builder = part_builder.for_render_env(self)
+      end
+
+      def format
+        renderer.format
+      end
+
+      def part(name, value, **options)
+        part_builder.(name, value, **options)
+      end
+
+      def scope(name = nil, locals) # rubocop:disable Style/OptionalArguments
+        scope_builder.(name, locals)
+      end
+
+      def template(name, scope, &block)
+        renderer.template(name, scope, &block)
+      end
+
+      def partial(name, scope, &block)
+        renderer.partial(name, scope, &block)
+      end
+
+      def chdir(dirname)
+        self.class.new(
+          renderer: renderer.chdir(dirname),
+          inflector: inflector,
+          context: context,
+          scope_builder: scope_builder,
+          part_builder: part_builder
+        )
+      end
+    end
+  end
+end