ree_lib 1.0.0

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_currency.schema.json

@@ -0,0 +1,54 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_currency",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_currency.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToCurrency",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Converts Integer, Float or String to a String with currency sign and delimiters.\n  number_to_currency(1234567890.506)\n  # => \"$1,234,567,890.51\"\n\n  number_to_currency(-1234567890.50)\n  # => \"-$1,234,567,890.50\"\n\n  number_to_currency(1234567890.50, unit: \"&pound\")\n  # => \"&pound1,234,567,890.50\"\n  \n  number_to_currency(1234567890.50, unit: \"£\", separator: \",\", delimiter: \"\")\n  # => \"£1234567890,50\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:format? => String, :precision? => Integer, :unit? => String, :negative_format? => String, :separator? => String, :delimiter? => String, :significant? => Bool, :strip_insignificant_zeros? => Bool, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "number_to_delimited",
+      "package_name": "ree_number",
+      "as": "number_to_delimited",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "number_to_rounded",
+      "package_name": "ree_number",
+      "as": "number_to_rounded",
+      "imports": [
+        "ROUND_MODES"
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_delimited.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_delimited",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_delimited.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToDelimited",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Converts Integer, Float or String to a String with delimiter.\n\nnumber_to_delimited(12345678)\n# => \"12,345,678\"\n\nnumber_to_delimited(123456.789)\n# => \"123,456.789\"\n\nnumber_to_delimited(123456.78, pattern: /(d+?)(?=(dd)+(d)(?!d))/))\n# => \"1,23,456.78\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:separator? => String, :delimiter? => String, :pattern? => Regexp]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_human.schema.json

@@ -0,0 +1,78 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_human",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_human.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToHuman",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Pretty prints (formats and approximates) a number in a way it\nis more readable by humans (e.g.: 1200000000 becomes \"1.2\nBillion\"). This is useful for numbers that can get very large\n(and too hard to read).\n\nSee <tt>number_to_human_size</tt> if you want to print a file\nsize.\n\nYou can also define your own unit-quantifier names if you want\nto use other decimal units (e.g.: 1500 becomes \"1.5\nkilometers\", 0.150 becomes \"150 milliliters\", etc). You may\ndefine a wide range of unit quantifiers, even fractional ones\n(centi, deci, mili, etc).\n\n==== Options\n* <tt>:locale</tt> - Sets the locale to be used for formatting\n  (defaults to current locale).\n* <tt>:precision</tt> - Sets the precision of the number\n  (defaults to 3).\n* <tt>:significant</tt> - If +true+, precision will be the number\n  of significant_digits. If +false+, the number of fractional\n  digits (defaults to +true+)\n* <tt>:round_mode</tt> - Determine how rounding is performed\n  (defaults to :default. See BigDecimal::mode)\n* <tt>:separator</tt> - Sets the separator between the\n  fractional and integer digits (defaults to \".\").\n* <tt>:delimiter</tt> - Sets the thousands delimiter (defaults\n  to \"\").\n* <tt>:strip_insignificant_zeros</tt> - If +true+ removes\n  insignificant zeros after the decimal separator (defaults to\n  +true+)\n* <tt>:units</tt> - A Hash of unit quantifier names. Or a\n  string containing an i18n scope where to find this hash. It\n  might have the following keys:\n  * *integers*: <tt>:unit</tt>, <tt>:ten</tt>,\n    <tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,\n    <tt>:billion</tt>, <tt>:trillion</tt>,\n    <tt>:quadrillion</tt>\n  * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>,\n    <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,\n    <tt>:pico</tt>, <tt>:femto</tt>\n* <tt>:format</tt> - Sets the format of the output string\n  (defaults to \"%n %u\"). The field types are:\n  * %u - The quantifier (ex.: 'thousand')\n  * %n - The number\n==== Examples\n  number_to_human(123)\n  # => \"123\"\n\n  number_to_human(1234)\n  # => \"1.23 Thousand\"\n\n  number_to_human(12345)\n  # => \"12.3 Thousand\"\n\n  number_to_human(1234567)\n  # => \"1.23 Million\"\n\n  number_to_human(1234567890)\n  # => \"1.23 Billion\"\n\n  number_to_human(1234567890123)\n  # => \"1.23 Trillion\"\n\n  number_to_human(1234567890123456)\n  # => \"1.23 Quadrillion\"\n\n  number_to_human(1234567890123456789)\n  # => \"1230 Quadrillion\"\n\n  number_to_human(489939, precision: 2)\n  # => \"490 Thousand\"\n\n  number_to_human(489939, precision: 4)\n  # => \"489.9 Thousand\"\n\n  number_to_human(1234567, precision: 4, significant: false)\n  # => \"1.2346 Million\"\n\n  number_to_human(1234567, precision: 1, separator: ',', significant: false)\n  # => \"1,2 Million\"\n\n  number_to_human(500000000, precision: 5)\n  # => \"500 Million\"\n\n  number_to_human(12345012345, significant: false)\n  # => \"12.345 Billion\"\n\nNon-significant zeros after the decimal separator are stripped\nout by default (set <tt>:strip_insignificant_zeros</tt> to\n+false+ to change that):\n\nnumber_to_human(12.00001)\n# => \"12\"\n\nnumber_to_human(12.00001, strip_insignificant_zeros: false)\n# => \"12.0\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:units? => String, :locale? => Symbol, :format? => String, :precision? => Integer, :significant? => Bool, :strip_insignificant_zeros? => Bool, :separator? => String, :delimiter? => String, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "number_to_delimited",
+      "package_name": "ree_number",
+      "as": "number_to_delimited",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "number_to_rounded",
+      "package_name": "ree_number",
+      "as": "number_to_rounded",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "round_helper",
+      "package_name": "ree_number",
+      "as": "round_helper",
+      "imports": [
+        "ROUND_MODES"
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "t",
+      "package_name": "ree_i18n",
+      "as": "t",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_human_size.schema.json

@@ -0,0 +1,62 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_human_size",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_human_size.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToHumanSize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Formats the bytes in +number+ into a more understandable\nrepresentation (e.g., giving it 1500 yields 1.46 KB). This\nmethod is useful for reporting file sizes to users. You can\ncustomize the format in the +options+ hash.\n\nSee <tt>number_to_human</tt> if you want to pretty-print a\ngeneric number.\n\n==== Options\n\n* <tt>:locale</tt> - Sets the locale to be used for formatting\n  (defaults to current locale).\n* <tt>:precision</tt> - Sets the precision of the number\n  (defaults to 3).\n* <tt>:round_mode</tt> - Determine how rounding is performed\n  (defaults to :default. See BigDecimal::mode)\n* <tt>:significant</tt> - If +true+, precision will be the number\n  of significant_digits. If +false+, the number of fractional\n  digits (defaults to +true+)\n* <tt>:separator</tt> - Sets the separator between the\n  fractional and integer digits (defaults to \".\").\n* <tt>:delimiter</tt> - Sets the thousands delimiter (defaults\n  to \"\").\n* <tt>:strip_insignificant_zeros</tt> - If +true+ removes\n  insignificant zeros after the decimal separator (defaults to\n  +true+)\n==== Examples\n  number_to_human_size(123)\n  # => \"123 Bytes\"\n\n  number_to_human_size(1234)\n  # => \"1.21 KB\"\n\n  number_to_human_size(12345)\n  # => \"12.1 KB\"\n  \n  number_to_human_size(1234567)\n  # => \"1.18 MB\"\n\n  number_to_human_size(1234567890)\n  # => \"1.15 GB\"\n\n  number_to_human_size(1234567890123)\n  # => \"1.12 TB\"\n\n  number_to_human_size(1234567890123456)\n  # => \"1.1 PB\"\n\n  number_to_human_size(1234567890123456789)\n  # => \"1.07 EB\"\n\n  number_to_human_size(1234567, precision: 2)\n  # => \"1.2 MB\"\n\n  number_to_human_size(483989, precision: 2)\n  # => \"470 KB\"\n\n  number_to_human_size(483989, precision: 2, round_mode: :up)\n  # => \"480 KB\"\n\n  number_to_human_size(1234567, precision: 2, separator: ',')\n  # => \"1,2 MB\"\n\n  number_to_human_size(1234567890123, precision: 5)\n  # => \"1.1228 TB\"\n\n  number_to_human_size(524288000, precision: 5)\n  # => \"500 MB\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:locale? => Symbol, :precision? => Integer, :significant? => Bool, :strip_insignificant_zeros? => Bool, :separator? => String, :delimiter? => String, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "number_to_delimited",
+      "package_name": "ree_number",
+      "as": "number_to_delimited",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "number_to_rounded",
+      "package_name": "ree_number",
+      "as": "number_to_rounded",
+      "imports": [
+        "ROUND_MODES"
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "t",
+      "package_name": "ree_i18n",
+      "as": "t",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_ordinalized.schema.json

@@ -0,0 +1,38 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_ordinalized",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_ordinalized.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToOrdinalized",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Turns a number into an ordinal string used to denote the position in an\nordered sequence such as 1st, 2nd, 3rd, 4th.\n\n  ordinalize(1)     # => \"1st\"\n  ordinalize(2)     # => \"2nd\"\n  ordinalize(1002)  # => \"1002nd\"\n  ordinalize(1003)  # => \"1003rd\"\n  ordinalize(-11)   # => \"-11th\"\n  ordinalize(-1021) # => \"-1021st\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Integer"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:locale? => Symbol]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "t",
+      "package_name": "ree_i18n",
+      "as": "t",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_percentage.schema.json

@@ -0,0 +1,46 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_percentage",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_percentage.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToPercentage",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Converts Integer, String or Float to a String with percentage at the end.\nThe +opts+ parameter takes a hash of any of these keys:\n    <tt>:format</tt>, <tt>:precision</tt>, \n    <tt>:significant</tt>, <tt>:strip_insignificant_zeros</tt>, <tt>:delimiter</tt>,\n    <tt>:round_mode</tt>\n  number_to_percentage(100)                                                      # => \"100.000%\"\n  number_to_percentage(123.400, precision: 3, strip_insignificant_zeros: true)   # => \"123.4%\"\n  number_to_percentage.(\"-0.13\", format_percentage: \" %\", precision: 2)          # => \"-0.13 %\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, String, Float]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:format? => String, :precision? => Integer, :significant? => Bool, :strip_insignificant_zeros? => Bool, :delimiter? => String, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "number_to_rounded",
+      "package_name": "ree_number",
+      "as": "number_to_rounded",
+      "imports": [
+        "ROUND_MODES"
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_phone.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_phone",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_phone.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToPhone",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Converts Integer to a formatted string (phone number format).\nCountry_code, delimiter, area_code, extension are optional.\n\nnumber_to_phone(5551234)                                     # => \"555-1234\"\nnumber_to_phone(8005551212)                                  # => \"800-555-1212\"\nnumber_to_phone(8005551212, area_code: true)                 # => \"(800) 555-1212\"\nnumber_to_phone(8005551212, delimiter: \" \")                  # => \"800 555 1212\"\nnumber_to_phone(8005551212, country_code: 7)                 # => \"+7-800-555-1212\"\nnumber_to_phone(8005551212, country_code: 7, extension: 123) # => \"+7-800-555-1212 x 123\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Integer"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:country_code? => Integer, :delimiter? => String, :area_code? => Bool, :pattern? => Regexp, :extension? => Integer]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/number_to_rounded.schema.json

@@ -0,0 +1,62 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "number_to_rounded",
+  "path": "packages/ree_number/package/ree_number/functions/number_to_rounded.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::NumberToRounded",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Rounds Integer(Float, Rational, String) and converts to a String.\n\nThe +options+ parameter takes a hash of any of these keys: \n  <tt>:precision</tt>, <tt>:significant</tt>, <tt>:strip_insignificant_zeros</tt>.\n\nPresicion is 3 by default.\n  number_to_rounded(111.2346)                                # => \"111.235\"\n  number_to_rounded(\"111.2346\")                              # => \"111.235\"\n  number_to_rounded(\"111.2346\", precision: 20)               # => \"111.23460000000000000000\"\n  number_to_rounded(Rational(1112346, 10000)                 # => \"111.2346\"\n  number_to_rounded(123987, precision: 3, significant: true) # => \"124000\"\n\n  number_to_rounded(\n    5.3929, \n    precision: 10, \n    significant: true, \n    strip_insignificant_zeros: true\n  )                                                          # => \"5.3929\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, Rational, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:precision? => Integer, :significant? => Bool, :strip_insignificant_zeros? => Bool, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "digit_count",
+      "package_name": "ree_number",
+      "as": "digit_count",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "number_to_delimited",
+      "package_name": "ree_number",
+      "as": "number_to_delimited",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "round_helper",
+      "package_name": "ree_number",
+      "as": "round_helper",
+      "imports": [
+        "ROUND_MODES"
+      ]
+    },
+    {
+      "target": "slice",
+      "package_name": "ree_hash",
+      "as": "slice",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/round.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "round",
+  "path": "packages/ree_number/package/ree_number/functions/round.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::Round",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Integer",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Integer"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_number/schemas/ree_numbers/functions/round_helper.schema.json

@@ -0,0 +1,38 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "round_helper",
+  "path": "packages/ree_number/package/ree_number/functions/round_helper.rb",
+  "mount_as": "fn",
+  "class": "ReeNumber::RoundHelper",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Or[Integer, BigDecimal]",
+      "args": [
+        {
+          "arg": "number",
+          "type": "Or[Integer, Float, Rational, String]"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:precision? => Integer, :significant? => Bool, :round_mode? => Or[up, down, truncate, half_up, default, half_down, half_even, banker, ceiling, floor]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "digit_count",
+      "package_name": "ree_number",
+      "as": "digit_count",
+      "imports": [
+
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,14 @@
+RSpec.describe "ReeNumber" do
+  it "generates package schema" do
+    require 'fileutils'
+
+    packages_schema_path = Ree.locate_packages_schema(__dir__)
+    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
+
+    FileUtils.cd packages_schema_dir do
+      expect(
+        system("bundle exec ree gen.package_json ree_number --silence")
+      ).to eq(true)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe :digit_count do
+  link :digit_count, from: :ree_number
+
+  it {
+    expect(digit_count(123456)).to eq(6)
+    expect(digit_count(12345.678)).to eq(5)
+    expect(digit_count(BigDecimal("123456"))).to eq(6)
+  }
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_currency do
+  link :number_to_currency, from: :ree_number
+
+  it {
+    expect(number_to_currency(1234567890.50)).to eq("$1,234,567,890.50")
+    expect(number_to_currency("1234567890.50")).to eq("$1,234,567,890.50")
+    expect(number_to_currency(1234567890.506)).to eq("$1,234,567,890.51")
+    expect(number_to_currency(-1234567890.50)).to eq("-$1,234,567,890.50")
+    expect(number_to_currency("-1,234,567,890.50")).to eq("-$1,234,567,890.50")
+    expect(number_to_currency(-1234567890.50, format: "%u %n")).to eq("-$ 1,234,567,890.50")
+    expect(number_to_currency(-1234567890.50, negative_format: "(%u%n)")).to eq("($1,234,567,890.50)")
+    expect(number_to_currency(1234567891.50, precision: 0)).to eq("$1,234,567,892")
+    expect(number_to_currency(1234567890.50, precision: 1)).to eq("$1,234,567,890.5")
+    expect(number_to_currency(123987, precision: 4, significant: true)).to eq("$124,000")
+    expect(number_to_currency(1234567890.50, unit: "&pound")).to eq("&pound1,234,567,890.50")
+    expect(number_to_currency(1234567890.50, unit: "£", separator: ",", delimiter: "")).to eq("£1234567890,50")
+    expect(number_to_currency(1234567891.50, precision: 0, round_mode: :down)).to eq("$1,234,567,891")
+
+    expect(
+      number_to_currency(
+        1234567890.50, 
+        unit: "£", 
+        separator: ",", 
+        delimiter: "", 
+        strip_insignificant_zeros: true
+      )
+    ).to eq("£1234567890,5")
+
+    expect(number_to_currency("1234567890.50", unit: "Kč", format: "%n %u")).to eq("1,234,567,890.50 Kč")
+
+    expect(
+      number_to_currency(
+        "-1234567890.50", 
+        unit: "Kč", 
+        format: "%n %u", 
+        negative_format: "%n - %u"
+      )
+    ).to eq("1,234,567,890.50 - Kč")
+
+    expect(number_to_currency(+0.0, unit: "", negative_format: "(%n)")).to eq("0.00")
+    expect(number_to_currency(-0.456789, precision: 0)).to eq("$0")
+    expect(number_to_currency(-0.0456789, precision: 1)).to eq("$0.0")
+    expect(number_to_currency(-0.00456789, precision: 2)).to eq("$0.00")
+    expect(number_to_currency(-0.5, precision: 0)).to eq("-$1")
+    expect(number_to_currency("1,11")).to eq("$1,11")
+    expect(number_to_currency(-0.0)).to eq("$0.00")
+    expect(number_to_currency("-0.0")).to eq("$0.00")
+  }
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_delimited do
+  link :number_to_delimited, from: :ree_number
+
+  it {
+    expect(number_to_delimited(12345678)).to eq("12,345,678")
+    expect(number_to_delimited("12345678")).to eq("12,345,678")
+    expect(number_to_delimited(0)).to eq("0")
+    expect(number_to_delimited(123)).to eq("123")
+    expect(number_to_delimited(123456)).to eq("123,456")
+    expect(number_to_delimited(123456.789)).to eq("123,456.789")
+    expect(number_to_delimited(123456.78901)).to eq("123,456.78901")
+    expect(number_to_delimited(123456789.78901)).to eq("123,456,789.78901")
+    expect(number_to_delimited(0.78901)).to eq("0.78901")
+    expect(number_to_delimited("0.78901")).to eq("0.78901")
+    expect(number_to_delimited(123456.78)).to eq("123,456.78")
+
+    expect(number_to_delimited(12345678, delimiter: "*")).to eq("12*345*678")
+    expect(number_to_delimited(123456.789, separator: ',', delimiter: ".")).to eq("123.456,789")
+    expect(number_to_delimited(123456.78, pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)).to eq("1,23,456.78")
+  }
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+RSpec.describe :number_to_human_size do
+  link :number_to_human_size, from: :ree_number
+
+  context "zero" do
+    it {
+      expect(number_to_human_size(0)).to eq("0 Bytes")
+    }
+  end
+
+  context "general" do
+    it {
+      expect(number_to_human_size(1234)).to eq("1.21 KB")
+      expect(number_to_human_size(12345)).to eq("12.1 KB")
+      expect(number_to_human_size(1234567)).to eq("1.18 MB")
+      expect(number_to_human_size(1234567890)).to eq("1.15 GB")
+      expect(number_to_human_size(1234567890123)).to eq("1.12 TB")
+      expect(number_to_human_size(1)).to eq("1 Byte")
+      expect(number_to_human_size(3.14159265)).to eq("3 Bytes")
+      expect(number_to_human_size(123.0)).to eq("123 Bytes")
+      expect(number_to_human_size(123)).to eq("123 Bytes")
+      expect(number_to_human_size("123")).to eq("123 Bytes")
+      expect(number_to_human_size(1.1)).to eq("1 Byte")
+      expect(number_to_human_size(10)).to eq("10 Bytes")
+      expect(number_to_human_size(444*1024)).to eq("444 KB")
+      expect(number_to_human_size(1023*1024*1024)).to eq("1020 MB")
+      expect(number_to_human_size(1234567890123456)).to eq("1.1 PB")
+      expect(number_to_human_size(1234567890123456789)).to eq("1.07 EB")
+      expect(number_to_human_size(1026*1024*1024*1024*1024*1024*1024)).to eq("1030 EB")
+      expect(number_to_human_size(3*1024*1024*1024*1024)).to eq("3 TB")
+    }
+  end
+
+  context "with options hash" do
+    it {
+      expect(number_to_human_size(1.0123*1024, precision: 2)).to eq("1 KB")
+      expect(number_to_human_size(1.0100*1024, precision: 4)).to eq("1.01 KB")
+      expect(number_to_human_size(10.000*1024, precision: 4)).to eq("10 KB")
+      expect(number_to_human_size(1234567, precision: 2)).to eq("1.2 MB")
+      expect(number_to_human_size(3.14159265, precision: 4)).to eq("3 Bytes")
+      expect(number_to_human_size(1.00, precision: 4)).to eq("1 Byte")
+      expect(number_to_human_size(1.0123*1024, precision: 2)).to eq("1 KB")
+      expect(number_to_human_size(1.0100*1024, precision: 4)).to eq("1.01 KB")
+      expect(number_to_human_size(10.000*1024, precision: 4)).to eq("10 KB")
+      expect(number_to_human_size(1234567890123, precision: 1)).to eq("1 TB")
+      expect(number_to_human_size(524288000, precision: 3)).to eq("500 MB")
+      expect(number_to_human_size(9961472, precision: 0)).to eq("10 MB")
+      expect(number_to_human_size(41010, precision: 1)).to eq("40 KB")
+      expect(number_to_human_size(41100, precision: 2)).to eq("40 KB")
+      expect(number_to_human_size(3.14159265, precision: 4)).to eq("3 Bytes")
+      expect(number_to_human_size(1234567, precision: 2)).to eq("1.2 MB")
+      expect(number_to_human_size(1.0123*1024, precision: 2, strip_insignificant_zeros: false)).to eq("1.0 KB")
+      expect(number_to_human_size(1.0123*1024, precision: 3, significant: false)).to eq("1.012 KB")
+      expect(number_to_human_size(1.0123*1024, precision: 0, significant: true)).to eq("1 KB")
+      expect(number_to_human_size(1234567, precision: 2, round_mode: :down)).to eq("1.1 MB")
+      expect(number_to_human_size(41100, precision: 1, round_mode: :up)).to eq("50 KB")
+    }
+  end
+
+  context "with delimiter and separator" do
+    it {
+      expect(number_to_human_size(1.0123*1024, precision: 3, separator: ",")).to eq("1,01 KB")
+      expect(number_to_human_size(1.0100*1024, precision: 4, separator: ",")).to eq("1,01 KB")
+      expect(number_to_human_size(1000.1*1024*1024*1024*1024, precision: 5, delimiter: ".", separator: ",")).to eq("1.000,1 TB")
+    }
+  end
+end