runby_pace 0.2.50 → 0.2.50.111

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1bbbedffe293b57223ce3e7795a29c5f0fb58db5
-  data.tar.gz: 12affb0bf93cffcaa9588ce58249183423c37a18
+SHA256:
+  metadata.gz: c865faf1b57fa5d059871913a9ffe259c5cfccc6f5e5c80819c2bcf7c7477ee9
+  data.tar.gz: d34065214cd2129a7f433c201150afdaf88bbf845b7214c2c88ec095f1064a4c
 SHA512:
-  metadata.gz: da7fc955a4382d455e2deb875c65746498955a7e8816d23867580cbb9522f14c685f0aea24323d269ace2791abf74d3fcba0bf046277e97256da7b8aec0b3600
-  data.tar.gz: 4d9955c7367220eac7097fbda94f12fc961295f7e07a78663cfc47ede689a8a3107fe2f0d7afdfb53e986f2d8a89d8d3f95a00f6c9a2e5fdea6b5d61f4de7407
+  metadata.gz: 1e20444a7feb901736b98135e27ac2f63d6d06e7f0cd0e594bbd5a2853a2e2586dad8338733d5f32c06265ddbc04eaf79ca3e672b08f2e3f495b350bca7d620d
+  data.tar.gz: e2405ad249c55e3473b9999cf761373aab346b26d395417921865d6e7d9b44b9f7a26cebebc1aedae27a531feacc2d20f3be98df520458d739cd2d25f944887a

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  Exclude:
+    - 'bin/**'
+
+Style/Encoding:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120

data/.travis.yml

@@ -1,11 +1,18 @@
 language: ruby
 rvm:
-- 2.2.4
-before_install: gem install bundler -v 1.11.2
+- 2.4
+before_install: gem install bundler -v 1.12.5
 deploy:
+  skip_cleanup: true
   provider: rubygems
   api_key:
     secure: AOOSaXksG1n9LsFbpc5wJWk/Rj7jYFohJMsfLEosWPHw1Kidgng7OlpgWC6+iBRM78Bo6lgeMK/8Ng9KxU9+Cs/+6pKjrMrj4T/cVmY4tlAXhHW3DBJe4KTmmTmTOWsSP4icPIXKCY24ExbIGLnwCGuagezBENyTemLBkQXMBXRtyubr77M2fB0K5zJwx76n1kGM6MkGOdEF4Qj64OswTudHxc98Rs2p4xdf8ft8YqGrGj19Z+ALj1NmOZgPfEXV0SuwtK6Yk3XPvCXojXJRRd4JfUQ/dghmiQkKBS7o7bwnhcWd6H5aJFJVVSjDwerdLpgHU0O16PSU2+gh4QcMDeWnzkciGaQQIrsy8eU3EUMN+N1Pn70eXFb4PtgS7esBTbzwivjZt94DYyvITaoOcZTs6ceX838CAj7QQcNkMZhb7HV49awlIYhJibpB5AWuBulXwTaD+6VozTGh0nVdAXaR8BcItv933rucmrjQx4WRvChjTV+oskW/C2QI7BgAZRQyqHy1UIuWe1r+kWWs1i+L8anshW/MrJ6S6JUUgUiONP1CldTgUezAjiIL6wiuIurjLRRa//wXmedr0x37cw+bwgq4l9KcU0X/0fYx2+8YN3BC5qvmxha7+AUljL1u/Jw8zwIa36g608tZ7RbshgTHDmFXxLRLVuSt3vjDlAI=
   gem: runby_pace
   on:
     repo: tygerbytes/runby-pace
+git:
+  depth: 1024
+notifications:
+  email:
+    on_success: always
+    on_failure: always

data/Gemfile

@@ -1,5 +1,9 @@
 source 'https://rubygems.org'
 
+group :development do
+  gem 'rubocop', require: false
+end
+
 group :test do
   gem 'coveralls', require: false
 end

data/README.md

@@ -6,6 +6,7 @@ RunbyPace contains the core logic for calculating the target "paces" used by run
 | | |
 | --- | --- |
 | **Build** | [![Build Status](https://travis-ci.org/tygerbytes/runby-pace.svg?branch=master)](https://travis-ci.org/tygerbytes/runby-pace) |
+| **Grade** | [![Codacy Badge](https://api.codacy.com/project/badge/Grade/7c228c8601ff4eeb9dfe0f6c60867f25)](https://www.codacy.com/app/tygerbytes/runby-pace?utm_source=github.com&utm_medium=referral&utm_content=tygerbytes/runby-pace&utm_campaign=badger) |
 | **Coverage** | [![Coverage Status](https://coveralls.io/repos/github/tygerbytes/runby-pace/badge.svg?branch=master)](https://coveralls.io/github/tygerbytes/runby-pace?branch=master) |
 | **Gem** | [![gem](https://img.shields.io/gem/v/runby_pace.svg)](https://rubygems.org/gems/runby_pace) |
 
@@ -20,7 +21,9 @@ Any sort of running program will include runs at varying paces, easy runs, dista
 So this is great, but a little tedious. RunbyPace automates this whole process by calculating all of the paces for you.
  All you need is your current 5K time and some Ruby, and you're off running at just the right pace.
 
-Note that this project is currently being developed, so the gem doesn't even exist yet. Coming soon!
+RunbyPace also encapsulates the logic and math necessary for many running-related calculations based on time, pace, speed, unit coversions, etc. If you're tired of constantly converting minutes and seconds to decimal and back again, RunbyPace is for you.
+
+[![RunbyPace logo](misc/runbypace_logo.png)](https://runbypace.com)
 
 ## Installation
 
@@ -34,24 +37,32 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Or install it yourself:
 
     $ gem install runby_pace
 
 ## Usage
 
-TODO: Coming soon... When the class interfaces are fleshed out.
+I plan to craft better docs in the future, but for now the **specs** make for excellent class usage documentation: https://github.com/tygerbytes/runby-pace/tree/master/spec/runby_pace
+
+For a live front end written in **Rails**, see https://runbypace.com. It's code will be open-sourced as well, as soon as we can guarantee secure deployment.
+
+For an open-source example front end written in **Elm**, see https://github.com/tygerbytes/pacebyelm
+
+The CLI is still in its infancy, but the gem comes with a basic CLI/REPL (`bin/runbypace`)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` or `bin/runbypace` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/tygerbytes/runby-pace.
 
+Contribute front-end and CLI ideas at [@runbypace](https://twitter.com/runbypace).
+
 ## Acknowledgements
 
 Crafted with care, with the support of [JetBrains RubyMine](https://www.jetbrains.com/ruby/)

data/Rakefile

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :build
+task default: :build
 
-task :build => [:gen_all_run_types,:spec]
+task build: %i[gen_version_number gen_all_run_types spec]
 
 desc 'Generate the all_run_types.g.rb file'
 task :gen_all_run_types do
-  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', 'Generate all_run_types.g.rb')
+  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', '> Generate all_run_types.g.rb')
   run_types_path = './lib/runby_pace/run_types'
 
   # Parse *_run.rb file names to generate array of the run type class names
@@ -19,16 +21,48 @@ task :gen_all_run_types do
     filename_sans_extension = filename[0, filename.length - 3]
     parts = filename_sans_extension.to_s.downcase.split(/_|\./)
     run_type = ''
-    parts.each { |part|
+    parts.each do |part|
       run_type += part[0].upcase + part[-(part.length - 1), part.length - 1]
-    }
+    end
     run_type
   end
   puts all_run_types.join(' ')
 
   # Write run types to the generated file, all_run_types.g.rb
   template = File.read(File.join(run_types_path, 'all_run_types.template'))
-  template.gsub!('__RUN_TYPES__', all_run_types.join(' '))
+  template.gsub!('__RUN_TYPE_NAMES__', all_run_types.join(' '))
+  template.gsub!('__RUN_TYPES__', all_run_types.join(', '))
   File.write(File.join(run_types_path, 'all_run_types.g.rb'), template)
   puts "\e[32mDone\e[0m\n\n"
 end
+
+desc 'Generate version number'
+task :gen_version_number do
+  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', '> Generate version number')
+
+  # Generate "teeny" version number based on the number of commits since the last tagged major/minor release
+  latest_tagged_release = `git describe --tags --abbrev=0 --match v*`.to_s.chomp
+  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', "Latest tagged release is #{latest_tagged_release}")
+  version = "#{latest_tagged_release[1..-1]}.#{`git rev-list --count #{latest_tagged_release}..HEAD`}".chomp
+
+  # Write version number to generated file
+  path = './lib/runby_pace'
+  template = File.read(File.join(path, 'version.seed'))
+  template.gsub!('__VERSION__', version)
+  version_file_path = File.join(path, 'version.g.rb')
+  File.write(version_file_path, template)
+  with_no_warnings do
+    # Silencing warnings about redefining constants, since it's intentional
+    load version_file_path
+    Runby::VERSION = Runby::GENERATED_VERSION
+  end
+  puts "\e[32m__TEXT__\e[0m".gsub('__TEXT__', "Version: #{Runby::VERSION}")
+end
+
+def with_no_warnings
+  warning_level = $VERBOSE
+  $VERBOSE = nil
+  result = yield
+  $VERBOSE = warning_level
+  result
+end

data/bin/_guard-core

@@ -1,16 +1,17 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application '_guard-core' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("guard", "_guard-core")
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application '_guard-core' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "_guard-core")

data/bin/guard

@@ -1,16 +1,17 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application 'guard' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("guard", "guard")
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("guard", "guard")

data/bin/runbypace

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+begin
+  require "bundler/setup"
+rescue LoadError
+end
+
+begin
+  require 'runby_pace'
+rescue LoadError
+  require_relative '../lib/runby_pace'
+end
+
+cli = Runby::Cli::Cli.new(ARGV)
+cli.run

data/lib/runby_pace/cli/cli.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'readline'
+require 'optparse'
+require_relative 'config'
+
+module Runby
+  module Cli
+    # Command line interface and REPL for RunbyPace
+    class Cli
+      def initialize(args = ARGV)
+        @args = args
+        @config = Config.new
+        @options = parse_options args
+      end
+
+      def run
+        puts 'Runby Pace REPL!'
+        bnd = binding
+        while (input = Readline.readline('🏃 ', true))
+          begin
+            result = bnd.eval input
+          rescue StandardError => e
+            puts "#{e.class}: #{e.message}"
+          else
+            puts result
+          end
+        end
+      end
+
+      def print_targets(five_k_time, distance_units = :mi)
+        five_k_time = @config['five_k_time'] if five_k_time.nil?
+
+        five_k_time = Runby.sanitize(five_k_time).as(RunbyTime)
+        puts "\nIf you can run a 5K in #{five_k_time}, your training paces should be:"
+        paces = []
+        RunTypes.all_classes.each do |run_type|
+          run = run_type.new
+          paces.push(description: run.description, pace: run.lookup_pace(five_k_time, distance_units))
+        end
+        paces.sort_by { |p| p[:pace].fast }.reverse_each { |p| puts "  #{p[:description]}: #{p[:pace]}" }
+        nil
+      end
+
+      # -- Shortcuts for the REPL
+      def di(*args)
+        Distance.new(*args)
+      end
+
+      def du(*args)
+        DistanceUnit.new(*args)
+      end
+
+      def pc(*args)
+        Pace.new(*args)
+      end
+
+      def sp(*args)
+        Speed.new(*args)
+      end
+
+      def tm(*args)
+        RunbyTime.new(*args)
+      end
+
+      private
+
+      def parse_options(options)
+        args = { targets: nil }
+
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: runbypace.rb [options]'
+
+          opts.on('-h', '--help', 'Display this help message') do
+            puts opts
+            exit
+          end
+
+          opts.on('-c', '--config [SETTING][=NEW_VALUE]', 'Get or set a configuration value') do |config|
+            manage_config config
+            exit
+          end
+
+          opts.on('-t', '--targets [5K race time]', 'Show target paces') do |targets|
+            args[:targets] = targets
+            print_targets targets
+            exit
+          end
+        end.parse!(options)
+        args
+      end
+
+      def manage_config(config)
+        c = parse_config_setting config
+        unless c.key
+          # No key specified. Print all settings.
+          @config.pretty_print
+          return
+        end
+        if c.value
+          # Set setting "key" to new "value"
+          @config[c.key] = c.value
+          return
+        end
+        if c.clear_setting
+          @config[c.key] = nil
+        else
+          # Print the value of setting "key"
+          p @config[c.key]
+        end
+      end
+
+      def parse_config_setting(setting)
+        setting = '' if setting.nil?
+        Class.new do
+          attr_reader :key, :value, :clear_setting
+          def initialize(setting)
+            tokens = setting.split('=')
+            @key = tokens[0]
+            @value = tokens[1]
+            @clear_setting = (@value.nil? && setting.include?('='))
+          end
+        end.new(setting)
+      end
+    end
+  end
+end

data/lib/runby_pace/cli/config.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pp'
+
+module Runby
+  #
+  module Cli
+    class Config
+      USER_CONFIG_PATH = File.expand_path('~/.runbypace').freeze
+
+      VALID_OPTIONS = {
+        five_k_time: { validate_as: RunbyTime }
+      }.freeze
+
+      def initialize
+        @settings = load_user_settings
+      end
+
+      def load_user_settings
+        if File.exist? USER_CONFIG_PATH
+          YAML.load_file USER_CONFIG_PATH
+        else
+          {}
+        end
+      end
+
+      def store_user_settings
+        File.open(USER_CONFIG_PATH, 'w') { |file| file.write @settings.to_yaml }
+      end
+
+      def [](key)
+        return unless known_setting?(key)
+        return unless option_configured?(key)
+        "#{key} => #{@settings[key]}"
+      end
+
+      def []=(key, value)
+        return unless known_setting?(key)
+        if value
+          value = sanitize_value key, value
+          return unless value
+          @settings[key] = value.to_s
+        else
+          @settings.delete(key)
+        end
+        store_user_settings
+      end
+
+      def pretty_print
+        pp @settings
+      end
+
+      def known_setting?(key)
+        unless VALID_OPTIONS.key?(key.to_sym)
+          puts "Unknown setting #{key}"
+          return false
+        end
+        true
+      end
+
+      def sanitize_value(key, value)
+        cls = VALID_OPTIONS[key.to_sym][:validate_as]
+        begin
+          value = Runby.sanitize(value).as(cls)
+        rescue StandardError => ex
+          value = nil
+          p ex.message
+        end
+        value
+      end
+
+      def option_configured?(key)
+        unless @settings.key? key
+          puts "#{key} not configured. Set with:\n\trunbypace --config #{key} VALUE"
+          false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/runby_pace/distance.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Runby
+  # Represents a distance (distance UOM and multiplier)
+  class Distance
+    include Comparable
+
+    attr_reader :uom, :multiplier
+
+    def self.new(uom = :km, multiplier = 1)
+      return uom if uom.is_a? Distance
+      return Distance.parse uom if uom.is_a? String
+      super
+    end
+
+    def initialize(uom = :km, multiplier = 1)
+      case uom
+      when DistanceUnit
+        init_from_distance_unit uom, multiplier
+      when Symbol
+        init_from_symbol uom, multiplier
+      else
+        raise 'Invalid distance unit of measure'
+      end
+      freeze
+    end
+
+    def convert_to(target_uom)
+      target_uom = DistanceUnit.new target_uom unless target_uom.is_a?(DistanceUnit)
+      return self if @uom == target_uom
+      target_multiplier = kilometers / (target_uom.conversion_factor * 1.0)
+      Distance.new target_uom, target_multiplier
+    end
+
+    def meters
+      kilometers * 1000.0
+    end
+
+    def kilometers
+      @multiplier * @uom.conversion_factor
+    end
+
+    def self.parse(str)
+      str = str.strip.chomp.downcase
+      multiplier = str.scan(/[\d,.]+/).first
+      multiplier = multiplier.nil? ? 1 : multiplier.to_f
+      uom = str.scan(/[-_a-z ]+$/).first
+      raise "Unable to find distance unit in '#{str}'" if uom.nil?
+
+      parsed_uom = Runby::DistanceUnit.parse uom
+      raise "'#{uom.strip}' is not recognized as a distance unit" if parsed_uom.nil?
+
+      new parsed_uom, multiplier
+    end
+
+    def self.try_parse(str)
+      distance, error_message = nil
+      begin
+        distance = parse str
+      rescue StandardError => ex
+        error_message = ex.message.to_s
+      end
+      { distance: distance, error: error_message }
+    end
+
+    def to_s(format: :short)
+      formatted_multiplier = format('%g', @multiplier.round(2))
+      case format
+      when :short then "#{formatted_multiplier} #{@uom.to_s(format: format)}"
+      when :long then "#{formatted_multiplier} #{@uom.to_s(format: format, pluralize: (@multiplier > 1))}"
+      else raise "Invalid string format #{format}"
+      end
+    end
+
+    # @param [Distance, String] other
+    def <=>(other)
+      raise "Unable to compare Runby::Distance to #{other.class}(#{other})" unless [Distance, String].include? other.class
+      if other.is_a?(String)
+        return 0 if to_s == other || to_s(format: :long) == other
+        return self <=> Distance.try_parse(other)[:distance]
+      end
+      kilometers <=> other.kilometers
+    end
+
+    # @param [Distance] other
+    # @return [Distance]
+    def +(other)
+      raise "Cannot add Runby::Distance to #{other.class}" unless other.is_a?(Distance)
+      sum_in_km = Distance.new(:km, kilometers + other.kilometers)
+      sum_in_km.convert_to(@uom)
+    end
+
+    # @param [Distance] other
+    # @return [Distance]
+    def -(other)
+      raise "Cannot add Runby::Distance to #{other.class}" unless other.is_a?(Distance)
+      sum_in_km = Distance.new(:km, kilometers - other.kilometers)
+      sum_in_km.convert_to(@uom)
+    end
+
+    # @param [Numeric] other
+    # @return [Distance]
+    def *(other)
+      raise "Cannot multiply Runby::Distance by #{other.class}" unless other.is_a?(Numeric)
+      product_in_km = Distance.new(:km, kilometers * other)
+      product_in_km.convert_to(@uom)
+    end
+
+    # @param [Numeric, Distance] other
+    # @return [Distance, Numeric]
+    def /(other)
+      raise "Cannot divide Runby::Distance by #{other.class}" unless other.is_a?(Numeric) || other.is_a?(Distance)
+      if other.is_a?(Numeric)
+        quotient_in_km = Distance.new(:km, kilometers / other)
+        return quotient_in_km.convert_to(@uom)
+      elsif other.is_a?(Distance)
+        return kilometers / other.kilometers
+      end
+    end
+
+    private
+
+    def init_from_distance_unit(uom, multiplier)
+      @uom = uom
+      @multiplier = multiplier
+    end
+
+    def init_from_symbol(distance_uom_symbol, multiplier)
+      raise "Unknown unit of measure #{distance_uom_symbol}" unless Runby::DistanceUnit.known_uom? distance_uom_symbol
+      raise 'Invalid multiplier' unless multiplier.is_a?(Numeric)
+      @uom = DistanceUnit.new distance_uom_symbol
+      @multiplier = multiplier * 1.0
+    end
+  end
+end