umbrellio-utils 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a8a024f0f4fc2df65b3ec0a9e8bfafc71122522cc9e633dec609ed7f03f1a59
+  data.tar.gz: 5e66a79927988a0a2232308315d8e0e07ccb3fcb40c9c770963babd81f77e47e
+SHA512:
+  metadata.gz: d8a5425810747fb97922019b388e54358623b39d119ea0482592d39f3ffda8efa54768b20d896ebcac3b2877059da24212ff2811c255eb29506108946309d8c4
+  data.tar.gz: e918d6b8324560d613fef02b68625373b6285b8a9791bbf5072c1a1bb0117b73f9699edc508f2456d88b7a3307cbc3ba42a86103f554518685b539efb3fd1728

data/.github/workflows/test.yml

@@ -0,0 +1,60 @@
+name: Test
+
+on: [push, pull_request]
+
+env:
+  FULL_COVERAGE_CHECK: false # Sometimes, sometimes...
+
+jobs:
+  full-check:
+    runs-on: ubuntu-latest
+
+    # We want to run on external PRs, but not on our own internal PRs as they'll be run on push event
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != 'umbrellio/utils'
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3
+          bundler-cache: true
+      - name: Run Linter
+        run: bundle exec ci-helper RubocopLint
+      - name: Check missed spec suffixes
+        run: bundle exec ci-helper CheckSpecSuffixes --extra-paths spec/*.rb --ignored-paths spec/*_helper.rb
+      - name: Run specs
+        run: bundle exec ci-helper RunSpecs
+      - name: Audit
+        run: bundle exec ci-helper BundlerAudit
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+  specs:
+    runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.experimental }}
+
+    env:
+      FULL_TEST_COVERAGE_CHECK: false
+
+    # We want to run on external PRs, but not on our own internal PRs as they'll be run on push event
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != 'umbrellio/utils'
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.6, 2.7]
+        experimental: [false]
+        include:
+          - ruby: head
+            experimental: true
+
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run specs
+        run: bundle exec rspec

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,19 @@
+inherit_gem:
+  rubocop-config-umbrellio: lib/rubocop.yml
+
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.6
+
+Naming/MethodParameterName:
+  AllowedNames: ["x", "y", "z"]
+
+RSpec/EmptyLineAfterHook:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - lib/umbrellio-utils.rb
+
+Naming/RescuedExceptionsVariableName:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in umbrellio_utils.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 JustAnotherDude
+
+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,132 @@
+# Umbrellio Utils
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "umbrellio-utils"
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install umbrellio-utils
+```
+
+## Usage
+
+### Quick Start
+
+You can use modules and classes directly by accessing modules and classes
+under namespace `UmbrellioUtils`. Or you can `include UmbrellioUtils` to other
+module with name you like.
+
+```ruby
+# Direct using
+UmbrellioUtils::Constants.get_class!(:object) #=> Object
+
+# Aliasing to shorter name.
+
+module Utils
+  include UmbrellioUtils
+end
+
+Utils::Constants.get_class!(:object) #=> Object
+Utils::Constants #=> UmbrellioUtils::Constants
+```
+
+### Configuration
+
+Some modules and classes are configurable. Here's the full list of settings and what they do:
+
+- `store_table_name` — table which is used by `UmbrellioUtils::Store` module.
+  Defaults to `:store`
+- `http_client_name` — fiber-local variable name for http client instance in
+  `UmbrellioUtils::HTTPClient`. Defaults to `:application_httpclient`
+
+You can change config in two ways. Firstly, you can change values by accessing configuration
+directly. Secondly, you can use `UmbrellioUtils::configure` method, which accepts a block.
+
+```ruby
+
+# First method
+
+UmbrellioUtils.config.store_table_name = :cool_name
+
+# Second method
+
+module Utils
+  include UmbrellioUtils
+
+  configure do |config|
+    config.store_table_name = :cool_name
+  end
+end
+```
+
+Keep in mind that the config is common to all modules: if you use multiple modules that include
+`UmbrellioUtils`, then all modules will use the same configuration object.
+
+### Extension
+
+You can extend module with you own project specific methods
+via `UmbrellioUtils::extend_util!`.
+
+```ruby
+module Utils
+  include UmbrellioUtils
+
+  configure do |config|
+    config.store_table_name = :cool_name
+  end
+
+  extend_util!(:Constants) do
+    def useful_method
+      "Just string"
+    end
+  end
+end
+
+Utils::Constants.useful_method #=> "Just string"
+```
+
+Or you can define methods in your module and then extend the desired module.
+
+```ruby
+module MyHelpers
+  def useful_method
+    "Just string"
+  end
+end
+
+module Utils
+  include UmbrellioUtils
+
+  extend_util!(:Constants) { extend MyHelpers }
+end
+
+Utils::Constants.useful_method #=> "Just string"
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/umbrellio/utils.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Authors
+
+Created by Umbrellio's Ruby developers
+
+<a href="https://github.com/umbrellio/">
+<img style="float: left;" src="https://umbrellio.github.io/Umbrellio/supported_by_umbrellio.svg" alt="Supported by Umbrellio" width="439" height="72">
+</a>

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "umbrellio_utils"
+require "pry"
+
+Pry.start

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/umbrellio-utils.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "umbrellio_utils"

data/lib/umbrellio_utils.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "memery"
+
+module UmbrellioUtils
+  CONFIG_SET_MUTEX = Mutex.new
+  CONFIG_MUTEX = Mutex.new
+  EXTENSION_MUTEX = Mutex.new
+
+  Dir["#{__dir__}/*/*.rb"].each { |file_path| require_relative(file_path) }
+
+  extend self
+
+  def included(othermod)
+    super
+    othermod.extend(self)
+  end
+
+  # rubocop:disable Style/ClassVars
+  def config
+    CONFIG_SET_MUTEX.synchronize do
+      @@config ||= Struct
+        .new(:store_table_name, :http_client_name, keyword_init: true)
+        .new(**default_settings)
+    end
+  end
+
+  # rubocop:enable Style/ClassVars
+
+  def configure
+    CONFIG_MUTEX.synchronize { yield config }
+  end
+
+  def extend_util!(module_name, &block)
+    const = UmbrellioUtils.const_get(module_name)
+    EXTENSION_MUTEX.synchronize { const.class_eval(&block) }
+  end
+
+  private
+
+  def default_settings
+    {
+      store_table_name: :store,
+      http_client_name: :application_httpclient,
+    }
+  end
+end

data/lib/umbrellio_utils/cards.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Cards
+    extend self
+
+    InvalidExpiryDateString = Class.new(StandardError)
+
+    def parse_expiry_date!(string, **options)
+      result = parse_expiry_date(string, **options)
+
+      unless result
+        raise InvalidExpiryDateString, "Failed to parse expiry date: #{string.inspect}"
+      end
+
+      result
+    end
+
+    def parse_expiry_date(string)
+      month, year = string.split("/", 2).map(&:to_i)
+      return unless month && year
+      year += 2000 if year < 100
+      time = suppress(ArgumentError) { Time.zone.local(year, month) }
+      time + 1.month - 1.second if time
+    end
+  end
+end

data/lib/umbrellio_utils/checks.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Checks
+    extend self
+
+    VOWELS_REGEX = /[AEIOUY]/.freeze
+    CONSONANTS_REGEX = /[BCDFGHJKLMNPQRSTVXZW]/.freeze
+    EMAIL_REGEXP = /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i.freeze
+
+    def secure_compare(src, dest)
+      ActiveSupport::SecurityUtils.secure_compare(
+        ::Digest::SHA256.hexdigest(src),
+        ::Digest::SHA256.hexdigest(dest),
+      )
+    end
+
+    def valid_card?(number)
+      numbers = number.to_s.chars.map(&:to_i)
+
+      modified_numbers = numbers.reverse.map.with_index do |number, index|
+        if index.odd?
+          number *= 2
+          number -= 9 if number > 9
+        end
+
+        number
+      end
+
+      (modified_numbers.sum % 10).zero?
+    end
+
+    def valid_email?(email)
+      email.to_s =~ EMAIL_REGEXP
+    end
+
+    def valid_card_holder?(holder)
+      words = holder.to_s.split
+      return if words.count != 2
+      return if words.any? { |x| x.match?(/(.+)(\1)(\1)/) }
+      return unless words.all? { |x| x.size >= 2 }
+      return unless words.all? { |x| x.match?(/\A[A-Z]+\z/) }
+      return unless words.all? { |x| x.match?(VOWELS_REGEX) && x.match?(CONSONANTS_REGEX) }
+
+      true
+    end
+
+    def valid_card_cvv?(cvv)
+      cvv = cvv.to_s.scan(/\d/).join
+      cvv.size.between?(3, 4)
+    end
+
+    def valid_phone?(phone)
+      Phonelib.valid?(phone)
+    end
+
+    def between?(checked_value, boundary_values, convert_sym: :to_f)
+      checked_value.public_send(convert_sym).between?(*boundary_values.first(2).map(&convert_sym))
+    end
+
+    def int_array?(value, size_range = 1..Float::INFINITY)
+      value.all? { |value| value.to_i.positive? } && value.size.in?(size_range)
+    end
+
+    def valid_limit?(limit)
+      int_array?(limit, 2..2) && limit.reduce(:<=)
+    end
+  end
+end

data/lib/umbrellio_utils/constants.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Constants
+    extend self
+
+    def get_class(*name_parts)
+      safe_constantize(name_parts.join("/").underscore.camelize)
+    end
+
+    def get_class!(*args)
+      get_class(*args) or raise "Failed to get class for #{args.inspect}"
+    end
+
+    def safe_constantize(constant_name)
+      constant = suppress(NameError) { Object.const_get(constant_name, false) }
+      constant if constant && constant.name == constant_name
+    end
+
+    def match_by_class!(**kwargs)
+      name, instance = kwargs.shift
+      result = kwargs.find { |klass, _| instance.is_a?(klass) }&.last
+      raise "Unsupported #{name} type: #{instance.inspect}" if result.nil?
+
+      result.is_a?(Proc) ? result.call : result
+    end
+  end
+end

data/lib/umbrellio_utils/control.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Control
+    extend self
+
+    class UniqueConstraintViolation < StandardError; end
+
+    def run_in_interval(interval, key:)
+      previous_string = Store[key]
+      previous = previous_string ? Time.zone.parse(previous_string) : Time.utc(0)
+
+      return if previous + interval > Time.current
+      Store[key] = Time.current
+
+      yield
+    ensure
+      Store.delete(key) rescue nil
+    end
+
+    def retry_on_unique_violation(
+      times: Float::INFINITY, retry_on_all_constraints: false, checked_constraints: [], &block
+    )
+      retry_on(Sequel::UniqueConstraintViolation, times: times) do
+        DB.transaction(savepoint: true, &block)
+      rescue Sequel::UniqueConstraintViolation => e
+        constraint_name = Database.get_violated_constraint_name(e)
+
+        if retry_on_all_constraints || checked_constraints.include?(constraint_name)
+          raise e
+        else
+          raise UniqueConstraintViolation, e.message
+        end
+      end
+    end
+
+    def run_non_critical(rescue_all: false, in_transaction: false, &block)
+      in_transaction ? DB.transaction(savepoint: true, &block) : yield
+    rescue (rescue_all ? Exception : StandardError) => e
+      Exceptions.notify!(e)
+      nil
+    end
+
+    def retry_on(exception, times: Float::INFINITY, wait: 0)
+      retries = 0
+
+      begin
+        yield
+      rescue exception
+        retries += 1
+        raise if retries > times
+        sleep(wait)
+        retry
+      end
+    end
+  end
+end

data/lib/umbrellio_utils/database.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Database
+    extend self
+
+    HandledConstaintError = Class.new(StandardError)
+
+    def handle_constraint_error(constraint_name, &block)
+      DB.transaction(savepoint: true, &block)
+    rescue Sequel::UniqueConstraintViolation => e
+      if constraint_name.to_s == get_violated_constraint_name(e)
+        raise HandledConstaintError
+      else
+        raise e
+      end
+    end
+
+    def get_violated_constraint_name(exception)
+      error = exception.wrapped_exception
+      error.result.error_field(PG::Result::PG_DIAG_CONSTRAINT_NAME)
+    end
+
+    def each_record(dataset, **options, &block)
+      primary_key = primary_key_from(options)
+      with_temp_table(dataset, **options) do |ids|
+        dataset.model.where(primary_key => ids).each(&block)
+      end
+    end
+
+    def with_temp_table(dataset, **options)
+      primary_key = primary_key_from(options)
+      page_size = options.fetch(:page_size, 1_000)
+      do_sleep = options.fetch(:sleep, Rails.env.production?)
+
+      temp_table_name = create_temp_table(dataset, primary_key: primary_key)
+
+      pk_set = []
+
+      loop do
+        DB.transaction do
+          pk_expr = DB[temp_table_name].select(primary_key).reverse(primary_key).limit(page_size)
+
+          deleted_items = DB[temp_table_name].where(primary_key => pk_expr).returning.delete
+          pk_set = deleted_items.map { |item| item[primary_key] }
+
+          yield(pk_set) if pk_set.any?
+        end
+
+        break if pk_set.empty?
+
+        sleep(1) if do_sleep
+        clear_lamian_logs!
+      end
+    ensure
+      DB.drop_table(temp_table_name)
+    end
+
+    def clear_lamian_logs!
+      Lamian.logger.send(:logdevs).each { |x| x.truncate(0) && x.rewind }
+    end
+
+    def create_temp_table(dataset, primary_key:)
+      model = dataset.model
+      time = Time.current
+      temp_table_name = "temp_#{model.table_name}_#{time.to_i}#{time.nsec}".to_sym
+      type = model.db_schema[primary_key][:db_type]
+
+      DB.drop_table?(temp_table_name)
+      DB.create_table(temp_table_name) { column primary_key, type, primary_key: true }
+
+      insert_ds = dataset.select(Sequel[model.table_name][primary_key])
+      DB[temp_table_name].insert(insert_ds)
+      temp_table_name
+    end
+
+    private
+
+    def primary_key_from(options)
+      options.fetch(:primary_key, :id)
+    end
+  end
+end

data/lib/umbrellio_utils/formatting.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Formatting
+    extend self
+
+    def pluralize(symbol)
+      symbol.to_s.pluralize.to_sym
+    end
+
+    def merge_query_into_url(url, query)
+      uri = Addressable::URI.parse(url)
+      url = uri.omit(:query)
+      original_query = uri.query_values || {}
+      to_url(url, **original_query, **query.stringify_keys)
+    end
+
+    def to_url(*parts)
+      params = parts.select { |x| x.is_a?(Hash) }
+      parts -= params
+      params = params.reduce(&:merge)
+      query = to_query(params).presence if params.present?
+      [File.join(*parts), query].compact.join("?")
+    end
+
+    def to_query(hash, namespace = nil)
+      pairs = hash.map do |key, value|
+        key = CGI.escape(key.to_s)
+        ns = namespace ? "#{namespace}[#{key}]" : key
+        value.is_a?(Hash) ? to_query(value, ns) : "#{CGI.escape(ns)}=#{CGI.escape(value.to_s)}"
+      end
+
+      pairs.join("&")
+    end
+
+    def uncapitalize_string(string)
+      string = string.dup
+      string[0] = string[0].downcase
+      string
+    end
+
+    def cache_key(*parts)
+      parts.flatten.compact.join("-")
+    end
+
+    def render_money(money)
+      "#{money.round} #{money.currency}"
+    end
+
+    def match_or_nil(str, regex)
+      return if str.blank?
+      return unless str.match?(regex)
+      str
+    end
+
+    def encode_key(key)
+      Base64.strict_encode64(key.to_der)
+    end
+
+    def to_date_part_string(part)
+      format("%<part>02d", part: part)
+    end
+  end
+end

data/lib/umbrellio_utils/http_client.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module UmbrellioUtils
+  class HTTPClient
+    include Singleton
+
+    def perform(*args, **kwargs)
+      client.perform(*args, **kwargs)
+    end
+
+    def perform!(*args, **kwargs)
+      client.perform!(*args, **kwargs)
+    end
+
+    def request(*args, **kwargs)
+      client.request(*args, **kwargs)
+    end
+
+    private
+
+    def client
+      Thread.current[UmbrellioUtils.config.http_client_name] ||= EzClient.new(**ezclient_options)
+    end
+
+    def ezclient_options
+      { keep_alive: 30, on_retry: method(:on_retry), timeout: 15 }
+    end
+
+    def on_retry(_request, error, _metadata)
+      log!("Retrying on error: #{error.class}: #{error.message}")
+    end
+
+    def log!(message)
+      Rails.logger.info "[httpclient] #{message}"
+    end
+  end
+end

data/lib/umbrellio_utils/misc.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Misc
+    extend self
+
+    def table_sync(scope, delay: 1, routing_key: nil)
+      scope.in_batches do |batch|
+        batch.each do |model|
+          next if model.try(:skip_table_sync?)
+
+          values = [model.class.name, model.values]
+          publisher = TableSync::Publishing::Publisher.new(*values, confirm: false)
+          publisher.routing_key = routing_key if routing_key
+          publisher.publish_now
+        end
+
+        sleep delay
+      end
+    end
+
+    # Ranges go from high to low priority
+    def merge_ranges(*ranges)
+      ranges = ranges.map { |x| x.present? && x.size == 2 ? x : [nil, nil] }
+      ranges.first.zip(*ranges[1..]).map { |x| x.find(&:present?) }
+    end
+  end
+end

data/lib/umbrellio_utils/parsing.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Parsing
+    extend self
+
+    RFC_AUTH_HEADERS = %w[
+      HTTP_AUTHORIZATION
+      HTTP_X_HTTP_AUTHORIZATION
+      HTTP_REDIRECT_X_HTTP_AUTHORIZATION
+    ].freeze
+    CARD_TRUNCATED_PAN_REGEX = /\A(\d{6}).*(\d{4})\z/.freeze
+
+    def try_to_parse_as_json(data)
+      JSON.parse(data) rescue data
+    end
+
+    def parse_xml(xml, remove_attributes: true, snakecase: true)
+      xml = Nokogiri::XML(xml)
+      xml.remove_namespaces!
+      xml.xpath("//@*").remove if remove_attributes
+
+      tags_converter = snakecase ? -> (tag) { tag.snakecase.to_sym } : -> (tag) { tag.to_sym }
+      nori = Nori.new(convert_tags_to: tags_converter)
+      nori.parse(xml.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION))
+    end
+
+    def card_truncated_pan(string)
+      string.gsub(CARD_TRUNCATED_PAN_REGEX, "\\1...\\2")
+    end
+
+    def card_expiry_time(string, year_format: "%y")
+      format_string = "%m/#{year_format}"
+      time = suppress(ArgumentError) { Time.zone.strptime(string, format_string) }
+      time + 1.month - 1.second if time
+    end
+
+    def extract_host(string)
+      URI(string).host
+    end
+
+    def parse_basic_auth(headers)
+      auth_header = headers.values_at(*RFC_AUTH_HEADERS).compact.first or return
+      credentials_b64 = auth_header[/\ABasic (.*)/, 1] or return
+      joined_credentials = Base64.strict_decode64(credentials_b64) rescue return
+
+      joined_credentials.split(":")
+    end
+
+    def safely_parse_base64(string)
+      Base64.strict_decode64(string)
+    rescue ArgumentError
+      nil
+    end
+
+    def safely_parse_json(string)
+      JSON.parse(string)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def parse_datetime(timestamp, timezone: "UTC", format: nil)
+      return if timestamp.blank?
+      tz = ActiveSupport::TimeZone[timezone]
+      format ? tz.strptime(timestamp, format) : tz.parse(timestamp)
+    end
+
+    def sanitize_phone(string, e164_format: false)
+      phone = Phonelib.parse(string)
+      return if phone.invalid?
+      return phone.e164 if e164_format
+
+      phone.sanitized
+    end
+  end
+end

data/lib/umbrellio_utils/passwords.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Passwords
+    extend self
+
+    def check(hash, password)
+      SCrypt::Password.new(hash).is_password?(password)
+    end
+
+    def create_hash(password)
+      SCrypt::Password.create(password).to_s
+    end
+  end
+end

data/lib/umbrellio_utils/random.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Random
+    extend self
+
+    def uuid
+      SecureRandom.uuid
+    end
+  end
+end

data/lib/umbrellio_utils/request_wrapper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  class RequestWrapper
+    include Memery
+
+    def initialize(request)
+      self.request = request
+    end
+
+    memoize def params
+      parse_params
+    end
+
+    memoize def body
+      request.body.read.dup.force_encoding("utf-8")
+    end
+
+    def [](key)
+      params[key]
+    end
+
+    def rails_params
+      request.params
+    end
+
+    def raw_request
+      request
+    end
+
+    memoize def http_headers
+      headers = request.headers.select do |key, _value|
+        key.start_with?("HTTP_") || key.in?(ActionDispatch::Http::Headers::CGI_VARIABLES)
+      end
+
+      HTTP::Headers.coerce(headers.sort)
+    end
+
+    memoize def path_parameters
+      request.path_parameters.except(:controller, :action).stringify_keys
+    end
+
+    def headers
+      request.headers
+    end
+
+    def ip
+      request.ip
+    end
+
+    private
+
+    attr_accessor :request
+
+    def parse_params
+      case request.content_type
+      when "application/json"
+        Parsing.safely_parse_json(body)
+      when "application/xml"
+        Parsing.parse_xml(body)
+      else
+        request.get? ? request.GET : request.POST
+      end
+    end
+  end
+end

data/lib/umbrellio_utils/rounding.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Rounding
+    extend self
+
+    def fancy_round(number, rounding_method: :round, ugliness_level: 1)
+      return 0 unless number.positive?
+      log = Math.log(number, 10).floor
+      coef = 2**ugliness_level
+      (number * coef).public_send(rounding_method, -log) / coef.to_f
+    end
+
+    def super_round(number, rounding_method: :round)
+      return 0 unless number.positive?
+
+      coef = 10**Math.log(number, 10).floor
+      num = number / coef.to_f
+
+      best_diff = best_target = nil
+
+      [1.0, 1.5, 2.5, 5.0, 10.0].each do |target|
+        diff = target - num
+
+        next if rounding_method == :ceil && diff.negative?
+        next if rounding_method == :floor && diff.positive?
+
+        if best_diff.nil? || diff.abs < best_diff
+          best_diff = diff.abs
+          best_target = target
+        end
+      end
+
+      (best_target.to_d * coef).to_f
+    end
+  end
+end

data/lib/umbrellio_utils/store.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Store
+    extend self
+
+    include Memery
+
+    def []=(key, value)
+      attrs = { key: key.to_s, value: JSON.dump(value), updated_at: Time.current }
+      entry.upsert_dataset.insert(attrs)
+      clear_cache_for(key)
+    end
+
+    def [](key)
+      find(key)&.value
+    end
+
+    def delete(key)
+      result = !!find(key)&.delete
+      clear_cache_for(key) if result
+      result
+    end
+
+    def find(key)
+      Rails.cache.fetch(cache_key_for(key)) { entry[key.to_s] }
+    end
+
+    memoize def entry
+      Sequel::Model(UmbrellioUtils.config.store_table_name)
+    end
+
+    private
+
+    def cache_key_for(key)
+      "store-entry-#{key}"
+    end
+
+    def clear_cache_for(key)
+      Rails.cache.delete(cache_key_for(key))
+    end
+  end
+end

data/lib/umbrellio_utils/vault.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module UmbrellioUtils
+  module Vault
+    extend self
+
+    def secret_engine_present?(engine_path)
+      ::Vault.logical.read("sys/mounts").data.key?("#{engine_path}/".to_sym)
+    end
+
+    def create_kv_engine(path)
+      ::Vault.logical.write(
+        "sys/mounts/#{path}",
+        config: {},
+        generate_signing_key: true,
+        options: { version: 2 },
+        path: path.to_s,
+        type: "kv",
+      )
+    end
+
+    def write_to_kv(engine_path:, secret_path:, data:)
+      full_data_path = File.join(engine_path, "data", secret_path)
+      full_meta_path = File.join(engine_path, "metadata", secret_path)
+      ::Vault.logical.write(full_data_path, data: data)
+      ::Vault.logical.write(full_meta_path, id: secret_path, max_versions: 1, cas_required: false)
+    end
+  end
+end

data/lib/umbrellio_utils/version.rb

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

data/umbrellio_utils.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/umbrellio_utils/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "umbrellio-utils"
+  spec.version       = UmbrellioUtils::VERSION
+  spec.authors       = ["JustAnotherDude"]
+  spec.email         = ["VanyaZ158@gmail.com"]
+
+  spec.summary       = "A set of utilities that speed up development"
+  spec.description   = "UmbrellioUtils is collection of utility classes and helpers"
+  spec.homepage      = "https://github.com/umbrellio/utils"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/umbrellio/utils"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "memery"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "bundler-audit"
+  spec.add_development_dependency "ci-helper"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop-config-umbrellio"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-lcov"
+end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: umbrellio-utils
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- JustAnotherDude
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: memery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ci-helper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-config-umbrellio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: UmbrellioUtils is collection of utility classes and helpers
+email:
+- VanyaZ158@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/umbrellio-utils.rb
+- lib/umbrellio_utils.rb
+- lib/umbrellio_utils/cards.rb
+- lib/umbrellio_utils/checks.rb
+- lib/umbrellio_utils/constants.rb
+- lib/umbrellio_utils/control.rb
+- lib/umbrellio_utils/database.rb
+- lib/umbrellio_utils/formatting.rb
+- lib/umbrellio_utils/http_client.rb
+- lib/umbrellio_utils/misc.rb
+- lib/umbrellio_utils/parsing.rb
+- lib/umbrellio_utils/passwords.rb
+- lib/umbrellio_utils/random.rb
+- lib/umbrellio_utils/request_wrapper.rb
+- lib/umbrellio_utils/rounding.rb
+- lib/umbrellio_utils/store.rb
+- lib/umbrellio_utils/vault.rb
+- lib/umbrellio_utils/version.rb
+- umbrellio_utils.gemspec
+homepage: https://github.com/umbrellio/utils
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/umbrellio/utils
+  source_code_uri: https://github.com/umbrellio/utils
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.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 set of utilities that speed up development
+test_files: []