flay 2.1.0 → 2.2.0

data/History.txt

@@ -1,3 +1,28 @@
+=== 2.2.0 / 2013-04-09
+
+Semantic versioning doesn't take into account how AWESOME a release
+is. In this case, it severely falls short. I'd jump to 4.0 if I could.
+
+* 2 major enhancements:
+
+  * Added --fuzzy (ie copy, paste, & modify) duplication detection.
+  * Added --liberal, which changes the way prune works to identify more duplication.
+
+* 12 minor enhancements:
+
+  * Added -# to turn off item numbering. Helps with diffs to compare runs over time.
+  * Added Sexp#+.
+  * Added Sexp#code_index to specify where *code starts in some sexps.
+  * Added Sexp#has_code?.
+  * Added Sexp#initalize_copy to propagate file/line/modified info.
+  * Added Sexp#modified, #modified=, and #modified?.
+  * Added Sexp#split_at(n). (Something I've wanted in Array for ages).
+  * Added Sexp#split_code.
+  * Added mass and diff options to rake debug.
+  * Added rake run task w/ mass, diff, and liberal options
+  * Made report's sort more stable, so I can do better comparison runs.
+  * Wrapped Sexp#[] to propagate file/line/modified info.
+
 === 2.1.0 / 2013-02-13
 
 * 5 minor enhancements:

data/README.txt

@@ -12,22 +12,23 @@ braces vs do/end, etc are all ignored. Making this totally rad.
 
 == FEATURES/PROBLEMS:
 
-* Plugin system allows other languages to be flayed.
-  * Ships with .rb and .erb. javascript and others will be available separately.
-* Includes FlayTask for Rakefiles.
+* Reports differences at any level of code.
+* Adds a score multiplier to identical nodes.
 * Differences in literal values, variable, class, and method names are ignored.
 * Differences in whitespace, programming style, braces vs do/end, etc are ignored.
 * Works across files.
-* Reports differences at any level of code.
+  * Add the flay-persistent plugin to work across large/many projects.
+* Run --diff to see an N-way diff of the code.
+* Provides conservative (default) and --liberal pruning options.
+* Provides --fuzzy duplication detection.
+* Language independent: Plugin system allows other languages to be flayed.
+  * Ships with .rb and .erb. javascript and others will be available separately.
+* Includes FlayTask for Rakefiles.
 * Totally rad.
-* Adds a score multiplier to identical nodes.
-* Run verbose to see an N-way diff of the code.
 
 == TODO:
 
 * Editor integration (emacs, textmate, other contributions welcome).
-* Score sequence fragments (a;b;c;d;e) vs (b;c;d) etc.
-* Persistent DB for efficient cross-project flaying.
 
 == SYNOPSIS:
 

data/Rakefile

@@ -25,10 +25,28 @@ task :debug do
   require "flay"
 
   file = ENV["F"]
+  mass = ENV["M"]
+  diff = ENV["D"]
+  libr = ENV["L"]
 
-  flay = Flay.new
+  opts = Flay.parse_options
+  opts[:mass] = mass.to_i if mass
+  opts[:diff] = diff.to_i if diff
+  opts[:liberal] = true if libr
+
+  flay = Flay.new opts
   flay.process(*Flay.expand_dirs_to_files(file))
   flay.report
 end
 
+task :run do
+  file = ENV["F"]
+  fuzz = ENV["Z"] && "-f #{ENV["Z"]}"
+  mass = ENV["M"] && "-m #{ENV["M"]}"
+  diff = ENV["D"] && "-d"
+  libr = ENV["L"] && "-l"
+
+  ruby "#{Hoe::RUBY_FLAGS} bin/flay #{mass} #{fuzz} #{diff} #{libr} #{file}"
+end
+
 # vim: syntax=ruby

data/lib/flay.rb

@@ -7,7 +7,7 @@ require 'ruby_parser'
 require 'timeout'
 
 class File
-  RUBY19 = "<3".respond_to? :encoding unless defined? RUBY19
+  RUBY19 = "<3".respond_to? :encoding unless defined? RUBY19 # :nodoc:
 
   class << self
     alias :binread :read unless RUBY19
@@ -15,7 +15,10 @@ class File
 end
 
 class Flay
-  VERSION = '2.1.0'
+  VERSION = "2.2.0" # :nodoc:
+
+  ##
+  # Returns the default options.
 
   def self.default_options
     {
@@ -23,10 +26,16 @@ class Flay
       :mass    => 16,
       :summary => false,
       :verbose => false,
+      :number  => true,
       :timeout => 10,
+      :liberal => false,
+      :fuzzy   => false,
     }
   end
 
+  ##
+  # Process options in +args+, defaulting to +ARGV+.
+
   def self.parse_options args = ARGV
     options = self.default_options
 
@@ -43,8 +52,13 @@ class Flay
         exit
       end
 
-      opts.on('-f', '--fuzzy', "DEAD: fuzzy similarities.") do
-        abort "--fuzzy is no longer supported. Sorry. It sucked."
+      opts.on('-f', '--fuzzy [DIFF]', Integer,
+              "Detect fuzzy (copy & paste) duplication (default 1).") do |n|
+        options[:fuzzy] = n || 1
+      end
+
+      opts.on('-l', '--liberal', "Use a more liberal detection method.") do
+        options[:liberal] = true
       end
 
       opts.on('-m', '--mass MASS', Integer,
@@ -52,6 +66,10 @@ class Flay
         options[:mass] = m.to_i
       end
 
+      opts.on('-#', "Don't number output (helps with diffs)") do |m|
+        options[:number] = false
+      end
+
       opts.on('-v', '--verbose', "Verbose. Show progress processing files.") do
         options[:verbose] = true
       end
@@ -89,6 +107,11 @@ class Flay
     options
   end
 
+  ##
+  # Expands +*dirs+ to all files within that match ruby and rake extensions.
+  # --
+  # REFACTOR: from flog
+
   def self.expand_dirs_to_files *dirs
     extensions = ['rb'] + Flay.load_plugins
 
@@ -101,6 +124,9 @@ class Flay
     }.flatten
   end
 
+  ##
+  # Loads all flay plugins. Files must be named "flog_*.rb".
+
   def self.load_plugins
     unless defined? @@plugins then
       @@plugins = []
@@ -123,8 +149,13 @@ class Flay
     # ignore
   end
 
+  # :stopdoc:
   attr_accessor :mass_threshold, :total, :identical, :masses
   attr_reader :hashes, :option
+  # :startdoc:
+
+  ##
+  # Create a new instance of Flay with +option+s.
 
   def initialize option = nil
     @option = option || Flay.default_options
@@ -138,6 +169,9 @@ class Flay
     require 'ruby2ruby' if @option[:diff]
   end
 
+  ##
+  # Process any number of files.
+
   def process(*files) # TODO: rename from process - should act as SexpProcessor
     files.each do |file|
       warn "Processing #{file}" if option[:verbose]
@@ -169,17 +203,38 @@ class Flay
     end
   end
 
+  ##
+  # Prune, find identical nodes, and update masses.
+
   def analyze
     self.prune
 
     self.hashes.each do |hash,nodes|
       identical[hash] = nodes[1..-1].all? { |n| n == nodes.first }
+    end
+
+    update_masses
+  end
+
+  ##
+  # Reset total and recalculate the masses for all nodes in +hashes+.
+
+  def update_masses
+    self.total = 0
+    masses.clear
+    self.hashes.each do |hash, nodes|
       masses[hash] = nodes.first.mass * nodes.size
       masses[hash] *= (nodes.size) if identical[hash]
       self.total += masses[hash]
     end
   end
 
+  ##
+  # Parse a ruby +file+ and return the sexp.
+  #
+  # --
+  # TODO: change the system and rename this to parse_rb.
+
   def process_rb file
     begin
       RubyParser.new.process(File.binread(file), file, option[:timeout])
@@ -188,26 +243,80 @@ class Flay
     end
   end
 
+  ##
+  # Process a sexp +pt+.
+
   def process_sexp pt
     pt.deep_each do |node|
       next unless node.any? { |sub| Sexp === sub }
       next if node.mass < self.mass_threshold
 
       self.hashes[node.structural_hash] << node
+
+      process_fuzzy node, option[:fuzzy] if option[:fuzzy]
+    end
+  end
+
+  # :stopdoc:
+  MAX_NODE_SIZE = 10 # prevents exponential blowout
+  MAX_AVG_MASS  = 12 # prevents exponential blowout
+  # :startdoc:
+
+  ##
+  # Process "fuzzy" matches for +node+. A fuzzy match is a subset of
+  # +node+ up to +difference+ elements less than the original.
+
+  def process_fuzzy node, difference
+    return unless node.has_code?
+
+    avg_mass = node.mass / node.size
+    return if node.size > MAX_NODE_SIZE or avg_mass > MAX_AVG_MASS
+
+    tmpl, code = node.split_code
+    tmpl.modified = true
+
+    (code.size - 1).downto(code.size - difference) do |n|
+      code.combination(n).each do |subcode|
+        new_node = tmpl + subcode
+
+        next unless new_node.any? { |sub| Sexp === sub }
+        next if new_node.mass < self.mass_threshold
+
+        # they're already structurally similar, don't bother adding another
+        next if self.hashes[new_node.structural_hash].any? { |sub|
+          sub.file == new_node.file and sub.line == new_node.line
+        }
+
+        self.hashes[new_node.structural_hash] << new_node
+      end
     end
   end
 
+  ##
+  # Prunes nodes that aren't relevant to analysis or are already
+  # covered by another node.
+
   def prune
     # prune trees that aren't duped at all, or are too small
     self.hashes.delete_if { |_,nodes| nodes.size == 1 }
+    self.hashes.delete_if { |_,nodes| nodes.all?(&:modified?) }
 
-    # extract all subtree hashes from all nodes
+    return prune_liberally if option[:liberal]
+
+    prune_conservatively
+  end
+
+  ##
+  # Conservative prune. Remove any bucket that is known to contain a
+  # subnode element of a node in another bucket.
+
+  def prune_conservatively
     all_hashes = {}
+
+    # extract all subtree hashes from all nodes
     self.hashes.values.each do |nodes|
-      nodes.each do |node|
-        node.all_structural_subhashes.each do |h|
-          all_hashes[h] = true
-        end
+      nodes.first.all_structural_subhashes.each do |h|
+        all_hashes[h] = true
       end
     end
 
@@ -215,6 +324,45 @@ class Flay
     self.hashes.delete_if { |h,_| all_hashes[h] }
   end
 
+  ##
+  # Liberal prune. Remove any _element_ from a bucket that is known to
+  # be a subnode of another node. Removed by identity.
+
+  def prune_liberally
+    update_masses
+
+    all_hashes = Hash.new { |h,k| h[k] = [] }
+
+    # record each subtree by subhash, but skip if subtree mass > parent mass
+    self.hashes.values.each do |nodes|
+      nodes.each do |node|
+        tophash  = node.structural_hash
+        topscore = self.masses[tophash]
+
+        node.deep_each do |subnode|
+          subhash  = subnode.structural_hash
+          subscore = self.masses[subhash]
+
+          next if subscore and subscore > topscore
+
+          all_hashes[subhash] << subnode
+        end
+      end
+    end
+
+    # nuke only individual items by object identity
+    self.hashes.each do |h,v|
+      v.delete_eql all_hashes[h]
+    end
+
+    # nuke buckets we happened to fully empty
+    self.hashes.delete_if { |k,v| v.size <= 1 }
+  end
+
+  ##
+  # Output an n-way diff from +data+. This is only used if --diff is
+  # given.
+
   def n_way_diff *data
     data.each_with_index do |s, i|
       c = (?A.ord + i).chr
@@ -246,6 +394,9 @@ class Flay
     groups.flatten.join("\n")
   end
 
+  ##
+  # Calculate summary scores on a per-file basis. For --summary.
+
   def summary
     score = Hash.new 0
 
@@ -260,13 +411,16 @@ class Flay
     score
   end
 
+  ##
+  # Output the report. Duh.
+
   def report prune = nil
     analyze
 
     puts "Total score (lower is better) = #{self.total}"
-    puts
 
     if option[:summary] then
+      puts
 
       self.summary.sort_by { |_,v| -v }.each do |file, score|
         puts "%8.2f: %s" % [score, file]
@@ -276,7 +430,13 @@ class Flay
     end
 
     count = 0
-    masses.sort_by { |h,m| [-m, hashes[h].first.file] }.each do |hash, mass|
+    sorted = masses.sort_by { |h,m|
+      [-m,
+       hashes[h].first.file,
+       hashes[h].first.line,
+       hashes[h].first.first.to_s]
+    }
+    sorted.each do |hash, mass|
       nodes = hashes[hash]
       next unless nodes.first.first == prune if prune
       puts
@@ -290,16 +450,24 @@ class Flay
                        ["Similar",   ""]
                      end
 
-      count += 1
-      puts "%d) %s code found in %p (mass%s = %d)" %
-        [count, match, node.first, bonus, mass]
+      if option[:number] then
+        count += 1
+
+        puts "%d) %s code found in %p (mass%s = %d)" %
+         [count, match, node.first, bonus, mass]
+      else
+        puts "%s code found in %p (mass%s = %d)" %
+         [match, node.first, bonus, mass]
+      end
 
       nodes.sort_by { |x| [x.file, x.line] }.each_with_index do |x, i|
         if option[:diff] then
           c = (?A.ord + i).chr
-          puts "  #{c}: #{x.file}:#{x.line}"
+          extra = " (FUZZY)" if x.modified?
+          puts "  #{c}: #{x.file}:#{x.line}#{extra}"
         else
-          puts "  #{x.file}:#{x.line}"
+          extra = " (FUZZY)" if x.modified?
+          puts "  #{x.file}:#{x.line}#{extra}"
         end
       end
 
@@ -313,14 +481,28 @@ class Flay
 end
 
 class String
-  attr_accessor :group
+  attr_accessor :group # :nodoc:
 end
 
 class Sexp
+  ##
+  # Whether or not this sexp is a mutated/modified sexp.
+
+  attr_accessor :modified
+  alias :modified? :modified # Is this sexp modified?
+
+  ##
+  # Calculate the structural hash for this sexp. Cached, so don't
+  # modify the sexp afterwards and expect it to be correct.
+
   def structural_hash
     @structural_hash ||= self.structure.hash
   end
 
+  ##
+  # Returns a list of structural hashes for all nodes (and sub-nodes)
+  # of this sexp.
+
   def all_structural_subhashes
     hashes = []
     self.deep_each do |node|
@@ -328,4 +510,70 @@ class Sexp
     end
     hashes
   end
+
+  def initialize_copy o # :nodoc:
+    s = super
+    s.file = o.file
+    s.line = o.line
+    s.modified = o.modified
+    s
+  end
+
+  def [] a # :nodoc:
+    s = super
+    if Sexp === s then
+      s.file = self.file
+      s.line = self.line
+      s.modified = self.modified
+    end
+    s
+  end
+
+  def + o # :nodoc:
+    self.dup.concat o
+  end
+
+  ##
+  # Useful general array method that splits the array from 0..+n+ and
+  # the rest. Returns both sections.
+
+  def split_at n
+    return self[0..n], self[n+1..-1]
+  end
+
+  ##
+  # Return the index of the last non-code element, or nil if this sexp
+  # is not a code-bearing node.
+
+  def code_index
+    {
+     :block  => 0,    # s(:block,                   *code)
+     :class  => 2,    # s(:class,      name, super, *code)
+     :module => 1,    # s(:module,     name,        *code)
+     :defn   => 2,    # s(:defn,       name, args,  *code)
+     :defs   => 3,    # s(:defs, recv, name, args,  *code)
+     :iter   => 2,    # s(:iter, recv,       args,  *code)
+    }[self.sexp_type]
+  end
+
+  alias has_code? code_index # Does this sexp have a +*code+ section?
+
+  ##
+  # Split the sexp into front-matter and code-matter, returning both.
+  # See #code_index.
+
+  def split_code
+    index = self.code_index
+    self.split_at index if index
+  end
+end
+
+class Array # :nodoc:
+
+  ##
+  # Delete anything in +self+ if they are identical to anything in +other+.
+
+  def delete_eql other
+    self.delete_if { |o1| other.any? { |o2| o1.equal? o2 } }
+  end
 end

data/lib/flay_erb.rb

@@ -5,6 +5,11 @@ require 'flay'
 require 'erb'
 
 class Flay
+
+  ##
+  # Process erb and parse the result. Returns the sexp of the parsed
+  # ruby.
+
   def process_erb file
     erb = File.read file
 

data/lib/flay_task.rb

@@ -1,9 +1,28 @@
 class FlayTask < Rake::TaskLib
+  ##
+  # The name of the task. Defaults to :flay
+
   attr_accessor :name
+
+  ##
+  # What directories to operate on. Sensible defaults.
+
   attr_accessor :dirs
+
+  ##
+  # Threshold to fail the task at. Default 200.
+
   attr_accessor :threshold
+
+  ##
+  # Verbosity of output. Defaults to rake's trace (-t) option.
+
   attr_accessor :verbose
 
+  ##
+  # Creates a new FlayTask instance with given +name+, +threshold+,
+  # and +dirs+.
+
   def initialize name = :flay, threshold = 200, dirs = nil
     @name      = name
     @dirs      = dirs || %w(app bin lib spec test)
@@ -17,6 +36,9 @@ class FlayTask < Rake::TaskLib
     define
   end
 
+  ##
+  # Defines the flay task.
+
   def define
     desc "Analyze for code duplication in: #{dirs.join(', ')}"
     task name do

data/lib/gauntlet_flay.rb

@@ -10,6 +10,7 @@ require 'flay'
 require 'gauntlet'
 require 'pp'
 
+# :stopdoc:
 class FlayGauntlet < Gauntlet
   $owners       = {}
   $score_file   = 'flay-scores.yml'
@@ -98,3 +99,4 @@ filter = Regexp.new filter if filter
 flayer = FlayGauntlet.new
 flayer.run_the_gauntlet filter
 flayer.display_report max
+# :startdoc:

data/test/test_flay.rb

@@ -24,6 +24,20 @@ class TestSexp < MiniTest::Unit::TestCase
     assert_equal hash, @s.deep_clone.structural_hash
   end
 
+  def test_delete_eql
+    s1 = s(:a, s(:b, s(:c)))
+    s2 = s(:a, s(:b, s(:c)))
+    s3 = s(:a, s(:b, s(:c)))
+
+    a1 = [s1, s2, s3]
+    a2 = [s1,     s3]
+
+    a1.delete_eql a2
+
+    assert_equal [s2], a1
+    assert_same s2, a1.first
+  end
+
   def test_all_structural_subhashes
     s = s(:iter,
           s(:call, s(:arglist, s(:lit))),
@@ -50,22 +64,110 @@ class TestSexp < MiniTest::Unit::TestCase
     assert_equal expected, x.sort.uniq
   end
 
+  DOG_AND_CAT = Ruby18Parser.new.process <<-RUBY
+    class Dog
+      def x
+        return "Hello"
+      end
+    end
+    class Cat
+      def y
+        return "Hello"
+      end
+    end
+  RUBY
+
+  ROUND = Ruby18Parser.new.process <<-RUBY
+    def x(n)
+      if n % 2 == 0
+        return n
+      else
+        return n + 1
+      end
+    end
+  RUBY
+
+  def test_prune
+    contained = s(:a, s(:b,s(:c)), s(:d,s(:e)))
+    container = s(:d, contained)
+
+    flay = Flay.new :mass => 0
+    flay.process_sexp s(:outer,contained)
+    2.times { flay.process_sexp s(:outer,container) }
+
+    exp = eval <<-EOM # just to prevent emacs from reindenting it
+          [
+           [      s(:a, s(:b, s(:c)), s(:d, s(:e))),
+                  s(:a, s(:b, s(:c)), s(:d, s(:e))),
+                  s(:a, s(:b, s(:c)), s(:d, s(:e)))],
+           [            s(:b, s(:c)),
+                        s(:b, s(:c)),
+                        s(:b, s(:c))],
+           [s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e)))),
+            s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e))))],
+           [                          s(:d, s(:e)),
+                                      s(:d, s(:e)),
+                                      s(:d, s(:e))],
+          ]
+    EOM
+
+    assert_equal exp, flay.hashes.values.sort_by(&:inspect)
+
+    flay.prune
+
+    exp = [
+           [s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e)))),
+            s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e))))]
+          ]
+
+    assert_equal exp, flay.hashes.values.sort_by(&:inspect)
+  end
+
+  def test_prune_liberal
+    contained = s(:a, s(:b,s(:c)), s(:d,s(:e)))
+    container = s(:d, contained)
+
+    flay = Flay.new :mass => 0, :liberal => true
+    flay.process_sexp s(:outer,contained)
+    2.times { flay.process_sexp s(:outer,container) }
+
+    exp = eval <<-EOM # just to prevent emacs from reindenting it
+          [
+           [      s(:a, s(:b, s(:c)), s(:d, s(:e))),
+                  s(:a, s(:b, s(:c)), s(:d, s(:e))),
+                  s(:a, s(:b, s(:c)), s(:d, s(:e)))],
+           [            s(:b, s(:c)),
+                        s(:b, s(:c)),
+                        s(:b, s(:c))],
+           [s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e)))),
+            s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e))))],
+           [                          s(:d, s(:e)),
+                                      s(:d, s(:e)),
+                                      s(:d, s(:e))],
+          ]
+    EOM
+
+    assert_equal exp, flay.hashes.values.sort_by(&:inspect)
+
+    flay.prune
+
+    exp = [
+           [s(:a, s(:b, s(:c)), s(:d, s(:e))),
+            s(:a, s(:b, s(:c)), s(:d, s(:e))),
+            s(:a, s(:b, s(:c)), s(:d, s(:e)))],
+           [s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e)))),
+            s(:d, s(:a, s(:b, s(:c)), s(:d, s(:e))))]
+          ]
+
+    assert_equal exp, flay.hashes.values.sort_by(&:inspect)
+  end
+
   def test_process_sexp
     flay = Flay.new
 
-    s = Ruby18Parser.new.process <<-RUBY
-      def x(n)
-        if n % 2 == 0
-          return n
-        else
-          return n + 1
-        end
-      end
-    RUBY
-
     expected = [] # only ones big enough
 
-    flay.process_sexp s
+    flay.process_sexp ROUND.deep_clone
 
     actual = flay.hashes.values.map { |sexps| sexps.map { |sexp| sexp.first } }
 
@@ -75,23 +177,13 @@ class TestSexp < MiniTest::Unit::TestCase
   def test_process_sexp_full
     flay = Flay.new(:mass => 1)
 
-    s = Ruby18Parser.new.process <<-RUBY
-      def x(n)
-        if n % 2 == 0
-          return n
-        else
-          return n + 1
-        end
-      end
-    RUBY
-
     expected = [[:call, :call],
                 [:call],
                 [:if],
                 [:return],
                 [:return]]
 
-    flay.process_sexp s
+    flay.process_sexp ROUND.deep_clone
 
     actual = flay.hashes.values.map { |sexps| sexps.map { |sexp| sexp.first } }
 
@@ -119,20 +211,7 @@ class TestSexp < MiniTest::Unit::TestCase
 
     flay = Flay.new opts
 
-    s = Ruby18Parser.new.process <<-RUBY
-      class Dog
-        def x
-          return "Hello"
-        end
-      end
-      class Cat
-        def y
-          return "Hello"
-        end
-      end
-    RUBY
-
-    flay.process_sexp s
+    flay.process_sexp DOG_AND_CAT.deep_clone
     flay.analyze
 
     out, err = capture_io do
@@ -142,7 +221,6 @@ class TestSexp < MiniTest::Unit::TestCase
     exp = <<-END.gsub(/\d+/, "N").gsub(/^ {6}/, "")
       Total score (lower is better) = 16
 
-
       1) Similar code found in :class (mass = 16)
         A: (string):1
         B: (string):6

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: flay
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: 
   segments: 
   - 2
-  - 1
+  - 2
   - 0
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2013-02-14 00:00:00 Z
+date: 2013-04-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sexp_processor
@@ -76,11 +76,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 21
         segments: 
         - 4
-        - 6
-        version: "4.6"
+        - 7
+        version: "4.7"
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -91,11 +91,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 27
         segments: 
-        - 3
-        - 10
-        version: "3.10"
+        - 4
+        - 0
+        version: "4.0"
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency