exobasic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 804b273f3d2c35dbf8f0ff3cde48e05830bd6baf75bc1e448b60b433b30daa29
+  data.tar.gz: 46a64b7e4b1dce72249e72e1992f673a577e096b8d568b8eb5696087a8cdceae
+SHA512:
+  metadata.gz: 66a06c15c4ea3c3f1862134f3e4a76ab8bf800002d2e35f97a297d66e88e82498b59070e4153001f16afcf4e8de030f3c682768fecfdbd01049552ed5d19401e
+  data.tar.gz: c5b9e1be628bb51eedf24fa6374eef6301a82549fa389339ef70c4bbe7749ff1168bd95f7a942945d02b3c4be884231fc7e33a89de9e030c7eb6a7eeee893604

data/README.md

@@ -0,0 +1,23 @@
+# ExoBasic
+
+BasicHelpers: This gem provides basic helpers for a Ruby project.
+
+  - data: DFS
+  - encryption: ECDSA, RSA, HMAC, Password
+  - http: JSON HTTP client
+  - stats: Average counters
+  - time: Timer
+  - Likert value
+  - Settings
+  - String helpers
+
+[reference for gem creation: [newgem-template](https://github.com/wycats/newgem-template)]
+
+[reference for git init: [github init](https://gist.github.com/seankross/8830032)]
+
+
+## Getting started
+
+### Requirements
+
+- Ruby 2.5+

data/lib/exobasic/data/dfs.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+module ExoBasic
+  class DFS
+    def self.search_helper!(target, curr, path, visited, edges_map)
+      children = edges_map[curr]
+
+      visited.add(curr)
+      path.push(curr)
+
+      if target == curr
+        path
+      else
+        found = false
+        if !children.nil?
+          for i in children
+            if !visited.include?(i)
+              found = DFS.search_helper!(target, i, path, visited, edges_map)
+              if found
+                break
+              end
+            end
+          end
+        end
+        if !found
+          path.pop
+        end
+        found
+      end
+    end
+
+    def self.search(to, from, edges_map)
+      DFS.search_helper!(to, from, [], Set.new, edges_map)
+    end
+
+    def self.has_loop_helper(node, edges_map)
+      children   = edges_map[node]
+      visited    = Set.new
+      found      = false
+      found_path = []
+      if children.nil?
+        []
+      else
+        for i in children
+          if !visited.include?(i)
+            found = DFS.search_helper!(node, i, [node], visited, edges_map)
+            if found
+              found_path = found
+              break
+            end
+          end
+        end
+        found_path
+      end
+    end
+
+    def self.has_loop(node, edges_map)
+      !DFS.has_loop_helper(node, edges_map).empty?
+    end
+
+    def self.loop_map(edges_map)
+      edges_map.keys.map do |node|
+        [node, DFS.has_loop_helper(node, edges_map)]
+      end
+      .to_h
+    end
+
+    def self.get_available(node, others, edges_map)
+      to_search = Set.new(others)
+      for i in to_search.to_a
+        if to_search.include?(i)
+          found = DFS.search_helper!(node, i, [], Set.new, edges_map)
+          if found
+            to_remove = Set.new(found)
+            to_search -= to_remove
+          end
+        end
+      end
+      to_search
+    end
+
+  end
+end

data/lib/exobasic/encrypt/ecdsa_keys.rb

@@ -0,0 +1,125 @@
+require 'openssl'
+require 'digest'
+require 'base64'
+
+#
+# see: https://gist.github.com/ostinelli/1770a93d5c01376728c9
+#      https://stackoverflow.com/questions/50077065/
+#              get-elliptic-curve-public-key-from-private-key-using-ruby-openssl
+#      https://stackoverflow.com/questions/38934615/
+#              not-sure-how-to-generate-an-ecdsa-signature-given-a-private-key-and-a-message
+#
+
+module ExoBasic
+  class ECDSAKeys
+    CURVE = 'secp256k1'
+
+    def self.private_pem_to_s(pem)
+      pem.gsub("-----BEGIN EC PRIVATE KEY-----\n", '')
+         .gsub("\n-----END EC PRIVATE KEY-----\n", '')
+         .gsub("\n", '')
+    end
+
+    def self.s_to_private_pem(b64)
+      "-----BEGIN EC PRIVATE KEY-----\n#{b64}-----END EC PRIVATE KEY-----\n"
+    end
+
+    def self.public_pem_to_s(pem)
+      pem.gsub("-----BEGIN PUBLIC KEY-----\n", '')
+         .gsub("\n-----END PUBLIC KEY-----\n", '')
+         .gsub("\n", '')
+    end
+
+    def self.s_to_public_pem(b64)
+      "-----BEGIN PUBLIC KEY-----\n#{b64}-----END PUBLIC KEY-----\n"
+    end
+
+    def self.get_key_details(private_key)
+      private_hex = private_key.to_der.unpack('H*').first
+      private_pem = private_key.to_pem
+
+      key2 = OpenSSL::PKey::EC.new(private_key.public_key.group)
+      key2.public_key = private_key.public_key
+
+      public_hex = private_key.public_key.to_bn.to_s(16).downcase
+      public_pem = key2.to_pem
+
+      {
+        :private_hex => private_hex,
+        :private_pem => private_pem,
+        :public_hex => public_hex,
+        :public_pem => public_pem
+      }
+    end
+
+    def self.to_pem(key)
+      key.to_pem
+    end
+
+    def self.from_pem(key_pem)
+      OpenSSL::PKey::EC.new(key_pem)
+    end
+
+    def self.private_from_hex(private_hex)
+      der = [private_hex].pack('H*')
+      b64 = Base64.encode64(der)
+      pem = ECDSAKeys.s_to_private_pem(b64)
+
+      ECDSAKeys.from_pem(pem)
+    end
+
+    def self.public_from_hex(public_hex, curve=nil)
+      # rebuild key
+      c     = curve.nil? ? ECDSAKeys::CURVE : curve
+      group = OpenSSL::PKey::EC::Group.new(c)
+      key   = OpenSSL::PKey::EC.new(group)
+
+      # create point from hex key
+      public_key_bn  = OpenSSL::BN.new(public_hex, 16)
+      public_key     = OpenSSL::PKey::EC::Point.new(group, public_key_bn)
+      key.public_key = public_key
+
+      key
+    end
+
+    def self.gen_key(curve=nil)
+      c = curve.nil? ? ECDSAKeys::CURVE : curve
+
+      ECDSAKeys.get_key_details(OpenSSL::PKey::EC.new(c).generate_key!)
+    end
+
+    def self.digest(data)
+      OpenSSL::Digest::SHA256.digest(data)
+    end
+
+    def self.sign_message(private_key_pem, data)
+      key = ECDSAKeys.from_pem(private_key_pem)
+
+      digested         = ECDSAKeys.digest(data)
+      digested_base64  = Base64.encode64(digested).gsub("\n", '')
+      signature        = key.dsa_sign_asn1(digested)
+      signature_base64 = Base64.encode64(signature).gsub("\n", '')
+
+      signature_base64
+    end
+
+    def self.verify_message(public_key_pem, signature_base64, data)
+      key           = OpenSSL::PKey::EC.new(public_key_pem)
+      signature     = Base64.decode64(signature_base64)
+      digested_data = ECDSAKeys.digest(data)
+
+      key.dsa_verify_asn1(digested_data, signature)
+    end
+
+    def self.verify_digested_message(public_key_hex, signature_base64, encoded_digested_data,
+                                     curve=nil)
+
+      key           = ECDSAKeys.public_from_hex(public_key_hex, curve)
+      signature     = Base64.decode64(signature_base64)
+      digested_data = Base64.decode64(encoded_digested_data)
+
+      key.dsa_verify_asn1(digested_data, signature)
+    end
+
+  end
+end

data/lib/exobasic/encrypt/hmac_keys.rb

@@ -0,0 +1,35 @@
+require 'securerandom'
+require 'openssl'
+require 'digest'
+require 'base64'
+
+#
+# see: https://docs.github.com/en/developers/webhooks-and-events/securing-your-webhooks
+#      https://github.com/square/connect-api-examples/blob/master/connect-examples/v1/ruby/webhooks.rb
+#
+
+module ExoBasic
+  class HMACKeys
+    SIZE = 20
+
+    def self.gen_key(size=nil)
+      s = size.nil? ? HMACKeys::SIZE : s
+
+      SecureRandom.hex(s)
+    end
+
+    def self.sign_message(key, data)
+      signature        = OpenSSL::HMAC.hexdigest('SHA256', key, data)
+      signature_base64 = Base64.encode64(signature).gsub("\n", '')
+
+      signature_base64
+    end
+
+    def self.verify_message(key, signature_base64, data)
+      # Hash the signatures a second time (to protect against timing attacks) and compare them
+      Digest::SHA256.base64digest(HMACKeys.sign_message(key, data)) ==
+      Digest::SHA256.base64digest(signature_base64)
+    end
+
+  end
+end

data/lib/exobasic/encrypt/password_encryption.rb

@@ -0,0 +1,14 @@
+require 'bcrypt'
+
+module ExoBasic
+  class PasswordEncryption
+    def self.encrypt(str)
+      BCrypt::Password.create(str)
+    end
+
+    def self.check_encrypted(encrypted, str)
+      BCrypt::Password.new(encrypted) == str
+    end
+
+  end
+end

data/lib/exobasic/encrypt/rsa_keys.rb

@@ -0,0 +1,123 @@
+require 'openssl'
+require 'base64'
+
+module ExoBasic
+  class RSAKeys
+    BITS = 2048
+
+    def self.private_pem_to_s(pem)
+      pem.gsub("-----BEGIN RSA PRIVATE KEY-----\n", '')
+         .gsub("\n-----END RSA PRIVATE KEY-----\n", '')
+         .gsub("\n", '')
+    end
+
+    def self.s_to_private_pem(b64)
+      "-----BEGIN RSA PRIVATE KEY-----\n#{b64}-----END RSA PRIVATE KEY-----\n"
+    end
+
+    def self.public_pem_to_s(pem)
+      pem.gsub("-----BEGIN PUBLIC KEY-----\n", '')
+         .gsub("\n-----END PUBLIC KEY-----\n", '')
+         .gsub("\n", '')
+    end
+
+    def self.s_to_public_pem(b64)
+      "-----BEGIN PUBLIC KEY-----\n#{b64}-----END PUBLIC KEY-----\n"
+    end
+
+    def self.get_key_details(private_key)
+      private_key_pem = private_key.to_pem
+      private_key_hex = private_key.to_der.unpack('H*').first
+
+      public_key      = private_key.public_key
+      public_key_pem  = public_key.to_pem
+      public_key_hex  = public_key.to_der.unpack('H*').first
+
+      {
+        :private_pem => private_key_pem,
+        :private_hex => private_key_hex,
+        :public_pem => public_key_pem,
+        :public_hex => public_key_hex
+      }
+    end
+
+    def self.to_pem(key)
+      key.to_pem
+    end
+
+    def self.from_pem(key_pem)
+      OpenSSL::PKey::RSA.new(key_pem)
+    end
+
+    def self.private_from_hex(private_hex)
+      der = [private_hex].pack('H*')
+      b64 = Base64.encode64(der)
+      pem = RSAKeys.s_to_private_pem(b64)
+
+      RSAKeys.from_pem(pem)
+    end
+
+    def self.public_from_hex(public_hex)
+      der = [public_hex].pack('H*')
+      b64 = Base64.encode64(der)
+      pem = RSAKeys.s_to_public_pem(b64)
+
+      RSAKeys.from_pem(pem)
+    end
+
+    def self.gen_key(bits=nil)
+      b = bits.nil? ? RSAKeys::BITS : bits
+
+      RSAKeys.get_key_details(OpenSSL::PKey::RSA.generate(b))
+    end
+
+    def self.sign_message(private_key_pem, data)
+      pkey = RSAKeys.from_pem(private_key_pem)
+
+      signature        = pkey.sign_pss('SHA256', data, salt_length: :max, mgf1_hash: 'SHA256')
+      signature_base64 = Base64.encode64(signature).gsub("\n", '')
+
+      signature_base64
+    end
+
+    def self.verify_message(public_key_pem, signature_base64, data)
+      pub_key = RSAKeys.from_pem(public_key_pem)
+
+      signature = Base64.decode64(signature_base64)
+      pub_key.verify_pss('SHA256', signature, data, salt_length: :auto, mgf1_hash: 'SHA256')
+    end
+
+    def self.private_encrypt(private_key_pem, data)
+      pkey = RSAKeys.from_pem(private_key_pem)
+
+      encrypted        = pkey.private_encrypt(data)
+      encrypted_base64 = Base64.encode64(encrypted).gsub("\n", '')
+
+      encrypted_base64
+    end
+
+    def self.public_encrypt(public_key_pem, data)
+      pub_key = RSAKeys.from_pem(public_key_pem)
+
+      encrypted        = pub_key.public_encrypt(data)
+      encrypted_base64 = Base64.encode64(encrypted).gsub("\n", '')
+
+      encrypted_base64
+    end
+
+    def self.private_decrypt(private_key_pem, encrypted_base64)
+      pkey = RSAKeys.from_pem(private_key_pem)
+
+      encrypted = Base64.decode64(encrypted_base64)
+      pkey.private_decrypt(encrypted)
+    end
+
+    def self.public_decrypt(public_key_pem, encrypted_base64)
+      pub_key = RSAKeys.from_pem(public_key_pem)
+
+      encrypted = Base64.decode64(encrypted_base64)
+      pub_key.public_decrypt(encrypted)
+    end
+
+  end
+end

data/lib/exobasic/http/json_http.rb

@@ -0,0 +1,90 @@
+module ExoBasic
+  class JsonHttp
+    def self.is_success_raw?(code)
+      code >= 200 && code < 300
+    end
+
+    def self.is_success?(code)
+      begin
+        JsonHttp.is_success_raw?(code.to_i)
+      rescue
+        false
+      end
+    end
+
+    def self.mk_http_return
+      {
+        :http_return => 0,
+        :warnings => [],
+        :errors => [],
+        :body => {}
+      }
+    end
+
+    def self.append_http_error(result, code, err)
+      result[:http_return] = code
+      result[:errors].push(err)
+
+      true
+    end
+
+    def self.append_http_errors(result, code, errs)
+      result[:http_return] = code
+      result[:errors]     += errs
+
+      true
+    end
+
+    def self.append_http_body(result, k, v)
+      result[:http_return] = 200
+      result[:body][k]     = v
+
+      false
+    end
+
+    def self.set_http_body(result, h)
+      result[:http_return] = 200
+      result[:body]        = h
+
+      false
+    end
+
+    def self.mk_result
+      {
+        :success => true,
+        :errors => [],
+        :warnings => [],
+        :body => {}
+      }
+    end
+
+    def self.append_result_error(result, err)
+      result[:success] = false
+      result[:errors].push(err)
+
+      true
+    end
+
+    def self.append_result_errors(result, errs)
+      result[:success] = false
+      result[:errors]  += errs
+
+      true
+    end
+
+    def self.append_result_body(result, k, v)
+      result[:success] = true
+      result[:body][k] = v
+
+      false
+    end
+
+    def self.set_result_body(result, h)
+      result[:success] = true
+      result[:body]    = h
+
+      false
+    end
+
+  end
+end

data/lib/exobasic/http/json_http_client.rb

@@ -0,0 +1,79 @@
+require 'uri'
+require 'net/https'
+require 'json'
+
+module ExoBasic
+  class JsonHttpClient
+    def self.prepare_http(url)
+      if !url.start_with?('http') && !url.start_with?('https')
+        url = "https://#{url}"
+      end
+      uri  = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      if url.start_with?('https')
+        http.use_ssl = true
+      end
+
+      [uri, http]
+    end
+
+    def self.url_with_parameters(url, parameters)
+      parameters_prime = parameters.map { |k, v| "#{k}=#{v}" }.join('&')
+      if !parameters_prime.empty?
+        "#{url}?#{parameters_prime}"
+      else
+        url
+      end
+    end
+
+    def self.do_get_request(url, headers={})
+      uri, http = JsonHttpClient.prepare_http(url)
+      req       = Net::HTTP::Get.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+
+      resp = http.request(req)
+
+      [resp.code, JSON.load(resp.body)]
+    end
+
+    def self.do_post_request(url, headers={}, payload)
+      uri, http = JsonHttpClient.prepare_http(url)
+      req       = Net::HTTP::Post.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+      req['Content-Type'] = 'application/json'
+      if !payload.nil?
+        req.body = payload.to_json
+      end
+
+      resp = http.request(req)
+
+      [resp.code, JSON.load(resp.body)]
+    end
+
+    def self.do_delete_request(url, headers={})
+      uri, http = JsonHttpClient.prepare_http(url)
+      req       = Net::HTTP::Delete.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+
+      resp = http.request(req)
+
+      [resp.code, resp.message]
+    end
+
+    def self.get_response_errors(response)
+      if response[1].is_a?(Hash) && response[1].key?('errors')
+        errs = response[1]['errors']
+        if response[1]['errors'].is_a?(Array)
+          errs
+        elsif response[1]['errors'].is_a?(String)
+          [errs]
+        else
+          [errs.to_s]
+        end
+      else
+        []
+      end
+    end
+
+  end
+end

data/lib/exobasic/likert_value.rb

@@ -0,0 +1,42 @@
+module ExoBasic
+  class LikertValue
+    attr_reader :v, :maximum
+
+    UNKNOWN = 0
+    MINIMUM = 1
+
+    def initialize(v, maximum)
+      @v       = [LikertValue::UNKNOWN, [v, maximum].min].max
+      @maximum = maximum
+    end
+
+    def get_range
+      LikertValue::MINIMUM..@maximum
+    end
+
+    def get_extended_range
+      LikertValue::UNKNOWN..@maximum
+    end
+
+    def normalize
+      if @v != LikertValue::UNKNOWN
+        [LikertValue::MINIMUM, [@v, @maximum].min].max
+      else
+        LikertValue::UNKNOWN
+      end
+    end
+
+    def normalize_known
+      [LikertValue::MINIMUM, [@v, @maximum].min].max
+    end
+
+    def self.real_to_likert(v, maximum)
+      LikertValue.new(v.round(), maximum).normalize_known
+    end
+
+    def self.likert_avg(total_likert, n, maximum)
+      LikertValue.real_to_likert(1.0 * total_likert / (1.0 * n), maximum)
+    end
+
+  end
+end

data/lib/exobasic/settings.rb

@@ -0,0 +1,112 @@
+require 'logger'
+require 'json'
+
+module ExoBasic
+  class Settings
+    DEFAULT_FILENAME = './settings.json'
+
+    @@app_name       = 'Untitled'
+    @@load_observers = []
+
+    def self.get_app_name
+      @@app_name
+    end
+    def self.set_app_name(appname)
+      @@app_name = appname
+    end
+
+    def self.add_on_load_observer(observer)
+      @@load_observers.push(observer)
+    end
+
+    def self.post_load(js)
+      merged = {}
+      if js.key?('_include')
+        to_include = []
+        if js['_include'].is_a?(Array)
+          to_include = js['_include']
+        else
+          to_include = [js['_include']]
+        end
+
+        to_include.each do |i|
+          h = Settings.get_conf_with_rem(i)
+          merged = merged.deep_merge(h)
+        end
+        merged = merged.deep_merge(js)
+      else
+        merged = js
+      end
+
+      merged
+    end
+
+    def self.get_conf_with_rem(filename=nil)
+      f = filename
+      if f.nil?
+        f = Settings::DEFAULT_FILENAME
+      end
+
+      if File.exists?(f)
+        js = JSON.load(
+          File.readlines(f)
+              .select { |line| !line.strip.start_with?('//') }
+              .join())
+        Settings.post_load(js)
+      else
+        {}
+      end
+    end
+
+    def self.get_conf(filename=nil)
+      f = filename
+      if f.nil?
+        f = Settings::DEFAULT_FILENAME
+      end
+
+      js = JSON.load(File.read(f))
+      Settings.post_load(js)
+    end
+
+    def self.try_get_key(conf, default_value=false, k)
+      conf.key?(k) ? conf[k] : default_value
+    end
+
+    def self.try_get_nested_key(conf, default_value=false, ks)
+      if ks.empty?
+        default_value
+      else
+        v = Settings.try_get_key(conf, default_value, ks[0])
+        if v != default_value && ks.length > 1
+          Settings.try_get_nested_key(v, default_value, ks[1..-1])
+        else
+          v
+        end
+      end
+    end
+
+    def self.load
+      Settings.get_conf_with_rem
+    end
+
+    @@loaded = Settings.load
+
+    def self.loaded
+      @@loaded
+    end
+
+    def self.reload(filename=nil)
+      @@loaded = Settings.get_conf_with_rem(filename)
+      @@load_observers.each { |observer| observer.settings_reloaded }
+    end
+
+    def self.get_app_conf
+      @@loaded[@@app_name]
+    end
+
+    def self.get_logger
+      Logger.new(STDOUT)
+    end
+
+  end
+end

data/lib/exobasic/stats/avg_meta.rb

@@ -0,0 +1,141 @@
+module ExoBasic
+  class AvgMeta
+    attr_reader :n,
+                :change,
+                :averageChange,
+                :squareOfChange,
+                :variance,
+                :averageDirectional,
+                :minPossibility,
+                :maxPossibility
+
+    def initialize
+      @n                  = 0
+      @change             = 0.0
+      @averageChange      = 0.0
+      @squareOfChange     = 0.0
+      @variance           = 0.0
+      @averageDirectional = 0.0
+      @minPossibility     = Float::MAX
+      @maxPossibility     = Float::MIN
+    end
+
+    def from_hash(h)
+      @n                  = h[:n]
+      @change             = h[:change]
+      @averageChange      = h[:averageChange]
+      @squareOfChange     = h[:squareOfChange]
+      @variance           = h[:variance]
+      @averageDirectional = h[:averageDirectional]
+      @minPossibility     = h[:minPossibility]
+      @maxPossibility     = h[:maxPossibility]
+    end
+
+    def self.mk(h)
+      x = AvgMeta.new
+      x.from_hash(h)
+
+      x
+    end
+
+    def empty?
+      @n == 0
+    end
+
+    def offer(x, prev_mean, d)
+      delta                  = x - prev_mean
+      d2                     = d <= 0 ? 1.0 : d.to_f
+      change_prime           = delta.abs
+      square_of_change_prime = delta * delta
+
+      AvgMeta.mk({
+        :n => @n + 1,
+        :change => change_prime,
+        :averageChange => change_prime / d2 + (d2 - 1.0) * @averageChange / d2,
+        :squareOfChange => square_of_change_prime,
+        :variance => square_of_change_prime / d2 + (d2 - 1.0) * @variance / d2,
+        :averageDirectional => delta,
+        :minPossibility => [x, @minPossibility].min,
+        :maxPossibility => [x, @maxPossibility].max
+      })
+    end
+
+    # Copy
+    def deep_copy
+      Marshal.load(Marshal.dump(self))
+    end
+
+    # Equal
+    def ==(other)
+      StatsHelpers.double_equals(@change,             other.change) &&
+      StatsHelpers.double_equals(@variance,           other.variance) &&
+      StatsHelpers.double_equals(@averageDirectional, other.averageDirectional) &&
+      StatsHelpers.double_equals(@minPossibility,     other.minPossibility) &&
+      StatsHelpers.double_equals(@maxPossibility,     other.maxPossibility)
+    end
+
+    # Monoid
+    def self.zero
+      AvgMeta.new
+    end
+
+    def self.append_helper(n1, d1, n2, d2, nAll)
+      d1 * n1 / nAll + d2 * n2 / nAll
+    end
+
+    def +(other)
+      n_prime = @n + other.n
+
+      nd = n_prime.to_f
+      n1 = @n.to_f
+      n2 = other.n.to_f
+
+      x = {
+        :n => n_prime
+      }
+      if n1 <= 0
+        x[:change]             = other.change
+        x[:averageChange]      = other.averageChange
+        x[:squareOfChange]     = other.squareOfChange
+        x[:variance]           = other.variance
+        x[:averageDirectional] = other.averageDirectional
+      elsif n2 <= 0
+        x[:change]             = @change
+        x[:averageChange]      = @averageChange
+        x[:squareOfChange]     = @squareOfChange
+        x[:variance]           = @variance
+        x[:averageDirectional] = @averageDirectional
+      else
+        x[:change]             = AvgMeta.append_helper(n1, @change,
+                                                       n2, other.change,
+                                                       nd),
+        x[:averageChange]      = AvgMeta.append_helper(n1, @averageChange,
+                                                       n2, other.averageChange,
+                                                       nd),
+        x[:squareOfChange]     = AvgMeta.append_helper(n1, @squareOfChange,
+                                                       n2, other.squareOfChange,
+                                                       nd),
+        x[:variance]           = AvgMeta.append_helper(n1, @variance,
+                                                       n2, other.variance,
+                                                       nd),
+        x[:averageDirectional] = AvgMeta.append_helper(n1, @averageDirectional,
+                                                       n2, other.averageDirectional,
+                                                       nd)
+      end
+
+      x[:minPossibility] = [@minPossibility, other.minPossibility].min
+      x[:maxPossibility] = [@maxPossibility, other.maxPossibility].max
+
+      AvgMeta.mk(x)
+    end
+
+    def standardDeviation
+      Math.sqrt(@variance)
+    end
+
+    def possibilityRange
+      [@minPossibility, @maxPossibility]
+    end
+
+  end
+end

data/lib/exobasic/stats/avg_traits.rb

@@ -0,0 +1,34 @@
+module ExoBasic
+  class StatsHelpers
+    def self.double_equals(a1, a2)
+      (a1 - a2).abs < 1e-4
+    end
+  end
+
+  module AvgTraits
+    def count
+      self.meta.n
+    end
+
+    def minimum
+      self.meta.possibilityRange[0]
+    end
+
+    def maximum
+      self.meta.possibilityRange[1]
+    end
+
+    def approx=(other)
+      StatsHelpers.double_equals(self.avg, other.avg)
+    end
+
+    def deep_copy
+      Marshal.load(Marshal.dump(self))
+    end
+
+    def offer_many(xs)
+      xs.each { |x| self.offer(x) }
+    end
+
+  end
+end

data/lib/exobasic/stats/decaying_avg.rb

@@ -0,0 +1,33 @@
+module ExoBasic
+  class DecayingAvg
+    include AvgTraits
+
+    attr_reader :d, :avg, :meta
+
+    DEFAULT_D = 12
+
+    def initialize(d=DEFAULT_D)
+      @d    = d <= 0 ? DEFAULT_D : d
+      @avg  = 0.0
+      @meta = AvgMeta.new
+    end
+
+    def d=(d)
+      @d = d <= 0 ? DecayingAvg::DEFAULT_D : d
+    end
+
+    def offer(x)
+      @meta = @meta.offer(x, @avg, d)
+
+      d_prime = @d.to_f
+      @avg    = x / d_prime + (d_prime - 1.0) * @avg / d_prime
+    end
+
+    def ==(other)
+      @d == other.d &&
+      StatsHelpers.double_equals(@avg, other.avg) &&
+      @meta == other.meta
+    end
+
+  end
+end

data/lib/exobasic/stats/mean_avg.rb

@@ -0,0 +1,47 @@
+module ExoBasic
+  class MeanAvg
+    include AvgTraits
+
+    attr_reader :avg, :meta
+
+    def initialize
+      @avg  = 0.0
+      @meta = AvgMeta.new
+    end
+
+    def from_hash(h)
+      @avg  = h[:avg]
+      @meta = h[:meta]
+    end
+
+    def self.mk(h)
+      x = MeanAvg.new
+      x.from_hash(h)
+
+      x
+    end
+
+    def offer(x)
+      n     = @meta.n + 1
+      @meta = @meta.offer(x, @avg, n)
+
+      n_prime = n.to_f
+      @avg    = x / n_prime + (n_prime - 1.0) * @avg / n_prime
+    end
+
+    def ==(other)
+      StatsHelpers.double_equals(@avg, other.avg) &&
+      @meta == other.meta
+    end
+
+    def +(other)
+      n_prime = @meta.n + other.meta.n
+
+      MeanAvg.mk({
+        :avg => n_prime == 0 ? 0.0 : (@avg * @meta.n + other.avg * other.meta.n) / n_prime.to_f,
+        :meta => @meta + other.meta
+      })
+    end
+
+  end
+end

data/lib/exobasic/stats/short_term_avg.rb

@@ -0,0 +1,42 @@
+module ExoBasic
+  class ShortTermAvg
+    include AvgTraits
+
+    attr_reader :d, :history, :meta
+
+    DEFAULT_D = 12
+
+    def initialize(d=DEFAULT_D)
+      @d       = d <= 0 ? DEFAULT_D : d
+      @history = []
+      @meta    = AvgMeta.new
+    end
+
+    def d=(d)
+      @d       = d <= 0 ? ShortTermAvg::DEFAULT_D : d
+      @history = @history[0..@d - 1]
+    end
+
+    def avg
+      history.empty? ? 0.0 : history.sum / history.length.to_f
+    end
+
+    def offer(x)
+      siz = history.length
+      if siz < @d
+        history.push(x)
+      else
+        history = history[1..-2].push(x)
+      end
+
+      @meta = @meta.offer(x, self.avg, siz)
+    end
+
+    def ==(other)
+      @d == other.d &&
+      (@history <=> other.history) == 0 &&
+      @meta == other.meta
+    end
+
+  end
+end

data/lib/exobasic/str_helpers.rb

@@ -0,0 +1,12 @@
+module ExoBasic
+  class StrHelpers
+    def self.normalize_name(name)
+      name.strip.gsub(/[^[:print:]]/, '.')
+    end
+
+    def self.is_name_valid?(name)
+      !name.nil? && !name.empty? && StrHelpers.normalize_name(name) == name
+    end
+
+  end
+end

data/lib/exobasic/time/date_timer.rb

@@ -0,0 +1,34 @@
+module ExoBasic
+  class DateTimer
+    def self.date_time_now
+      DateTime.now
+    end
+
+    def self.get(date_time)
+      if date_time.nil?
+        DateTimer.date_time_now
+      elsif date_time.is_a?(String)
+        DateTime.parse(date_time)
+      else
+        date_time
+      end
+    end
+
+    def self.duration_in_days(from, to)
+      (to - from).to_i
+    end
+
+    def self.duration_in_sec(from, to)
+      to.to_i - from.to_i
+    end
+
+    def self.add_days(t, days)
+      t + days
+    end
+
+    def self.add_sec(t, sec)
+      t + Rational(sec, 86400)
+    end
+
+  end
+end

data/lib/exobasic/time/timer.rb

@@ -0,0 +1,166 @@
+module ExoBasic
+  class Timer
+    attr_reader :name, :start, :prev, :now, :samples
+
+    EPOCH           = Time.utc(1970, 1, 1)
+    END_OF_ALL_DAYS = Time.utc(3000, 1, 1)
+
+    def initialize(name=nil)
+      @name    = name
+      @start   = Time.now
+      @prev    = @start
+      @now     = @start
+      @samples = 0
+    end
+
+    def sample
+      t         = Time.now
+      @prev     = @now
+      @now      = t
+      @samples += 1
+    end
+
+    def tick
+      @now = Time.now
+    end
+
+    def warp
+      @start   = @prev
+      @samples = 1
+    end
+
+    def delta
+      Time.now - @now
+    end
+
+    def lifetime
+      Time.now - @start
+    end
+
+    def diff_from(that)
+      @now - that.now
+    end
+
+    def merge_with(that)
+      if that.start < @start
+        @start    = that.start
+        @samples += 1
+      end
+      if that.now > @now
+        @now      = that.now
+        @samples += 1
+      end
+    end
+
+    def show(msg=nil)
+      "-- TIME_MEASUREMENT #{@name}::#{msg}::#{@samples}\tfrom_prev = #{@now - @prev}\tfrom_start = #{@now - @start}"
+    end
+
+    def checkpoint(msg=nil)
+      self.sample
+      STDERR.puts self.show(msg)
+    end
+
+    def self.time_now
+      Time.now
+    end
+
+    def self.get(date_time)
+      if date_time.nil?
+        Timer.time_now
+      elsif date_time.is_a?(String)
+        Time.parse(date_time)
+      else
+        date_time
+      end
+    end
+
+    def self.duration_in_days(from, to)
+      ((to - from) / 86400).to_i
+    end
+
+    def self.duration_in_sec(from, to)
+      to - from
+    end
+
+    def self.add_days(t, days)
+      t + days * 86400
+    end
+
+    def self.add_sec(t, sec)
+      t + sec
+    end
+
+    # sec
+    def self.from_epoch(epoch)
+      Time.at(epoch)
+    end
+
+    # sec
+    def self.to_epoch(t)
+      t.strftime('%s').to_i
+    end
+
+    def self.to_iso8601(t)
+      t.iso8601
+    end
+
+    def self.year(t)
+      t.year
+    end
+
+    # [YYYY, (1..366)]
+    def self.date_by_day(t)
+      [t.year, t.strftime('%-j').to_i]
+    end
+
+    def self.date_by_day_to_epoch(tuple)
+      Timer.to_epoch(Time.strptime("#{tuple[0]} #{tuple[1]}", '%Y %j'))
+    end
+
+    def self.day_of_year(t)
+      Timer.date_by_day(t)[1]
+    end
+
+    # [YYYY, (1..54), (1..7)]
+    # week starts with Monday
+    def self.date_by_week(t)
+      [t.year, t.strftime('%W').to_i + 1, t.strftime('%u').to_i]
+    end
+
+    def self.date_by_week_to_epoch(tuple)
+      Timer.to_epoch(Time.strptime("#{tuple[0]} #{tuple[1] - 1} #{tuple[2]}", '%Y %W %u'))
+    end
+
+    def self.week_of_year(t)
+      Timer.date_by_week(t)[1]
+    end
+
+    def self.day_of_week_of_year(t)
+      Timer.date_by_week(t)[2]
+    end
+
+    # [YYYY, (1..12), (1..31)]
+    def self.date_by_month(t)
+      [t.year, t.month, t.strftime('%-d').to_i]
+    end
+
+    def self.date_by_month_to_epoch(tuple)
+      Timer.to_epoch(Time.strptime("#{tuple[0]} #{tuple[1]} #{tuple[2]}", '%Y %m %d'))
+    end
+
+    def self.month(t)
+      Timer.date_by_month(t)[1]
+    end
+
+    def self.day_of_month(t)
+      Timer.date_by_month(t)[2]
+    end
+
+    # (+, -)HH:MM
+    def self.tz_of(t)
+      t.strftime('%:z')
+    end
+
+  end
+end

data/lib/exobasic/version.rb

@@ -0,0 +1,3 @@
+module ExoBasic
+  VERSION = "0.1.0"
+end

data/lib/exobasic.rb

@@ -0,0 +1,22 @@
+require 'exobasic/likert_value'
+require 'exobasic/settings'
+require 'exobasic/str_helpers'
+
+require 'exobasic/data/dfs'
+
+require 'exobasic/encrypt/ecdsa_keys'
+require 'exobasic/encrypt/hmac_keys'
+require 'exobasic/encrypt/password_encryption'
+require 'exobasic/encrypt/rsa_keys'
+
+require 'exobasic/http/json_http_client'
+require 'exobasic/http/json_http'
+
+require 'exobasic/stats/avg_meta'
+require 'exobasic/stats/avg_traits'
+require 'exobasic/stats/decaying_avg'
+require 'exobasic/stats/mean_avg'
+require 'exobasic/stats/short_term_avg'
+
+require 'exobasic/time/date_timer'
+require 'exobasic/time/timer'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: exobasic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dionysios Kakolyris
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.12
+description: Exotic Basic Helpers
+email:
+- contact@exotic.industries
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/exobasic.rb
+- lib/exobasic/data/dfs.rb
+- lib/exobasic/encrypt/ecdsa_keys.rb
+- lib/exobasic/encrypt/hmac_keys.rb
+- lib/exobasic/encrypt/password_encryption.rb
+- lib/exobasic/encrypt/rsa_keys.rb
+- lib/exobasic/http/json_http.rb
+- lib/exobasic/http/json_http_client.rb
+- lib/exobasic/likert_value.rb
+- lib/exobasic/settings.rb
+- lib/exobasic/stats/avg_meta.rb
+- lib/exobasic/stats/avg_traits.rb
+- lib/exobasic/stats/decaying_avg.rb
+- lib/exobasic/stats/mean_avg.rb
+- lib/exobasic/stats/short_term_avg.rb
+- lib/exobasic/str_helpers.rb
+- lib/exobasic/time/date_timer.rb
+- lib/exobasic/time/timer.rb
+- lib/exobasic/version.rb
+homepage: https://bitbucket.org/vertigoindustries/exotic-basic
+licenses:
+- MIT
+metadata: {}
+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: 1.3.6
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: BasicHelpers
+test_files: []