tranzito_utils 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4045a5fec9bb07e94ee83a17aafb7f7e58b1c228de4a5562116a9982a362d12
+  data.tar.gz: dc1d4c81f7f71079c0b66e5b7c6b8e23b88d3fbde4372eef0c50a3ff50569ff6
+SHA512:
+  metadata.gz: 501bde401f008a5d0ae611539dec533d448d4d75e40ad23b262a1030818a9785201ff75429435cb4fc78c3b4f59e67b5d41d037d10a8a3a21588bb37d13c4282
+  data.tar.gz: 9ec818c62b80d08cba34103ef490bb6339f431ed835e1d9584428ada2270f4a80bb54e34216577e4cf3ec86e9822b93fb0aae01b5cf7d9783a0e9349ed46c61a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 
+
+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,137 @@
+# TranzitoUtils [![CircleCI](https://dl.circleci.com/status-badge/img/gh/Tranzito/tranzito_utils/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/Tranzito/tranzito_utils/tree/main)
+
+`tranzito_utils` is a ruby gem containing these Rails helpers, concerns and services.
+
+| Name | Type | Description |
+| ---- | ---- | ----------- |
+| `SetPeriod` | Controller Concern | Time period selection and browsing |
+| `SortableTable` | Controller Concern | Sort column and direction  |
+| `TimeParser` | Service | Parse time strings into activerecord time objects |
+| `ParamsNormalizer` | Service | Normalize truthy and falsey strings |
+| `GraphingHelper` | Helper | Graphing helper for [chartkick](https://chartkick.com/) charts |
+| `SortableHelper` | Helper | Sort table headers |
+
+# Installation
+
+## tranzito_utils (gem)
+Install the gem by adding this line to your application's Gemfile:
+
+```
+gem "tranzito_utils"
+```
+
+Then run `bundle install`
+
+To include the config file inside your host app run this command.
+
+```
+rails g tranzito_utils:install
+```
+
+This will add the `tranzito_utils.rb` file in the initializer where you can alter the default behaviour of several variables being used throughout the gem.
+
+
+# Usage
+
+#### SortableTable
+
+To use the SortableTable module you can include it in your required controllers and then be able to use its methods.
+
+```
+include TranzitoUtils::SortableTable
+```
+
+You can use the following methods of ` TranzitoUtils::SortableTable` in your controllers. These are also the helper methods.
+
+```
+sort_column, sort_direction
+```
+
+#### SetPeriod
+
+Include the `SetPeriod` module into your `ApplicationController` by adding this line
+
+```
+include TranzitoUtils::SetPeriod
+```
+
+You just need to add this line in the controller where you want to use the `SetPeriod` module.
+
+```
+  before_action :set_period, only: [:index]
+```
+
+Also, the `SetPeriod` has a partial file which you can include in your views using this line.
+
+```
+render partial: "/tranzito_utils/period_select"
+```
+
+This will include the period_select view for filtering.
+
+### SortableHelper
+
+For SortableHelper, you need to add that line into your `application_helper.rb` file.
+
+```
+include TranzitoUtils::SortableHelper
+```
+
+### GraphingHelper
+
+Same for GraphingHelper, if you want to use its methods then you need to add that line into your `application_helper.rb` file.
+
+```
+include TranzitoUtils::GraphingHelper
+```
+
+#### ParamsNormalizer
+
+Params normalizer uses activerecord to parse strings into booleans.
+
+## tranzito_utils_js (npm)
+You also need to add this NPM package in order to use the gem without any issue. You can install it using `yarn` or `npm`.
+
+For yarn
+```
+yarn add tranzito_utils_js
+```
+For npm
+```
+npm install tranzito_utils_js
+```
+
+Then import it into your application by adding this line in `application.js` or any `.js` file where you need it.
+
+```
+import { PeriodSelector, TimeParser } from "tranzito_utils_js"
+```
+Here `TimeParser` and `PeriodSelector` are classes we can use in our app.
+
+For `TimeParser` You can use it by initializing like this
+
+```
+if (!window.timeParser) { window.timeParser = new TimeParser() }
+window.timeParser.localize()
+```
+
+As for `PeriodSelector`, you can use it by initializing like this
+```
+  if ($('#timeSelectionBtnGroup').length) {
+    const periodSelector = new PeriodSelector()
+    periodSelector.init()
+  }
+```
+`#timeSelectionBtnGroup` is being used in the partial in `tranzito_utils` gem.
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+
+## Testing
+
+To setup testing, you have to create the database:
+
+```shell
+cd spec/dummy
+RAILS_ENV=test bundle exec rails db:create db:schema:load db:migrate
+```

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bundler/gem_tasks"

data/app/views/tranzito_utils/_period_select.html.haml

@@ -0,0 +1,45 @@
+- skip_submission ||= false
+- include_future ||= false
+- prepend_text ||= nil
+
+#timeSelectionBtnGroup.text-right{ role: "group", class: @period == "custom" ? "custom-period-selected" : "", "data-nosubmit" => "#{skip_submission}" }
+  - if prepend_text.present?
+    %span.mr-2.less-strong.d-block.d-lg-inline-block
+      = prepend_text
+
+  - if include_future
+    %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "next_week")), class: ("active" if @period == "next_week"), data: { period: "next_week" } }
+      %span.d-none.d-md-inline-block next
+      seven days
+    %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "next_month")), class: ("active" if @period == "next_month"), data: { period: "next_month" } }
+      %span.d-none.d-md-inline-block next
+      thirty days
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "hour")), class: ("active" if @period == "hour"), data: { period: "hour" } }
+    %span.d-none.d-md-inline-block past
+    hour
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "day")), class: ("active" if @period == "day"), data: { period: "day" } }
+    %span.d-none.d-md-inline-block past
+    day
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "week")), class: ("active" if @period == "week"), data: { period: "week" } }
+    %span.d-none.d-md-inline-block past
+    seven days
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "month")), class: ("active" if @period == "month"), data: { period: "month" } }
+    %span.d-none.d-md-inline-block past
+    thirty days
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "year")), class: ("active" if @period == "year"), data: { period: "year" } }
+    %span.d-none.d-md-inline-block past
+    year
+  %a.btn.btn-outline-secondary.btn-sm.period-select-standard{ href: url_for(sortable_search_params.merge(period: "all")), class: ("active" if @period == "all"), data: { period: "all" } }
+    all
+  %button#periodSelectCustom.btn.btn-outline-secondary.btn-sm.ml-2{ class: ("active" if @period == "custom"), data: { period: "custom" } }
+    custom
+
+%form#timeSelectionCustom.custom-time-selection.mt-2.collapse{ class: @period == "custom" ? "in show" : "" }
+  .form-group
+    = label_tag :start_time_selector, "from", class: "control-label mr-2"
+    = datetime_local_field_tag :start_time_selector, @start_time.strftime("%Y-%m-%dT%H:%M"), step: 60, class: "form-control"
+  .form-group.end-time-control
+    = label_tag :end_time_selector, "to", class: "control-label mr-2 ml-2"
+    = datetime_local_field_tag :end_time_selector, @end_time.strftime("%Y-%m-%dT%H:%M"), step: 60, class: "form-control"
+  %button#updatePeriodSelectCustom.btn.btn-success.btn-sm.ml-2
+    update

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  time:
+    formats:
+      convert_time: "%FT%T%z"
+      dotted: "%Y.%-m.%-d"

data/lib/generators/tranzito_utils/install_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module TranzitoUtils
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates/", __FILE__)
+
+    # it will copy the tranzito_utils.rb file into the hosts application
+    def copy_initializer
+      template "tranzito_utils.rb", "config/initializers/tranzito_utils.rb"
+    end
+  end
+end

data/lib/generators/tranzito_utils/templates/tranzito_utils.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Tranzito_utils initializer file
+# Customize only when you want to override the default values of tranzito_utils
+
+# For TranzitoUtils::SetPeriod
+# You can update the time for earliest period for SetPeriod concern
+# TranzitoUtils::DEFAULT[:earliest_period_time] = Time.at(1637388000)
+
+# For TranzitoUtils::SortableHelper
+# You can add the more sortable search params for the sortable_search_params method in sortable_helper
+# TranzitoUtils::DEFAULT[:additional_search_keys] = []
+
+# For TranzitoUtils::TimeParser service
+# You can update the earliest year and latest year for TimeParser service
+# TranzitoUtils::DEFAULT[:earliest_year] = 1900
+# TranzitoUtils::DEFAULT[:latest_year] = Time.current.year + 100

data/lib/tranzito_utils/concerns/set_period.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module SetPeriod
+    extend ActiveSupport::Concern
+    PERIOD_TYPES = %w[hour day month year week all next_week next_month].freeze
+
+    # For setting periods, particularly for graphing
+    def set_period
+      set_timezone
+      # Set time period
+      @period ||= params[:period]
+      if @period == "custom"
+        if params[:start_time].present?
+          @start_time = TimeParser.parse(params[:start_time], @timezone)
+          @end_time = TimeParser.parse(params[:end_time], @timezone) || Time.current
+
+          @start_time, @end_time = @end_time, @start_time if @start_time > @end_time
+        else
+          set_time_range_from_period
+        end
+      elsif params[:search_at].present?
+        @period = "custom"
+        @search_at = TimeParser.parse(params[:search_at], @timezone)
+        offset = params[:period].present? ? params[:period].to_i : 10.minutes.to_i
+        @start_time = @search_at - offset
+        @end_time = @search_at + offset
+      else
+        set_time_range_from_period
+      end
+
+      # Add this render_chart in here so we don't have to define it in all the controllers
+      @render_chart = ActiveRecord::Type::Boolean.new.cast(params[:render_chart].to_s.strip)
+      @time_range = @start_time..@end_time
+    end
+
+    private
+
+    def set_time_range_from_period
+      @period = default_period unless PERIOD_TYPES.include?(@period)
+
+      case @period
+      when "hour"
+        @start_time = Time.current - 1.hour
+      when "day"
+        @start_time = Time.current.beginning_of_day - 1.day
+      when "month"
+        @start_time = Time.current.beginning_of_day - 30.days
+      when "year"
+        @start_time = Time.current.beginning_of_day - 1.year
+      when "week"
+        @start_time = Time.current.beginning_of_day - 1.week
+      when "next_month"
+        @start_time ||= Time.current
+        @end_time = Time.current.beginning_of_day + 30.days
+      when "next_week"
+        @start_time = Time.current
+        @end_time = Time.current.beginning_of_day + 1.week
+      when "all"
+        @start_time = TranzitoUtils::DEFAULT[:earliest_period_time]
+      else
+        @period = default_period
+        @start_time = TranzitoUtils::DEFAULT[:earliest_period_time]
+      end
+      @end_time ||= latest_period_date
+    end
+
+    # Separate method so it can be overridden on per controller basis
+    def default_period
+      "all"
+    end
+
+    # Separate method so it can be overriden
+    def latest_period_date
+      Time.current
+    end
+
+    def set_timezone
+      return true if @timezone.present?
+
+      # Parse the timezone params if they are passed (tested in admin#activity_groups#index)
+      if params[:timezone].present?
+        @timezone = TimeParser.parse_timezone(params[:timezone])
+        # If it's a valid timezone, save to session
+        session[:timezone] = @timezone&.name
+      end
+
+      # Set the timezone on a per request basis if we have a timezone saved
+      if session[:timezone].present?
+        @timezone ||= TimeParser.parse_timezone(session[:timezone])
+        Time.zone = @timezone
+      end
+
+      @timezone ||= TranzitoUtils::DEFAULT[:time_zone]
+    end
+  end
+end

data/lib/tranzito_utils/concerns/sortable_table.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module SortableTable
+    extend ActiveSupport::Concern
+    SORT_DIRECTIONS = %w[asc desc].freeze
+
+    included do
+      helper_method :sort_column, :sort_direction
+    end
+
+    def sort_column
+      @sort_column ||= sortable_columns.include?(params[:sort]) ? params[:sort] : default_column
+    end
+
+    def sort_direction
+      @sort_direction ||= SORT_DIRECTIONS.include?(params[:direction]) ? params[:direction] : default_direction
+    end
+
+    # So it can be overridden
+    def default_direction
+      "desc"
+    end
+
+    def default_column
+      sortable_columns.first
+    end
+  end
+end

data/lib/tranzito_utils/gem.rb

@@ -0,0 +1,8 @@
+module TranzitoUtils
+  class Gem < Rails::Engine
+    initializer "tranzito_utils.config", before: :load_config_initializers do |app|
+      # Setting the default timezone for timeparser service from host application configuration
+      TranzitoUtils::DEFAULT[:time_zone] = ActiveSupport::TimeZone[Rails.application.config.time_zone]
+    end
+  end
+end

data/lib/tranzito_utils/helpers/graphing_helper.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module GraphingHelper
+    def time_range_counts(collection:, column: "created_at", time_range: nil)
+      time_range ||= @time_range
+      # Note: by specifying the range parameter, we force it to display empty days
+      collection.send(group_by_method(time_range), column, range: time_range, format: group_by_format(time_range))
+        .count
+    end
+
+    def time_range_amounts(collection:, column: "created_at", amount_column: "amount_cents", time_range: nil)
+      time_range ||= @time_range
+      # Note: by specifying the range parameter, we force it to display empty days
+      collection.send(group_by_method(time_range), column, range: time_range, format: group_by_format(time_range))
+        .sum(amount_column)
+        .map { |k, v| [k, (v.to_f / 100.00).round(2)] } # Convert cents to dollars
+        .to_h
+    end
+
+    def time_range_duration(collection:, column: "created_at", duration_column: "duration_seconds", time_range: nil)
+      time_range ||= @time_range
+      # Note: by specifying the range parameter, we force it to display empty days
+      collection.send(group_by_method(time_range), column, range: time_range, format: group_by_format(time_range))
+        .sum(duration_column)
+        .map { |k, v| [k, (v.to_f / 3600.00).round(2)] } # Convert seconds to decimal hours
+        .to_h
+    end
+
+    def group_by_method(time_range)
+      if time_range.last - time_range.first < 3601 # 1.hour + 1 second
+        :group_by_minute
+      elsif time_range.last - time_range.first < 500_000 # around 6 days
+        :group_by_hour
+      elsif time_range.last - time_range.first < 5_000_000 # around 60 days
+        :group_by_day
+      elsif time_range.last - time_range.first < 31449600 # 364 days (52 weeks)
+        :group_by_week
+      else
+        :group_by_month
+      end
+    end
+
+    def group_by_format(time_range, group_period = nil)
+      group_period ||= group_by_method(time_range)
+      if group_period == :group_by_minute
+        "%l:%M %p"
+      elsif group_period == :group_by_hour
+        "%a%l %p"
+      elsif group_period == :group_by_week
+        "%Y-%-m-%-d"
+      elsif %i[group_by_day group_by_week].include?(group_period) || time_range.present? && time_range.last - time_range.first < 2.weeks.to_i
+        "%a %Y-%-m-%-d"
+      elsif group_period == :group_by_month
+        "%Y-%-m"
+      end
+    end
+
+    def humanized_time_range_column(time_range_column, return_value_for_all: false)
+      return_value_for_all = true if @render_chart
+      return nil unless return_value_for_all || !(@period == "all")
+      humanized_text = time_range_column.to_s.gsub("_at", "").humanize.downcase
+      return humanized_text.gsub("start", "starts") if time_range_column&.match?("start_at")
+      return humanized_text.gsub("end", "ends") if time_range_column&.match?("end_at")
+      return humanized_text.gsub("needs", "need") if time_range_column&.match?("needs_renewal_at")
+      humanized_text
+    end
+
+    def humanized_time_range(time_range)
+      return nil if @period == "all"
+
+      unless @period == "custom"
+        period_display = @period.match?("next_") ? @period.tr("_", " ") : "past #{@period}"
+        return "in the #{period_display}"
+      end
+
+      group_by = group_by_method(time_range)
+      precision_class = if group_by == :group_by_minute
+        "preciseTimeSeconds"
+      elsif group_by == :group_by_hour
+        "preciseTime"
+      else
+        ""
+      end
+
+      content_tag(:span) do
+        concat "from "
+        concat content_tag(:em, l(time_range.first, format: :convert_time), class: "convertTime #{precision_class}")
+        concat " to "
+        if time_range.last > Time.current - 5.minutes
+          concat content_tag(:em, "now")
+        else
+          concat content_tag(:em, l(time_range.last, format: :convert_time), class: "convertTime #{precision_class}")
+        end
+      end
+    end
+
+    # Initially just used by scheduled jobs display, but now used by other things!
+    def period_in_words(seconds)
+      return "" if seconds.blank?
+
+      seconds = seconds.to_i.abs
+      if seconds < 1.minute
+        pluralize(seconds, "second")
+      elsif seconds >= 1.minute && seconds < 1.hour
+        pluralize((seconds / 60.0).round(1), "minute")
+      elsif seconds >= 1.hour && seconds < 24.hours
+        pluralize((seconds / 3600.0).round(1), "hour")
+      elsif seconds >= 24.hours
+        pluralize((seconds / 86400.0).round(1), "day")
+      end.gsub(".0 ", " ") # strip out the empty zero
+    end
+  end
+end

data/lib/tranzito_utils/helpers/sortable_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module SortableHelper
+    DEFAULT_SEARCH_KEYS = [:direction, :sort, :user_id, :period, :start_time, :end_time, :per_page].freeze
+
+    def sortable(column, title = nil, html_options = {})
+      if title.is_a?(Hash) # If title is a hash, it wasn't passed
+        html_options = title
+        title = nil
+      end
+
+      title ||= column.gsub(/_(id|at)\z/, "").titleize
+      # Check for render_sortable - otherwise default to rendering
+      render_sortable = html_options.key?(:render_sortable) ? html_options[:render_sortable] : !html_options[:skip_sortable]
+      return title unless render_sortable
+
+      html_options[:class] = "#{html_options[:class]} sortable-link"
+      direction = column == sort_column && sort_direction == "desc" ? "asc" : "desc"
+      if column == sort_column
+        html_options[:class] += " active"
+        span_content = direction == "asc" ? "\u2193" : "\u2191"
+      end
+
+      link_to(sortable_search_params.merge(sort: column, direction: direction), html_options) do
+        concat(title.html_safe)
+        concat(content_tag(:span, span_content, class: "sortable-direction"))
+      end
+    end
+
+    def sortable_search_params
+      search_param_keys = params.keys.select { |k| k.to_s.start_with?(/search_/) }
+      params.permit(*(DEFAULT_SEARCH_KEYS | TranzitoUtils::DEFAULT[:additional_search_keys] | search_param_keys))
+    end
+
+    def sortable_search_params_without_sort
+      sortable_search_params.except(:direction, :sort)
+    end
+
+    def sortable_search_params?(except: [])
+      except_keys = %i[direction sort period per_page] + except
+      s_params = sortable_search_params.except(*except_keys).values.reject(&:blank?).any?
+
+      return true if s_params
+      return false if except.map(&:to_s).include?("period")
+      params[:period].present? && params[:period] != "all"
+    end
+  end
+end

data/lib/tranzito_utils/services/params_normalizer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module ParamsNormalizer
+    def self.boolean(param = nil)
+      return false if param.blank?
+      ActiveRecord::Type::Boolean.new.cast(param.to_s.strip)
+    end
+  end
+end

data/lib/tranzito_utils/services/time_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  module TimeParser
+    def self.parse(time_str = nil, timezone_str = nil)
+      return nil unless time_str.present?
+      return time_str if time_str.is_a?(Time)
+
+      if time_str.is_a?(Integer) || time_str.is_a?(Float) || time_str.to_s.strip.match(/^\d+\z/) # it's only numbers
+        return parse("#{time_str}-01-01") if time_str.to_s.length == 4 # Looks a year, valid 8601 format
+        # otherwise it's a timestamp
+        Time.at(time_str.to_i)
+      else
+        Time.zone = parse_timezone(timezone_str)
+        time = Time.zone.parse(time_str.to_s)
+        Time.zone = TranzitoUtils::DEFAULT[:time_zone]
+        time
+      end
+    rescue ArgumentError => e
+      # Try to parse some other, unexpected formats -
+      paychex_formatted = %r{(?<month>\d+)/(?<day>\d+)/(?<year>\d+) (?<hour>\d\d):(?<minute>\d\d) (?<ampm>\w\w)}.match(time_str)
+      ie11_formatted = %r{(?<month>\d+)/(?<day>\d+)/(?<year>\d+)}.match(time_str)
+      just_date = %r{(?<year>\d{4})[^\d|\w](?<month>\d\d?)}.match(time_str)
+      just_date_backward = %r{(?<month>\d\d?)[^\d|\w](?<year>\d{4})}.match(time_str)
+
+      # Get the successful matching regex group, and then reformat it in an expected way
+      regex_match = [paychex_formatted, ie11_formatted, just_date, just_date_backward].compact.first
+      raise e unless regex_match.present?
+
+      new_str = %w[year month day]
+        .map { |component| regex_match[component] if regex_match.names.include?(component) }
+        .compact
+        .join("-")
+
+      # If we end up with an unreasonable year, throw an error
+      raise e unless new_str.split("-").first.to_i.between?(TranzitoUtils::DEFAULT[:earliest_year], TranzitoUtils::DEFAULT[:latest_year])
+      # Add the day, if there isn't one
+      new_str += "-01" unless regex_match.names.include?("day")
+      # If it's paychex_formatted there is an hour and minute
+      if paychex_formatted.present?
+        new_str += " #{regex_match["hour"]}:#{regex_match["minute"]}#{regex_match["ampm"]}"
+      end
+      # Run it through TimeParser again
+      parse(new_str, timezone_str)
+    end
+
+    def self.parse_timezone(timezone_str)
+      return TranzitoUtils::DEFAULT[:time_zone] unless timezone_str.present?
+      return timezone_str if timezone_str.is_a?(ActiveSupport::TimeZone) # in case we were given a timezone obj
+
+      # tzinfo requires non-whitespaced strings, so try that if the normal lookup fails
+      ActiveSupport::TimeZone[timezone_str] || ActiveSupport::TimeZone[timezone_str.strip.tr("\s", "_")]
+    end
+
+    # Accepts a time object, rounds to minutes
+    def self.round(time, unit = "minute")
+      unit == "second" ? time.change(usec: 0, sec: 0) : time.change(min: 0, usec: 0, sec: 0)
+    end
+  end
+end

data/lib/tranzito_utils/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TranzitoUtils
+  VERSION = "1.0.0"
+end

data/lib/tranzito_utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "tranzito_utils/version"
+
+module TranzitoUtils
+  DEFAULT = {
+    earliest_period_time: Time.at(1637388000),
+    earliest_year: 1900,
+    latest_year: (Time.current.year + 100),
+    additional_search_keys: [],
+    time_zone: ""
+  }
+end
+
+require "tranzito_utils/concerns/set_period"
+require "tranzito_utils/concerns/sortable_table"
+require "tranzito_utils/helpers/graphing_helper"
+require "tranzito_utils/helpers/sortable_helper"
+require "tranzito_utils/services/time_parser"
+require "tranzito_utils/services/params_normalizer"
+require "tranzito_utils/gem"

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: tranzito_utils
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- willbarrett
+- sethherr
+- hafiz-ahmed
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Ruby gem contain several modules mainly containing the helpers, concerns
+  and services for personal use by Tranzito
+email:
+- info@tranzito.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/views/tranzito_utils/_period_select.html.haml
+- config/locales/en.yml
+- lib/generators/tranzito_utils/install_generator.rb
+- lib/generators/tranzito_utils/templates/tranzito_utils.rb
+- lib/tranzito_utils.rb
+- lib/tranzito_utils/concerns/set_period.rb
+- lib/tranzito_utils/concerns/sortable_table.rb
+- lib/tranzito_utils/gem.rb
+- lib/tranzito_utils/helpers/graphing_helper.rb
+- lib/tranzito_utils/helpers/sortable_helper.rb
+- lib/tranzito_utils/services/params_normalizer.rb
+- lib/tranzito_utils/services/time_parser.rb
+- lib/tranzito_utils/version.rb
+homepage: https://github.com/Tranzito/tranzito_utils
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Tranzito/tranzito_utils
+  source_code_uri: https://github.com/Tranzito/tranzito_utils
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Ruby gem contain several modules mainly containing the helpers, concerns
+  and services for personal use by Tranzito
+test_files: []