blazer 1.3.5 → 1.4.0

data/app/views/blazer/checks/run.html.erb

@@ -1,7 +1,9 @@
 <p style="text-muted">Running check...</p>
 
 <script>
-  $.post("<%= run_queries_path %>", <%= blazer_json_escape({statement: @query.statement, query_id: @query.id, check: true}.to_json).html_safe %>, function (data) {
+  var data = <%= blazer_json_escape({statement: @query.statement, query_id: @query.id, check: true}.to_json).html_safe %>;
+
+  runQuery(data, function (data) {
     setTimeout( function () {
       window.location.href = "<%= checks_path %>";
     }, 200);

data/app/views/blazer/dashboards/show.html.erb

@@ -32,9 +32,9 @@
 
 <div style="margin-bottom: 60px;"></div>
 
-<% if @data_sources.any? { |ds| ds.cache } %>
+<% if @data_sources.any? { |ds| ds.cache_mode != "off" } %>
   <p class="text-muted" style="float: right;">
-    Some queries are cached
+    Some queries may be cached
     <%= link_to "Refresh", refresh_dashboard_path(@dashboard, variable_params), method: :post %>
   </p>
 <% end %>
@@ -143,16 +143,12 @@
     </div>
   </div>
   <script>
-    var request = $.ajax({
-      url: "<%= run_queries_path %>",
-      method: "POST",
-      data: <%= blazer_json_escape({statement: query.statement, query_id: query.id, only_chart: true}.to_json).html_safe %>,
-      dataType: "html"
-    }).done(function(data) {
+    var data = <%= blazer_json_escape({statement: query.statement, query_id: query.id, only_chart: true}.to_json).html_safe %>;
+
+    runQuery(data, function (data) {
       $("#chart-<%= i %>").html(data);
       $("#chart-<%= i %> table").stupidtable();
-    }).fail(function(jqXHR, textStatus, errorThrown) {
-      var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message;
+    }, function (message) {
       $("#chart-<%= i %>").css("color", "red").html(message);
     });
   </script>

data/app/views/blazer/queries/_form.html.erb

@@ -124,7 +124,10 @@
     if (xhr) {
       xhr.abort();
     }
-    xhr = $.post("<%= run_queries_path %>", $.extend({}, params, {statement: editor.getValue().replace(/\n/g, "\r\n"), data_source: $("#query_data_source").val()}), function (data) {
+
+    var data = $.extend({}, params, {statement: editor.getValue().replace(/\n/g, "\r\n"), data_source: $("#query_data_source").val()});
+
+    xhr = runQuery(data, function (data) {
       $("#results").html(data);
 
       error_line = /LINE (\d+)/g.exec($("#results").find('.alert-danger').text());

data/app/views/blazer/queries/run.html.erb

@@ -8,12 +8,15 @@
   <% end %>
 <% else %>
   <% unless @only_chart %>
-    <% if @cached_at || @data_source.cache %>
+    <% if @cached_at || @just_cached %>
       <p class="text-muted" style="float: right;">
         <% if @cached_at %>
           Cached <%= time_ago_in_words(@cached_at, include_seconds: true) %> ago
         <% elsif !params[:data_source] %>
           Cached just now
+          <% if @data_source.cache_mode == "slow" %>
+            (over <%= "%g" % @data_source.cache_slow_threshold %>s)
+          <% end %>
         <% end %>
 
         <% if @query && !params[:data_source] %>
@@ -24,13 +27,14 @@
     <p class="text-muted"><%= pluralize(@rows.size, "row") %></p>
   <% end %>
   <% if @rows.any? %>
-    <% values = @rows.first.values %>
+    <% values = @rows.first %>
     <% chart_id = SecureRandom.hex %>
     <% column_types = blazer_column_types(@columns, @rows, @boom) %>
     <% chart_options = {id: chart_id, min: nil} %>
     <% series_library = {} %>
-    <% @columns.keys.select { |k| k.downcase == "target" }.each do |key| %>
-      <% series_library[key] = {pointStyle: "line", hitRadius: 5, borderColor: "#109618", pointBackgroundColor: "#109618", backgroundColor: "#109618"} %>
+    <% target_index = @columns.index { |k| k.downcase == "target" } %>
+    <% if target_index %>
+      <% series_library[target_index - 1] = {pointStyle: "line", hitRadius: 5, borderColor: "#109618", pointBackgroundColor: "#109618", backgroundColor: "#109618"} %>
     <% end %>
     <% if blazer_maps? && @markers.any? %>
       <div id="map" style="height: <%= @only_chart ? 300 : 500 %>px;"></div>
@@ -62,32 +66,35 @@
         map.fitBounds(featureLayer.getBounds());
       </script>
     <% elsif values.size >= 2 && column_types.compact == ["time"] + (column_types.compact.size - 1).times.map { "numeric" } %>
-      <% time_k = @columns.keys.first %>
-      <%= line_chart @columns.keys[1..-1].map{ |k| {name: k, data: @rows.map{|r| [r[time_k], r[k]] }, library: series_library[k]} }, chart_options %>
+      <%= line_chart @columns[1..-1].each_with_index.map{ |k, i| {name: k, data: @rows.map{ |r| [r[0], r[i + 1]] }, library: series_library[i]} }, chart_options %>
     <% elsif values.size == 3 && column_types == ["time", "string", "numeric"] %>
-      <% keys = @columns.keys %>
-      <%= line_chart @rows.group_by { |r| k = keys[1]; v = r[k]; (@boom[k] || {})[v.to_s] || v }.map { |name, v| {name: name, data: v.map { |v2| [v2[keys[0]], v2[keys[2]]] }, library: series_library[name]} }, chart_options %>
+      <%= line_chart @rows.group_by { |r| v = r[1]; (@boom[@columns[1]] || {})[v.to_s] || v }.each_with_index.map { |(name, v), i| {name: name, data: v.map { |v2| [v2[0], v2[2]] }, library: series_library[i]} }, chart_options %>
     <% elsif values.size >= 2 && column_types == ["string"] + (values.size - 1).times.map { "numeric" } %>
-      <% keys = @columns.keys %>
-      <%= column_chart (values.size - 1).times.map { |i| name = @columns.keys[i + 1]; {name: name, data: @rows.first(20).map { |r| [(@boom[keys[0]] || {})[r[keys[0]].to_s] || r[keys[0]], r[keys[i + 1]]] } } }, id: chart_id %>
+      <%= column_chart (values.size - 1).times.map { |i| name = @columns[i + 1]; {name: name, data: @rows.first(20).map { |r| [(@boom[@columns[0]] || {})[r[0].to_s] || r[0], r[i + 1]] } } }, id: chart_id %>
     <% elsif @only_chart %>
       <% if @rows.size == 1 && @rows.first.size == 1 %>
-        <p style="font-size: 160px;"><%= blazer_format_value(@rows.first.keys.first, @rows.first.values.first) %></p>
+        <% v = @rows.first.first %>
+        <% if v.is_a?(String) && v == "" %>
+          <div class="text-muted">empty string</div>
+        <% else %>
+          <p style="font-size: 160px;"><%= blazer_format_value(@columns.first, v) %></p>
+        <% end %>
       <% else %>
         <% @no_chart = true %>
       <% end %>
     <% end %>
 
     <% unless @only_chart && !@no_chart %>
-      <% header_width = 100 / @rows.first.keys.size.to_f %>
+      <% header_width = 100 / @columns.size.to_f %>
       <div class="results-container">
-        <% if @columns.keys == ["QUERY PLAN"] %>
-          <pre><code><%= @rows.map { |r| r["QUERY PLAN"] }.join("\n") %></code></pre>
+        <% if @columns == ["QUERY PLAN"] %>
+          <pre><code><%= @rows.map { |r| r[0] }.join("\n") %></code></pre>
         <% else %>
           <table class="table results-table" style="margin-bottom: 0;">
             <thead>
               <tr>
-                <% @columns.each do |key, type| %>
+                <% @columns.each_with_index do |key, i| %>
+                  <% type = @column_types[i] %>
                   <th style="width: <%= header_width %>%;" data-sort="<%= type %>">
                     <div style="min-width: <%= @min_width_types.include?(key) ? 180 : 60 %>px;">
                       <%= key %>
@@ -99,10 +106,11 @@
             <tbody>
               <% @rows.each do |row| %>
                 <tr>
-                  <% row.each do |k, v| %>
+                  <% row.each_with_index do |v, i| %>
+                    <% k = @columns[i] %>
                     <td>
                       <% if v.is_a?(Time) %>
-                        <% v = blazer_time_value(k, v) %>
+                        <% v = blazer_time_value(@data_source, k, v) %>
                       <% end %>
 
                       <% unless v.nil? %>

data/app/views/blazer/queries/show.html.erb

@@ -157,23 +157,27 @@
   </div>
 
   <script>
-    var request = $.ajax({
-      url: "<%= run_queries_path %>",
-      method: "POST",
-      data: <%= blazer_json_escape(variable_params.merge(statement: @statement, query_id: @query.id).to_json).html_safe %>,
-      dataType: "html"
-    }).done(function(data) {
+    function showRun(data) {
       $("#results").html(data);
       $("#results table").stupidtable().stickyTableHeaders({fixedOffset: 60});
-    }).fail(function(jqXHR, textStatus, errorThrown) {
-      var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message;
+    }
+
+    function showError(message) {
       $("#results").css("color", "red").html(message);
-    });
+    }
+
+    var data = <%= blazer_json_escape(variable_params.merge(statement: @statement, query_id: @query.id).to_json).html_safe %>;
+
+    runQuery(data, showRun, showError);
   </script>
 <% end %>
 
 <script>
-  hljs.initHighlightingOnLoad();
+  // do not highlight really long queries
+  // this can lead to performance issues
+  if ($("code").text().length < 10000) {
+    hljs.initHighlightingOnLoad();
+  }
 
   $(".form-inline input, .form-inline select").change( function () {
     submitIfCompleted($(this).closest("form"));

data/app/views/layouts/blazer/application.html.erb

@@ -6,10 +6,10 @@
     <meta charset="utf-8" />
 
     <%= stylesheet_link_tag "blazer/application" %>
+    <%= javascript_include_tag "blazer/application" %>
     <script>
-      var Chartkick = {smarterDates: true, smarterDiscrete: true};
+      var runQueriesPath = <%= run_queries_path.to_json.html_safe %>;
     </script>
-    <%= javascript_include_tag "blazer/application" %>
     <% if blazer_maps? %>
       <%= stylesheet_link_tag "https://api.mapbox.com/mapbox.js/v2.4.0/mapbox.css" %>
       <%= javascript_include_tag "https://api.mapbox.com/mapbox.js/v2.4.0/mapbox.js" %>

data/blazer.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "rails"
   spec.add_dependency "chartkick"
+  spec.add_dependency "safely_block", ">= 0.1.1"
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/blazer/data_source.rb

@@ -7,6 +7,11 @@ module Blazer
     def initialize(id, settings)
       @id = id
       @settings = settings
+
+      unless settings["url"] || Rails.env.development?
+        raise Blazer::Error, "Empty url"
+      end
+
       @connection_model =
         Class.new(Blazer::Connection) do
           def self.name
@@ -41,7 +46,32 @@ module Blazer
     end
 
     def cache
-      settings["cache"]
+      @cache ||= begin
+        if settings["cache"].is_a?(Hash)
+          settings["cache"]
+        elsif settings["cache"]
+          {
+            "mode" => "all",
+            "expires_in" => settings["cache"]
+          }
+        else
+          {
+            "mode" => "off"
+          }
+        end
+      end
+    end
+
+    def cache_mode
+      cache["mode"]
+    end
+
+    def cache_expires_in
+      (cache["expires_in"] || 60).to_f
+    end
+
+    def cache_slow_threshold
+      (cache["slow_threshold"] || 15).to_f
     end
 
     def local_time_suffix
@@ -52,19 +82,70 @@ module Blazer
       settings.key?("use_transaction") ? settings["use_transaction"] : true
     end
 
+    def cost(statement)
+      result = explain(statement)
+      match = /cost=\d+\.\d+..(\d+\.\d+) /.match(result)
+      match[1] if match
+    end
+
+    def explain(statement)
+      if postgresql? || redshift?
+        connection_model.connection.select_all("EXPLAIN #{statement}").rows.first.first
+      end
+    rescue
+      nil
+    end
+
+    def run_main_statement(statement, options = {})
+      query = options[:query]
+      Blazer.transform_statement.call(self, statement) if Blazer.transform_statement
+
+      # audit
+      if Blazer.audit
+        audit = Blazer::Audit.new(statement: statement)
+        audit.query = query
+        audit.data_source = id
+        audit.user = options[:user]
+        audit.save!
+      end
+
+      start_time = Time.now
+      columns, rows, error, cached_at, just_cached = run_statement(statement, options.merge(with_just_cached: true))
+      duration = Time.now - start_time
+
+      if Blazer.audit
+        audit.duration = duration if audit.respond_to?(:duration=)
+        audit.error = error if audit.respond_to?(:error=)
+        audit.timed_out = error == Blazer::TIMEOUT_MESSAGE if audit.respond_to?(:timed_out=)
+        audit.cached = cached_at.present? if audit.respond_to?(:cached=)
+        if !cached_at && duration >= 10
+          audit.cost = cost(statement) if audit.respond_to?(:cost=)
+        end
+        audit.save! if audit.changed?
+      end
+
+      if query && error != Blazer::TIMEOUT_MESSAGE
+        query.checks.each do |check|
+          check.update_state(rows, error)
+        end
+      end
+
+      [columns, rows, error, cached_at, just_cached]
+    end
+
     def run_statement(statement, options = {})
+      columns = nil
       rows = nil
       error = nil
       cached_at = nil
+      just_cached = false
       cache_key = self.cache_key(statement) if cache
       if cache && !options[:refresh_cache]
         value = Blazer.cache.read(cache_key)
-        rows, cached_at = Marshal.load(value) if value
+        columns, rows, cached_at = Marshal.load(value) if value
       end
 
       unless rows
-        rows = []
-
         comment = "blazer"
         if options[:user].respond_to?(:id)
           comment << ",user_id:#{options[:user].id}"
@@ -76,38 +157,12 @@ module Blazer
         if options[:query].respond_to?(:id)
           comment << ",query_id:#{options[:query].id}"
         end
-
-        in_transaction do
-          begin
-            if timeout
-              if postgresql? || redshift?
-                connection_model.connection.execute("SET statement_timeout = #{timeout.to_i * 1000}")
-              elsif mysql?
-                connection_model.connection.execute("SET max_execution_time = #{timeout.to_i * 1000}")
-              else
-                raise Blazer::TimeoutNotSupported, "Timeout not supported for #{adapter_name} adapter"
-              end
-            end
-
-            result = connection_model.connection.select_all("#{statement} /*#{comment}*/")
-            cast_method = Rails::VERSION::MAJOR < 5 ? :type_cast : :cast_value
-            result.each do |untyped_row|
-              row = {}
-              untyped_row.each do |k, v|
-                row[k] = result.column_types.empty? ? v : result.column_types[k].send(cast_method, v)
-              end
-              rows << row
-            end
-          rescue ActiveRecord::StatementInvalid => e
-            error = e.message.sub(/.+ERROR: /, "")
-            error = Blazer::TIMEOUT_MESSAGE if Blazer::TIMEOUT_ERRORS.any? { |e| error.include?(e) }
-          end
-        end
-
-        Blazer.cache.write(cache_key, Marshal.dump([rows, Time.now]), expires_in: cache.to_f * 60) if !error && cache
+        columns, rows, error, just_cached = run_statement_helper(statement, comment)
       end
 
-      [rows, error, cached_at]
+      output = [columns, rows, error, cached_at]
+      output << just_cached if options[:with_just_cached]
+      output
     end
 
     def clear_cache(statement)
@@ -115,7 +170,7 @@ module Blazer
     end
 
     def cache_key(statement)
-      ["blazer", "v2", id, Digest::MD5.hexdigest(statement)].join("/")
+      ["blazer", "v3", id, Digest::MD5.hexdigest(statement)].join("/")
     end
 
     def schemas
@@ -124,8 +179,8 @@ module Blazer
     end
 
     def tables
-      rows, error, cached_at = run_statement(connection_model.send(:sanitize_sql_array, ["SELECT table_name, column_name, ordinal_position, data_type FROM information_schema.columns WHERE table_schema IN (?)", schemas]))
-      Hash[rows.group_by { |r| r["table_name"] }.map { |t, f| [t, f.sort_by { |f| f["ordinal_position"] }.map { |f| f.slice("column_name", "data_type") }] }.sort_by { |t, _f| t }]
+      columns, rows, error, cached_at = run_statement(connection_model.send(:sanitize_sql_array, ["SELECT table_name FROM information_schema.tables WHERE table_schema IN (?) ORDER BY table_name", schemas]))
+      rows.map(&:first)
     end
 
     def postgresql?
@@ -146,6 +201,53 @@ module Blazer
 
     protected
 
+    def run_statement_helper(statement, comment)
+      columns = []
+      rows = []
+      error = nil
+      start_time = Time.now
+      result = nil
+
+      begin
+        in_transaction do
+          if timeout
+            if postgresql? || redshift?
+              connection_model.connection.execute("SET statement_timeout = #{timeout.to_i * 1000}")
+            elsif mysql?
+              connection_model.connection.execute("SET max_execution_time = #{timeout.to_i * 1000}")
+            else
+              raise Blazer::TimeoutNotSupported, "Timeout not supported for #{adapter_name} adapter"
+            end
+          end
+
+          result = connection_model.connection.select_all("#{statement} /*#{comment}*/")
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        error = e.message.sub(/.+ERROR: /, "")
+        error = Blazer::TIMEOUT_MESSAGE if Blazer::TIMEOUT_ERRORS.any? { |e| error.include?(e) }
+      end
+
+      duration = Time.now - start_time
+
+      if result
+        columns = result.columns
+        cast_method = Rails::VERSION::MAJOR < 5 ? :type_cast : :cast_value
+        result.rows.each do |untyped_row|
+          rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] ? result.column_types[c].send(cast_method, untyped_row[i]) : nil })
+        end
+      end
+
+      cache_data = nil
+      if !error && (cache_mode == "all" || (cache_mode == "slow" && duration >= cache_slow_threshold))
+        cache_data = Marshal.dump([columns, rows, Time.now]) rescue nil
+        if cache_data
+          Blazer.cache.write(cache_key(statement), cache_data, expires_in: cache_expires_in.to_f * 60)
+        end
+      end
+
+      [columns, rows, error, !cache_data.nil?]
+    end
+
     def adapter_name
       connection_model.connection.adapter_name
     end

data/lib/blazer/version.rb

@@ -1,3 +1,3 @@
 module Blazer
-  VERSION = "1.3.5"
+  VERSION = "1.4.0"
 end

data/lib/blazer.rb

@@ -4,9 +4,11 @@ require "chartkick"
 require "blazer/version"
 require "blazer/data_source"
 require "blazer/engine"
+require "safely/core"
 
 module Blazer
-  class TimeoutNotSupported < StandardError; end
+  class Error < StandardError; end
+  class TimeoutNotSupported < Error; end
 
   class << self
     attr_accessor :audit
@@ -28,7 +30,9 @@ module Blazer
   TIMEOUT_ERRORS = [
     "canceling statement due to statement timeout", # postgres
     "cancelled on user's request", # redshift
-    "system requested abort" # redshift
+    "canceled on user's request", # redshift
+    "system requested abort", # redshift
+    "maximum statement execution time exceeded" # mysql
   ]
   BELONGS_TO_OPTIONAL = {}
   BELONGS_TO_OPTIONAL[:optional] = true if Rails::VERSION::MAJOR >= 5
@@ -64,43 +68,52 @@ module Blazer
     checks = Blazer::Check.includes(:query)
     checks = checks.where(schedule: schedule) if schedule
     checks.find_each do |check|
-      rows = nil
-      error = nil
-      tries = 1
+      Safely.safely { run_check(check) }
+    end
+  end
 
-      ActiveSupport::Notifications.instrument("run_check.blazer", check_id: check.id, query_id: check.query.id, state_was: check.state) do |instrument|
-        # try 3 times on timeout errors
-        while tries <= 3
-          rows, error, cached_at = data_sources[check.query.data_source].run_statement(check.query.statement, refresh_cache: true)
-          if error == Blazer::TIMEOUT_MESSAGE
-            Rails.logger.info "[blazer timeout] query=#{check.query.name}"
-            tries += 1
-            sleep(10)
-          elsif error.to_s.start_with?("PG::ConnectionBad")
-            data_sources[check.query.data_source].reconnect
-            Rails.logger.info "[blazer reconnect] query=#{check.query.name}"
-            tries += 1
-            sleep(10)
-          else
-            break
-          end
-        end
-        check.update_state(rows, error)
-        # TODO use proper logfmt
-        Rails.logger.info "[blazer check] query=#{check.query.name} state=#{check.state} rows=#{rows.try(:size)} error=#{error}"
+  def self.run_check(check)
+    rows = nil
+    error = nil
+    tries = 1
 
-        instrument[:state] = check.state
-        instrument[:rows] = rows.try(:size)
-        instrument[:error] = error
-        instrument[:tries] = tries
+    ActiveSupport::Notifications.instrument("run_check.blazer", check_id: check.id, query_id: check.query.id, state_was: check.state) do |instrument|
+      # try 3 times on timeout errors
+      data_source = data_sources[check.query.data_source]
+      statement = check.query.statement
+      Blazer.transform_statement.call(data_source, statement) if Blazer.transform_statement
+
+      while tries <= 3
+        columns, rows, error, cached_at = data_source.run_statement(statement, refresh_cache: true)
+        if error == Blazer::TIMEOUT_MESSAGE
+          Rails.logger.info "[blazer timeout] query=#{check.query.name}"
+          tries += 1
+          sleep(10)
+        elsif error.to_s.start_with?("PG::ConnectionBad")
+          data_sources[check.query.data_source].reconnect
+          Rails.logger.info "[blazer reconnect] query=#{check.query.name}"
+          tries += 1
+          sleep(10)
+        else
+          break
+        end
       end
+      check.update_state(rows, error)
+      # TODO use proper logfmt
+      Rails.logger.info "[blazer check] query=#{check.query.name} state=#{check.state} rows=#{rows.try(:size)} error=#{error}"
 
+      instrument[:statement] = statement
+      instrument[:data_source] = data_source
+      instrument[:state] = check.state
+      instrument[:rows] = rows.try(:size)
+      instrument[:error] = error
+      instrument[:tries] = tries
     end
   end
 
   def self.send_failing_checks
     emails = {}
-    Blazer::Check.includes(:query).where(state: %w[failing error]).find_each do |check|
+    Blazer::Check.includes(:query).where(state: ["failing", "error", "timed out", "disabled"]).find_each do |check|
       check.split_emails.each do |email|
         (emails[email] ||= []) << check
       end

data/lib/generators/blazer/templates/config.yml

@@ -8,10 +8,13 @@ data_sources:
     # none by default
     # timeout: 15
 
-    # time to cache results, in minutes
+    # caching settings
     # can greatly improve speed
-    # none by default
-    # cache: 60
+    # off by default
+    # cache:
+    #   mode: slow # or all
+    #   expires_in: 60 # min
+    #   slow_threshold: 15 # sec, only used in slow mode
 
     # wrap queries in a transaction for safety
     # not necessary if you use a read-only user

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blazer
 version: !ruby/object:Gem::Version
-  version: 1.3.5
+  version: 1.4.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-12 00:00:00.000000000 Z
+date: 2016-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: safely_block
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement