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(render_env: RenderEnvironmentMissing.new, name: self.class.part_name(render_env.inflector), value:) ⇒ Part

Returns a new Part instance



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

def initialize(render_env: RenderEnvironmentMissing.new, name: self.class.part_name(render_env.inflector), value:)
  @_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.



193
194
195
196
197
198
199
200
201
 
# File 'lib/dry/view/part.rb', line 193

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.



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



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.



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.



105
106
107
 
# File 'lib/dry/view/part.rb', line 105

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.



90
91
92
 
# File 'lib/dry/view/part.rb', line 90

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.



124
125
126
 
# File 'lib/dry/view/part.rb', line 124

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.



142
143
144
 
# File 'lib/dry/view/part.rb', line 142

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



185
186
187
 
# File 'lib/dry/view/part.rb', line 185

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.

See Also:



171
172
173
174
175
176
177
178
 
# File 'lib/dry/view/part.rb', line 171

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



151
152
153
 
# File 'lib/dry/view/part.rb', line 151

def to_s
  _value.to_s
end