Class: Jstreamer::BaseJson

Inherits:
Object
  • Object
show all
Defined in:
lib/jstreamer/base_json.rb

Overview

Provides main DSL and base class for json rendering.

Direct Known Subclasses

RailsJson

Instance Attribute Summary collapse

DSL collapse

Helpers collapse

Extendable methods collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(stream = nil, **opts) ⇒ BaseJson

Initializer

Parameters:

  • stream (stream) (defaults to: nil)
  • opts (kwargs) 


33
34
35
36
37
38
 
# File 'lib/jstreamer/base_json.rb', line 33

def initialize(stream = nil, **opts)
  @current_stream = stream || create_new_stream
  @options = opts
  @local_cache = {}
  @index = nil
end

Instance Attribute Details

#current_model ⇒ Object? (readonly)

Returns current model (data object) passed to the renderer.

Returns:

  • (Object, nil) —

    current model (data object) passed to the renderer



41
42
43
 
# File 'lib/jstreamer/base_json.rb', line 41

def current_model
  @current_model
end

#current_stream ⇒ stream (readonly)

Returns current json stream (low-level).

Returns:

  • (stream) —

    current json stream (low-level)



44
45
46
 
# File 'lib/jstreamer/base_json.rb', line 44

def current_stream
  @current_stream
end

#index ⇒ Integer? (readonly)

Returns index of currently rendering element inside array’s rendering loop.

Returns:

  • (Integer, nil) —

    index of currently rendering element inside array’s rendering loop



47
48
49
 
# File 'lib/jstreamer/base_json.rb', line 47

def index
  @index
end

#options ⇒ Hash (readonly)

Returns current options passed to the renderer.

Returns:

  • (Hash) —

    current options passed to the renderer



50
51
52
 
# File 'lib/jstreamer/base_json.rb', line 50

def options
  @options
end

Class Method Details

.delegated_options(*opts) ⇒ Object

Simple delegation helper for options as methods

Examples:

class SomeMyJson < ApplicationJson
  delegated_options :slug

  def render
    options[:slug]    # access directly
    slug              # access with delegate_options helper
  end
end

Parameters:

  • opts (Array<Symbol>) —

    option key(s)

Returns:

  • void



245
246
247
248
249
 
# File 'lib/jstreamer/base_json.rb', line 245

def self.delegated_options(*opts)
  opts.each do |opt|
    define_method(opt) { options.fetch(opt) }
  end
end

.generate(obj = nil, **opts) ⇒ String

Generates json for a single object

Parameters:

  • obj (Object, nil) (defaults to: nil)
  • opts (kwargs) —

    options

Returns:

  • (String) —

    generated json



18
19
20
 
# File 'lib/jstreamer/base_json.rb', line 18

def self.generate(obj = nil, **opts)
  new(**opts).call(obj).to_s
end

.generate_collection(collection, **opts) ⇒ String

Generates json for a collection of objects

Parameters:

  • collection (Array)
  • opts (kwargs) —

    options

Returns:

  • (String) —

    generated json



26
27
28
 
# File 'lib/jstreamer/base_json.rb', line 26

def self.generate_collection(collection, **opts)
  new(**opts).call_collection(collection).to_s
end

Instance Method Details

#array(key, array_obj) { ... } ⇒ Object

Pushes an array to a json stream

Examples:

Array with a block

array(:my_items, items) do |item|
  from(item, :a, :b, :c)
  prop(:x, item.d)
end

Array with a helper method

def render
  array(:my_items, items)
end

def my_items(item)
  from(item, :a, :b, :c)
  prop(:x, item.d)
end

Parameters:

  • key (Symbol)
  • array_obj (Array)

Yields:

  • optional block

Returns:

  • void



219
220
221
222
223
224
225
226
227
 
# File 'lib/jstreamer/base_json.rb', line 219

def array(key, array_obj)
  current_stream.push_array(normalized_key(key))
  array_obj.each do |obj|
    current_stream.push_object
    block_given? ? yield(obj) : __send__(key, obj)
    current_stream.pop
  end
  current_stream.pop
end

#call(obj = nil) ⇒ Object

Performs render for a single object

Parameters:

  • obj (Object) (defaults to: nil) —

    current model

Returns:

  • self



55
56
57
58
59
60
61
 
# File 'lib/jstreamer/base_json.rb', line 55

def call(obj = nil)
  @current_model = obj
  current_stream.push_object
  render
  current_stream.pop
  self
end

#call_collection(collection) ⇒ Object

Performs render for a collection of objects

Parameters:

  • collection (Array)

Returns:

  • self



66
67
68
69
70
71
72
73
74
 
# File 'lib/jstreamer/base_json.rb', line 66

def call_collection(collection)
  current_stream.push_array
  collection.each_with_index do |obj, index|
    @index = index
    call(obj)
  end
  current_stream.pop
  self
end

#encode_value(value) ⇒ String

Value encoding logic (can be extended by ancestors)

Examples:

class ApplicaiontJson < BaseJson
  def encode_value(value)
    case value
    when BigDecimal then value.to_f    # e.g. we want those as floats, not as strings
    else super
    end
  end
end

Parameters:

  • value (Object)

Returns:

  • (String) —

    string to be written to json



282
283
284
285
286
287
288
289
290
 
# File 'lib/jstreamer/base_json.rb', line 282

def encode_value(value)
  case value
  when String then value.to_str
  when Integer, Float, TrueClass, FalseClass, NilClass then value
  when Date then value.strftime("%F")
  when Time then value.strftime("%FT%T.%L%:z")
  else raise(Jstreamer::Error, "Unsupported json encode class #{value.class}")
  end
end

#from(obj, *keys) ⇒ Object

Extracts properties from an object or hash and pushes them to a json stream

Examples:

With inlined keys

from(current_model, :method1, :method2)  # calling methods of provided object
from(some_hash, :prop1, :prop2)          # fetching props of provided hash

With keys as array

PROPS = %i[prop1 prop2]

from(some, PROPS)   # pass array directly
from(some, *PROPS)  # pass array with splat

Parameters:

  • obj (Hash, Object)
  • keys (Array<Symbol>)

Returns:

  • void



114
115
116
117
118
119
120
121
 
# File 'lib/jstreamer/base_json.rb', line 114

def from(obj, *keys)
  from_hash = obj.is_a?(Hash)
  keys = keys[0] if keys[0].is_a?(Array)
  keys.each do |key|
    value = from_hash ? obj.fetch(key) : obj.__send__(key)
    prop(key, value)
  end
end

#merge_json(json) ⇒ Object

Merges a json string to a json stream directly

Parameters:

  • json (String)

Returns:

  • void



148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/jstreamer/base_json.rb', line 148

def merge_json(json)
  return if [nil, "", "{}", "[]"].include?(json)

  key_start = json.index('"') + 1
  key_end = json.index('"', key_start) - 1
  key = json[key_start..key_end].to_sym
  key = normalized_key(key)

  value_start = json.index(":", key_end) + 1
  value_end = json.rindex("}") - 1
  value = json[value_start..value_end]

  current_stream.push_json(value, key)
end

#object(key) { ... } ⇒ Object

Pushes an object to a json stream

Examples:

Object with a block

object(:object_with_block) do
  prop(:a, 1)
end

Object with helper method

def render
  object(:object_with_helper_method)
end

def object_with_helper_method
  prop(:a, 1)
end

Parameters:

  • key (Symbol)

Yields:

  • optional block

Returns:

  • void



139
140
141
142
143
 
# File 'lib/jstreamer/base_json.rb', line 139

def object(key)
  current_stream.push_object(normalized_key(key))
  block_given? ? yield : __send__(key)
  current_stream.pop
end

#partial(key, klass, klass_obj, **klass_opts) ⇒ Object

Pushes a partial to a stream

Parameters:

  • key (Symbol)
  • klass (Class) —

    partial class

  • klass_obj (Object) —

    data model passed to a class

  • klass_opts (kwargs) —

    options

Raises:



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/jstreamer/base_json.rb', line 168

def partial(key, klass, klass_obj, **klass_opts) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
  normalized_key = normalized_key(key)
  current_stream.push_key(normalized_key)

  cache_key = klass_opts.delete(:cache_key)
  cache_type = klass_opts.delete(:cache_type)
  raise(Jstreamer::Error, "No cache_key provided") if cache_type && cache_key.nil?
  raise(Jstreamer::Error, "No cache_type provided") if cache_key && cache_type.nil?

  case cache_type
  when :local
    execute_partial_with_local_caching(normalized_key, cache_key, klass, klass_obj, **klass_opts)
  when :rails
    execute_partial_with_rails_caching(cache_key, klass, klass_obj, **klass_opts)
  when nil
    execute_partial_directly(current_stream, klass, klass_obj, **klass_opts)
  else
    raise(Jstreamer::Error, "Unknown cache_type: #{cache_type}")
  end
end

#prop(key, value) ⇒ Object

Pushes a simple property to a json stream

Examples:

prop(:abc, 123)
prop(:xyz, "qwerty")

Parameters:

  • key (Symbol)
  • value (Object)

Returns:

  • void



91
92
93
94
95
96
97
98
99
100
 
# File 'lib/jstreamer/base_json.rb', line 91

def prop(key, value)
  key = normalized_key(key)
  if value.is_a?(Array)
    current_stream.push_array(key)
    value.each { |v| current_stream.push_value(encode_value(v)) }
    current_stream.pop
  else
    current_stream.push_value(encode_value(value), key)
  end
end

#to_s ⇒ String

Returns json string of current object

Returns:

  • (String) 


78
79
80
 
# File 'lib/jstreamer/base_json.rb', line 78

def to_s # rubocop:disable Rails/Delegate
  current_stream.to_s
end

#transform_key(key) ⇒ String

Key transformation logic (can be extended by ancestors)

Examples:

Camelizing all props in json

class ApplicationJson < BaseJson
  def transform_key(key)
    super.camelize(:lower)   # please always handle super gracefully
  end
end

Parameters:

  • key (Symbol)

Returns:

  • (String) —

    transformed key as string

Raises:



264
265
266
267
268
 
# File 'lib/jstreamer/base_json.rb', line 264

def transform_key(key)
  raise(Jstreamer::Error, "Keys should be Symbols only") unless key.is_a?(Symbol)

  key.to_s.tr("?!", "")
end

#view?(*views) ⇒ Boolean

Helper, checks current view(s) by name

Examples:

if view?(:api_v1, :api_v2)        # either of views
  prop(:some_api_only_prop, 1)
end

Parameters:

  • views (Array<Symbol>) —

    view names

Returns:

  • (Boolean) 


196
197
198
 
# File 'lib/jstreamer/base_json.rb', line 196

def view?(*views)
  views.include?(options[:view])
end