cotcube-bardata 0.1.6 → 0.1.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 241ac82617b49386e5ab3b2291a0d5a0e6f6f792a1184ad5956ec5eedce56d5e
-  data.tar.gz: a70bb34fe89fdc62138e2efbb8dcc7119f5e07d58672c4c9bb6923da95ab1bd1
+  metadata.gz: 4bf0d80a7c81bd75a4d9ca26c5571a57938a73fdfd47543ab82e9ea93f42e3f0
+  data.tar.gz: 9c53d62b2fbcb17700a2f1f4c08586ed218098ad80a9247b6b839486d46829ce
 SHA512:
-  metadata.gz: 5e80e2f64b55ea2df59ca62d2407ea7d534568d0bcdbd75eed6c0df233fc16f9e9c0651213f0d53401a9ac336eb4fb4e4325d874fb299ce8ba01dee53c7d25d0
-  data.tar.gz: 875c0bcca1eab089286a7ecb94979db433d15d6cb5c4a45fccc46695615da632aa48f68ae3119a908287f127cee0dd93f24319e02d45103148eb7acdad992de8
+  metadata.gz: ac6600a7a6f7791df53e631e49f3a4f56e8f2c95801b699dd06510f0b072f7a20d22a8edefbc2b53ef183954c4c13e0889442af2b06911e1ddd3c339217daa3b
+  data.tar.gz: c30e7df2409407c08433baf345660d1dcaeb24b85a035bc2344d2c401303b0961b7dcf901d6e2c5f98f34f273228df2588a8fd83a4e50b0fbbff61d4b541c7c3

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.1.9.3 (February 08, 2021)
+  - cached: minor change fixing problem to get yesterday in rth subsets
+
+## 0.1.9.2 (February 07, 2021)
+  - minor changes
+  - daily#continuous_table: introducing debuglevel
+
+## 0.1.9.1 (January 29, 2021)
+  - provide: added new interval 'synth', mixing available dailies with synthetic days based on quarters
+  - minor change / cleanup
+  - setting gemspec to use rake 13 and changing version spec to overcome warnings
+
+## 0.1.8 (January 27, 2021)
+  - in helpers, #extended_range_for_date: fixed comparison signs
+  - range_matrix: applied cops, noted appearance of Cotcube::Helpers.simple_series_stats
+  - cached: Fixing wrong comparison sign
+  - daily: slimmed down results for #continuous_overview
+
+## 0.1.7 (January 14, 2021)
+  - added :range parameter to :provide, hence to :provide_cached, :provide_daily
+  - added forgotten module_functions
+
 ## 0.1.6 (January 07, 2021)
   - prefering datetime instead date (in helpers and daily)
   - changed keyword :set to :filter in cached, provide and trading_hours

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.9.3

data/cotcube-bardata.gemspec

@@ -34,7 +34,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'parallel',           '~> 1'
   spec.add_dependency 'yaml',               '~> 0.1'
 
-  spec.add_development_dependency 'rake',  '>= 12'
+  # using ~> in favor of >= to overcome warning
+  spec.add_development_dependency 'rake',  '~> 13'
   spec.add_development_dependency 'rspec', '~>3.6'
-  spec.add_development_dependency 'yard', '~>0.9'
+  spec.add_development_dependency 'yard',  '~>0.9'
 end

data/lib/cotcube-bardata.rb

@@ -52,6 +52,8 @@ module Cotcube
                     :continuous_actual_ml,
                     # based on continuous, create list of when which contract was most liquid
                     :continuous_overview,
+                    # provider estimation of current ML usability
+                    :continuous_table,
                     # provide the list of quarters, possibly as hours or days.
                     :provide_quarters,
                     # some statistics to estimate daily volatility of specific contract
@@ -60,6 +62,8 @@ module Cotcube
                     :trading_hours,
                     # receive id / symbol information on an uncertain set of parameters
                     :get_id_set,
+                    :select_specific_date,
+                    :extended_select_for_range,
                     :provide_cached,
                     :compare,
                     :holidays,

data/lib/cotcube-bardata/cached.rb

@@ -6,12 +6,29 @@ module Cotcube
     # send pre-created days based on quarters
     def provide_cached(contract:, # rubocop:disable Metrics/ParameterLists
                        symbol: nil, id: nil,
+                       range: nil,
                        config: init,
+                       debug: false,
                        timezone: Time.find_zone('America/Chicago'),
                        filter: :full, # most probably either :full or :rth
                        force_update: false, # force reloading via provide_quarters
                        force_recent: false) #
 
+      unless range.nil? ||
+             range.is_a?(Range) &&
+             [Date, DateTime, ActiveSupport::TimeWithZone].map do |cl|
+               (range.begin.nil? || range.begin.is_a?(cl)) &&
+               (range.end.nil? || range.end.is_a?(cl))
+             end.reduce(:|)
+        raise ArgumentError, 'Range, if given, must be either (Integer..Integer) or (Timelike..Timelike)'
+      end
+
+      unless range.nil?
+        range_begin = range.begin.nil? ? nil : timezone.parse(range.begin.to_s)
+        range_end   = range.end.nil? ? nil : timezone.parse(range.end.to_s)
+        range = (range_begin..range_end)
+      end
+
       headers = %i[contract datetime open high low close volume]
       sym      = get_id_set(symbol: symbol, id: id, contract: contract)
       contract = contract[-3..]
@@ -33,18 +50,40 @@ module Cotcube
         if base.last[:high].zero?
           # contract exists but is closed (has the CLOSED marker)
           base.pop
-          return base
-        elsif File.mtime(file) < File.mtime(quarters_file)
-          return base
+          # rubocop:disable Metrics/BlockNesting
+          result = if range.nil?
+                     base
+                   else
+                     base.select do |x|
+                       (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+                         (range.end.nil? ? true : x[:datetime] <= range.end)
+                     end
+                   end
+          return result
+        elsif File.mtime(file) + 1.day > File.mtime(quarters_file)
+          puts "CACHE #{File.mtime(file)}\t#{file}" if debug
+          puts "QUART #{File.mtime(quarters_file)}\t#{quarters_file}" if debug
+          result = if range.nil?
+                     base
+                   else
+                     base.select do |x|
+                       (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+                         (range.end.nil? ? true : x[:datetime] <= range.end)
+                     end
+                   end
+          # rubocop:enable Metrics/BlockNesting
+          return result
         else
-          puts "File #{file} exists, but is neither closed nor current. Running update.".colorize(:light_green)
+          # write a (positive warning, that the cache needs to be updated, as cached value is older
+          #   than one day but not closed
+          puts "File #{file} exists, but is neither closed nor current. Running update...".colorize(:light_green)
         end
       end
       begin
         data = provide_quarters(contract: contract, id: sym[:id], keep_marker: true)
       rescue StandardError
         puts "Cannot provide quarters for requested contract #{sym[:symbol]}:#{contract},"\
-             "returning '[ ]'".colorize(:light_red)
+            "returning '[ ]'".colorize(:light_red)
         return []
       end
 
@@ -59,21 +98,28 @@ module Cotcube
       base = Cotcube::Helpers.reduce(bars: data, to: :days)
 
       # remove last day of result unless marked
-      base.pop unless contract_is_marked || force_recent
+      base.pop if base.last[:datetime].to_date == timezone.now.to_date and not force_recent
 
       base.map do |x|
-        x[:datetime] = x[:datetime].to_date
+        x[:date] = x[:datetime].to_date
         x[:type] = "#{filter}_day".to_sym
         x.delete(:day)
       end
       CSV.open(file, 'w') do |csv|
         base.each { |b| csv << b.values_at(*headers) }
         if contract_is_marked
-          marker = ["#{sym[:symbol]}#{contract}", base.last[:datetime] + 1.day, 0, 0, 0, 0, 0]
+          marker = ["#{sym[:symbol]}#{contract}", base.last[:date] + 1.day, 0, 0, 0, 0, 0]
           csv << marker
         end
       end
-      base
+      if range.nil?
+        base
+      else
+        base.select do |x|
+          (range.begin.nil? ? true : x[:date] >= range.begin) and
+            (range.end.nil? ? true : x[:date] <= range.end)
+        end
+      end
     end
   end
 end

data/lib/cotcube-bardata/daily.rb

@@ -4,14 +4,30 @@ module Cotcube
   # Missing top level documentation comment
   module Bardata
     # just reads bardata/daily/<id>/<contract>.csv
-    def provide_daily(contract:,
+    def provide_daily(contract:, # rubocop:disable Metrics/ParameterLists
                       symbol: nil, id: nil,
+                      range: nil,
                       timezone: Time.find_zone('America/Chicago'),
                       config: init)
       contract = contract.to_s.upcase
       unless contract.is_a?(String) && [3, 5].include?(contract.size)
         raise ArgumentError, "Contract '#{contract}' is bogus, should be like 'M21' or 'ESM21'"
       end
+      unless range.nil? ||
+             (range.is_a?(Range) &&
+             [Date, DateTime, ActiveSupport::TimeWithZone].map do |cl|
+               (range.begin.nil? || range.begin.is_a?(cl)) &&
+               (range.end.nil?   || range.end.is_a?(cl))
+             end.reduce(:|))
+
+        raise ArgumentError, 'Range, if given, must be either (Integer..Integer) or (Timelike..Timelike)'
+      end
+
+      unless range.nil?
+        range_begin = range.begin.nil? ? nil : timezone.parse(range.begin.to_s)
+        range_end   = range.end.nil? ? nil : timezone.parse(range.end.to_s)
+        range = (range_begin..range_end)
+      end
 
       sym = get_id_set(symbol: symbol, id: id, contract: contract)
       contract = contract[2..4] if contract.to_s.size == 5
@@ -33,7 +49,14 @@ module Cotcube
         row
       end
       data.pop if data.last[:high].zero?
-      data
+      if range.nil?
+        data
+      else
+        data.select do |x|
+          (range.begin.nil? ? true : x[:datetime] >= range.begin) and
+            (range.end.nil? ? true : x[:datetime] <= range.end)
+        end
+      end
     end
 
     # reads all files in  bardata/daily/<id> and aggregates by date
@@ -109,6 +132,13 @@ module Cotcube
       end
       data.reject! { |x| x[selector].empty? }
       result = data.group_by { |x| x[selector].first[:contract] }
+      result.each_key do |key|
+        result[key].map! do |x|
+          x[:volume].select! { |z| z[:contract] == key }
+          x[:oi].select!     { |z| z[:contract] == key }
+          x
+        end
+      end
       if human
         result.each do |k, v|
           next unless filter.nil? || v.first[selector].first[:contract][2..4] =~ (/#{filter}/)
@@ -119,15 +149,112 @@ module Cotcube
              }\t#{v.last[:date]
              }\t#{format('%4d', (Date.parse(v.last[:date]) - Date.parse(v.first[:date])))
              }\t#{result[k].map do |x|
-                    x[:volume].select do
-                      x[:contract] == k
-                    end
-                  end.size
+               x[:volume].select do
+                 x[:contract] == k
+               end
+             end.size
              }"
           # rubocop:enable Layout/ClosingParenthesisIndentation
         end
       end
       result
     end
+
+    def continuous_table(symbol: nil, id: nil,
+                         selector: :volume,
+                         filter: nil,
+                         date: Date.today,
+                         debuglevel: 1,
+                         debug: false)
+      if debug.is_a?(Integer)
+        debuglevel = debug
+        debug = debuglevel > 0 ? true : false
+      end
+      raise ArgumentError, 'Selector must be either :volume or :oi' unless selector.is_a?(Symbol) &&
+                                                                           %i[volume oi].include?(selector)
+
+      sym = get_id_set(symbol: symbol, id: id)
+      if %w[R6 BJ GE].include? sym[:symbol]
+        puts "Rejecting to process symbol '#{sym[:symbol]}'."
+        return
+      end
+      id  = sym[:id]
+      dfm = lambda do |x, y = date.year|
+        k = Date.strptime("#{y} #{x.negative? ? x + 366 : x}", '%Y %j')
+        k -= 1 while [0, 6].include?(k.wday)
+        k.strftime('%a, %Y-%m-%d')
+      rescue StandardError
+        puts "#{sym[:symbol]}\t#{x}\t#{y}"
+      end
+
+      ytoday = date.yday
+      data = continuous_overview(id: id, selector: selector, filter: filter, human: false, config: init)
+        .reject { |k, _| k[-2..].to_i == date.year % 2000 }
+             .group_by { |k, _| k[2] }
+      output_sent = []
+      early_year=nil
+      data.keys.sort.each do |month|
+        puts "Processing #{sym[:symbol]}#{month}" if debuglevel > 1
+        v0 = data[month]
+        ydays = v0.map { |_, v1| Date.parse(v1.last[:date]).yday }
+        fdays = v0.map { |_, v1| Date.parse(v1.first[:date]).yday }.sort
+        # if the last ml day nears the end of the year, we must fix
+        ydays.map! { |x| x > 350 ? x - 366 : x } if ydays.min < 50
+        fday  = fdays[fdays.size / 2]
+        yavg  = ydays.reduce(:+) / ydays.size
+        # a contract is proposed to use after fday - 1, but before ydays.min (green)
+        # it is warned to user after fday - 1 but before yavg - 1            (red)
+        # it is warned red >= yavg - 1 and <= yavg + 1
+        color = if (ytoday >= yavg - 1) && (ytoday <= yavg + 1)
+                  :light_red
+                elsif (ytoday > ydays.min) && (ytoday < yavg - 1)
+                  :light_yellow
+                elsif (ytoday >= (fday > yavg ? 0 : fday - 5)) && (ytoday <= ydays.min)
+                  :light_green
+                else
+                  :white
+                end
+        # rubocop:disable Layout/ClosingParenthesisIndentation
+        output = "#{sym[:symbol]
+             }#{month
+             }\t#{format '%12s', sym[:type]
+             }\t#{ytoday
+              }/#{fday
+             }\t#{format '%5d', ydays.min
+             }: #{dfm.call(ydays.min)
+             }\t#{format '%5d', yavg
+             }: #{dfm.call(yavg)
+             }\t#{format '%5d', ydays.max
+             }: #{dfm.call(ydays.max)}".colorize(color)
+        if debug || (color != :white)
+          puts output
+          output_sent << "#{sym[:symbol]}#{month}" unless color == :white
+        end
+        early_year  ||= output
+        next unless (debug and debuglevel >= 2)
+
+        v0.each do |contract, v1|
+          puts "\t#{contract
+               }\t#{v1.first[:date]
+               }\t#{Date.parse(v1.last[:date]).strftime('%a')
+               }, #{v1.last[:date]
+               } (#{Date.parse(v1.last[:date]).yday}"
+               # rubocop:enable Layout/ClosingParenthesisIndentation
+        end
+      end
+      case output_sent.size
+      when 0
+        puts "WARNING: No output was sent for symbol '#{sym[:symbol]}'.".colorize(:light_yellow)
+        puts "         Assuming late-year-processing.".light_yellow
+        puts early_year.light_green
+      when 1
+        # all ok
+        true
+      else
+        puts "---- #{output_sent} for #{sym[:symbol]} ---------------"
+
+      end
+      output_sent
+    end
   end
 end

data/lib/cotcube-bardata/helpers.rb

@@ -36,11 +36,11 @@ module Cotcube
             ' is assumed (starting 5 pm CT yesterday, ending 4 pm CT today)'.colorize(:light_yellow)
         end
         result = select_specific_date(date: starting, base: base)
-        result += base.select { |d| d[:datetime] > starting and d[:datetime] < ending.to_date }
+        result += base.select { |d| d[:datetime] >= starting and d[:datetime] < ending.to_date }
         result += select_specific_date(date: ending, base: base)
         result.uniq!
       else
-        result = base.select { |x| x[:datetime] >= starting and x[:datetime] < ending }
+        result = base.select { |x| x[:datetime] >= starting and x[:datetime] <= ending }
       end
       result
     end

data/lib/cotcube-bardata/provide.rb

@@ -10,7 +10,7 @@ module Cotcube
                 config: init,
                 # supported types are :quarters, :hours, :days, :rth, :dailies, :weeks, :months
                 interval: :days,
-                # supported filters are :raw, :_24x7_, :full and :rth (and custom named, if provided as file)
+                # supported filters are :full and :rth (and custom named, if provided as file)
                 filter: :full,
                 # TODO: for future compatibility and suggestion: planning to include a function to update
                 #       with live data from broker
@@ -33,16 +33,22 @@ module Cotcube
 
       when :days, :weeks, :months
         base = provide_cached contract: contract, symbol: symbol, id: id, config: config, filter: filter,
-                              force_recent: force_recent
-        base = extended_select_for_range(range: range, base: base) if range
+                              range: range, force_recent: force_recent
         return base if %i[day days].include? interval
 
         # TODO: Missing implementation to reduce cached days to weeks or months
         raise 'Missing implementation to reduce cached days to weeks or months'
       when :dailies, :daily
-        base = provide_daily contract: contract, symbol: symbol, id: id, config: config
-        base = extended_select_for_range(range: range, base: base) if range
-        base
+        provide_daily contract: contract, symbol: symbol, id: id, config: config, range: range
+      when :synth, :synthetic, :synthetic_days
+        days = provide_cached contract: contract, symbol: symbol, id: id, config: config, filter: filter,
+                              range: range, force_recent: force_recent
+        dailies = provide_daily contract: contract, symbol: symbol, id: id, config: config, range: range
+        if days.last[:datetime] > dailies.last[:datetime]
+          dailies[..-2] + days.select { |d| d[:datetime] > dailies[-2][:datetime] }
+        else
+          dailies
+        end
       else
         raise ArgumentError, "Unsupported or unknown interval '#{interval}' in Bardata.provide"
       end

data/lib/cotcube-bardata/range_matrix.rb

@@ -12,7 +12,7 @@ module Cotcube
     #   2. avg:
     #   3. lower: like median, but not at 1/2 but 1/4
     #   4. median:
-    #   5. upper: like median, bot not at 1/2 but 3/4
+    #   5. upper: like median, but not at 1/2 but 3/4
     #   6. max:
     # and columns:
     #   1.a) all days os the series
@@ -20,6 +20,8 @@ module Cotcube
     #   1.c) the last 200 days
     #   2.a-c) same with days reduced to weeks (c: 52 weeks)
     #   3.a-c) same with days reduced to months (c: 12 months)
+    #
+    # NOTE: there is now a new method Cotcube::Helpers.simple_series_stats, that should be used in favor.
     def range_matrix(symbol: nil, id: nil, print: false, dim: 0.05)
       # rubocop:disable Style/MultilineBlockChain
       sym = get_id_set(symbol: symbol, id: id)
@@ -38,36 +40,43 @@ module Cotcube
         target[period][:all_size]   =  source[period].size
         target[period][:all_avg]    = (source[period].map { |x| x[:range] }.reduce(:+) / source[period].size).round
         target[period][:all_lower]  =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 1 / 4).round ]
-        target[period][:all_median] =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 2 / 4).round ]
-        target[period][:all_upper]  =  source[period].sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (source[period].size * 3 / 4).round ]
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 1 / 4).round ]
+
+        target[period][:all_median] = source[period].sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 2 / 4).round ]
+
+        target[period][:all_upper] = source[period].sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (source[period].size * 3 / 4).round ]
+
         target[period][:all_max] = source[period].map { |x| x[:range] }.max
         target[period][:all_records] = source[period].sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
 
         tenth = (source[period].size * dim).round
         custom = source[period].sort_by { |x| x[:range] }[tenth..source[period].size - tenth]
+
         target[period][:dim_size]   =  custom.size
         target[period][:dim_avg]    = (custom.map { |x| x[:range] }.reduce(:+) / custom.size).round
         target[period][:dim_lower]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
-        target[period][:dim_median] =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
-        target[period][:dim_upper]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
-        target[period][:dim_max]    =  custom.map { |x| x[:range] }.max
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
+
+        target[period][:dim_median] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
+
+        target[period][:dim_upper] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
+
+        target[period][:dim_max] = custom.map { |x| x[:range] }.max
         target[period][:dim_records] = custom.sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
 
         range = case period
                 when :months
@@ -83,18 +92,18 @@ module Cotcube
         target[period][:rec_size]   =  custom.size
         target[period][:rec_avg]    = (custom.map { |x| x[:range] }.reduce(:+) / custom.size).round
         target[period][:rec_lower]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
-        target[period][:rec_median] =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
-        target[period][:rec_upper]  =  custom.sort_by do |x|
-                                         x[:range]
-                                       end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
-        target[period][:rec_max]    =  custom.map { |x| x[:range] }.max
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 1 / 4).round ]
+        target[period][:rec_median] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 2 / 4).round ]
+        target[period][:rec_upper] = custom.sort_by do |x|
+          x[:range]
+        end.map { |x| x[:range] }[ (custom.size * 3 / 4).round ]
+        target[period][:rec_max] = custom.map { |x| x[:range] }.max
         target[period][:rec_records] = custom.sort_by do |x|
-                                         -x[:range]
-                                       end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
+          -x[:range]
+        end.map { |x| { contract: x[:contract], range: x[:range] } }.take(5)
       end
 
       if print

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-bardata
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.9.3
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -112,16 +112,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '12'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement