runby_pace 0.2.50.111 → 0.2.55

data/bin/runbypace

@@ -1,15 +0,0 @@
-#!/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

@@ -1,127 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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

@@ -1,135 +0,0 @@
-# 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

data/lib/runby_pace/distance_unit.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Runby
-  # Represents the distance units (e.g. kilometers, miles) used in paces
-  #  including the human-readable description of each unit
-  #  and the factor used to convert it to kilometers.
-  class DistanceUnit
-    attr_reader :symbol, :description, :conversion_factor
-
-    def self.new(unit_of_measure)
-      return unit_of_measure if unit_of_measure.is_a? DistanceUnit
-      return DistanceUnit.parse(unit_of_measure) if unit_of_measure.is_a? String
-      super
-    end
-
-    def initialize(unit_of_measure)
-      raise "':#{unit_of_measure}' is an unknown unit of measure" unless DistanceUnit.known_uom? unit_of_measure
-      @symbol = unit_of_measure
-      @conversion_factor = UOM_DEFINITIONS[@symbol][:conversion_factor]
-      @description = UOM_DEFINITIONS[@symbol][:description]
-      freeze
-    end
-
-    def to_s(format: :long, pluralize: false)
-      case format
-      when :short then @symbol.to_s
-      when :long then pluralize ? description_plural : @description
-      else raise "Invalid string format #{format}"
-      end
-    end
-
-    def description_plural
-      UOM_DEFINITIONS[@symbol][:description_plural]
-    end
-
-    def self.parse(description)
-      return new description if description.is_a? Symbol
-      description = description.strip.chomp.downcase
-      found_uom = nil
-      UOM_DEFINITIONS.each do |uom, details|
-        if details[:synonyms].include? description
-          found_uom = uom
-          break
-        end
-      end
-      raise "Error parsing distance unit '#{description}'" unless found_uom
-      DistanceUnit.new found_uom
-    end
-
-    def self.try_parse(str)
-      uom, error_message = nil
-      begin
-        uom = parse str
-      rescue StandardError => ex
-        error_message = ex.message
-      end
-      { uom: uom, error: error_message }
-    end
-
-    def self.known_uom?(symbol)
-      UOM_DEFINITIONS.key?(symbol)
-    end
-
-    def ==(other)
-      if other.is_a? DistanceUnit
-        @symbol == other.symbol
-      elsif other.is_a? String
-        self == DistanceUnit.parse(other)
-      else
-        raise "Unable to compare DistanceUnit to #{other.class}(#{other})"
-      end
-    end
-
-    UOM_DEFINITIONS =
-      { km: { description: 'kilometer', description_plural: 'kilometers', conversion_factor: 1.0,
-              synonyms: %w[k km kms kilometer kilometers] },
-        m:  { description: 'meter', description_plural: 'meters', conversion_factor: 0.001,
-              synonyms: %w[m meter meters] },
-        mi: { description: 'mile', description_plural: 'miles', conversion_factor: 1.609344,
-              synonyms: %w[mi mile miles] },
-        ft: { description: 'foot', description_plural: 'feet', conversion_factor: 0.0003048,
-              synonyms: %w[ft foot feet] },
-        yd: { description: 'yard', description_plural: 'yards', conversion_factor: 1093.61,
-              synonyms: %w[y yd yds yard yards] },
-        # Fun distance unit of measures
-        marathon: { description: 'marathon', description_plural: 'marathons', conversion_factor: 42.1648128,
-                    synonyms: %w[marathon] } }.freeze
-  end
-end