ips 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b0cebe0c91bffd744baf3e8f52b8215799699ba4ca56d0856af1802dfc3df13
-  data.tar.gz: 43f27237a0abb534d951ac7da7c96fe0f8e3f053a1910a0534fcbfafaaf4dabf
+  metadata.gz: e1f6fa1d4276f6a2e4490785949a2f9d776fd22deefd7bf8b4a32a1373e1ace2
+  data.tar.gz: dc254907783de35d83da05e504aff4b94479fcbb0b18e5fd227fc9af97864a6e
 SHA512:
-  metadata.gz: 5bbe4651a8879db139bdd2be7b551d4f5787a42cb22ab145056b92883e02acc7818144b61689f94e70f3218ea9f7566f8e337a97ef0a6ba9b280174a508cafb4
-  data.tar.gz: 3665d4bf59457dcfb246908fcc7f4d0eba583790d9171995f25dc02dad786fb6f5ab44ac4e32ee573b4775a87f4dfbbeb46e4389b1b3ad77ce2d994da5a51d3b
+  metadata.gz: aaabca2ef626e4c0856f7ba3786fc0f91613b8a52a5681351dcd5dfd563918188dc62f2ffd2b1e25b6940ddabe447da85b9608002c63d01373a3de95548c990c
+  data.tar.gz: e9ba746e1183237048aff5b35f41865d7886ee6e57b77be7c238f1d9ae09f2e707599adf7aa32c98bfee964ab3ae7a909cf80d5d1602b05dd989b28396d9b0dd

data/README.md

@@ -1,47 +1,54 @@
 # IPS
 
-A Ruby benchmarking tool that measures iterations per second with statistical analysis, automatic warmup, and comparison summaries.
+![demo](demo.gif)
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
-
-```bash
-bundle add ips
-```
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
 ```bash
 gem install ips
 ```
 
 ## Usage
 
+### Library
+
 ```ruby
 require "ips"
 
 IPS.run do |x|
-  x.report("addition")       { 1 + 1 }
-  x.report("multiplication") { 2 * 3 }
-  x.report("wtf") { eval("#{1.to_s} + #{1.to_s}") }
+  x.report("split/join") { "hello world".split(" ").join("-") }
+  x.report("gsub")       { "hello world".gsub(" ", "-") }
 end
 ```
 
-Output:
+### CLI
+
+```
+$ ips -e '"hello world".split(" ").join("-")' -e '"hello world".gsub(" ", "-")'
+```
+
+Compare across Ruby versions:
 
 ```
-            addition:    45.759M i/s (± 1.2%)
-      multiplication:    45.593M i/s (± 0.2%)
-                 wtf:   463.420k i/s (± 0.9%, GC  6.3%)
+$ ips --ruby 3.4 --ruby 4.0 -e 'Object.new'
+```
 
-Summary
-  addition ran
-    1.00 ± 0.01 times faster than multiplication
-    98.74 ± 1.49 times faster than wtf
+Compare across Ruby versions, arguments, and commands:
+
+```
+$ ips --ruby '3.4' --ruby '3.4 --yjit' --ruby '4.0' --ruby '4.0 --yjit' -e 'Object.new' -e 'Object.allocate'
 ```
 
-When two or more items are reported, a comparison summary is automatically displayed.
+Options:
+
+- `--ruby VERSION` — run against a specific Ruby (repeatable)
+- `-e CODE` — inline benchmark expression (repeatable)
+- `-t SECONDS` — benchmark time (default: 5)
+- `-w SECONDS` — warmup time (default: 20% of benchmark time)
+- `--save PATH` — save results to JSON (appends to existing file)
+- `--debug` — show compiled source, cycle counts, and per-batch timing
+- `--yjit`, `--zjit`, `--disable-gems` — passed through to Ruby
+- `-r LIB` — require a library before running
 
 ## Contributing
 

data/demo.tape

@@ -0,0 +1,16 @@
+# https://github.com/charmbracelet/vhs
+Output demo.gif
+
+Set Width 960
+Set Height 500
+Set FontSize 14
+Set FontFamily "Menlo"
+Set Theme "Catppuccin Mocha"
+Set TypingSpeed 10ms
+Set Padding 20
+
+Type "ips -t 2 --ruby 3.4 --ruby 4.0 --ruby '4.0 --yjit' -e 'Object.new' -e 'Object.allocate'"
+Sleep 250ms
+Enter
+
+Sleep 25s

data/exe/ips

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+versions = []
+inline_code = []
+ruby_flags = []
+save_path = nil
+bench_time = nil
+warmup_time = nil
+debug = false
+frozen_string_literal = true
+args = ARGV.dup
+while args.first
+  case args.first
+  when "--ruby"
+    args.shift
+    versions << args.shift
+  when "-e"
+    args.shift
+    inline_code << args.shift
+  when "-r"
+    args.shift
+    ruby_flags.push("-r", args.shift)
+  when "--disable-gems", /\A--yjit/, /\A--zjit/
+    ruby_flags << args.shift
+  when "--save"
+    args.shift
+    save_path = args.shift
+  when "-t"
+    args.shift
+    bench_time = args.shift.to_f
+  when "-w"
+    args.shift
+    warmup_time = args.shift.to_f
+  when "--no-frozen-string-literal"
+    args.shift
+    frozen_string_literal = false
+  when "--debug"
+    args.shift
+    debug = true
+  when "-v", "--verbose"
+    args.shift
+    verbose = true
+  when /\A-/
+    $stderr.puts "Unknown option: #{args.first}"
+    exit 1
+  else
+    break
+  end
+end
+script = args.shift
+
+if script.nil? && inline_code.empty?
+  $stderr.puts "Usage: ips [--ruby VERSION ...] [-e CODE ...] [<script>]"
+  exit 1
+end
+
+if inline_code.any?
+  run_opts = []
+  run_opts << "summary: false" if versions.size > 1
+  run_opts << "time: #{bench_time}" if bench_time
+  run_opts << "warmup: #{warmup_time}" if warmup_time
+  run_opts << "debug: true" if debug
+  run_opts << "frozen_string_literal: false" unless frozen_string_literal
+  run_opts_str = run_opts.any? ? "(#{run_opts.join(", ")})" : ""
+  script_source = +""
+  script_source << "# frozen_string_literal: true\n" if frozen_string_literal
+  script_source << "require 'ips'\nresult = IPS.run#{run_opts_str} do |x|\n"
+  inline_code.each do |code|
+    script_source << "  x.report(#{code.inspect}, #{code.inspect})\n"
+  end
+  script_source << "end\n"
+  script_source << "IO.open(3, 'w') { |f| Marshal.dump(result, f) }\n"
+  ruby_args = ["-e", script_source]
+else
+  ruby_args = [script]
+end
+
+# Shell-escape for display purposes only, not for security.
+def shell_quote(arg)
+  return arg if arg =~ /\A[A-Za-z0-9_\-.,:+\/@]+\z/
+  "'" + arg.gsub("'", "'\\\\''") + "'"
+end
+
+RUBY_DIRS = [File.expand_path("~/.rubies"), "/opt/rubies"]
+LIB_DIR = File.expand_path("../lib", __dir__)
+
+def find_ruby(version)
+  RUBY_DIRS.each do |dir|
+    next unless Dir.exist?(dir)
+    Dir.children(dir).sort.each do |name|
+      bare = name.delete_prefix("ruby-")
+      if bare.start_with?(version)
+        ruby = File.join(dir, name, "bin", "ruby")
+        return ruby if File.executable?(ruby)
+      end
+    end
+  end
+  nil
+end
+
+def resolve_ruby(str)
+  version, *extra_flags = str.split
+  if File.executable?(version)
+    ruby = version
+  else
+    ruby = find_ruby(version) or abort "No ruby found matching #{version.inspect}"
+  end
+  [ruby, extra_flags]
+end
+
+if versions.empty?
+  rubies = [[nil, nil, []]]
+else
+  rubies = versions.map { |v|
+    ruby, extra_flags = resolve_ruby(v)
+    [v, ruby, extra_flags]
+  }
+end
+
+$LOAD_PATH.unshift(LIB_DIR)
+require "ips"
+
+results = []
+
+rubies.each do |version_str, ruby, extra_flags|
+  if ruby
+    env = { "GEM_HOME" => nil, "GEM_PATH" => nil }
+  else
+    ruby = "ruby"
+    env = {}
+  end
+
+  cmd = [ruby, *extra_flags, *ruby_flags, "-v", "-I", LIB_DIR, *ruby_args]
+  $stderr.puts cmd.map { |a| shell_quote(a) }.join(" ") if verbose
+  rd, wr = IO.pipe
+  pid = spawn(env, *cmd, 3 => wr)
+  wr.close
+  data = rd.read
+  rd.close
+  Process.wait(pid)
+  raise "Child process failed" unless $?.success?
+  unless data.empty?
+    result = Marshal.load(data)
+    result.ruby_executable = ruby
+    result.run_label = "ruby #{version_str}" if version_str
+    results << result
+  end
+  puts
+end
+
+IPS::Result.compare(results)
+
+if save_path && results.any?
+  IPS::Result.save!(save_path, results)
+end

data/lib/ips/display.rb

@@ -4,11 +4,11 @@ module IPS
   class Display
     BAR_WIDTH = 30
 
-    def initialize(labels, out: $stdout)
+    def initialize(labels, out: $stdout, debug: false)
       @out = out
       @max_label = labels.map(&:size).max
       @max_label = 20 if @max_label < 20
-      @tty = @out.tty?
+      @tty = @out.tty? && !debug
     end
 
     def start_item(label, total_ns)
@@ -42,22 +42,32 @@ module IPS
 
     def summary(results)
       return if results.size < 2
+      pairs = results.map { |r| [r.label, r] }
+      Display.compare(pairs, out: @out)
+    end
+
+    def self.compare(pairs, out: $stdout)
+      return if pairs.size < 2
 
-      sorted = results.sort_by { |r| -r.ips }
-      best = sorted.first
+      sorted = pairs.sort_by { |_, e| -e.ips }
+      best_label, best = sorted.first
 
-      @out.puts "\nSummary"
-      @out.puts "  #{best.label} ran"
+      out.puts "\nSummary"
+      out.puts "  #{best_label} ran"
 
-      sorted[1..].each do |r|
-        ratio = best.ips / r.ips
-        ratio_error = ratio * Math.sqrt((best.stddev / best.ips)**2 + (r.stddev / r.ips)**2)
-        @out.printf "    %.2f ± %.2f times faster than %s\n",
-          ratio, ratio_error, r.label
+      sorted[1..].each do |label, entry|
+        ratio = best.ips / entry.ips
+        ratio_error = ratio * Math.sqrt((best.stddev / best.ips)**2 + (entry.stddev / entry.ips)**2)
+        out.printf "    %.2f ± %.2f times faster than %s\n",
+          ratio, ratio_error, label
       end
     end
 
     def format_ips(ips)
+      Display.format_ips(ips)
+    end
+
+    def self.format_ips(ips)
       if ips >= 1_000_000_000
         "%.3fB" % (ips / 1_000_000_000.0)
       elsif ips >= 1_000_000

data/lib/ips/job/entry.rb

@@ -3,23 +3,40 @@
 module IPS
   class Job
     class Entry
-      attr_reader :label
+      attr_reader :label, :source
 
-      def initialize(label, action)
+      def initialize(label, action, frozen_string_literal:)
         @label = label
-        @action = action
+        @source = nil
+        @frozen_string_literal = frozen_string_literal
 
-        if action.arity > 0
-          define_call_times_manual_loop
+        if action.kind_of?(String)
+          compile_string(action)
+        elsif action.arity > 0
+          define_call_times_manual_loop(action)
         else
-          define_call_times_block
+          define_call_times_block(action)
         end
       end
 
       private
 
-      def define_call_times_block
-        act = @action
+      def compile_string(str)
+        @source = <<~RUBY
+          def call_times(__total)
+            __i = 0
+            while __i < __total
+              #{str}
+              __i += 1
+            end
+          end
+        RUBY
+        eval_source = "# frozen_string_literal: #{@frozen_string_literal}\n#{@source}"
+        m = (class << self; self; end)
+        m.class_eval(eval_source)
+      end
+
+      def define_call_times_block(act)
         define_singleton_method(:call_times) do |times|
           i = 0
           while i < times
@@ -29,8 +46,7 @@ module IPS
         end
       end
 
-      def define_call_times_manual_loop
-        act = @action
+      def define_call_times_manual_loop(act)
         define_singleton_method(:call_times) do |times|
           act.call(times)
         end

data/lib/ips/job.rb

@@ -10,24 +10,35 @@ module IPS
 
     attr_accessor :warmup, :time
 
-    def initialize(time: 5, warmup: 2, out: $stdout)
+    def initialize(time: 5, warmup: time * 0.2, summary: true, debug: false, frozen_string_literal: true, out: $stdout)
       @list = []
       @time = time
       @warmup = warmup
+      @summary = summary
+      @debug = debug
+      @frozen_string_literal = frozen_string_literal
       @timing = {}
       @out = out
     end
 
-    def report(label, &block)
-      @list.push Entry.new(label, block)
+    def report(label, action = nil, &block)
+      raise ArgumentError, "cannot specify both action and block" if action && block
+      action ||= block || label
+      @list.push Entry.new(label, action, frozen_string_literal: @frozen_string_literal)
       self
     end
 
     def run
-      display = Display.new(@list.map(&:label), out: @out)
+      display = Display.new(@list.map(&:label), out: @out, debug: @debug)
       total_ns = ((@warmup + @time) * Timing::NANOSECONDS_PER_SECOND).to_i
 
       results = @list.map do |item|
+        if @debug
+          source = item.source
+          @out.puts "--- #{item.label} ---"
+          @out.puts source if source
+          @out.puts
+        end
         display.start_item(item.label, total_ns)
         warmup_item(item, display)
         result = measure_item(item, display)
@@ -35,7 +46,8 @@ module IPS
         result
       end
 
-      display.summary(results)
+      display.summary(results) if @summary
+      Result.build(results)
     end
 
     private
@@ -69,6 +81,7 @@ module IPS
       per_100ms = cycles_per_100ms(warmup_ns, warmup_iter)
       cycles = per_100ms > MAX_ITERATIONS ? MAX_ITERATIONS : per_100ms
       @timing[item] = cycles
+      @out.puts "  cycles: #{cycles}" if @debug
 
       target = Timing.add_second(before, @warmup)
       while Timing.now + Timing::NANOSECONDS_PER_100MS < target
@@ -104,11 +117,18 @@ module IPS
         times << t0 << t1
         gc_times << gc0 << gc1
 
+        if @debug
+          batch_ips = Timing::NANOSECONDS_PER_SECOND * (cycles.to_f / elapsed_ns)
+          gc_ns = gc1 - gc0
+          @out.printf "  batch: %.3fms  ips: %s  gc: %.3fms\n",
+            elapsed_ns / 1_000_000.0, Display.format_ips(batch_ips), gc_ns / 1_000_000.0
+        end
+
         total_ns = t1 - times[0]
         display.progress(estimate: Timing::NANOSECONDS_PER_SECOND * (iter.to_f / total_ns))
       end while Timing.now < target
 
-      Result.new(item.label, cycles, times, gc_times)
+      Result::Entry.new(item.label, cycles, times, gc_times)
     end
   end
 end

data/lib/ips/result.rb

@@ -2,90 +2,206 @@
 
 module IPS
   class Result
-    attr_reader :label, :cycles, :times, :gc_times
-
-    # times: flat array [start0, end0, start1, end1, ...]
-    # gc_times: flat array [gc_before0, gc_after0, gc_before1, gc_after1, ...]
-    def initialize(label, cycles, times, gc_times)
-      @label = label
-      @cycles = cycles
-      @times = times
-      @gc_times = gc_times
+    attr_accessor :uuid, :run_label, :ruby_version, :ruby_description, :ruby_executable, :pid, :yjit_enabled, :entries
+
+    def initialize(entries, uuid:, ruby_version:, ruby_description:, ruby_executable:, pid:, yjit_enabled:)
+      @entries = entries
+      @uuid = uuid
+      @ruby_version = ruby_version
+      @ruby_description = ruby_description
+      @ruby_executable = ruby_executable
+      @pid = pid
+      @yjit_enabled = yjit_enabled
+    end
+
+    def self.build(entries)
+      new(entries,
+        uuid: generate_uuid,
+        ruby_version: RUBY_VERSION,
+        ruby_description: RUBY_DESCRIPTION,
+        ruby_executable: nil,
+        pid: Process.pid,
+        yjit_enabled: defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?)
     end
 
-    def sample_count
-      @times.size / 2
+    def self.generate_uuid
+      random = Random.urandom(16)
+      bytes = random.unpack("NnnnnN")
+      bytes[2] = (bytes[2] & 0x0fff) | 0x4000
+      bytes[3] = (bytes[3] & 0x3fff) | 0x8000
+      "%08x-%04x-%04x-%04x-%04x%08x" % bytes
     end
 
-    def iterations
-      sample_count * @cycles
+    def to_h
+      {
+        "uuid" => @uuid,
+        "ruby_version" => @ruby_version,
+        "ruby_description" => @ruby_description,
+        "ruby_executable" => @ruby_executable,
+        "pid" => @pid,
+        "yjit_enabled" => @yjit_enabled,
+        "results" => @entries.map(&:to_h)
+      }
     end
 
-    # Total wall time from first batch start to last batch end
-    def total_ns
-      @times[-1] - @times[0]
+    def self.from_h(hash)
+      entries = hash["results"].map { |h| Entry.from_h(h) }
+      new(entries,
+        uuid: hash["uuid"],
+        ruby_version: hash["ruby_version"],
+        ruby_description: hash["ruby_description"],
+        ruby_executable: hash["ruby_executable"],
+        pid: hash["pid"],
+        yjit_enabled: hash["yjit_enabled"])
     end
 
-    # Time spent actually running batches
-    def busy_ns
-      total = 0
-      i = 0
-      while i < @times.size
-        total += @times[i + 1] - @times[i]
-        i += 2
+    def self.save!(path, results)
+      require "json"
+
+      data = if File.exist?(path)
+        JSON.parse(File.read(path))
+      else
+        { "runs" => [] }
+      end
+
+      Array(results).each do |result|
+        data["runs"] << result.to_h
       end
-      total
+
+      File.write(path, JSON.pretty_generate(data) + "\n")
     end
 
-    # Time between batches (measurement overhead, GC, scheduling)
-    def overhead_ns
-      total_ns - busy_ns
+    def self.load(path)
+      require "json"
+      data = JSON.parse(File.read(path))
+      data["runs"].map { |h| from_h(h) }
     end
 
-    # Total GC time during measurement
-    def gc_ns
-      total = 0
-      i = 0
-      while i < @gc_times.size
-        total += @gc_times[i + 1] - @gc_times[i]
-        i += 2
-      end
-      total
+    def self.compare(results, out: $stdout)
+      return if results.size < 2
+
+      run_labels = distinguish(results)
+      one_entry = results.all? { |r| r.entries.size == 1 }
+
+      pairs = results.flat_map { |r|
+        r.entries.map { |e|
+          label = one_entry ? run_labels[r.uuid] : "#{e.label} (#{run_labels[r.uuid]})"
+          [label, e]
+        }
+      }
+
+      Display.compare(pairs, out: out)
     end
 
-    def ips
-      Timing::NANOSECONDS_PER_SECOND * (iterations.to_f / total_ns)
+    def self.distinguish(results)
+      [:run_label, :ruby_version, :ruby_description, :ruby_executable, :uuid].each do |field|
+        values = results.map { |r| r.send(field) }
+        next if values.any?(&:nil?)
+        if values.uniq.size == results.size
+          return results.each_with_object({}) { |r, h| h[r.uuid] = r.send(field).to_s }
+        end
+      end
     end
 
-    # Per-batch IPS samples for error estimation
-    def samples
-      @samples ||= begin
-        s = Array.new(sample_count)
+    class Entry
+      attr_reader :label, :cycles, :times, :gc_times
+
+      # times: flat array [start0, end0, start1, end1, ...]
+      # gc_times: flat array [gc_before0, gc_after0, gc_before1, gc_after1, ...]
+      def initialize(label, cycles, times, gc_times)
+        @label = label
+        @cycles = cycles
+        @times = times
+        @gc_times = gc_times
+      end
+
+      def sample_count
+        @times.size / 2
+      end
+
+      def iterations
+        sample_count * @cycles
+      end
+
+      # Total wall time from first batch start to last batch end
+      def total_ns
+        @times[-1] - @times[0]
+      end
+
+      # Time spent actually running batches
+      def busy_ns
+        total = 0
         i = 0
         while i < @times.size
-          s[i / 2] = Timing::NANOSECONDS_PER_SECOND * (@cycles.to_f / (@times[i + 1] - @times[i]))
+          total += @times[i + 1] - @times[i]
           i += 2
         end
-        s
+        total
       end
-    end
 
-    def sample_mean
-      @sample_mean ||= samples.sum / samples.size
-    end
+      # Time between batches (measurement overhead, GC, scheduling)
+      def overhead_ns
+        total_ns - busy_ns
+      end
 
-    def stddev
-      variance = samples.sum { |s| (s - sample_mean) ** 2 } / samples.size
-      Math.sqrt(variance)
-    end
+      # Total GC time during measurement
+      def gc_ns
+        total = 0
+        i = 0
+        while i < @gc_times.size
+          total += @gc_times[i + 1] - @gc_times[i]
+          i += 2
+        end
+        total
+      end
 
-    def error_pct
-      (stddev / ips) * 100.0
-    end
+      def ips
+        Timing::NANOSECONDS_PER_SECOND * (iterations.to_f / total_ns)
+      end
+
+      # Per-batch IPS samples for error estimation
+      def samples
+        @samples ||= begin
+          s = Array.new(sample_count)
+          i = 0
+          while i < @times.size
+            s[i / 2] = Timing::NANOSECONDS_PER_SECOND * (@cycles.to_f / (@times[i + 1] - @times[i]))
+            i += 2
+          end
+          s
+        end
+      end
 
-    def gc_pct
-      total = total_ns
-      total > 0 ? (gc_ns.to_f / total) * 100.0 : 0.0
+      def sample_mean
+        @sample_mean ||= samples.sum / samples.size
+      end
+
+      def stddev
+        variance = samples.sum { |s| (s - sample_mean) ** 2 } / samples.size
+        Math.sqrt(variance)
+      end
+
+      def error_pct
+        (stddev / ips) * 100.0
+      end
+
+      def gc_pct
+        total = total_ns
+        total > 0 ? (gc_ns.to_f / total) * 100.0 : 0.0
+      end
+
+      def to_h
+        {
+          "label" => @label,
+          "cycles" => @cycles,
+          "times" => @times,
+          "gc_times" => @gc_times
+        }
+      end
+
+      def self.from_h(hash)
+        new(hash["label"], hash["cycles"], hash["times"], hash["gc_times"])
+      end
     end
   end
 end

data/lib/ips/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IPS
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ips.rb

@@ -6,11 +6,23 @@ require "ips/display"
 require "ips/job"
 
 module IPS
-  def self.run(time: 5, warmup: 2, out: $stdout)
-    job = Job.new(time: time, warmup: warmup, out: out)
+  def self.run(time: 5, warmup: time * 0.2, summary: true, debug: false, frozen_string_literal: true, out: $stdout)
+    job = Job.new(time: time, warmup: warmup, summary: summary, debug: debug, frozen_string_literal: frozen_string_literal, out: out)
     yield job
     job.run
   end
+
+  def self.report(label = nil, action = nil, &block)
+    action ||= block || label || raise(ArgumentError, "no action or block given")
+    label ||= action.is_a?(String) ? action : "block"
+    run do |x|
+      x.report(label, action)
+    end
+  end
+
+  class << self
+    alias_method :ips, :run
+  end
 end
 
 Ips = IPS

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ips
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - John Hawthorn
@@ -13,7 +13,8 @@ description: A Ruby benchmarking tool that measures iterations per second with a
   warmup, statistical error estimation, GC reporting, and comparison summaries.
 email:
 - john@hawthorn.email
-executables: []
+executables:
+- ips
 extensions: []
 extra_rdoc_files: []
 files:
@@ -21,6 +22,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- demo.gif
+- demo.tape
 - examples/basic.rb
 - examples/gc_pressure.rb
 - examples/hash_vs_struct.rb
@@ -28,6 +31,7 @@ files:
 - examples/outlier.rb
 - examples/singleton_class.rb
 - examples/string_matching.rb
+- exe/ips
 - lib/ips.rb
 - lib/ips/display.rb
 - lib/ips/job.rb
@@ -55,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Iterations per second benchmarking with statistical analysis
 test_files: []