time_up 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2814efda7871308dcafe0196407a3bbea424770069d9b998c8728f974a641413
+  data.tar.gz: 791e65a388e0d62ece0166a747a20cd41f37259d6283e197ff020a05b6eb3e70
+SHA512:
+  metadata.gz: a697b5da2199813b882d8a1b3994670dde64c8ce5adb95b321a8bef3c8892cda9110e778c505e0fd4c327f1956f474be07db9f5fc008926093af9c60c4a8accf
+  data.tar.gz: 1b7089abf119e10a4cff97f880d9a05536a960b112ba59a57f6c6d8642771e566b697db88f6d7c7e2fdca73ff0549803864314de7601d0643e0c018cfbc3731e

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.1
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.15
+        bundle install
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 0.0.1
+
+- Make the gem
+
+

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "minitest"
+gem "standard"

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    time_up (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    minitest (5.14.4)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rubocop (1.18.3)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.7.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.8.0)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.11.4)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.1.5)
+      rubocop (= 1.18.3)
+      rubocop-performance (= 1.11.4)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  arm64-darwin-20
+
+DEPENDENCIES
+  minitest
+  rake
+  standard
+  time_up!
+
+BUNDLED WITH
+   2.2.15

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Test Double, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# time_up
+
+Ever need to measure the elapsed wall-time for one or more bits of Ruby code,
+but don't necessarily want to reach for
+[Benchmark](https://ruby-doc.org/stdlib-3.0.1/libdoc/benchmark/rdoc/Benchmark.html) or roll your own ad hoc measurement code?
+Try `time_up`!
+
+This gem is especially useful for long-running processes (like test suites) that
+have several time-intensive operations that are repeated over time and that you
+want to measure and aggregate. (For example, to see how much time your
+test suite spends creating factories, truncating the database, or invoking a
+critical code path.)
+
+## Install
+
+Just run `gem install time_up` or add time_up to your Gemfile:
+
+```ruby
+gem "time_up"
+```
+
+## Usage
+
+Starting a timer is easy! Just call `TimeUp.start`:
+
+```ruby
+# Pass a block and time_up will only count the time while the block executes:
+TimeUp.start(:factories) do
+  # … create some factories
+end
+
+# Without a block, a started timer will run until you stop it:
+TimeUp.start(:truncation)
+# … truncate some stuff
+TimeUp.stop(:truncation)
+```
+
+To get the total time that's elapsed while the timer has been running, call
+`elapsed`:
+
+```ruby
+slow_time = TimeUp.elapsed(:slow_code_path)
+```
+
+Which will return a `Float` representing the number of seconds that have elapsed
+while the timer is running.
+
+Timers aggregate total elapsed time running, just like a digital stopwatch. That
+means if you start a timer after it's been stopped, the additional time will be
+_added_ to the previous elapsed time:
+
+```ruby
+TimeUp.start :eggs
+sleep 1
+puts TimeUp.stop :eggs # => ~1.0
+
+TimeUp.start :eggs
+sleep 1
+# To get the elapsed time without necessarily stopping the timer, call `elapsed`
+puts TimeUp.elapsed :eggs # => ~2.0
+
+# To reset a timer to 0, call `reset` (if it's running, it'll keep running!)
+TimeUp.reset :eggs
+sleep 5
+puts TimeUp.stop :eggs # => ~5.0
+```
+
+`TimeUp.start` also returns an instance of the named timer, which has its own
+`start`, `stop`, `elaped`, and `reset` methods. If you want to find that
+instance later, you can also call `TimeUp.timer(:some_name)`. So the above
+example could be rewritten as:
+
+```ruby
+egg_timer = TimeUp.start :eggs
+sleep 1
+puts egg_timer.stop # => ~1.0
+
+egg_timer.start
+sleep 1
+
+# To get the elapsed time without necessarily stopping the timer, call `elapsed`
+puts egg_timer.elapsed # => ~2.0
+
+# To reset a timer to 0, call `reset` (if it's running, it'll keep running!)
+egg_timer.reset
+sleep 5
+puts egg_timer.stop # => ~5.0
+```
+
+Finally, if you're juggling a bunch of timers, you can get a summary report of
+them printed for you, like so:
+
+```ruby
+TimeUp.start :roast
+sleep 0.03
+TimeUp.start :veggies
+sleep 0.02
+TimeUp.start :pasta
+sleep 0.01
+TimeUp.stop_all
+
+TimeUp.start :souffle
+
+TimeUp.print_summary
+```
+
+Which will output something like:
+
+```
+TimeUp timers summary
+========================
+:roast   	0.07267s
+:veggies 	0.03760s
+:pasta   	0.01257s
+:souffle*	0.00003s
+
+* Denotes that the timer is still active
+```
+
+## API
+
+This gem defines a bunch of public methods but they're all pretty short and
+straightforward, so I'd encourage you to [read the code](/lib/time_up.rb).
+
+### `TimeUp` module
+
+`TimeUp.start(name, [&blk])` - Starts (or restarts) and returns a named `Timer`
+
+`TimeUp.timer(name)` - Returns any a `Timer` instance named `name` or `nil`
+
+`TimeUp.stop(name)` - Stops the named timer or raises if it's not defined
+
+`TimeUp.elapsed(name)` - Returns a `Float` of the total elapsed seconds that the
+named timer has been running (and raises if no timer is defined with the given
+`name`)
+
+`TimeUp.reset(name)` - Resets the named timer's elapsed time to 0, effectively
+restarting it if it's currently running. Raises if the timer isn't defined.
+
+`TimeUp.total_elapsed` - Returns a `Float` of the sum of `elapsed` for all the
+timers you've created
+
+`TimeUp.all_elapsed` - Returns a hash of timer name keys mapped to their
+`elapsed` values. Handy for grabbing a snapshot of the state of things at a
+particular point in time without stopping all your timers
+
+`TimeUp.active_timers` - Returns an array of all timers that are currently
+running. Useful for detecting cases where you might be counting the same time in
+multiple places simultaneously
+
+`TimeUp.print_summary([IO])` - Pretty-prints a multi-line summary of all your
+timers to STDOUT (or the provided IO)
+
+`TimeUp.stop_all` - Stops all timers
+
+`TimeUp.reset_all` - Resets all timers
+
+`TimeUp.delete_all` - Stops and resets all timers and deletes any internal
+reference to them
+
+### `TimeUp::Timer` class
+
+`start` - Starts the timer
+
+`stop` - Stops the timer
+
+`elapsed` - A `Float` of the total elapsed seconds the timer has been running
+
+`active?` - Returns `true` if the timer is running
+
+`reset(force: false)` - Resets the timer to 0 elapsed seconds. If `force` is
+true, will also stop the timer if it's running
+
+## Code of Conduct
+
+This project follows Test Double's [code of
+conduct](https://testdouble.com/code-of-conduct) for all community interactions,
+including (but not limited to) one-on-one communications, public posts/comments,
+code reviews, pull requests, and GitHub issues. If violations occur, Test Double
+will take any action they deem appropriate for the infraction, up to and
+including blocking a user from the organization's repositories.
+
+
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: [:test, "standard:fix"]

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "time_up"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/time_up.rb

@@ -0,0 +1,136 @@
+require_relative "time_up/version"
+
+module TimeUp
+  class Error < StandardError; end
+
+  @timers = {}
+  def self.start(name, &blk)
+    raise Error.new("Timer name must be a String or Symbol") unless name.is_a?(Symbol) || name.is_a?(String)
+    timer = @timers[name] ||= Timer.new(name)
+    timer.start
+    if blk
+      blk.call
+      timer.stop
+    end
+    timer
+  end
+
+  # Delegate methods
+  def self.timer(name)
+    @timers[name]
+  end
+
+  def self.stop(name)
+    __ensure_timer(name)
+    @timers[name].stop
+  end
+
+  def self.elapsed(name)
+    __ensure_timer(name)
+    @timers[name].elapsed
+  end
+
+  def self.reset(name)
+    __ensure_timer(name)
+    @timers[name].reset
+  end
+
+  # Interrogative methods
+  def self.total_elapsed
+    @timers.values.sum(&:elapsed)
+  end
+
+  def self.all_elapsed
+    @timers.values.map { |timer|
+      [timer.name, timer.elapsed]
+    }.to_h
+  end
+
+  def self.active_timers
+    @timers.values.select(&:active?)
+  end
+
+  def self.print_summary(io = $stdout)
+    longest_name_length = @timers.values.map { |t| t.name.inspect.size }.max
+    summaries = @timers.values.map { |timer|
+      name = "#{timer.name.inspect}#{"*" if timer.active?}".ljust(longest_name_length + 1)
+      "#{name}\t#{"%.5f" % timer.elapsed}s"
+    }
+    io.puts <<~SUMMARY
+
+      TimeUp timers summary
+      ========================
+      #{summaries.join("\n")}
+
+      #{"* Denotes that the timer is still active\n" if @timers.values.any?(&:active?)}
+    SUMMARY
+  end
+
+  # Iterative methods
+  def self.stop_all
+    @timers.values.each(&:stop)
+  end
+
+  def self.reset_all
+    @timers.values.each(&:reset)
+  end
+
+  def self.delete_all
+    @timers.values.each { |t| t.reset(force: true) }
+    @timers = {}
+  end
+
+  # Internal methods
+  def self.__ensure_timer(name)
+    raise Error.new("No timer named #{name.inspect}") unless @timers[name]
+  end
+
+  class Timer
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @start_time = nil
+      @elapsed = 0.0
+    end
+
+    def start
+      @start_time ||= now
+    end
+
+    def stop
+      if @start_time
+        @elapsed += now - @start_time
+        @start_time = nil
+      end
+      @elapsed
+    end
+
+    def elapsed
+      if active?
+        @elapsed + (now - @start_time)
+      else
+        @elapsed
+      end
+    end
+
+    def active?
+      !!@start_time
+    end
+
+    def reset(force: false)
+      if force
+        @start_time = nil
+      elsif !@start_time.nil?
+        @start_time = now
+      end
+      @elapsed = 0.0
+    end
+
+    private
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/time_up/version.rb

@@ -0,0 +1,3 @@
+module TimeUp
+  VERSION = "0.0.1"
+end

data/time_up.gemspec

@@ -0,0 +1,23 @@
+require_relative "lib/time_up/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "time_up"
+  spec.version = TimeUp::VERSION
+  spec.authors = ["Justin Searls"]
+  spec.email = ["searls@gmail.com"]
+
+  spec.summary = "A little library for managing multiple named timers"
+  spec.homepage = "https://github.com/testdouble/time_up"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/testdouble/time_up"
+  spec.metadata["changelog_uri"] = "https://github.com/testdouble/time_up/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: time_up
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Searls
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-07-15 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- searls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/time_up.rb
+- lib/time_up/version.rb
+- time_up.gemspec
+homepage: https://github.com/testdouble/time_up
+licenses: []
+metadata:
+  homepage_uri: https://github.com/testdouble/time_up
+  source_code_uri: https://github.com/testdouble/time_up
+  changelog_uri: https://github.com/testdouble/time_up/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: A little library for managing multiple named timers
+test_files: []