Need help with smart_init?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

pawurb
140 Stars 3 Forks MIT License 65 Commits 0 Opened issues

Description

A simple gem for eliminating Ruby initializers boilerplate code, and providing unified service objects API

Services available

!
?

Need anything else?

Contributors list

Smart Init - Simple service objects in Ruby Build Status Gem Version

Do you find yourself writing a lot of boilerplate code like this?

def initialize(network_provider, api_token)
  @network_provider = network_provider
  @api_token = api_token
end

def self.call(network_provider, api_token) new(network_provider, api_token).call end

This gem provides a simple DSL for getting rid of it. It offers an alternative to using

Struct.new
which does not check for number of parameters provided in initializer, exposes getters and instantiates unecessary class instances.

Smart Init offers a unified API convention for stateless service objects, accepting values in initializer and exposing one public class method

call
which instantiates new objects and accepts arguments passed to initializer.

Check out this blog post for my reasoning behind this approach to service object pattern.

Installation

In your Gemfile

gem 'smart_init'

API

You can use it either by extending a module:

require 'smart_init'

class ApiClient extend SmartInit

initialize_with :network_provider, :api_token end

or subclassing:

class ApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token
end

Now you can just:

object = ApiClient.new(network_provider: Faraday.new, api_token: 'secret_token')
# <0x007fa16684ec20>, @api_token="secret_token">

If you omit a required attribute an

ArgumentError
will be thrown:
client = ApiClient.new(network_provider: Faraday.new)

ArgumentError (missing required attribute api_token)

Making the object callable

You can use the

is_callable
method:
class Calculator < SmartInit::Base
  initialize_with :data
  is_callable

def call ... result end end

Calculator.call(data: data) => result

Optionally you can customize a callable method name:

class Routine < SmartInit::Base
  initialize_with :params
  is_callable method_name: :run!

def run! ... end end

Routine.run!(params: params)

Default arguments

You can use hash based, default argument values:

class Adder < SmartInit::Base
  initialize_with :num_a, num_b: 2
  is_callable

def call num_a + num_b end end

Adder.call(num_a: 2) => 4 Adder.call(num_a: 2, num_b: 3) => 5

Readers access

Contrary to using Struct, by default the reader methods are not publicly exposed:

client = ApiClient.new(network_provider: Faraday.new, api_token: 'secret_token')
client.api_token => # NoMethodError (private method `api_token' called for #<0x000..>)

Optionally you can make all or subset of readers public using the

public_readers
config option. It accepts
true
or an array of method names as an argument.
class PublicApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, public_readers: true
end

client = PublicApiClient.new(network_provider: Faraday.new, api_token: 'secret_token') client.network_provider => #<:connection:0x000...> client.api_token => 'secret_token' </:connection:0x000...>

class SemiPublicApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, public_readers: [:network_provider]
end

client = SemiPublicApiClient.new(network_provider: Faraday.new, api_token: 'secret_token') client.network_provider => #<:connection:0x000...> client.api_token => 'secret_token' => # NoMethodError (private method `api_token' called for #<0x000...>) </0x000...></:connection:0x000...>

Accessors access

Similarly, this is how it would look if you tried to use a writer method:

client = ApiClient.new(network_provider: Faraday.new, api_token: 'secret_token')
client.api_token = 'new_token' => # NoMethodError (private method `api_token=' called for #<0x000..>)

Optionally you can make all or subset of accessors public using the

public_accessors
config option. It accepts
true
or an array of method names as an argument. This will provide both reader and writer methods publicly.
class PublicApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, public_accessors: true
end

client = PublicApiClient.new(network_provider: Faraday.new, api_token: 'secret_token') client.network_provider => #<:connection:0x000...> client.network_provider = Typhoeus::Request.new(...) => #<:request:0x000...> client.api_token => 'secret_token' client.api_token = 'new_token' => 'new_token' </:request:0x000...></:connection:0x000...>

class SemiPublicApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, public_accessors: [:network_provider]
end

client = SemiPublicApiClient.new(network_provider: Faraday.new, api_token: 'secret_token') client.network_provider => #<:connection:0x000...> client.network_provider = Typhoeus::Request.new(...) => #<:request:0x000...> client.api_token => # NoMethodError (private method api_token' called for #<0x000...>) client.api_token = 'new_token' =&gt; # NoMethodError (undefined method api_token=' called for #<0x000...>) </0x000...></0x000...></:request:0x000...></:connection:0x000...>

Finally, you can mix them together like this:

class PublicReadersSemiPublicAccessorsApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, :timeout,
                  public_readers: true, public_accessors: [:network_provider]
end

client = PublicReadersSemiPublicAccessorsApiClient.new( network_provider: Faraday.new, api_token: 'secret_token', timeout_length: 100 ) client.network_provider => #<:connection:0x000...> client.network_provider = Typhoeus::Request.new(...) => #<:request:0x000...> client.api_token => 'secret_token' client.api_token = 'new_token' => # NoMethodError (undefined method api_token=' called for #<0x000...>) client.timeout_length =&gt; 100 client.timeout_length = 150 =&gt; # NoMethodError (undefined method timeout_length=' called for #<0x000...>) </0x000...></0x000...></:request:0x000...></:connection:0x000...>

class SemiPublicReadersSemiPublicAccessorsApiClient < SmartInit::Base
  initialize_with :network_provider, :api_token, :timeout,
                  public_readers: [:timeout], public_accessors: [:network_provider]
end

client = SemiPublicReadersSemiPublicAccessorsApiClient.new( network_provider: Faraday.new, api_token: 'secret_token', timeout_length: 100 ) client.network_provider => #<:connection:0x000...> client.network_provider = Typhoeus::Request.new(...) => #<:request:0x000...> client.api_token => # NoMethodError (private method api_token' called for #<0x000...>) client.api_token = 'new_token' =&gt; # NoMethodError (undefined method api_token=' called for #<0x000...>) client.timeout_length => 100 client.timeout_length = 150 => # NoMethodError (undefined method `timeout_length=' called for #<0x000...>) </0x000...></0x000...></0x000...></:request:0x000...></:connection:0x000...>

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.