fastly_nsq 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 675e3b849867520a11d52017b73a07381287abee
-  data.tar.gz: 6f6f61ed2785d5872e2ea944d88bafffdc1c7817
+  metadata.gz: 9f152c638769443e0a5a05d21222eeb4830d4873
+  data.tar.gz: d7bf933bf02602023f81c09480064745baf547cb
 SHA512:
-  metadata.gz: 5c8e596008b721e62a78064d98e185dfeae6c2f176a995ffdf3835103d90b9bf1e537aa29a004c9acfdd9d3503961eecb998e9dcb6a7afaf9e6d46c3f6c3fc62
-  data.tar.gz: f386146874a9fd8ed2bcfeaff3a17fac5568b28873a55de583dda3f33b0ab821bc4a56a36008b5ad971be4e4a4d69ac3f7cb23d1fb2bb326721372e3d71c06c1
+  metadata.gz: 987c9d1a7c2e654c8fcd540c6cd78f8d819a9b1723cabc74aee1a7ac27937d045c3c0ce2b80676dc171cb7b84e73d656d0b5b087618aff1dc67b4028f72847d2
+  data.tar.gz: e2e808a1f5daea8da64331e47b5097a1b33efd43376adbe7da14f906d3ac51f88d987b4c81a073f965a35f42b1b672fd37d15a90890dc05b3f78e83681a061d4

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -19,7 +19,7 @@ Checklist
 _Put an `x` in the boxes that apply. 
 You can also fill these out after creating the PR._
 
-- [ ] I have linked to all relavant reference issues or work requests
+- [ ] I have linked to all relevant reference issues or work requests
 - [ ] I have added tests that prove my fix is effective or that my feature works
 - [ ] I have added or updated necessary documentation (if appropriate)
 - [ ] Any dependent changes have been merged and published in downstream

data/README.md

@@ -52,7 +52,6 @@ write messages onto the queue:
 
 ```ruby
 message_data = {
-  "event_type" => "heartbeat",
   "data" => {
     "key" => "value"
   }
@@ -65,7 +64,6 @@ producer = MessageQueue::Producer.new(
 
 producer.write(message_data.to_json)
 ```
-
 The mock/real strategy used
 can be switched
 by adding an environment variable
@@ -94,7 +92,7 @@ consumer = MessageQueue::Consumer.new(
 
 consumer.size #=> 1
 message = consumer.pop
-message.body #=> "{ 'event_type': 'heartbeat','data': { 'key': 'value' } }"
+message.body #=> "{ 'data': { 'key': 'value' } }"
 message.finish
 consumer.size #=> 0
 consumer.terminate
@@ -119,7 +117,7 @@ MessageQueue::Listener.new(topic: topic, channel: channel).process_next_message
 This will pop the next message
 off of the queue
 and send the JSON text body
-to `MessageProcessor.new(message_body).go`.
+to `MessageProcessor.new(message_body: message_body, topic: topic).go`.
 
 To initiate a blocking loop to process messages continuously:
 
@@ -141,15 +139,23 @@ there is a new message on the queue,
 To help facilitate running the `MessageQueue::Listener` in a blocking fashion
 outside your application, a simple `RakeTask` is provided.
 
-This can be added into your `Rakefile` in one of two ways:
+NOTE: The rake task expects a
+`MessageProcessor.topics` method,
+which must return an array of strings
+defining the topics to which
+we would like to listen and process messages.
+
+The task will listen
+to all specified topics,
+each in a separate thread.
+
+This task can be added into your `Rakefile` in one of two ways:
 
 Using a block:
 ```ruby
-require 'fastly_nsq'
 require 'fastly_nsq/rake_task'
 
 MessageQueue::RakeTask.new(:listen_task) do |task|
-  task.topic   = 'some_topic'
   task.channel = 'some_channel'
 end
 
@@ -159,13 +165,12 @@ end
 
 or using passed in values:
 ```ruby
-require 'fastly_nsq'
 require 'fastly_nsq/rake_task'
 
-MessageQueue::RakeTask.new(:listen_task, [:topic, :channel])
+MessageQueue::RakeTask.new(:listen_task, [:channel])
 
 # usage:
-`rake listen_task['my_topic','my_channel']`
+`rake listen_task['my_channel']`
 ```
 
 Both methods can be used at the same time with the passed in values taking

data/examples/Rakefile

@@ -1,41 +1,88 @@
-require 'fastly_nsq'
 require 'fastly_nsq/rake_task'
 
-##
-# Both topic and channel will need to be passed into the rake task when
-# it is called.
-#
-# ex: `rake listen_task[my_topic,my_channel]`
-# topic will be 'my_topic' and channel will be 'my_channel'
-#
-MessageQueue::RakeTask.new(:listen_task, [:topic, :channel])
+#-------------------------------------------------------------------------------
+# You are required to to set the topics in MessageProcessor.topics as an array:
 
-##
-# In Rails, you can include the environment like so:
-#
-MessageQueue::RakeTask.new(:listen_task, [:topic, :channel] => :environment)
+class MessageProcessor
+  def self.topics
+    ['customer_created', 'customer_deleted']
+  end
 
-##
-# Topic and channel can also be preset in the task by passing a block and
-# assigning value like so. This is useful if you want a single purpose
-# listener task.
-#
-# ex: `rake listen_task`
-# topic will be 'some_topic' and channel will be 'some_channel'
+  # ...
+end
+
+# A channel will need to be passed in
+# to the Rake task
+# when it is called.
 #
+# The task looks like:
+
+desc 'Listen to the messaging queue with the given channel.'
+
+MessageQueue::RakeTask.new(:listen_task, [:channel])
+
+# Call `rake listen_task[my_channel]`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'my_channel'.
+
+#-------------------------------------------------------------------------------
+# In Rails, you can include the application environment. The task looks like:
+
+desc 'Listen to the messaging queue with the given channel.'
+
+MessageQueue::RakeTask.new(:listen_task, [:channel] => :environment)
+
+# Call `rake listen_task[your_channel]`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'your_channel'.
+
+#-------------------------------------------------------------------------------
+# The channel can also be preset in the task
+# by passing a block and assigning the value. The task looks like:
+
+desc 'Listen to the messaging queue with the given channel.'
+
 MessageQueue::RakeTask.new(:listen_task) do |task|
-  task.topic   = 'some_topic'
   task.channel = 'some_channel'
 end
 
-##
-# Both forms can be combine to provide defaults of a sort with the ability
-# to override at time of rake call
-#
-# ex: `rake listen_task[altered_topic]`
-# topic will be 'altered_topic' and channel will be 'some_channel'
-#
-MessageQueue::RakeTask.new(:listen_task, [:topic, :channel]) do |task|
-  task.topic   = 'some_topic'
-  task.channel = 'some_channel'
+# Call `rake listen_task`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'some_channel'.
+
+#-------------------------------------------------------------------------------
+# Do the same thing and include the environment:
+
+desc 'Listen to the messaging queue with the given channel.'
+
+MessageQueue::RakeTask.new(:listen_task, [] => :environment) do |task|
+  task.channel = 'her_channel'
 end
+
+# Call `rake listen_task`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'her_channel'.
+
+#-------------------------------------------------------------------------------
+# Both forms can be combined
+# to provide defaults
+# with the ability to override at time of Rake call:
+
+MessageQueue::RakeTask.new(:listen_task, [:channel]) do |task|
+  task.channel = 'default_channel'
+end
+
+# Call `rake listen_task[overridden_channel]`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'overridden_channel'.
+
+#-------------------------------------------------------------------------------
+# The same, but including the environment:
+
+MessageQueue::RakeTask.new(:listen_task, [:channel] => :environment) do |task|
+  task.channel = 'default_channel'
+end
+
+# Call `rake listen_task[overridden_channel]`.
+# The topics will be ['customer_created', 'customer_deleted']
+# and channel will be 'overridden_channel'.

data/lib/fastly_nsq/message_queue/listener.rb

@@ -26,14 +26,14 @@ module MessageQueue
 
     private
 
+    attr_reader :channel, :topic
+
     def process_one_message
       message = consumer.pop
-      MessageProcessor.new(message.body).go
+      MessageProcessor.new(message_body: message.body, topic: topic).go
       message.finish
     end
 
-    attr_reader :channel, :topic
-
     def consumer
       @consumer ||= MessageQueue::Consumer.new(consumer_params).connection
     end

data/lib/fastly_nsq/rake_task.rb

@@ -3,38 +3,77 @@ require 'rake/tasklib'
 
 module MessageQueue
   class RakeTask < Rake::TaskLib
-    attr_accessor :name, :topic, :channel
+    attr_accessor :name, :channel
 
     def initialize(*args, &task_block)
       @name = args.shift || :begin_listening
 
-      desc 'Listen to NSQ on topic using channel' unless ::Rake.application.last_comment
+      unless ::Rake.application.last_comment
+        desc 'Listen to NSQ on topic using channel'
+      end
 
       task(name, *args) do |_, task_args|
         RakeFileUtils.send(:verbose, verbose) do
-          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-          @topic   = task_args[:topic] if task_args[:topic]
-          @channel = task_args[:channel] if task_args[:channel]
-          run_task
+          if block_given?
+            yield(*[self, task_args].slice(0, task_block.arity))
+          end
+
+          if task_args[:channel]
+            @channel = task_args[:channel]
+          end
+
+          guard_missing_channel
+          run_tasks
         end
       end
     end
 
     private
 
-    def run_task
-      raise ArgumentError, "topic and channel are required. Recieved topic: #{topic} channel: #{channel}" unless topic && channel
+    def run_tasks
+      topics.each do |topic|
+        Thread.new do
+          wrap_helpful_output(topic) do
+            MessageQueue::Listener.new(topic: topic, channel: channel).go
+          end
+        end
+      end
+
+      non_main_threads.map(&:join)
+    end
 
-      output "Listening to the queue on topic:'#{topic}' and channel ':#{channel}'"
+    def non_main_threads
+      (Thread.list - [Thread.main])
+    end
 
-      MessageQueue::Listener.new(topic: topic, channel: channel).go
+    def guard_missing_channel
+      unless channel
+        raise ArgumentError, "channel is required. Received channel: #{channel}"
+      end
+    end
+
+    def wrap_helpful_output(topic)
+      output "Listening to queue, topic:'#{topic}' and channel: '#{channel}'"
+      yield
+      output "... done listening on topic:'#{topic}' and channel: '#{channel}'."
+    end
+
+    def topics
+      MessageProcessor.topics
+    rescue NoMethodError => exception
+      if exception.message =~ /undefined method `topics'/
+        raise ArgumentError, 'MessageProcessor.topics is not defined.'
+      else
+        raise exception
+      end
+    end
 
-      output "... done listening to queue on topic:'#{topic}' and channel ':#{channel}'"
+    def output(string)
+      logger.info(string)
     end
 
-    # wrapping output for stubbing in tests to avoid clobbering output...
-    def output(str)
-      puts str
+    def logger
+      MessageQueue.logger = Logger.new(STDOUT)
     end
   end
 end

data/lib/fastly_nsq/sample_message_processor.rb

@@ -11,12 +11,17 @@ class UnknownMessageWorker
 end
 
 class SampleMessageProcessor
-  EVENT_TYPE_TO_WORKER_MAP = {
+  TOPIC_TO_WORKER_MAP = {
     'heartbeat' => HeartbeatWorker,
   }.freeze
 
-  def initialize(message_body)
+  def self.topics
+    TOPIC_TO_WORKER_MAP.keys
+  end
+
+  def initialize(message_body:, topic:)
     @message_body = message_body
+    @topic = topic
   end
 
   def go
@@ -25,18 +30,14 @@ class SampleMessageProcessor
 
   private
 
-  attr_reader :message_body
+  attr_reader :message_body, :topic
 
   def process_message_body
     message_processor.perform_async(message_data)
   end
 
   def message_processor
-    EVENT_TYPE_TO_WORKER_MAP.fetch(event_type, UnknownMessageWorker)
-  end
-
-  def event_type
-    parsed_message_body['event_type']
+    TOPIC_TO_WORKER_MAP.fetch(topic, UnknownMessageWorker)
   end
 
   def message_data

data/lib/fastly_nsq/version.rb

@@ -1,3 +1,3 @@
 module FastlyNsq
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

data/spec/lib/fastly_nsq/message_queue/listener_spec.rb

@@ -32,7 +32,8 @@ RSpec.describe MessageQueue::Listener do
       MessageQueue::Listener.new(topic: topic, channel: channel).
         process_next_message
 
-      expect(MessageProcessor).to have_received(:new).with(message_body)
+      expect(MessageProcessor).to have_received(:new).
+        with(topic: topic, message_body: message_body)
       expect(process_message).to have_received(:go)
     end
 

data/spec/lib/fastly_nsq/message_queue_spec.rb

@@ -2,25 +2,21 @@ require 'spec_helper'
 
 RSpec.describe MessageQueue do
   describe '.logger' do
-    describe 'when using the fake queue' do
+    describe 'when using the fake queue', fake_queue: true do
       it 'allows the logger to be set and retrieved' do
-        use_fake_connection do
-          logger = Logger.new(STDOUT)
-          MessageQueue.logger = logger
+        logger = Logger.new(STDOUT)
+        MessageQueue.logger = logger
 
-          expect(MessageQueue.logger).to eq logger
-        end
+        expect(MessageQueue.logger).to eq logger
       end
     end
 
-    describe 'when using the real queue' do
+    describe 'when using the real queue, fake_queue: false' do
       it 'allows the logger to be set and retrieved' do
-        use_real_connection do
-          logger = Logger.new(STDOUT)
-          MessageQueue.logger = logger
+        logger = Logger.new(STDOUT)
+        MessageQueue.logger = logger
 
-          expect(MessageQueue.logger).to eq logger
-        end
+        expect(MessageQueue.logger).to eq logger
       end
     end
   end

data/spec/lib/fastly_nsq/rake_task_spec.rb

@@ -3,71 +3,126 @@ require 'fastly_nsq/rake_task'
 
 RSpec.describe MessageQueue::RakeTask do
   before(:each) do
-    Rake::Task['begin_listening'].clear if Rake::Task.task_defined?('begin_listening')
+    Rake::Task.clear
+    allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
   end
 
   describe 'when defining tasks' do
-    it 'creates a begin_listening task' do
-      MessageQueue::RakeTask.new
+    context 'when no task name is provided' do
+      it 'creates a task with the default name' do
+        default_task_name = 'begin_listening'
 
-      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+        MessageQueue::RakeTask.new
+        defined_tasks = Rake::Task.tasks
+        first_task_name = defined_tasks.first.name
 
-      is_defined = Rake::Task.task_defined?(:begin_listening)
-      expect(is_defined).to be_truthy
+        expect(first_task_name).to eq default_task_name
+      end
     end
 
-    it 'creates a named task' do
-      MessageQueue::RakeTask.new(:test_name)
+    context 'when a task name is passed in' do
+      it 'creates a task with the provided name' do
+        task_name = 'test_name'
 
-      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+        MessageQueue::RakeTask.new(task_name.to_sym)
+        defined_tasks = Rake::Task.tasks
+        first_task_name = defined_tasks.first.name
 
-      is_defined = Rake::Task.task_defined?(:test_name)
-      expect(is_defined).to be_truthy
+        expect(first_task_name).to eq task_name
+      end
     end
   end
 
   describe 'when running tasks' do
-    it 'runs with inline options defined' do
-      options = { topic: 'dwarf', channel: 'star' }
-      task = MessageQueue::RakeTask.new(:begin_listening, [:topic, :channel])
+    context 'when multiple topics are defined' do
+      it 'creates a listener for each' do
+        channel = 'clown_generating_service'
+        topics = ['customer_created', 'customer_now_awesome']
+        allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+        message_queue_listener = double('listener', go: nil)
+        allow(MessageQueue::Listener).to receive(:new).
+          and_return(message_queue_listener)
+
+        MessageQueue::RakeTask.new(:begin_listening, [:channel])
+        Rake::Task['begin_listening'].execute(channel: channel)
+
+        topics.each do |topic|
+          expect(MessageQueue::Listener).to have_received(:new).
+            with(topic: topic, channel: channel)
+        end
+      end
+    end
+
+    it 'listens to the command-line-provided channel' do
+      channel = 'salesforce'
+      topics = ['customer_created']
+      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
 
-      message_queue_listener = double('go', go: nil)
+      message_queue_listener = double('listener', go: nil)
       expect(MessageQueue::Listener).to receive(:new).
-        with(options).
+        with(topic: topics.first, channel: channel).
         and_return(message_queue_listener)
 
-      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
-      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+      MessageQueue::RakeTask.new(:begin_listening, [:channel])
+      Rake::Task['begin_listening'].execute(channel: channel)
     end
 
-    it 'runs with specified options if a block is given' do
+    it 'runs with specified channel if a block is given' do
+      channel = 'send_new_customers_a_sticker_service'
+      topics = ['customer_created']
+      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+
+      message_queue_listener = double('listener', go: nil)
+      expect(MessageQueue::Listener).to receive(:new).
+        with(topic: topics.first, channel: channel).
+        and_return(message_queue_listener)
+
       MessageQueue::RakeTask.new do |task|
-        task.topic   = 'dwarf'
-        task.channel = 'star'
+        task.channel = channel
       end
+      Rake::Task['begin_listening'].execute(channel: channel)
+    end
+
+    it 'prefers inline channel definition over block assignments' do
+      default_channel = 'throw_a_huge_pizza_party_service'
+      new_channel = 'send_balloons_to_customer_service'
+      topics = ['customer_created']
+      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
 
-      message_queue_listener = double('go', go: nil)
+      message_queue_listener = double('listener', go: nil)
       expect(MessageQueue::Listener).to receive(:new).
-        with(topic: 'dwarf', channel: 'star').
+        with(topic: topics.first, channel: new_channel).
         and_return(message_queue_listener)
 
-      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
-      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+      MessageQueue::RakeTask.new(:begin_listening, [:channel]) do |task|
+        task.channel = default_channel
+      end
+      Rake::Task['begin_listening'].execute(channel: new_channel)
     end
 
-    it 'uses inline definitions over block assignments' do
-      MessageQueue::RakeTask.new(:begin_listening, [:topic, :channel]) do |task|
-        task.topic   = 'loud'
-        task.channel = 'noise'
+    context 'when no channel is provided' do
+      it 'raises an error' do
+        topics = ['customer_created']
+        allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+
+        expect {
+          MessageQueue::RakeTask.new(:begin_listening, [:channel])
+          Rake::Task['begin_listening'].execute
+        }.to raise_error(ArgumentError, /channel is required/)
       end
+    end
 
-      message_queue_listener = double('go', go: nil)
-      expect(MessageQueue::Listener).to receive(:new).
-        with(topic: 'dwarf', channel: 'star').
-        and_return(message_queue_listener)
+    context 'when MessageProcessor.topics is not defined' do
+      it 'raises an error' do
+        channel = 'best_server_number_1'
+        allow(SampleMessageProcessor).to receive(:topics).
+          and_raise(NoMethodError, "undefined method `topics'")
 
-      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
-      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+        expect {
+          MessageQueue::RakeTask.new(:begin_listening, [:channel])
+          Rake::Task['begin_listening'].execute(channel: channel)
+        }.to raise_error(ArgumentError, /MessageProcessor.topics is not defined/)
+      end
     end
   end
 end

data/spec/lib/fastly_nsq/sample_message_processor_spec.rb

@@ -1,42 +1,35 @@
 require 'spec_helper'
 
 RSpec.describe SampleMessageProcessor do
-  describe '#start' do
-    it 'enqueues the appropriate message processor' do
-      data =  { 'key' => 'value' }
-      message_body = { 'event_type' => 'heartbeat', 'data' => data }.to_json
-      allow(HeartbeatWorker).to receive(:perform_async)
+  describe '.topics' do
+    it 'specifies the array of topics to listen to' do
+      topics = SampleMessageProcessor.topics
 
-      SampleMessageProcessor.new(message_body).go
-
-      expect(HeartbeatWorker).to have_received(:perform_async).with(data)
+      expect(topics).to be_an Array
+      expect(topics.first).to be_a String
     end
+  end
 
-    describe 'when the message event_type is not known' do
-      it 'uses the null object processor' do
-        data = { 'sample_key' => 'sample value' }
-        message_body = {
-          'event_type' => 'unregistered_message_type',
-          'data' => data,
-        }.to_json
-        allow(UnknownMessageWorker).to receive(:perform_async)
+  describe '#go' do
+    it 'enqueues the appropriate message processor' do
+      data = { 'key' => 'value' }
+      message_body = { 'data' => data }.to_json
+      allow(HeartbeatWorker).to receive(:perform_async)
+      topic = 'heartbeat'
 
-        SampleMessageProcessor.new(message_body).go
+      SampleMessageProcessor.new(message_body: message_body, topic: topic).go
 
-        expect(UnknownMessageWorker).to have_received(:perform_async).with(data)
-      end
+      expect(HeartbeatWorker).to have_received(:perform_async).with(data)
     end
 
-    describe 'when the message lacks an event_type' do
+    describe 'when the message topic is not known' do
       it 'uses the null object processor' do
         data = { 'sample_key' => 'sample value' }
-        message_body = {
-          'not_the_event_type_key' => 'unregistered_message_type',
-          'data' => data,
-        }.to_json
+        message_body = { 'data' => data }.to_json
         allow(UnknownMessageWorker).to receive(:perform_async)
+        topic = 'unknown_topic'
 
-        SampleMessageProcessor.new(message_body).go
+        SampleMessageProcessor.new(message_body: message_body, topic: topic).go
 
         expect(UnknownMessageWorker).to have_received(:perform_async).with(data)
       end

data/spec/spec_helper.rb

@@ -5,8 +5,6 @@ require 'pry-byebug'
 require_relative '../lib/fastly_nsq/sample_message_processor'
 require_relative 'support/env_helpers'
 
-MessageProcessor = SampleMessageProcessor
-
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
@@ -21,7 +19,7 @@ RSpec.configure do |config|
   config.example_status_persistence_file_path = 'spec/examples.txt'
   config.filter_run :focus
   config.order = :random
-  config.profile_examples = false
+  config.profile_examples = 1
   config.run_all_when_everything_filtered = true
   Kernel.srand config.seed
 
@@ -29,6 +27,10 @@ RSpec.configure do |config|
     config.default_formatter = 'doc'
   end
 
+  config.before(:suite) do
+    MessageProcessor = SampleMessageProcessor
+  end
+
   config.before(:each) do
     load_sample_environment_variables
     FakeMessageQueue.reset!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastly_nsq
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Tommy O'Neil
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-11 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print