urbit-aura 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 993880e08fb2125ef19a39a73722871eee1f10fa8015c3c6a35d98a46d4e7b80
+  data.tar.gz: a87a2d689bd51dbe9537d14fbe7e0d4d3d5dfe6b4ba65e542077f0cb3631d387
+SHA512:
+  metadata.gz: eef10f9a4babc15ff80141c8dc06bf3778c9cbccc07e81efe399db268cce0fb79b1e9af37b3be87d773f05f97535bd5638eb9281b869c208a75edb09439246a0
+  data.tar.gz: 1d8d895729563443c1875706f7a38ddcae0bf4332cadd0eb318ac8e7d0dc40cd8755059492d2b457edaad5c5c57e3312ecd4a8e1dd44c49ff2bf7714ff93980b

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Naming/MethodParameterName:
+  MinNameLength: 1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Matthew LeVan
+
+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,77 @@
+# aura-rb
+
+Parsing, conversion, and validation for Urbit date, phonetic name, and number
+auras.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add urbit-aura
+
+If bundler is not being used to manage dependencies, install the gem by
+executing:
+
+    $ gem install urbit-aura
+
+## Usage
+
+```ruby
+require 'aura'
+
+Aura.version # => "0.1.0"
+
+# @p
+Aura::P.patp(0) # => "~zod"
+Aura::P.patp("0") # => "~zod"
+Aura::P.hex2patp("0x12345678") # => "~milbyt-wacmeg"
+Aura::P.patp2hex("~zod") # => "00"
+Aura::P.patp2dec("~zod") # => 0
+Aura::P.clan("~zod") # => "galaxy"
+Aura::P.clan("~mastyr-bottec") # => "planet"
+Aura::P.sein("~mastyr-bottec") # => "~wanzod"
+Aura::P.valid_pat?("~zod") # => true
+Aura::P.valid_patp?("invalid") # => false
+Aura::P.pre_sig("zod") # => "~zod"
+Aura::P.de_sig("~zod") # => "zod"
+Aura::P.cite("~mastyr-bottec") # => "~mastyr-bottec"
+
+# @q
+Aura::Q.patq(123456) # => "~doznec-fitrys"
+Aura::Q.patq("123456") # => "~doznec-fitrys"
+Aura::Q.hex2patq("1e240") # => "~doznec-fitrys"
+Aura::Q.hex2patq("0x1e240") # => "~doznec-fitrys"
+Aura::Q.patq2hex("~doznec-fitrys") # => "0001e240"
+Aura::Q.patq2dec("~doznec-fitrys") # => 123456
+Aura::Q.valid_patq?("~doznec-fitrys") # => true
+Aura::Q.valid_patq?("invalid") # => false
+```
+
+## Development
+
+TODO:
+
+- [ ] Tests
+- [ ] Dates (`@da`)
+- [ ] More numbers (`@uv`, `@ud`, etc...)
+- [ ] Linting errors (formally ignore rules, or fix)
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/urbit/aura-rb.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/aura.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require_relative("ob")
+
+# Functionality for wrangling Urbit `@da`, `@p`, `@q`, `@ux`, etc.
+module Aura
+  VERSION = "0.1.0"
+
+  def self.version
+    VERSION
+  end
+
+  # List of all possible prefixes for @p encoding.
+  PREFIXES = %w[
+    doz mar bin wan sam lit sig hid fid lis sog dir wac sab wis sib
+    rig sol dop mod fog lid hop dar dor lor hod fol rin tog sil mir
+    hol pas lac rov liv dal sat lib tab han tic pid tor bol fos dot
+    los dil for pil ram tir win tad bic dif roc wid bis das mid lop
+    ril nar dap mol san loc nov sit nid tip sic rop wit nat pan min
+    rit pod mot tam tol sav pos nap nop som fin fon ban mor wor sip
+    ron nor bot wic soc wat dol mag pic dav bid bal tim tas mal lig
+    siv tag pad sal div dac tan sid fab tar mon ran nis wol mis pal
+    las dis map rab tob rol lat lon nod nav fig nom nib pag sop ral
+    bil had doc rid moc pac rav rip fal tod til tin hap mic fan pat
+    tac lab mog sim son pin lom ric tap fir has bos bat poc hac tid
+    hav sap lin dib hos dab bit bar rac par lod dos bor toc hil mac
+    tom dig fil fas mit hob har mig hin rad mas hal rag lag fad top
+    mop hab nil nos mil fop fam dat nol din hat nac ris fot rib hoc
+    nim lar fit wal rap sar nal mos lan don dan lad dov riv bac pol
+    lap tal pit nam bon ros ton fod pon sov noc sor lav mat mip fip
+  ].freeze
+
+  # List of all possible suffixes for @p encoding.
+  SUFFIXES = %w[
+    zod nec bud wes sev per sut let ful pen syt dur wep ser wyl sun
+    ryp syx dyr nup heb peg lup dep dys put lug hec ryt tyv syd nex
+    lun mep lut sep pes del sul ped tem led tul met wen byn hex feb
+    pyl dul het mev rut tyl wyd tep bes dex sef wyc bur der nep pur
+    rys reb den nut sub pet rul syn reg tyd sup sem wyn rec meg net
+    sec mul nym tev web sum mut nyx rex teb fus hep ben mus wyx sym
+    sel ruc dec wex syr wet dyl myn mes det bet bel tux tug myr pel
+    syp ter meb set dut deg tex sur fel tud nux rux ren wyt nub med
+    lyt dus neb rum tyn seg lyx pun res red fun rev ref mec ted rus
+    bex leb dux ryn num pyx ryg ryx fep tyr tus tyc leg nem fer mer
+    ten lus nus syl tec mex pub rym tuc fyl lep deb ber mug hut tun
+    byl sud pem dev lur def bus bep run mel pex dyt byt typ lev myl
+    wed duc fur fex nul luc len ner lex rup ned lec ryd lyd fen wel
+    nyd hus rel rud nes hes fet des ret dun ler nyr seb hul ryl lud
+    rem lys fyn wer ryc sug nys nyl lyn dyn dem lux fed sed bec mun
+    lyr tes mud nyt byr sen weg fyr mur tel rep teg pec nel nev fes
+  ].freeze
+
+  def bex(n)
+    2**n
+  end
+
+  def rsh(a, b, c)
+    c / bex(bex(a) * b)
+  end
+
+  def met(a, b, c = 0)
+    b.zero? ? c : met(a, rsh(a, 1, b), c + 1)
+  end
+
+  def end_bits(a, b, c)
+    c % bex(bex(a) * b)
+  end
+
+  def patp2syls(name)
+    name.gsub(/[\^~-]/, "").scan(/.{1,3}/)
+  end
+
+  def valid_pat?(name)
+    raise ArgumentError, "valid_pat?: non-string input" unless name.is_a? String
+
+    leading_tilde = name.start_with?("~")
+
+    return false if !leading_tilde || name.length < 4
+
+    syls = patp2syls(name)
+    wrong_length = syls.length.odd? && syls.length != 1
+    syls_exist = syls.each_with_index.all? do |syl, index|
+      if index.odd? || syls.length == 1
+        SUFFIXES.include?(syl)
+      else
+        PREFIXES.include?(syl)
+      end
+    end
+
+    !wrong_length && syls_exist
+  end
+
+  # @p
+  module P
+    extend Aura
+
+    # Convert a hex-encoded string to a @p-encoded string.
+    def self.hex2patp(hex)
+      raise ArgumentError, "hex2patp: null input" if hex.nil?
+
+      patp(hex.delete_prefix("0x").to_i(16))
+    end
+
+    # Convert a @p-encoded string to a hex-encoded string.
+    def self.patp2hex(name)
+      raise ArgumentError, "patp2hex: not a valid @p" unless valid_pat?(name)
+
+      syls = patp2syls(name)
+      addr = syls.each_with_index.inject("") do |acc, (syl, idx)|
+        idx.odd? || syls.length == 1 ? acc + syl2bin(SUFFIXES.index(syl)) : acc + syl2bin(PREFIXES.index(syl))
+      end
+
+      bn = addr.to_i(2)
+      hex = Ob.fynd(bn).to_s(16)
+      hex.length.odd? ? hex.rjust(hex.length + 1, "0") : hex
+    end
+
+    # Convert a @p-encoded string to an integer.
+    def self.patp2dec(name)
+      patp2hex(name).to_i(16)
+    rescue ArgumentError
+      raise "patp2dec: not a valid @p"
+    end
+
+    # Find whether the given @p-encoded string is a galaxy, star, planet, moon,
+    # or comet.
+    def self.clan(who)
+      begin
+        name = patp2dec(who)
+      rescue ArgumentError
+        raise "clan: not a valid @p"
+      end
+
+      wid = met(3, name)
+      case wid
+      when (0..1) then "galaxy"
+      when 2 then "star"
+      when (3..4) then "planet"
+      when (5..8) then "moon"
+      else "comet"
+      end
+    end
+
+    # Find the parent of the given @p-encoded string.
+    def self.sein(name)
+      begin
+        who = patp2dec(name)
+        mir = clan(name)
+      rescue ArgumentError
+        raise "sein: not a valid @p"
+      end
+
+      res = case mir
+            when "galaxy" then who
+            when "star" then end_bits(3, 1, who)
+            when "planet" then end_bits(4, 1, who)
+            when "moon" then end_bits(5, 1, who)
+            else 0
+            end
+      patp(res)
+    end
+
+    # Validate a @p-encoded string.
+    def self.valid_patp?(str)
+      valid_pat?(str) && str == patp(patp2dec(str))
+    end
+
+    # Convert a number into a @p-encoded string.
+    def self.patp(arg)
+      raise ArgumentError, "patp: null input" if arg.nil?
+
+      n = arg.to_i # Assuming arg can be converted to an integer directly
+      sxz = Ob.fein(n)
+      dyy = met(4, sxz)
+
+      loop_fn = lambda do |tsxz, timp, trep|
+        log = end_bits(4, 1, tsxz)
+        pre = PREFIXES[rsh(3, 1, log)]
+        suf = SUFFIXES[end_bits(3, 1, log)]
+        etc = if (timp % 4).zero?
+                timp.zero? ? "" : "--"
+              else
+                "-"
+              end
+
+        res = pre + suf + etc + trep
+
+        timp == dyy ? trep : loop_fn.call(rsh(4, 1, tsxz), timp + 1, res)
+      end
+
+      dyx = met(3, sxz)
+
+      "~#{dyx <= 1 ? SUFFIXES[sxz] : loop_fn.call(sxz, 0, "")}"
+    end
+
+    def self.pre_sig(ship)
+      return "" if ship.nil? || ship.empty?
+
+      ship.strip.start_with?("~") ? ship.strip : "~#{ship.strip}"
+    end
+
+    def self.de_sig(ship)
+      return "" if ship.nil? || ship.empty?
+
+      ship.gsub("~", "")
+    end
+
+    def self.cite(ship)
+      return nil if ship.nil? || ship.empty?
+
+      patp = de_sig(ship)
+      case patp.length
+      when 56 # comet
+        pre_sig("#{patp[0..5]}_#{patp[50..55]}")
+      when 27 # moon
+        pre_sig("#{patp[14..19]}^#{patp[21..26]}")
+      else
+        pre_sig(patp)
+      end
+    end
+
+    def self.syl2bin(idx)
+      idx.to_s(2).rjust(8, "0")
+    end
+  end
+
+  # @q utility functions.
+  module Q
+    extend Aura
+
+    # Convert a number to a @q-encoded string.
+    def self.patq(arg)
+      n = arg.to_i
+      hex = n.to_s(16)
+      buf = hex.rjust((hex.length + 1) & ~1, "0").scan(/../).map(&:hex)
+      buf2patq(buf)
+    end
+
+    def self.buf2patq(buf)
+      # Split the buffer into chunks of 2, with a special case for odd-length buffers
+      chunked = if buf.length.odd? && buf.length > 1
+                  [[buf[0]]] + buf[1..].each_slice(2).to_a
+                else
+                  buf.each_slice(2).to_a
+                end
+
+      chunked.reduce("~") do |acc, elem|
+        acc + (acc == "~" ? "" : "-") + alg(elem, chunked)
+      end
+    end
+
+    # Convert a hex-encoded string to a @q-encoded string.
+    #
+    # Note that this preserves leading zero bytes.
+    def self.hex2patq(arg)
+      raise ArgumentError, "hex2patq: input must be a string" unless arg.is_a?(String)
+
+      arg = arg.delete_prefix("0x")
+      hex = arg.length.odd? ? arg.rjust(arg.length + 1, "0") : arg
+      buf = hex.to_s.scan(/../).map(&:hex)
+      buf2patq(buf)
+    end
+
+    # Convert a @q-encoded string to an integer.
+    def self.patq2dec(name)
+      patq2hex(name).to_i(16)
+    end
+
+    # Convert a @q-encoded string to a hex-encoded string.
+    #
+    # Note that this preservers leading zero bytes.
+    def self.patq2hex(name)
+      raise ArgumentError, "patq2hex: not a valid @q" unless valid_pat?(name)
+
+      chunks = name.delete_prefix("~").split("-")
+      dec2hex = ->(dec) { format("%02x", dec) }
+      splat = chunks.map do |chunk|
+        syls = chunk[0..2], chunk[3..]
+        if syls[1].nil? || syls[1].empty?
+          dec2hex.call(SUFFIXES.index(syls[0]))
+        else
+          dec2hex.call(PREFIXES.index(syls[0])) + dec2hex.call(SUFFIXES.index(syls[1]))
+        end
+      end
+
+      name.empty? ? "00" : splat.join("")
+    end
+
+    # Validate a @q-encoded string.
+    def self.valid_patq?(str)
+      valid_pat?(str) && eq_patq(str, patq(patq2dec(str)))
+    end
+
+    # Validate @q-encoded string equality.
+    def self.eq_patq(p, q)
+      # Convert p to hex, raise an exception if not valid
+      phex = begin
+        Aura::Q.patq2hex(p)
+      rescue ArgumentError
+        raise ArgumentError, "eq_patq: not a valid @q"
+      end
+
+      # Convert q to hex, raise an exception if not valid
+      qhex = begin
+        Aura::Q.patq2hex(q)
+      rescue ArgumentError
+        raise ArgumentError, "eq_patq: not a valid @q"
+      end
+
+      # Assuming eq_mod_leading_zero_bytes is defined elsewhere in your Ruby code
+      eq_mod_leading_zero_bytes(phex, qhex)
+    end
+
+    # Helper method to compare hex strings ignoring leading zero bytes
+    def self.eq_mod_leading_zero_bytes(hex1, hex2)
+      # Remove any leading zeros and compare
+      hex1.gsub(/^0+/, "") == hex2.gsub(/^0+/, "")
+    end
+
+    module_function
+
+    def prefix_name(byts)
+      byts[1].nil? ? PREFIXES[0] + SUFFIXES[byts[0]] : PREFIXES[byts[0]] + SUFFIXES[byts[1]]
+    end
+
+    def name(byts)
+      byts[1].nil? ? SUFFIXES[byts[0]] : PREFIXES[byts[0]] + SUFFIXES[byts[1]]
+    end
+
+    def alg(pair, chunked)
+      pair.length.odd? && chunked.length > 1 ? prefix_name(pair) : name(pair)
+    end
+  end
+end

data/lib/muk.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require("murmurhash3")
+
+# ++  muk
+module Muk
+  def self.muk(syd, key)
+    # Extract the least significant byte and the second byte
+    lo = key & 0xff
+    hi = (key >> 8) & 0xff
+
+    # Create a string from these two bytes
+    kee = [lo, hi].pack("CC")
+
+    # Use murmurhash3 gem to compute the hash
+    MurmurHash3::V32.str_hash(kee, syd)
+  end
+end

data/lib/ob.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative("muk")
+
+# ++  ob
+module Ob
+  # A pseudorandom function for j in (0..3)
+  def self.F(j, arg)
+    raku = [0xb76d5eed, 0xee281300, 0x85bcae01, 0x4b387af7]
+    Muk.muk(raku[j], arg)
+  end
+
+  def self.feis(arg)
+    Fe(4, 65_535, 65_536, 0xffffffff, method(:F), arg)
+  end
+
+  def self.Fe(r, a, b, k, f, m)
+    c = fe(r, a, b, f, m)
+    c < k ? c : fe(r, a, b, f, c)
+  end
+
+  def self.fe(r, a, b, f, m)
+    loop_fn = lambda do |j, ell, arr|
+      if j > r
+        if r.odd?
+          a * arr + ell
+        else
+          arr == a ? a * arr + ell : a * ell + arr
+        end
+      else
+        eff = f.call(j - 1, arr) # Assuming f is a Proc/lambda
+
+        tmp = if j.odd?
+                (ell + eff) % a
+              else
+                (ell + eff) % b
+              end
+
+        loop_fn.call(j + 1, arr, tmp)
+      end
+    end
+
+    left = m % a
+    right = m / a
+
+    loop_fn.call(1, left, right)
+  end
+
+  def self.tail(arg)
+    Fen(4, 65_535, 65_536, 0xffffffff, method(:F), arg)
+  end
+
+  def self.Fen(r, a, b, k, f, m)
+    c = fen(r, a, b, f, m)
+    c < k ? c : fen(r, a, b, f, c)
+  end
+
+  # TODO: FIXME
+  def self.fen(r, a, b, f, m)
+    # Inner recursive function using Ruby way of doing recursion
+    loop_fn = lambda do |j, ell, arr|
+      return a * arr + ell if j < 1
+
+      eff = f.call(j - 1, ell) # Assuming f is a Proc/lambda
+
+      # Same comment about deviation from B&R (2002)
+      tmp = if j.odd?
+              (arr + a - (eff % a)) % a
+            else
+              (arr + b - (eff % b)) % b
+            end
+
+      loop_fn.call(j - 1, tmp, ell)
+    end
+
+    ahh = r.odd? ? m / a : m % a
+    ale = r.odd? ? m % a : m / a
+
+    left = ale == a ? ahh : ale
+    right = ale == a ? ale : ahh
+
+    loop_fn.call(r, left, right)
+  end
+
+  def self.fein_loop(pyn)
+    lo = pyn & 0xffffffff
+    hi = pyn & 0xffffffff00000000
+
+    if (pyn >= 0x10000) && (pyn <= 0xffffffff)
+      0x10000 + feis(pyn - 0x10000)
+    elsif (pyn >= 0x100000000) && (pyn <= 0xffffffffffffffff)
+      hi | fein_loop(lo)
+    else
+      pyn
+    end
+  end
+
+  def self.fein(arg)
+    fein_loop(arg)
+  end
+
+  def self.fynd_loop(cry)
+    lo = cry & 0xffffffff
+    hi = cry & 0xffffffff00000000
+
+    if (cry >= 0x10000) && (cry <= 0xffffffff)
+      0x10000 + tail(cry - 0x10000)
+    elsif (cry >= 0x100000000) && (cry <= 0xffffffffffffffff)
+      hi | fynd_loop(lo)
+    else
+      cry
+    end
+  end
+
+  def self.fynd(arg)
+    fynd_loop(arg)
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: urbit-aura
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew LeVan
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: murmurhash3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+description: Parsing, conversion, and validation for dates, phonetic names, and numbers.
+email:
+- matthew@coeli.network
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/aura.rb
+- lib/muk.rb
+- lib/ob.rb
+homepage: https://github.com/urbit/aura-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/urbit/aura-rb
+  source_code_uri: https://github.com/urbit/aura-rb
+  changelog_uri: https://github.com/urbit/aura-rb/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Urbit aura utilities.
+test_files: []