Module: LinkedRails::Serializer::ClassMethods

Defined in:
lib/linked_rails/serializer.rb

Instance Method Summary collapse

Instance Method Details

#anonymous_object?(object) ⇒ Boolean

Returns:



24
25
26
 
# File 'lib/linked_rails/serializer.rb', line 24

def anonymous_object?(object)
  object.iri.anonymous?
end

#default_enum_opts(attr) ⇒ Object 



52
53
54
55
56
57
58
59
 
# File 'lib/linked_rails/serializer.rb', line 52

def default_enum_opts(attr)
  enum_opts = serializable_class.try(:defined_enums).try(:[], attr.to_s)
  return [] if enum_opts.blank?

  HashWithIndifferentAccess[
    enum_opts&.map { |k, _v| [k.to_sym, {}] }
  ]
end

#enum(attr, opts = nil) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/linked_rails/serializer.rb', line 28

def enum(attr, opts = nil)
  self._enums ||= HashWithIndifferentAccess.new
  opts[:type] ||= Vocab.ontola[:FormOption]
  opts[:options] ||= default_enum_opts(attr)
  self._enums[attr] = enum_values(attr, opts)

  attribute(attr, if: opts[:if], predicate: opts[:predicate]) do |object, params|
    block_given? ? yield(object, params) : enum_value(attr, object)
  end
end

#enum_options(key) ⇒ Object 



39
40
41
 
# File 'lib/linked_rails/serializer.rb', line 39

def enum_options(key)
  _enums && _enums[key]
end

#enum_value(key, object) ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/linked_rails/serializer.rb', line 43

def enum_value(key, object)
  options = enum_options(key)
  return if options.blank?

  raw_value = object.send(key)

  options[raw_value].try(:iri) if raw_value.present?
end

#has_many(key, opts = {}) ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/linked_rails/serializer.rb', line 72

def has_many(key, opts = {})
  opts[:id_method_name] = :iri

  return super if block_given?

  super do |object|
    object.send(key)
  end
end

#has_one(key, opts = {}) ⇒ Object

rubocop:disable Naming/PredicateName



62
63
64
65
66
67
68
69
70
 
# File 'lib/linked_rails/serializer.rb', line 62

def has_one(key, opts = {})
  opts[:id_method_name] = :iri

  return super if block_given?

  super do |object|
    object.send(key)
  end
end

#named_object?(object) ⇒ Boolean

rubocop:enable Naming/PredicateName

Returns:



83
84
85
 
# File 'lib/linked_rails/serializer.rb', line 83

def named_object?(object)
  !object.iri.anonymous?
end

#never(_object, _params) ⇒ Object 



87
88
89
 
# File 'lib/linked_rails/serializer.rb', line 87

def never(_object, _params)
  false
end

#serializable_class ⇒ Object 



91
92
93
 
# File 'lib/linked_rails/serializer.rb', line 91

def serializable_class
  @serializable_class ||= name.gsub('Serializer', '').safe_constantize
end

#serialize_image(obj) ⇒ Object 



95
96
97
98
99
100
101
 
# File 'lib/linked_rails/serializer.rb', line 95

def serialize_image(obj)
  if obj.is_a?(String) || obj.is_a?(Symbol)
    RDF::URI(obj.to_s.gsub(/^fa-/, 'http://fontawesome.io/icon/'))
  else
    obj.presence
  end
end

#with_collection(name, opts = {}) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/linked_rails/serializer.rb', line 103

def with_collection(name, opts = {})
  collection_name = "#{name.to_s.singularize}_collection"
  page_size = opts.delete(:page_size)
  display = opts.delete(:display)
  opts[:association] ||= name
  opts[:polymorphic] ||= true
  opts[:if] ||= method(:named_object?)

  has_one collection_name, opts do |object, params|
    object.send(collection_name, user_context: params[:scope], display: display, page_size: page_size)
  end
end