ree_lib 1.0.0

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/number_to_human_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_human do
+  link :number_to_human, from: :ree_number
+
+  context 'general' do
+    it {
+      expect(number_to_human(-123)).to eq("-1.23 Hundred")
+      expect(number_to_human(-0.5)).to eq("-5 Tenth")
+      expect(number_to_human(0)).to eq("0")
+      expect(number_to_human(0.5)).to eq("5 Tenth")
+      expect(number_to_human(123)).to eq("1.23 Hundred")
+      expect(number_to_human(1234)).to eq("1.23 Thousand")
+      expect(number_to_human(12345)).to eq("12.3 Thousand")
+      expect(number_to_human(1234567)).to eq("1.23 Million")
+      expect(number_to_human(1234567890)).to eq("1.23 Billion")
+      expect(number_to_human(1234567890123)).to eq("1.23 Trillion")
+      expect(number_to_human(1234567890123456)).to eq("1.23 Quadrillion")    
+      expect(number_to_human(1234567890123456789)).to eq("1230 Quadrillion")      
+    }
+  end
+
+  context "precision, separator, round mode" do
+    it {
+      expect(number_to_human(489939, precision: 2)).to eq("490 Thousand")
+      expect(number_to_human(489939, precision: 4)).to eq("489.9 Thousand")
+      expect(number_to_human(489000, precision: 4)).to eq("489 Thousand")
+      expect(number_to_human(489000, precision: 4, strip_insignificant_zeros: false)).to eq("489.0 Thousand")
+      expect(number_to_human(1234567, precision: 1, significant: false, separator: ",")).to eq("1,2 Million")
+      expect(number_to_human(1234567, precision: 4, significant: false)).to eq("1.2346 Million")
+      expect(number_to_human(1234567, precision: 0, significant: true, separator: ",")).to eq("1 Million") 
+      expect(number_to_human(489939, precision: 2, round_mode: :down)).to eq("480 Thousand")
+    }
+  end
+
+  context "large numbers" do
+    it {
+      expect(number_to_human(999999)).to eq("1 Million")
+      expect(number_to_human(999999999)).to eq("1 Billion")
+    }
+  end
+
+  context "custom format and units" do
+    it {
+      expect(number_to_human(123456, format: "%n times %u")).to eq("123 times Thousand")
+      expect(number_to_human(1230, units: "distance")).to eq("1.23 km")
+      expect(number_to_human(1234567, units: "volume")).to eq("1.23 m3")
+    }
+  end
+end

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/number_to_ordinalized_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_ordinalized do
+  link :number_to_ordinalized, from: :ree_number
+
+  context 'general' do
+    it {
+      expect(number_to_ordinalized(12)).to eq("12th")
+      expect(number_to_ordinalized(-1)).to eq("-1st")
+      expect(number_to_ordinalized(-1)).to eq("-1st")
+      expect(number_to_ordinalized(-11)).to eq("-11th")
+      expect(number_to_ordinalized(2)).to eq("2nd")
+      expect(number_to_ordinalized(3)).to eq("3rd")
+      expect(number_to_ordinalized(4)).to eq("4th")
+      expect(number_to_ordinalized(2012)).to eq("2012th")
+      expect(number_to_ordinalized(-2012)).to eq("-2012th")
+      expect(number_to_ordinalized(-2022)).to eq("-2022nd")
+      expect(number_to_ordinalized(-102022)).to eq("-102022nd")
+      expect(number_to_ordinalized(-102012)).to eq("-102012th")
+      expect(number_to_ordinalized(102034)).to eq("102034th")
+      expect(number_to_ordinalized(102033)).to eq("102033rd")
+      expect(number_to_ordinalized(2000)).to eq("2000th")
+    }
+  end
+
+end

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/number_to_percentage_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_percentage do
+  link :number_to_percentage, from: :ree_number
+
+  it {
+    expect(number_to_percentage(100)).to eq("100.000%")
+    expect(number_to_percentage(Float::NAN)).to eq("NaN%")
+    expect(number_to_percentage(Float::INFINITY)).to eq("Inf%")
+    
+    expect(number_to_percentage(Float::NAN, precision: 1)).to eq("NaN%")
+    expect(number_to_percentage(Float::INFINITY, precision: 1)).to eq("Inf%")
+    expect(number_to_percentage("-0.13", format: "%n %", precision: 2)).to eq("-0.13 %")
+    expect(number_to_percentage(1000, format: "%n  %")).to eq("1000.000  %")
+    expect(number_to_percentage(123.400, precision: 3, strip_insignificant_zeros: true)).to eq("123.4%")
+    expect(number_to_percentage(1.25, precision: 2, significant: true)).to eq("1.3%")
+    expect(number_to_percentage(302.0574, precision: 2, round_mode: :down)).to eq("302.05%")
+  }
+end

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/number_to_phone_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_phone do
+  link :number_to_phone, from: :ree_number
+
+  it {
+    expect(number_to_phone(5551234)).to eq("555-1234")
+    expect(number_to_phone(8005551212)).to eq("800-555-1212")
+    expect(number_to_phone(8005551212, area_code: true)).to eq("(800) 555-1212")
+    expect(number_to_phone(8005551212, delimiter: " ")).to eq("800 555 1212")
+    expect(number_to_phone(5551234, delimiter: ".")).to eq("555.1234")
+    expect(number_to_phone(5551234, country_code: 375, delimiter: "")).to eq("+375551234")
+    expect(number_to_phone(5551234, country_code: 375)).to eq("+375-555-1234")
+    expect(number_to_phone(225551212)).to eq("22-555-1212")
+    expect(number_to_phone(225551212, country_code: 45)).to eq("+45-22-555-1212")
+    expect(number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})/)).to eq("133-1234-5678")
+    expect(number_to_phone(8005551212, area_code: true, extension: 123)).to eq("(800) 555-1212 x 123")
+    expect(number_to_phone(
+      8005551212, 
+      country_code: 7, 
+      area_code: true, 
+      extension: 123, 
+      delimiter: " "
+      )
+    ).to eq("+7 (800) 555 1212 x 123")
+  }
+end

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/number_to_rounded_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_rounded do
+  link :number_to_rounded, from: :ree_number
+
+  context "default presicion" do
+    it {
+      expect(number_to_rounded(-111.2346)).to eq("-111.235")
+      expect(number_to_rounded(111.2346)).to eq("111.235")
+      expect(number_to_rounded("111.2346")).to eq("111.235")
+      expect(number_to_rounded(Float::NAN)).to eq("NaN")   
+      expect(number_to_rounded(Float::INFINITY)).to eq("Inf")
+      expect(number_to_rounded(-Float::INFINITY)).to eq("-Inf")
+    }
+  end
+
+  context "custom precision" do
+    it {
+      expect(number_to_rounded(111.2346, precision: 20)).to eq("111.23460000000000000000")
+      expect(number_to_rounded("111.2346", precision: 20)).to eq("111.23460000000000000000")
+      expect(number_to_rounded(31.825, precision: 2)).to eq("31.83")
+      expect(number_to_rounded(111.2346, precision: 2)).to eq("111.23")
+      expect(number_to_rounded(111, precision: 2)).to eq("111.00")
+      expect(number_to_rounded("31.825", precision: 2)).to eq("31.83")
+      expect(number_to_rounded(0.001, precision: 5)).to eq("0.00100")
+      expect(number_to_rounded(0.00111, precision: 3)).to eq("0.001")
+      expect(number_to_rounded(9.995, precision: 2)).to eq("10.00")
+      expect(number_to_rounded(10.995, precision: 2)).to eq("11.00")
+      expect(number_to_rounded(-0.001, precision: 2)).to eq("0.00")
+      expect(number_to_rounded(Rational(1112346, 10000), precision: 20)).to eq("111.23460000000000000000")
+      expect(number_to_rounded("111.2346", precision: 100)).to eq("111.2346" + "0" * 96)
+      expect(number_to_rounded(Rational(1112346, 10000), precision: 4)).to eq("111.2346")
+      expect(number_to_rounded(Rational(0, 1), precision: 2)).to eq("0.00")
+      expect(number_to_rounded(111.2346, precision: 2, round_mode: :up)).to eq("111.24")
+    }    
+  end
+
+  context "zero presicion" do 
+    it {
+      expect(number_to_rounded((32.6751 * 100.00), precision: 0)).to eq("3268")
+      expect(number_to_rounded(111.50, precision: 0)).to eq("112")
+      expect(number_to_rounded(1234567891.50, precision: 0)).to eq("1234567892")
+      expect(number_to_rounded(0, precision: 0)).to eq("0")
+    }
+  end
+
+  context "significant  = true" do
+    it {
+      expect(number_to_rounded(123987, precision: 3, significant: true)).to eq("124000")
+      expect(number_to_rounded(1, precision: 1, significant: true)).to eq("1")
+      expect(number_to_rounded(5.3929, precision: 7, significant: true)).to eq("5.392900")
+      expect(number_to_rounded(5.3929, precision: 7, significant: true)).to eq("5.392900")
+      expect(number_to_rounded(10.995, precision: 3, significant: true)).to eq("11.0")
+      expect(number_to_rounded(0.0001, precision: 3, significant: true)).to eq("0.000100")
+      expect(number_to_rounded(9775, precision: 20, significant: true)).to eq("9775.0000000000000000")
+      expect(number_to_rounded(Rational(9775, 100), precision: 20, significant: true)).to eq("97.750000000000000000")
+      expect(number_to_rounded(9775, precision: 100, significant: true)).to eq("9775." + "0" * 96)
+      expect(number_to_rounded(Rational(9772,100), precision: 3, significant: true)).to eq("97.7")
+      expect(number_to_rounded(123987, precision: 3, significant: true, round_mode: :down)).to eq("123000")
+    }
+  end
+
+  context "significant = true, zero precision" do
+    it {
+      expect(number_to_rounded(123.987, precision: 0, significant: true)).to eq("124")
+      expect(number_to_rounded(12, precision: 0, significant: true)).to eq("12")
+      expect(number_to_rounded("12.3", precision: 0, significant: true)).to eq("12")
+    }
+  end
+
+  context "strip_unsignuficant_zeros = true" do
+    it {
+      expect(number_to_rounded(9775.43, precision: 4, strip_insignificant_zeros: true)).to eq("9775.43") 
+      expect(number_to_rounded(9775.2, precision: 6, strip_insignificant_zeros: true)).to eq("9775.2")  
+      expect(number_to_rounded(0, precision: 4, significant: true, strip_insignificant_zeros: true)).to eq("0")  
+      expect(number_to_rounded(5.3929, precision: 10, significant: true, strip_insignificant_zeros: true)).to eq("5.3929")
+    }
+  end
+end

data/lib/ree_lib/packages/ree_number/spec/ree_number/functions/round_helper_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe :round_helper do
+  link :round_helper, from: :ree_number
+
+  it {
+    expect(round_helper(999999)).to be_a(BigDecimal)
+  }
+end

data/lib/ree_lib/packages/ree_number/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end

data/lib/ree_lib/packages/ree_object/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/ree_lib/packages/ree_object/Package.schema.json

@@ -0,0 +1,43 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_object",
+  "entry_path": "packages/ree_object/package/ree_object.rb",
+  "tags": [
+    "ree_object"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_hash"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "as_json",
+      "schema": "packages/ree_object/schemas/ree_object/functions/as_json.schema.json"
+    },
+    {
+      "name": "deep_dup",
+      "schema": "packages/ree_object/schemas/ree_object/functions/deep_dup.schema.json"
+    },
+    {
+      "name": "deep_freeze",
+      "schema": "packages/ree_object/schemas/ree_object/functions/deep_freeze.schema.json"
+    },
+    {
+      "name": "is_blank",
+      "schema": "packages/ree_object/schemas/ree_object/functions/is_blank.schema.json"
+    },
+    {
+      "name": "not_blank",
+      "schema": "packages/ree_object/schemas/ree_object/functions/not_blank.schema.json"
+    },
+    {
+      "name": "to_obj",
+      "schema": "packages/ree_object/schemas/ree_object/functions/to_obj.schema.json"
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_object/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/as_json.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class ReeObject::AsJson
+  include Ree::FnDSL
+
+  fn :as_json do
+    def_error { RecursiveObjectErr }
+  end
+  
+  BASIC_TYPES = [
+    Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,
+    Module, Class
+  ].freeze
+
+  contract(
+    Any => Or[Hash, ArrayOf[Any], *BASIC_TYPES]
+  ).throws(RecursiveObjectErr)
+  def call(obj)
+    recursively_convert(obj, {}, {})
+  end
+
+  private
+
+  def recursively_convert(obj, acc, cache)
+    ancestors = obj.class.ancestors
+
+    if ancestors.intersection(BASIC_TYPES).size > 0
+      obj
+    elsif obj.is_a?(Array)
+      convert_array(obj, acc, cache)
+    elsif obj.is_a?(Hash)
+      convert_hash(obj, acc, cache)
+    elsif obj.respond_to?(:to_h)
+      convert_hash(obj.to_h, acc, cache)
+    else
+      convert_object(obj, acc, cache)
+    end
+  end
+
+  def convert_array(obj, acc, cache)
+    obj.map { |el| recursively_convert(el, {}, cache) }
+  end
+
+  def convert_hash(obj, acc, cache)
+    obj.each do |k, v|
+      key_sym = k.to_sym
+      acc[key_sym] = recursively_convert(v, {}, cache)
+    end
+
+    acc
+  end
+
+  def convert_object(obj, acc, cache)
+    return obj if obj.is_a?(Class) || obj.is_a?(Module)
+
+    if cache.key?(obj.object_id)
+      raise RecursiveObjectErr, "Recursive object found: #{obj}"
+    end
+
+    cache[obj.object_id] = acc
+    
+    obj.instance_variables.each do |var|
+      key_name = var.to_s.delete("@")
+      key_sym = key_name.to_sym
+
+      key = key_sym
+      value = obj.instance_variable_get(var)
+
+      acc[key] = recursively_convert(value, {}, cache)
+    end
+
+    acc
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/deep_dup.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class ReeObject::DeepDup
+  include Ree::FnDSL
+
+  fn :deep_dup
+
+  doc(<<~DOC)
+    Create deep duplicate of source object.
+    Duplicate object will also have singleton methods copied from source object.
+
+    Options:
+      :freeze - freeze duplicate object
+      
+    Examples of usage:
+      deep_dup({name: 'John'}) => {name: 'John'}
+      deep_dup({name: 'John'}, freeze: true) => {name: 'John'}
+  DOC
+
+  contract(
+    Any,
+    Ksplat[
+      freeze?: Bool
+    ] => Any
+  )
+  def call(obj, **opts)
+    recursively_dup(obj, opts, {})
+  end
+
+  private
+
+  def recursively_dup(obj, opts, cache)
+    if obj.is_a?(Array)
+      dup_array(obj, opts, cache)
+    elsif obj.is_a?(Hash)
+      dup_hash(obj, opts, cache)
+    else
+      dup_object(obj, opts, cache)
+    end
+  end
+
+  def dup_object(obj, opts, cache)
+    return obj if obj.is_a?(Class) || obj.is_a?(Module)
+    return cache[obj.object_id] if cache.key?(obj.object_id)
+
+    dup = obj.dup
+    cache[obj.object_id] = dup
+
+    dup.instance_variables.each do |var|
+      dup.instance_variable_set(
+        var, recursively_dup(
+          dup.instance_variable_get(var), opts, cache
+        )
+      )
+    end
+
+    dup_singleton_methods(obj, dup)
+
+    opts[:freeze] ? dup.freeze : dup
+  end
+
+  def dup_hash(hash, opts, cache)
+    dup = {}
+
+    dup.default = recursively_dup(hash.default, opts, cache)
+    dup.default_proc = hash.default_proc if hash.default_proc
+
+    hash.each do |k, v|
+      dup[recursively_dup(k, opts, cache)] = recursively_dup(v, opts, cache)
+    end
+
+    dup_singleton_methods(hash, dup)
+    
+    opts[:freeze] ? dup.freeze : dup
+  end
+
+  def dup_array(array, opts, cache)
+    dup = array.map { recursively_dup(_1, opts, cache) }
+    dup_singleton_methods(array, dup)
+    opts[:freeze] ? dup.freeze : dup
+  end
+
+  def dup_singleton_methods(source, target)
+    return if source.singleton_methods.empty?
+
+    source.singleton_methods.each do |method_name|
+      target.define_singleton_method(
+        method_name, &source.method(method_name)
+      )
+    end
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/deep_freeze.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class ReeObject::DeepFreeze
+  include Ree::FnDSL
+
+  fn :deep_freeze
+
+  doc(<<~DOC)
+    Deeply freezes object.
+      
+    Examples of usage:
+      deep_freeze(Object.new)
+  DOC
+
+  contract(Any => Any)
+  def call(obj)
+    recursively_freeze(obj, {})
+  end
+
+  private
+
+  def recursively_freeze(obj, cache)
+    if obj.class == Array
+      freeze_array(obj, cache)
+    elsif obj.class == Hash
+      freeze_hash(obj, cache)
+    else
+      freeze_obj(obj, cache)
+    end
+  end
+
+  def freeze_array(array, cache)
+    array.each { recursively_freeze(_1, cache) }
+    array.freeze
+  end
+
+  def freeze_hash(hash, cache)
+    hash.default.freeze
+
+    hash.each do |k, v|
+      recursively_freeze(k, cache)
+      recursively_freeze(v, cache)
+    end
+
+    hash.freeze
+  end
+
+  def freeze_obj(obj, cache)
+    return obj if obj.is_a?(Class) || obj.is_a?(Module)
+    return cache[obj.object_id] if cache.key?(obj.object_id)
+
+    cache[obj.object_id] = obj
+
+    obj.instance_variables.each do |var|
+      recursively_freeze(obj.instance_variable_get(var), cache)
+    end
+
+    obj.freeze
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/is_blank.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+class ReeObject::IsBlank
+  include Ree::FnDSL
+
+  fn :is_blank
+
+  BLANK_RE = /\A[[:space:]]*\z/
+
+  ENCODED_BLANKS = Concurrent::Map.new do |h, enc|
+    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
+  end
+
+  doc(<<~DOC)
+    An object is blank if it's false, empty, or a whitespace string.
+    For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
+  DOC
+  contract(Any => Bool)
+  def call(obj)
+    return is_string_blank?(obj) if obj.is_a?(String)
+    return obj.empty? if obj.is_a?(Array) || obj.is_a?(Hash) || obj.is_a?(Set)
+    return true if obj.nil?
+    return true if obj == false
+    return false if obj == true
+    false
+  end
+
+  private
+
+  def is_string_blank?(str)
+    str.empty? ||
+      begin
+        BLANK_RE.match?(str)
+      rescue Encoding::CompatibilityError
+        ENCODED_BLANKS[str.encoding].match?(str)
+      end
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/not_blank.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ReeObject::NotBlank
+  include Ree::FnDSL
+
+  fn :not_blank do
+    link :is_blank
+  end
+
+  doc("Opposite to is_blank")
+  contract(Any => Bool)
+  def call(obj)
+    !is_blank(obj)
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/to_obj.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class ReeObject::ToObj
+  include Ree::FnDSL
+
+  fn :to_obj do
+    link :as_json, import: -> { BASIC_TYPES }
+    link :slice, from: :ree_hash
+    link :except, from: :ree_hash
+    link 'ree_hash/contracts/hash_keys_contract', -> { HashKeysContract }
+  end
+
+  contract(
+    Any,
+    Ksplat[
+      include?: HashKeysContract,
+      exclude?: HashKeysContract,
+      global_exclude?: ArrayOf[Symbol]
+    ] => Or[Object, ArrayOf[Object], *BASIC_TYPES]
+  ).throws(ArgumentError)
+  def call(obj, **opts)
+    dump = as_json(obj)
+
+    options = prepare_options(opts)
+
+    if opts[:include]
+      dump = slice(dump, options[:include])
+    end
+
+    if opts[:exclude]
+      dump = except(dump, options[:exclude])
+    end
+
+    if opts[:global_exclude]
+      dump = except(dump, global_except: options[:global_exclude])
+    end
+
+    ancestors = dump.class.ancestors
+    return dump if ancestors.intersection(BASIC_TYPES).size > 0
+      
+    if dump.is_a?(Array)
+      build_array(dump)
+    else
+      recursively_assign(Object.new, dump)
+    end
+  end
+
+  private
+
+  def build_array(array)
+    array.map do |value|
+      if value.is_a?(Array)
+        build_array(value)
+      elsif value.is_a?(Hash)
+        recursively_assign(Object.new, value)
+      else
+        value
+      end
+    end
+  end
+
+  def recursively_assign(obj, hash)
+    hash.each do |key, value|
+      var = :"@#{key}"
+
+      obj.define_singleton_method key do 
+        instance_variable_get(var)
+      end
+
+      if value.is_a?(Array)
+        obj.instance_variable_set(var, build_array(value))
+      elsif value.is_a?(Hash)
+        obj.instance_variable_set(var, recursively_assign(Object.new, value))
+      else
+        obj.instance_variable_set(var, value)
+      end
+    end
+    
+    obj
+  end
+
+  def prepare_options(opts)
+    if opts[:include] && (opts[:exclude] || opts[:global_exclude])
+      intersection = opts_keys(opts[:include]).intersection(opts_keys(opts[:exclude] || opts[:global_exclude]))
+
+      if intersection.length > 0
+        raise ArgumentError, "Exclude and include have the same values: #{intersection}"
+      end
+    end
+
+    opts
+  end
+
+  def opts_keys(arr)
+    arr.reject { |e| e.is_a?(Hash) }
+  end
+end

data/lib/ree_lib/packages/ree_object/package/ree_object.rb

@@ -0,0 +1,7 @@
+module ReeObject
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_hash
+  end
+end