Class: Dry::View::Part Abstract

Inherits:
Object
  • Object
show all
Includes:
DecoratedAttributes
Defined in:
lib/dry/view/part.rb

Overview

This class is abstract.

Subclass this and provide your own methods adding view-specific behavior. You should not override ‘#initialize`.

Decorates an exposure value and provides a place to encapsulate view-specific behavior alongside your application’s domain objects.

See Also:

Constant Summary collapse

CONVENIENCE_METHODS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[
  format
  context
  render
  scope
  value
].freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DecoratedAttributes

included

Constructor Details

#initialize(value:, render_env: RenderEnvironmentMissing.new, name: self.class.part_name(render_env.inflector)) ⇒ Part

Returns a new Part instance

Parameters:

  • name (Symbol) (defaults to: self.class.part_name(render_env.inflector)) —

    part name

  • value (Object) —

    the value to decorate

  • render_env (RenderEnvironment) (defaults to: RenderEnvironmentMissing.new) —

    render environment



73
74
75
76
77
78
79
80
 
# File 'lib/dry/view/part.rb', line 73

def initialize(
  value:, render_env: RenderEnvironmentMissing.new,
  name: self.class.part_name(render_env.inflector)
)
  @_name = name
  @_value = value
  @_render_env = render_env
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object (private)

Handles missing methods. If the ‘_value` responds to the method, then the method will be sent to the value.



198
199
200
201
202
203
204
205
206
 
# File 'lib/dry/view/part.rb', line 198

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

Instance Attribute Details

#_name ⇒ Symbol (readonly)

The part’s name. This comes from the exposure supplying the value.

Returns:

  • (Symbol) —

    name



36
37
38
 
# File 'lib/dry/view/part.rb', line 36

def _name
  @_name
end

#_render_env ⇒ RenderEnvironment (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The current render environment

Returns:



56
57
58
 
# File 'lib/dry/view/part.rb', line 56

def _render_env
  @_render_env
end

#_value ⇒ Object (readonly) #value ⇒ Object (readonly)

The decorated value. This is the value returned from the exposure.

Overloads:

  • #_value ⇒ Object

    Returns the value.

  • #value ⇒ Object

    A convenience alias for ‘_value`. Is available unless the value itself responds to `#value`.

Returns:

  • (Object) —

    value



49
50
51
 
# File 'lib/dry/view/part.rb', line 49

def _value
  @_value
end

Class Method Details

.part_name(inflector) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determins a part name (when initialized without one). Intended for use only while unit testing Parts.



62
63
64
 
# File 'lib/dry/view/part.rb', line 62

def self.part_name(inflector)
  name ? inflector.underscore(inflector.demodulize(name)) : "part"
end

Instance Method Details

#_context ⇒ Context #context ⇒ Context

The context object for the current render environment

Overloads:

  • #_context ⇒ Context

    Returns the context.

  • #context ⇒ Context

    A convenience alias for ‘#_context`. Is available unless the value itself responds to `#context`.

Returns:



108
109
110
 
# File 'lib/dry/view/part.rb', line 108

def _context
  _render_env.context
end

#_format ⇒ Symbol #format ⇒ Symbol

The template format for the current render environment.

Overloads:

  • #_format ⇒ Symbol

    Returns the format.

  • #format ⇒ Symbol

    A convenience alias for ‘#_format.` Is available unless the value itself responds to `#format`.

Returns:

  • (Symbol) —

    format



93
94
95
 
# File 'lib/dry/view/part.rb', line 93

def _format
  _render_env.format
end

#_render(partial_name, as: _name, **locals, &block) ⇒ String #render(partial_name, as: _name, **locals, &block) ⇒ String

Renders a new partial with the part included in its locals.

Overloads:

  • #_render(partial_name, as: _name, **locals, &block) ⇒ String

    Renders the partial.

  • #render(partial_name, as: _name, **locals, &block) ⇒ String

    A convenience alias for ‘#_render`. Is available unless the value itself responds to `#render`.

Parameters:

  • partial_name (Symbol, String) —

    partial name

  • as (Symbol) (defaults to: _name) —

    the name for the Part to assume in the partial’s locals. Defaults to the Part’s ‘_name`.

  • locals (Hash<Symbol, Object>) —

    other locals to provide the partial

Returns:

  • (String) —

    rendered partial



128
129
130
 
# File 'lib/dry/view/part.rb', line 128

def _render(partial_name, as: _name, **locals, &block)
  _render_env.partial(partial_name, _render_env.scope({as => self}.merge(locals)), &block)
end

#_scope(scope_name = nil, **locals) ⇒ Dry::View::Scope #scope(scope_name = nil, **locals) ⇒ Dry::View::Scope

Builds a new scope with the part included in its locals.

Overloads:

  • #_scope(scope_name = nil, **locals) ⇒ Dry::View::Scope

    Builds the scope.

  • #scope(scope_name = nil, **locals) ⇒ Dry::View::Scope

    A convenience alias for ‘#_scope`. Is available unless the value itself responds to `#scope`.

Parameters:

  • scope_name (Symbol, nil) (defaults to: nil) —

    scope name, used by the scope builder to determine the scope class

  • locals (Hash<Symbol, Object>) —

    other locals to provide the partial

Returns:



147
148
149
 
# File 'lib/dry/view/part.rb', line 147

def _scope(scope_name = nil, **locals)
  _render_env.scope(scope_name, {_name => self}.merge(locals))
end

#inspect ⇒ String

Returns a string representation of the part

Returns:

  • (String) 


190
191
192
 
# File 'lib/dry/view/part.rb', line 190

def inspect
  %(#<#{self.class.name} name=#{_name.inspect} value=#{_value.inspect}>)
end

#new(klass = self.class, name: _name, value: _value, **options) ⇒ Object

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.

Parameters:

  • klass (Class) (defaults to: self.class) —

    part class to use (defaults to the part’s class)

  • name (Symbol) (defaults to: _name) —

    part name (defaults to the part’s name)

  • value (Object) (defaults to: _value) —

    value to decorate (defaults to the part’s value)

  • options (Hash<Symbol, Object>) —

    other options to provide when initializing the new part

See Also:



176
177
178
179
180
181
182
183
 
# File 'lib/dry/view/part.rb', line 176

def new(klass = self.class, name: _name, value: _value, **options)
  klass.new(
    name: name,
    value: value,
    render_env: _render_env,
    **options
  )
end

#to_s ⇒ String

Returns a string representation of the value

Returns:

  • (String) 


156
157
158
 
# File 'lib/dry/view/part.rb', line 156

def to_s
  _value.to_s
end