Class: Clicksign::Resource

Inherits:
Object
  • Object
show all
Defined in:
lib/clicksign/resource.rb

Defined Under Namespace

Classes: QueryProxy

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object 



288
289
290
291
292
293
294
 
# File 'lib/clicksign/resource.rb', line 288

def method_missing(name, *args, &block)
  key = name.to_s.delete_suffix('=')
  return super unless @_attributes&.key?(key)

  @_attributes[key] = args.first if name.to_s.end_with?('=')
  @_attributes[key]
end

Class Attribute Details

.endpoint ⇒ Object 



93
94
95
 
# File 'lib/clicksign/resource.rb', line 93

def endpoint
  @endpoint || "/#{resource_type}"
end

.resource_type ⇒ Object 



89
90
91
 
# File 'lib/clicksign/resource.rb', line 89

def resource_type
  @resource_type || infer_resource_type
end

Instance Attribute Details

#id ⇒ Object (readonly)

Returns the value of attribute id.



254
255
256
 
# File 'lib/clicksign/resource.rb', line 254

def id
  @id
end

#relationships ⇒ Object (readonly)

Returns the value of attribute relationships.



254
255
256
 
# File 'lib/clicksign/resource.rb', line 254

def relationships
  @relationships
end

Class Method Details

.auto_paging_each(&block) ⇒ Object 



173
174
175
176
177
 
# File 'lib/clicksign/resource.rb', line 173

def auto_paging_each(&block)
  return enum_for(:auto_paging_each) unless block_given?

  fetch_auto_pages({}) { |page| page.each(&block) }
end

.client ⇒ Object 



185
186
187
 
# File 'lib/clicksign/resource.rb', line 185

def client
  Thread.current[:clicksign_client] || Clicksign.client
end

.create(**attributes) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/clicksign/resource.rb', line 109

def create(**attributes)
  relationships = attributes.delete(:relationships) || {}
  raw = client.post(
    endpoint,
    body: JsonApi::Serializer.dump(
      type: resource_type, attributes: attributes, relationships: relationships,
    ),
  )
  parsed = JsonApi::Parser.parse(raw)
  build_instance(parsed[:data].first)
end

.each_page(&block) ⇒ Object 



179
180
181
182
183
 
# File 'lib/clicksign/resource.rb', line 179

def each_page(&block)
  return enum_for(:each_page) unless block_given?

  fetch_auto_pages({}, &block)
end

.fields(**types) ⇒ Object 



159
160
161
 
# File 'lib/clicksign/resource.rb', line 159

def fields(**types)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.fields(**types))
end

.filter(**params) ⇒ Object 



121
122
123
 
# File 'lib/clicksign/resource.rb', line 121

def filter(**params)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.filter(**params))
end

.filter_params(**filters) ⇒ Object 



169
170
171
 
# File 'lib/clicksign/resource.rb', line 169

def filter_params(**filters)
  filters.empty? ? {} : JsonApi::QueryBuilder.new.filter(**filters).to_params
end

.include(*types) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/clicksign/resource.rb', line 132

def include(*types)
  modules, jsonapi = types.partition { |t| t.is_a?(Module) }
  if modules.any? && jsonapi.any?
    raise ArgumentError,
          'cannot mix Module with JSON:API ' \
          'include types — use with_includes for sideload'
  end
  if modules.any?
    modules.each { |mod| super(mod) }
    return self
  end

  with_includes(*types)
end

.list ⇒ Object

Returns the first page with no query chain. Use filter for filters, sort, pagination.



99
100
101
 
# File 'lib/clicksign/resource.rb', line 99

def list
  fetch_list({})
end

.nested_list(parent_id, nested_type:, as: self, params: {}) ⇒ Object 



163
164
165
166
167
 
# File 'lib/clicksign/resource.rb', line 163

def nested_list(parent_id, nested_type:, as: self, params: {})
  raw    = client.get("#{endpoint}/#{parent_id}/#{nested_type}", params: params)
  parsed = JsonApi::Parser.parse(raw)
  parsed[:data].map { |item| as.send(:build_instance, item, parent_id: parent_id) }
end

.order(field) ⇒ Object 



147
148
149
 
# File 'lib/clicksign/resource.rb', line 147

def order(field)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.order(field))
end

.page(number) ⇒ Object 



151
152
153
 
# File 'lib/clicksign/resource.rb', line 151

def page(number)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.page(number))
end

.per(size) ⇒ Object 



155
156
157
 
# File 'lib/clicksign/resource.rb', line 155

def per(size)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.per(size))
end

.retrieve(id) ⇒ Object 



103
104
105
106
107
 
# File 'lib/clicksign/resource.rb', line 103

def retrieve(id)
  raw    = client.get("#{endpoint}/#{id}")
  parsed = JsonApi::Parser.parse(raw)
  build_instance(parsed[:data].first)
end

.validate_jsonapi_include_types!(types) ⇒ Object

Raises:

  • (ArgumentError) 


189
190
191
192
193
194
195
196
197
198
 
# File 'lib/clicksign/resource.rb', line 189

def validate_jsonapi_include_types!(types)
  raise ArgumentError, 'at least one include type is required' if types.empty?

  invalid = types.reject { |t| t.is_a?(String) || t.is_a?(Symbol) }
  return if invalid.empty?

  raise ArgumentError,
        'JSON:API include types must be String or Symbol, ' \
        "got: #{invalid.map(&:class).uniq.join(', ')}"
end

.with_includes(*types) ⇒ Object

JSON:API sideload — use with_includes; include also accepts Module for Ruby mixins.



127
128
129
130
 
# File 'lib/clicksign/resource.rb', line 127

def with_includes(*types)
  validate_jsonapi_include_types!(types)
  QueryProxy.new(self, JsonApi::QueryBuilder.new.include(*types))
end

Instance Method Details

#[](key) ⇒ Object 



284
285
286
 
# File 'lib/clicksign/resource.rb', line 284

def [](key)
  @_attributes&.[](key.to_s)
end

#base_path ⇒ Object 



280
281
282
 
# File 'lib/clicksign/resource.rb', line 280

def base_path
  self.class.endpoint
end

#delete ⇒ Object 



268
269
270
271
 
# File 'lib/clicksign/resource.rb', line 268

def delete
  self.class.client.delete("#{base_path}/#{@id}")
  nil
end

#reload ⇒ Object 



273
274
275
276
277
278
 
# File 'lib/clicksign/resource.rb', line 273

def reload
  raw    = self.class.client.get("#{base_path}/#{@id}")
  parsed = JsonApi::Parser.parse(raw)
  load_data(parsed[:data].first, parent_id: @_parent_id)
  self
end

#respond_to_missing?(name, include_private = false) ⇒ Boolean

Returns:

  • (Boolean) 


296
297
298
299
 
# File 'lib/clicksign/resource.rb', line 296

def respond_to_missing?(name, include_private = false)
  key = name.to_s.delete_suffix('=')
  @_attributes&.key?(key) || super
end

#update(**attributes) ⇒ Object 



256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/clicksign/resource.rb', line 256

def update(**attributes)
  raw = self.class.client.patch(
    "#{base_path}/#{@id}",
    body: JsonApi::Serializer.dump(
      type: self.class.resource_type, id: @id, attributes: attributes,
    ),
  )
  parsed = JsonApi::Parser.parse(raw)
  load_data(parsed[:data].first, parent_id: @_parent_id)
  self
end