Module: Brainstem::Concerns::PresenterDSL::ClassMethods

Defined in:
lib/brainstem/concerns/presenter_dsl.rb

Instance Method Summary collapse

Instance Method Details

#associations(&block) ⇒ Object 



37
38
39
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 37

def associations(&block)
  AssociationsBlock.new(configuration, &block)
end

#brainstem_key(key) ⇒ Object 



148
149
150
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 148

def brainstem_key(key)
  configuration[:brainstem_key] = key.to_s
end

#conditionals(&block) ⇒ Object 



29
30
31
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 29

def conditionals(&block)
  ConditionalsBlock.new(configuration, &block)
end

#default_sort_order(sort_string) ⇒ String #default_sort_order ⇒ String

Overloads:

  • #default_sort_order(sort_string) ⇒ String

    Sets a default sort order.

    Parameters:

    • sort_string (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.

    Returns:

    • (String) —

      The new default sort order.

  • #default_sort_order ⇒ String

    Returns The default sort order, or nil if one is not set.

    Returns:

    • (String) —

      The default sort order, or nil if one is not set.



75
76
77
78
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 75

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 }) ⇒ Object 



45
46
47
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 45

def description(str, options = { nodoc: false })
  configuration[:description] = options.merge(info: str)
end

#fields(&block) ⇒ Object 



33
34
35
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 33

def fields(&block)
  FieldsBlock.new(configuration[:fields], &block)
end

#filter(name, options = {}) ⇒ Object #filter(name, options = {}) {|scope, arg| ... } ⇒ Object

Overloads:

  • #filter(name, options = {}) ⇒ Object

    Parameters:

    • name (Symbol) —

      The name of the scope that may be applied as a filter.

    Options Hash (options):

    • :default (Object) —

      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.

    • :info (String) —

      Docstring for the filter.

  • #filter(name, options = {}) {|scope, arg| ... } ⇒ Object

    Parameters:

    • name (Symbol) —

      The filter can be requested using this name.

    Yield Parameters:

    • scope (ActiveRecord::Relation) —

      The scope that the filter should use as a base.

    • arg (Object) —

      The argument passed when the filter was requested.

    Yield Returns:

    • (ActiveRecord::Relation) —

      A new scope that filters the scope that was yielded.



134
135
136
137
138
139
140
141
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 134

def filter(name, options = {}, &block)
  valid_options = %w(default info include_params nodoc)
  options.select! { |k, v| valid_options.include?(k.to_s) }

  configuration[:filters][name] = options.merge({
    value: (block_given? ? block : nil)
  })
end

#helper(mod = nil, &block) ⇒ Object

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



54
55
56
57
58
59
60
61
62
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 54

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

#nodoc! ⇒ Object 



49
50
51
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 49

def nodoc!
  configuration[:nodoc] = true
end

#preload(*args) ⇒ Object 



25
26
27
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 25

def preload(*args)
  configuration.array!(:preloads).concat args
end

#query_strategy(strategy) ⇒ Object 



152
153
154
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 152

def query_strategy(strategy)
  configuration[:query_strategy] = strategy
end

#reset_configuration! ⇒ 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. 



157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 157

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

#search(&block) ⇒ Object 



144
145
146
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 144

def search(&block)
  configuration[:search] = block
end

#sort_order(name, order, options) ⇒ Object #sort_order(name, options) {|scope| ... } ⇒ Object

Overloads:

  • #sort_order(name, order, options) ⇒ Object

    Parameters:

    • name (Symbol) —

      The name of the sort order.

    • order (String) —

      The SQL string to use to sort the presented data.

    • options (Hash)

    Options Hash (options):

    • :info (String) —

      Docstring for the sort order

    • :nodoc (Boolean) —

      Whether this sort order be included in the generated documentation

  • #sort_order(name, options) {|scope| ... } ⇒ Object

    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.

    Yield Parameters:

    • scope (ActiveRecord::Relation) —

      The scope representing the data being presented.

    Yield Returns:

    • (ActiveRecord::Relation) —

      A new scope that adds ordering requirements to the scope that was yielded.

Raises:

  • (ArgumentError) —

    if neither an order string or block is given.



103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 103

def sort_order(name, *args, &block)
  valid_options = %w(info nodoc)
  options       = args.extract_options!
                    .select { |k, v| valid_options.include?(k.to_s) }
  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 }) ⇒ Object 



41
42
43
 
# File 'lib/brainstem/concerns/presenter_dsl.rb', line 41

def title(str, options = { nodoc: false })
  configuration[:title] = options.merge(info: str)
end