module Brainstem::Concerns::PresenterDSL::ClassMethods

Constants

DEFAULT_FILTER_DATA_TYPE

Public Instance Methods

associations(&block) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 38
def associations(&block)
  AssociationsBlock.new(configuration, &block)
end
brainstem_key(key) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 167
def brainstem_key(key)
  configuration[:brainstem_key] = key.to_s
end
conditionals(&block) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 30
def conditionals(&block)
  ConditionalsBlock.new(configuration, &block)
end
default_sort_order(sort_string = nil) click to toggle source

@overload default_sort_order(sort_string)

Sets a default sort order.
@param [String] sort_string The sort order to apply by default
  while presenting. The string must contain the name of a sort order
  that has explicitly been declared using {sort_order}. The string
  may end in +:asc+ or +:desc+ to indicate the default order's
  direction.
@return [String] The new default sort order.

@overload default_sort_order

@return [String] The default sort order, or nil if one is not set.
# File lib/brainstem/concerns/presenter_dsl.rb, line 86
def default_sort_order(sort_string = nil)
  configuration[:default_sort_order] = sort_string if sort_string
  configuration[:default_sort_order]
end
description(str, options = { nodoc: false, internal: false }) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 46
def description(str, options = { nodoc: false, internal: false })
  configuration[:description] = options.merge(info: str)
end
documented!() click to toggle source

Temporary implementation to track controllers that have been documented.

# File lib/brainstem/concerns/presenter_dsl.rb, line 61
def documented!
  configuration[:documented] = true
end
fields(&block) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 34
def fields(&block)
  FieldsBlock.new(configuration[:fields], &block)
end
filter(name, type, options = {}, &block) click to toggle source

@overload filter(name, type, options = {})

@param [Symbol] name The name of the scope that may be applied as a
  filter.
@param [Symbol] type The type of the value that filter holds.
@option options [Object] :default If set, causes this filter to be
  applied to every request. If the filter accepts parameters, the
  value given here will be passed to the filter when it is applied.
@option options [String] :info Docstring for the filter.
@option options [Array] :items List of assignable values for the filter.

@overload filter(name, type, options = {}, &block)

@param [Symbol] name The filter can be requested using this name.
@yieldparam scope [ActiveRecord::Relation] The scope that the
  filter should use as a base.
@yieldparam arg [Object] The argument passed when the filter was
  requested.
@yieldreturn [ActiveRecord::Relation] A new scope that filters the
  scope that was yielded.
# File lib/brainstem/concerns/presenter_dsl.rb, line 149
def filter(name, type, options = {}, &block)
  if type.to_s == 'array'
    options[:item_type] = options[:item_type].to_s.presence || DEFAULT_FILTER_DATA_TYPE
  end

  valid_options = %w(default info include_params nodoc items item_type)
  options.select! { |k, v| valid_options.include?(k.to_s) }

  configuration[:filters][name] = options.merge({
    value: (block_given? ? block : nil),
    type: type.to_s,
  })
end
helper(mod = nil, &block) click to toggle source

Declare a helper module or block whose methods will be available in dynamic fields and associations.

# File lib/brainstem/concerns/presenter_dsl.rb, line 66
def helper(mod = nil, &block)
  if mod
    configuration[:helpers] << mod
  end

  if block
    configuration[:helpers] << Module.new.tap { |mod| mod.module_eval(&block) }
  end
end
internal!(description = true) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 54
def internal!(description = true)
  configuration[:internal] = description
end
nodoc!(description = true) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 50
def nodoc!(description = true)
  configuration[:nodoc] = description
end
preload(*args) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 26
def preload(*args)
  configuration.array!(:preloads).concat args
end
query_strategy(strategy) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 171
def query_strategy(strategy)
  configuration[:query_strategy] = strategy
end
reset_configuration!() click to toggle source

@api private

# File lib/brainstem/concerns/presenter_dsl.rb, line 176
def reset_configuration!
  configuration.array!(:preloads)
  configuration.array!(:helpers)
  configuration.nest!(:conditionals)
  configuration.nest!(:fields)
  configuration.nest!(:filters)
  configuration.nest!(:sort_orders)
  configuration.nest!(:associations)
  configuration.nonheritable!(:title)
  configuration.nonheritable!(:description)
  configuration.nonheritable!(:nodoc)
end
sort_order(name, *args, &block) click to toggle source

@overload sort_order(name, order, options)

@param [Symbol] name The name of the sort order.
@param [String] order The SQL string to use to sort the presented
  data.
@param [Hash] options
@option options [String] :info Docstring for the sort order
@option options [Boolean] :nodoc Whether this sort order be
  included in the generated documentation
@option options [Boolean] :direction Whether this sort order
  has direction based ordering (asc/desc). Defaults to true

@overload sort_order(name, options, &block)

@yieldparam scope [ActiveRecord::Relation] The scope representing
  the data being presented.
@yieldreturn [ActiveRecord::Relation] A new scope that adds
  ordering requirements to the scope that was yielded.

Create a named sort order, either containing a string to use as
ORDER in a query, or with a block that adds an order Arel predicate
to a scope.

@raise [ArgumentError] if neither an order string or block is given.

# File lib/brainstem/concerns/presenter_dsl.rb, line 115
def sort_order(name, *args, &block)
  valid_options       = %w(info nodoc internal direction)
  options             = args.extract_options!
                          .select { |k, v| valid_options.include?(k.to_s) }
                          .with_indifferent_access
  options[:direction] = true unless options.has_key?(:direction)
  order               = args.first

  raise ArgumentError, "A sort order must be given" unless block_given? || order
  configuration[:sort_orders][name] = options.merge({
    value: (block_given? ? block : order)
  })
end
title(str, options = { nodoc: false, internal: false }) click to toggle source
# File lib/brainstem/concerns/presenter_dsl.rb, line 42
def title(str, options = { nodoc: false, internal: false })
  configuration[:title] = options.merge(info: str)
end