Module: RecordViewHelper

Extended by:
ActiveSupport::Concern
Includes:
ActionView::Helpers::TagHelper, ActionView::Helpers::TextHelper, ActionView::Helpers::TranslationHelper, ActionView::Helpers::UrlHelper
Defined in:
lib/record_view_helper.rb,
lib/record_view_helper/dl.rb,
lib/record_view_helper/util.rb,
lib/record_view_helper/table.rb,
lib/record_view_helper/config.rb,
lib/record_view_helper/railtie.rb,
lib/record_view_helper/version.rb,
lib/record_view_helper/record_value_setting.rb

Overview

table builder and description list (dl) helper for Rails / ActiveModels

Defined Under Namespace

Classes: Config, Railtie, RecordValueSetting

Constant Summary collapse

VERSION =

version

"1.3.4".freeze

Instance Method Summary collapse

Instance Method Details

#deep_record_value(record, column) ⇒ Object

deep call

Examples:

deep_record_value(record, [:a, :b]) == record.a.b

Parameters:

  • record (Object) —

    record

  • column (Symbol|Array<Symbol>) —

    call methods



66
67
68
 
# File 'lib/record_view_helper/util.rb', line 66

def deep_record_value(record, column)
  Array(column).reduce(record) {|receiver, method| receiver.try(:public_send, method) }
end

#deep_record_values(record, columns) ⇒ Object

deep call as array

Examples:

deep_record_values(record, [:a, [:a, :b]]) == [record.a, record.a.b]

Parameters:

  • record (Object) —

    record

  • columns (Array<Symbol|Array<Symbol>>) —

    call methods by columns



54
55
56
 
# File 'lib/record_view_helper/util.rb', line 54

def deep_record_values(record, columns)
  columns.map {|column| deep_record_value(record, column) }
end

#dl_for(record, options = {}) {|setting| ... } ⇒ ActiveSupport::SafeBuffer

build definition list(dl) for records

the options is same as ‘table_for`

Parameters:

  • record (Object) —

    record

  • options (Hash) (defaults to: {}) —

    (same as ‘table_for`)

Yields:

  • (setting) —

    optional setting block (see RecordValueSetting document)

Yield Parameters:

Yield Returns:

  • (void)

Returns:

  • (ActiveSupport::SafeBuffer) —

    rendered result



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/record_view_helper/dl.rb', line 13

def dl_for(record, options = {}) # rubocop:disable Metrics/AbcSize
  setting = RecordValueSetting.build_from_hash!(
    record.try(:attributes).try(:keys) || record.keys,
    record.class.try(:name).try(:tableize),
    options,
  )
  yield setting if block_given?
  content_tag(
    "dl",
    safe_join(
      setting.columns.map do |column|
        safe_join [
          content_tag("dt", record_view_helper_t(record.class, column), setting.header_attrs[column]),
          content_tag("dd", format_record_value(record, column, setting.formats[column], setting.links[column]), setting.attrs[column]),
        ]
      end,
    ),
    options,
  )
end

#format_record_value(record, column, format = nil, link = nil) ⇒ Object

format record value

Examples:

basic

format_view_value(record, :name) == record.name

with format

format_view_value(record, :foo_id, [:foo_id, [:foo, :name]]) == "#{record.foo_id} #{record.foo.name}"

with link

format_view_value(record, :foo_id, nil, :foo_path) == link_to record.foo_id, foo_path(record.foo_id)

with link with deep call

format_view_value(record, :id, [:id, :name], foo_bar_path: [:foo_id, :id]) ==
  link_to "#{record.id} #{record.name}", foo_bar_path(record.foo_id, record.id)

Parameters:

  • record (Object) —

    record

  • column (Symbol) —

    target column name

  • format (Proc|Symbol|Array<Symbol|Array<Symbol>>) (defaults to: nil) —

    format

  • link (Symbol|Hash<Symbol, Array<Symbol>>) (defaults to: nil) —

    link options



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/record_view_helper/util.rb', line 23

def format_record_value(record, column, format = nil, link = nil)
  values =
    case format
    when Proc
      [defined?(capture) ? capture(record, &format) : format.call(record)]
    else
      deep_record_values(record, format || [column])
    end
  formatted_value = safe_join values.map {|value| [format_view_value(value), " "] }.flatten[0..-2]
  case link
  when String, Symbol
    link_record_value(record, formatted_value, link, [column])
  when Hash
    path_method, param_columns = link.first
    link_record_value(record, formatted_value, path_method, param_columns)
  when Proc
    link_uri = link.call(record)
    link_uri ? link_to(formatted_value, link_uri) : formatted_value
  else
    formatted_value
  end
end

#format_view_value(value) ⇒ Object

format value

Parameters:

  • value (Object) —

    value



72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/record_view_helper/util.rb', line 72

def format_view_value(value)
  case value
  when Date, Time, DateTime
    l(value)
  when true
    record_view_helper_config.true_view
  when false
    record_view_helper_config.false_view
  else
    value
  end
end

#link_record_value(record, title, path_method, param_columns) ⇒ Object

make link_to

Examples:

link_record_value(record, "title", :foo_bar_path, [:foo_id, :id])
# makes...
link_to "title", foo_bar_path(record.foo_id, record.id)

Parameters:

  • record (Object) —

    record

  • title (String) —

    link_to title

  • path_method (Symbol) —

    path method name (like :root_path)

  • param_columns (Symbol|Array<Symbol|Array<Symbol>>) —

    column call methods for path method’s args



96
97
98
99
 
# File 'lib/record_view_helper/util.rb', line 96

def link_record_value(record, title, path_method, param_columns)
  send_params = [path_method] + deep_record_values(record, Array(param_columns))
  link_to(title, send(*send_params))
end

#record_view_helper_config ⇒ RecordViewHelper::Config

config

Returns:



31
32
33
 
# File 'lib/record_view_helper.rb', line 31

def record_view_helper_config
  self.class.send(__method__) || Rails.application.config.record_view_helper
end

#table_for(records, options = {}) {|setting| ... } ⇒ ActiveSupport::SafeBuffer

build table for records

Examples:

basic

= table_for(records)

only columns

= table_for(records, only: [:id, :name])
/ only :id, :name columns will rendered

except columns

= table_for(records, except: [:created_at, :updated_at])
/ except timestamp columns

link settings

= table_for(records, links: {id: :foo_path})
/ link to foo_path(record.id)

nested path link

= table_for(records, links: {id: {foo_bar_path: [:foo_id, :id]}})
/ link to foo_bar_path(record.foo_id, record.id)

formats

= table_for(records, formats: {foo_id: [:foo_id, [:foo, :name]]})
/ foo_id column will rendered as "#{foo_id} #{foo.name}"

proc formats

= table_for(records, formats: {statuses: ->(record) { record.statuses.join(" ") } })
/ you can use also free format

column header locale

= table_for(records, table_name: "foos")
/ table header will rendered by t("record_view_helper.#{table_name}.columns.#{column}")
/ table_name is automatically detected from record class name by default
/ if you want to change locale namespace, see RecordViewHelper::Config document

attrs / header attrs

= table_for(records, attrs: {id: {style: "width: 3em"}}, header_attrs: {id: {style: "width: 3em"}})
/ td(attrs) and th(header_attrs) attrs

table attrs

= table_for(records, width: "100%")
/ <table width="100%">

setting block

= table_for(records) do |s|
  - s.only :id, :name
/ recommended for complex settings
/ see RecordValueSetting for details

Parameters:

  • records (Enumerable<Object>) —

    records

  • options (Hash) (defaults to: {})

Yields:

  • (setting) —

    optional setting block (see RecordValueSetting document)

Yield Parameters:

Yield Returns:

  • (void)

Returns:

  • (ActiveSupport::SafeBuffer) —

    rendered result



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/record_view_helper/table.rb', line 58

def table_for(records, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
  setting = RecordValueSetting.build_from_hash!(
    records.try(:klass).try(:column_names) || records.first.try(:attributes).try(:keys) || records.first.try(:keys) || [],
    (records.try(:klass) || records.first.try(:class)).try(:name).try(:tableize),
    options,
  )
  yield setting if block_given?
  content_tag(
    "table",
    safe_join([
      content_tag(
        "thead",
        content_tag(
          "tr",
          safe_join(
            setting.columns.map do |column|
              content_tag("th", record_view_helper_t(records.try(:klass) || records.first.class, column), setting.header_attrs[column])
            end,
          ),
        ),
      ),
      content_tag(
        "tbody",
        safe_join(
          records.map do |record|
            content_tag(
              "tr",
              safe_join(
                setting.columns.map do |column|
                  content_tag("td", format_record_value(record, column, setting.formats[column], setting.links[column]), setting.attrs[column])
                end,
              ),
            )
          end,
        ),
      ),
    ]),
    options,
  )
end