ruby Archives – Coding Randomly

Custom initializer when subclassing Dry::Struct

By Jean-Sebastien Gelinas | September 25, 2020 - 8:30 am | September 20, 2020 ruby

The Problem

The solution seems simple: the subclass should simply not send part of the information to its base constructor. But Dry::Struct was built in a way that we can’t do that as easily. The first thing I tried was the following:

require 'dry-struct'

module ::Types
  include ::Dry.Types()
end

class ::A < ::Dry::Struct
  attribute :X, ::Types::Integer
  attribute :Y, ::Types::Integer
end

class ::B < ::A
  attribute :Z, ::Types::Integer

  def initialize(**kwargs)
    kwargs[:X] = kwargs[:Z] * 10
    super(**kwargs)
  end
end

pp(B.new(X:1, Y: 2, Z: 3))  # < Good
pp(B.new(Y: 2, Z: 3))  # < Boom!

require 'dry-struct'

module ::Types

include ::Dry.Types()

end

class ::A < ::Dry::Struct

attribute :X, ::Types::Integer

attribute :Y, ::Types::Integer

end

class ::B < ::A

attribute :Z, ::Types::Integer

def initialize(**kwargs)

kwargs[:X] = kwargs[:Z] * 10

super(**kwargs)

end

pp(B.new(X:1, Y: 2, Z: 3)) # < Good

pp(B.new(Y: 2, Z: 3)) # < Boom!

Line 21 works correctly, but this is not what I wanted to achieve. I wanted to not have to specify X when creating the object, like the line 22. When doing so, I got greeted with a: in `block in resolve_missing_keys': :X is missing in Hash input (Dry::Types::MissingKeyError).

After investigating the callstack, I figured that the validation was not done in the initializer, but in the class’s new function.

The Solution

Armed with the information that the validation is done in the new function, I tried something else. The following is the version I ended up with:

require 'dry-struct'

module ::Types
  include ::Dry.Types()
end

class ::A < ::Dry::Struct
  attribute :X, ::Types::Integer
  attribute :Y, ::Types::Integer
end

class ::B < ::A
  attribute :Z, ::Types::Integer

  def self.new(**kwargs)
    kwargs[:X] = kwargs[:Z] * 10
    super(**kwargs)
  end
end

pp(B.new(X:1, Y: 2, Z: 3))  # < Good
pp(B.new(Y: 2, Z: 3))  # < Good

require 'dry-struct'

module ::Types

include ::Dry.Types()

end

class ::A < ::Dry::Struct

attribute :X, ::Types::Integer

attribute :Y, ::Types::Integer

end

class ::B < ::A

attribute :Z, ::Types::Integer

def self.new(**kwargs)

kwargs[:X] = kwargs[:Z] * 10

super(**kwargs)

end

pp(B.new(X:1, Y: 2, Z: 3)) # < Good

pp(B.new(Y: 2, Z: 3)) # < Good

The magic is on line 15: instead of defining an initializer, I overload the new function of my class. This allows me the same control as an initializer but does this before Dry::Struct validations.

Now, is this the best solution … probably not. But following the documentation, I could not find any other ways to do it.

Using SemanticLogger with Highline in Ruby

By Jean-Sebastien Gelinas | September 11, 2020 - 8:50 am | September 12, 2020 ruby

The problem

The first input I did, after showing a few debug information, ended up a mangled mess looking like:

$ bundle exec bin/test.rb 
Input?  2020-09-11 08:35:00.147566 D [7973:70368367434100] test -- I am a debug info!
123

$ bundle exec bin/test.rb

Input? 2020-09-11 08:35:00.147566 D [7973:70368367434100] test -- I am a debug info!

123

You can clearly see that the output is intertwined with the input selection. This is really annoying and needed fixing.

The associated code did not look anything weird, even a simple test like the following produces the issue:

#!/usr/bin/env ruby

require 'highline'
require 'semantic_logger'

::SemanticLogger.default_level = :trace
::SemanticLogger.add_appender(io: ::STDOUT, formatter: :color)

cli = ::HighLine.new
logger = ::SemanticLogger['test']

logger.debug('I am a debug info!')
cli.ask('Input?  ')

#!/usr/bin/env ruby

require 'highline'

require 'semantic_logger'

::SemanticLogger.default_level = :trace

::SemanticLogger.add_appender(io: ::STDOUT, formatter: :color)

cli = ::HighLine.new

logger = ::SemanticLogger['test']

logger.debug('I am a debug info!')

cli.ask('Input? ')

The only explanation for me was that the output from the logger was done in an asynchronous way, either some kind of buffering or simply done in a background thread. After checking a bit more Highline’s homepage, I found the answer:

Logging is performed in a separate thread so as not to slow down the application whilst logging to one or more destinations.

The solution

After looking through more guides from the official site, I finally found what I needed: a way to make SemanticLogger log in the current thread.

There are multiple ways of enabling this feature, I decided to go with the code-based approach: add ::SemanticLogger.sync! before any of my appenders got created.

Doing so, my final solution looks like:

#!/usr/bin/env ruby

require 'highline'
require 'semantic_logger'

::SemanticLogger.sync!
::SemanticLogger.default_level = :trace
::SemanticLogger.add_appender(io: ::STDOUT, formatter: :color)

cli = ::HighLine.new
logger = ::SemanticLogger['test']

logger.debug('I am a debug info!')
cli.ask('Input?  ')

#!/usr/bin/env ruby

require 'highline'

require 'semantic_logger'

::SemanticLogger.sync!

::SemanticLogger.default_level = :trace

::SemanticLogger.add_appender(io: ::STDOUT, formatter: :color)

cli = ::HighLine.new

logger = ::SemanticLogger['test']

logger.debug('I am a debug info!')

cli.ask('Input? ')

And my output is finally as expected:

$ bundle exec bin/test.rb 
2020-09-11 08:47:46.313660 D [8129:70368255498600] test -- I am a debug info!
Input?  123

$ bundle exec bin/test.rb

2020-09-11 08:47:46.313660 D [8129:70368255498600] test -- I am a debug info!

Input? 123

Interacting with Google Tasks using Ruby

By Jean-Sebastien Gelinas | January 29, 2018 - 10:28 pm | January 29, 2018 ruby

Project Setup

All of the Google Tasks APIs are basically REST endpoints. One could simply call all these HTTP endpoints manually, but this would be painful. I decided to use google-api-client to do all the heavy lifting. In order to include it in your project, simply add the following to your Gemfile:

gem 'google-api-client', '~> 0.11'

1	gem 'google-api-client', '~> 0.11'

Google API Setup

In order to access Google Tasks using Ruby, you will need to use Google’s OAuth. Google’s OAuth uses what they call client secrets file. These files contain all the information needed to access the selected services.

To get a client secrets file, you can follow my other post.

Handling the user’s credentials

The way the Google APIs work, an URL will be provided to you. Opening that URL and grabbing the authentication token is all on you. Therefore, there is three consideration when handling the user’s credential:

Storing the credentials (so that you don’t ask access every time);
Showing the consent webpage;
Grabbing the authentication token;

For this quick test, I decided to use a file storage for the token. The FileTokenStore token store will simply use a YAML file to store the user’s tokens. To show the consent webpage, I went with launchy. This cross-platform library will handle opening URLs in the default browser and such. Finally, I decided to basically do nothing to grab the token: I expect the user to paste it on the command line.

require 'googleauth'
require 'googleauth/stores/file_token_store'
require 'launchy'

OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'

scope = 'https://www.googleapis.com/auth/tasks'
client_id = Google::Auth::ClientId.from_file('./client_secrets.json')
token_store = Google::Auth::Stores::FileTokenStore.new(:file => './tokens.yaml')
authorizer = Google::Auth::UserAuthorizer.new(client_id, scope, token_store)

user_id = 'default'
credentials = authorizer.get_credentials(user_id)
if credentials.nil?
  url = authorizer.get_authorization_url(base_url: OOB_URI )
  Launchy.open(url)
  code = gets
  credentials = authorizer.get_and_store_credentials_from_code(user_id: user_id, code: code, base_url: OOB_URI)
end

require 'googleauth'

require 'googleauth/stores/file_token_store'

require 'launchy'

OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'

scope = 'https://www.googleapis.com/auth/tasks'

client_id = Google::Auth::ClientId.from_file('./client_secrets.json')

token_store = Google::Auth::Stores::FileTokenStore.new(:file => './tokens.yaml')

authorizer = Google::Auth::UserAuthorizer.new(client_id, scope, token_store)

user_id = 'default'

credentials = authorizer.get_credentials(user_id)

if credentials.nil?

url = authorizer.get_authorization_url(base_url: OOB_URI )

Launchy.open(url)

code = gets

credentials = authorizer.get_and_store_credentials_from_code(user_id: user_id, code: code, base_url: OOB_URI)

end

Initializing the Google Tasks API

Now that you have the user’s credentials, you can initialize the API you want to use. In my case, this is the task API. In order to do so, simply create a new instance of the service you want to use (Google::Apis::TasksV1::TasksService) and set its authorization member to the credentials you got from the client.

require 'google/apis/tasks_v1'

[snip]

Tasks = Google::Apis::TasksV1 # Alias the module
tasks_service = Tasks::TasksService.new
tasks_service.authorization = credentials

require 'google/apis/tasks_v1'

[snip]

Tasks = Google::Apis::TasksV1 # Alias the module

tasks_service = Tasks::TasksService.new

tasks_service.authorization = credentials

Interacting with Google Tasks using Ruby

Creating a task list

The tasklist is basically a grouping of tasks. It is the root concept of Google Tasks. Creating one is quite straightforward:

tasklist = tasks_service.insert_tasklist(
  Tasks::TaskList.new(title:'generated')
)

tasklist = tasks_service.insert_tasklist(

Tasks::TaskList.new(title:'generated')

)

Finding a task list

The Google Tasks API only allows you to search by tasklist ID, not a title. This ID is automatically generated and therefore not really easy to use. The easiest way to find a task list is to list all task lists and find the one you are looking for in there:

tasklists = tasks_service.list_tasklists
tasklist = tasklists.items.find { |t| t.title == 'generated' }

1 2	tasklists = tasks_service.list_tasklists tasklist = tasklists.items.find { \|t\| t.title == 'generated' }

Creating a task

Creating a simple task, at the top of the task list is quite straightforward:

task = tasks_service.insert_task(
  tasklist.id,
  Tasks::Task.new(title:'generated')
)

task = tasks_service.insert_task(

tasklist.id,

Tasks::Task.new(title:'generated')

)

Finding a task

Just like finding a task list, finding a task by its title can’t be done directly through the API. In order to do so, you need to iterate over the tasks and check them:

tasks = tasks_service.list_tasks(tasklist.id)
task = tasks.items.nil? ? nil : tasks.items.find { |t| t.title == 'generated' }

1 2	tasks = tasks_service.list_tasks(tasklist.id) task = tasks.items.nil? ? nil : tasks.items.find { \|t\| t.title == 'generated' }

Updating a task

Once you have your hand on the task you want to update, simply update the field you want to update and call update_task:

task.due = DateTime.new(2020,2,3,4,5,6)
task = tasks_service.update_task(tasklist.id, task.id, task)

1 2	task.due = DateTime.new(2020,2,3,4,5,6) task = tasks_service.update_task(tasklist.id, task.id, task)

Completing a task

Completing a task is done by setting its status to “completed” and updating the task:

task.status = "completed"
task = tasks_service.update_task(tasklist.id, task.id, task)

1 2	task.status = "completed" task = tasks_service.update_task(tasklist.id, task.id, task)

Handling a large number of return values

Google’s Task API uses pagination in order to handle a large number of return values. By default, a maximum of 100 return values will be returned by calls to list_tasklists and list_tasks. The return values of these two APIs will contain a next_page_token value. You can then use this token in a subsequent call to the API specifying the optional argument page_token in order to get another set of return values.

Here is a quick example of handling of pagination with the list_tasks call. Do note that in this example, I set the max_results value in the call so that I do not have to create 100+ tasks.

tasklists = tasks_service.list_tasklists
tasklist = tasklists.items.find { |t| t.title == 'overflow' }
token = nil
begin
  tasks = tasks_service.list_tasks(tasklist.id, max_results: 10, page_token: token)
  puts "Found #{tasks.items.size} tasks"
  token = tasks.next_page_token
end while not token.nil?

tasklists = tasks_service.list_tasklists

tasklist = tasklists.items.find { |t| t.title == 'overflow' }

token = nil

begin

tasks = tasks_service.list_tasks(tasklist.id, max_results: 10, page_token: token)

puts "Found #{tasks.items.size} tasks"

token = tasks.next_page_token

end while not token.nil?

Category Archives: ruby

Custom initializer when subclassing Dry::Struct

The Problem

The Solution

Using SemanticLogger with Highline in Ruby

The problem

The solution

Interacting with Google Tasks using Ruby

Project Setup

Google API Setup

Handling the user’s credentials

Initializing the Google Tasks API

Interacting with Google Tasks using Ruby

Creating a task list

Finding a task list

Creating a task

Finding a task

Updating a task

Completing a task

Handling a large number of return values

Sources

Recent Posts

Categories

Meta

The Problem

The Solution

The problem

The solution

Project Setup

Google API Setup

Handling the user’s credentials

Initializing the Google Tasks API

Interacting with Google Tasks using Ruby

Creating a task list

Finding a task list

Creating a task

Finding a task

Updating a task

Completing a task

Handling a large number of return values

Sources

Recent Posts

Categories

Tags

Meta