Class: SimpleJsonapi::Node::Base Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/simple_jsonapi/node/base.rb

Overview

This class is abstract.

Represents a node in the JSONAPI document. See README for more details.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root_node:, serializer_inferrer: nil, serializer: nil, fields: nil, include: nil, sort_related: nil, extras: {}, **_options) ⇒ Base

Returns a new instance of Base.

Parameters:



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/simple_jsonapi/node/base.rb', line 31

def initialize(
  root_node:,
  serializer_inferrer: nil,
  serializer: nil,
  fields: nil,
  include: nil,
  sort_related: nil,
  extras: {},
  **_options
)
  @root_node = root_node
  @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
  @serializer = serializer
  @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
  @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
  @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
  @extras = extras
end

Instance Attribute Details

#extras ⇒ Hash{Symbol => Object} (readonly)

Returns:

  • (Hash{Symbol => Object}) 


21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#fields_spec ⇒ Parameters::FieldsSpec (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#include_spec ⇒ Parameters::IncludeSpec (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#root_node ⇒ Node::Base (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#serializer ⇒ Serializer, ErrorSerializer (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#serializer_inferrer ⇒ SerializerInferrer (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

#sort_spec ⇒ Parameters::SortSpec (readonly)

Returns:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
 
# File 'lib/simple_jsonapi/node/base.rb', line 21

class Base
  attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras

  # @param root_node [Node::Base]
  # @param serializer_inferrer [SerializerInferrer]
  # @param serializer [Serializer,ErrorSerializer]
  # @param fields [Parameters::FieldsSpec]
  # @param include [Parameters::IncludeSpec]
  # @param sort_related [Parameters::SortSpec]
  # @param extras [Hash{Symbol => Object}]
  def initialize(
    root_node:,
    serializer_inferrer: nil,
    serializer: nil,
    fields: nil,
    include: nil,
    sort_related: nil,
    extras: {},
    **_options
  )
    @root_node = root_node
    @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
    @serializer = serializer
    @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
    @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
    @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
    @extras = extras
  end

  # @abstract
  # @return [Hash{Symbol => Hash}]
  def as_jsonapi
    raise NotImplementedError, "Implement #{__method__} in each subclass."
  end

  private

  def build_child_node(node_class, **options)
    defaults = {
      root_node: root_node,
      serializer_inferrer: serializer_inferrer,
      serializer: serializer,
      fields: fields_spec,
      include: include_spec,
      sort_related: sort_spec,
      extras: extras,
    }

    node_class.new(defaults.merge(options))
  end

  def evaluate(callable, object, **data)
    serializer.with(data.merge(extras)) do
      serializer.instance_exec(object, &callable)
    end
  end

  def render?(definition, object)
    if_proc = definition.if_predicate
    unless_proc = definition.unless_predicate

    if if_proc && !evaluate(if_proc, object)
      false
    elsif unless_proc && evaluate(unless_proc, object)
      false
    else
      true
    end
  end
end

Instance Method Details

#as_jsonapi ⇒ Hash{Symbol => Hash}

This method is abstract.

Returns:

  • (Hash{Symbol => Hash})

Raises:

  • (NotImplementedError) 


52
53
54
 
# File 'lib/simple_jsonapi/node/base.rb', line 52

def as_jsonapi
  raise NotImplementedError, "Implement #{__method__} in each subclass."
end