quran-audio 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc399ffb1f9b7ca57d21c91e2efea8044d2f3f36d48b42263ad3198a1648523a
-  data.tar.gz: 8123974f8d534c884035802c1698e4fcea0ed1c60df2f3b5613cff26c01cbb30
+  metadata.gz: f31510aaf2b2ac45001870411b82eb1e1ff7c8103cdbebb4f9b92268906b4cfb
+  data.tar.gz: 6c54cbdf7ed5493fcb9cc0cf0e84305adae279c2433d5f1e6204ac9ba9af9b38
 SHA512:
-  metadata.gz: 8bedbadb87f13cca4c13c7150fb9ff1b9c5cb6ab5b5c77127495c942ba6d9c83734887de13e0a2abfcfa246e9509b44d573b834933f62212be1da04aba33af12
-  data.tar.gz: 3b5f5404f99cc8d64d817326cc747c36356caf76fabe9fb8c99962effb6fac5e3a3a28a5b086c9903b2df4ccf1a185a1ade01ed0417f9386685827f0284d5e19
+  metadata.gz: c2a714b375cab47aea59c2f03132e291b4f8b617a271e75aeb15b7ee9c07b0835734a35ca3ef99d988604531d4c91a68fdad0aecbebaa184c857a0c0ff123d3a
+  data.tar.gz: a25e352aa4d91b529e9943e07d4a58ed49f4a9c6f40ad56249f60c9a3bc038b929fef304dba2f9da0357bc8a01b7aab7abc32f18498f9150e0fa5c101311e6c8

data/bundle/io-line.rb/lib/io/line/multiple.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class IO::Line::Multiple
+  def initialize(lines, cursor)
+    @lines = lines
+    @cursor = cursor
+  end
+
+  def print(*strs, lineno:)
+    line = @lines[lineno]
+    if lineno > @cursor
+      line.io.cursor_down(lineno - @cursor)
+    elsif lineno < @cursor
+      line.io.cursor_up(lineno + @cursor)
+    end
+    @cursor = lineno
+    line.rewind.print(*strs)
+  end
+end

data/bundle/io-line.rb/lib/io/line.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class IO::Line
+  require "io/console"
+  require_relative "line/multiple"
+
+  VERSION = "0.1.0"
+  attr_reader :io
+
+  def initialize(io)
+    @io = io
+  end
+
+  def print(*strs)
+    tap { @io.print(strs.join.gsub($/, "")) }
+  end
+
+  def end
+    tap { @io.print($/) }
+  end
+
+  def rewind
+    tap do
+      @io.erase_line(2)
+      @io.goto_column(0)
+    end
+  end
+end

data/bundle/ryo.rb/lib/ryo/basic_object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+##
+# {Ryo::BasicObject Ryo::BasicObject} is a Ryo object and subclass
+# of Ruby's BasicObject class that can be created by using
+# {Ryo.BasicObject Ryo.BasicObject()},
+# {Ryo::BasicObject.from Ryo::BasicObject.from}, or
+# {Ryo::BasicObject.create Ryo::BasicObject.create}.
+class Ryo::BasicObject < BasicObject
+  ##
+  # @param props (see Ryo::Builder.build)
+  # @param prototype (see Ryo::Builder.build)
+  # @return [Ryo::BasicObject]
+  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
+  def self.create(props, prototype = nil)
+    ::Ryo::Builder.build(self, props, prototype)
+  end
+
+  ##
+  # Creates a Ryo object by recursively walking a Hash object
+  #
+  # @param props (see Ryo::Builder.recursive_build)
+  # @param prototype (see Ryo::Builder.recursive_build)
+  # @return [Ryo::BasicObject]
+  #  Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
+  def self.from(props, prototype = nil)
+    ::Ryo::Builder.recursive_build(self, props, prototype)
+  end
+
+  ##
+  # Duplicates the internals of a Ryo object
+  #
+  # @param [Ryo::BasicObject] ryo
+  #  A Ryo object
+  # @return [Ryo::BasicObject]
+  #  Returns a Ryo object
+  def initialize_dup(ryo)
+    ::Ryo.set_table_of(self, ::Ryo.table_of(ryo).dup)
+    ::Ryo.extend!(self, ::Ryo)
+  end
+end
+
+##
+# @example
+#  point = Ryo::BasicObject(x: 0, y: 0)
+#  p [point.x, point.y] # => [0, 0]
+#
+# @param props (see Ryo::Builder.build)
+# @param prototype (see Ryo::Builder.build)
+# @return [Ryo::BasicObject]
+#   Returns an instance of {Ryo::BasicObject Ryo::BasicObject}
+def Ryo.BasicObject(props, prototype = nil)
+  Ryo::BasicObject.create(props, prototype)
+end

data/bundle/ryo.rb/lib/ryo/builder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Builder Ryo::Builder} module is responsible for
+# the creation of instances of {Ryo::Object Ryo::Object},
+# and {Ryo::BasicObject Ryo::BasicObject}. This module is
+# not intended to be used directly.
+# @api private
+module Ryo::Builder
+  ##
+  # @note
+  #  When "props" is given as a Ryo object, a duplicate Ryo object is
+  #  returned in its place
+  # @param [<Ryo::Object, Ryo::BasicObject>] buildee
+  # @param [<#each_pair>] props
+  # @param [<Ryo::Object, Ryo::BasicObject>, nil] prototype
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns a Ryo object
+  def self.build(buildee, props, prototype = nil)
+    if Ryo.ryo?(props)
+      build(buildee, Ryo.table_of(props), prototype || Ryo.prototype_of(props))
+    else
+      ryo = buildee.new
+      Ryo.set_prototype_of(ryo, prototype)
+      Ryo.set_table_of(ryo, {})
+      Ryo.extend!(ryo, Ryo)
+      props.each_pair { ryo[_1] = _2 }
+      ryo
+    end
+  end
+
+  ##
+  # Creates a Ryo object by recursively walking a Hash object, or
+  # an Array of Hash objects
+  #
+  # @example
+  #   objects = Ryo.from([{x: 0, y: 0}, "foo", {point: {x: 0, y: 0}}])
+  #   objects[0].x       # => 0
+  #   objects[1]         # => "foo"
+  #   objects[2].point.x # => 0
+  #
+  # @note (see Ryo::Builder.build)
+  # @param (see Ryo::Builder.build)
+  # @return (see Ryo::Builder.build)
+  def self.recursive_build(buildee, props, prototype = nil)
+    if Ryo.ryo?(props)
+      recursive_build(buildee, Ryo.table_of(props), prototype || Ryo.prototype_of(props))
+    elsif !respond_to_each?(props)
+      raise TypeError, "The provided object does not implement #each / #each_pair"
+    elsif !props.respond_to?(:each_pair)
+      map(props) do
+        noop = Ryo.ryo?(_1) || !_1.respond_to?(:each_pair)
+        noop ? _1 : recursive_build(buildee, _1)
+      end
+    else
+      visited = {}
+      props.each_pair { visited[_1] = map_value(buildee, _2) }
+      build(buildee, visited, prototype)
+    end
+  end
+
+  module Private
+    private
+
+    def map_value(buildee, value)
+      if Ryo.ryo?(value) || !respond_to_each?(value)
+        value
+      elsif value.respond_to?(:each_pair)
+        recursive_build(buildee, value)
+      elsif value.respond_to?(:each)
+        map(value) { map_value(buildee, _1) }
+      end
+    end
+
+    def respond_to_each?(value)
+      value.respond_to?(:each) || value.respond_to?(:each_pair)
+    end
+
+    def map(obj)
+      ary = []
+      obj.each { ary.push(yield(_1)) }
+      ary
+    end
+  end
+  private_constant :Private
+  extend Private
+end

data/bundle/ryo.rb/lib/ryo/enumerable.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Enumerable Ryo::Enumerable} module provides methods
+# that are similar to Ruby's Enumerable module, and at the same
+# time - intentionally different.
+#
+# For example: {Ryo::Enumerable Ryo::Enumerable}
+# methods receive 'self' as an argument rather than from the
+# surrounding context. The methods implemented by this
+# module are available as singleton methods on the {Ryo Ryo}
+# module.
+module Ryo::Enumerable
+  ##
+  # The {#each} method iterates through a Ryo object, and
+  # yields two parameters: a key, and a value
+  #
+  # @example
+  #  point_a = Ryo(x: 1, y: 2)
+  #  point_b = Ryo(y: 1)
+  #  Ryo.each(point_b) { p [_1, _2] }
+  #  # ["y", 1]
+  #  # ["y", 2]
+  #  # ["x", 1]
+  #
+  # @param (see #each_ryo)
+  # @return [<Enumerator, Array>]
+  def each(ryo, ancestors: nil)
+    return enum_for(:each, ryo) unless block_given?
+    each_ryo(ryo, ancestors:) do |_, key, value|
+      yield(key, value)
+    end
+  end
+
+  ##
+  # The {#each_ryo} method iterates through a Ryo object,
+  # and its prototypes. {#each_ryo} yields three parameters:
+  # a Ryo object, a key, and a value
+  #
+  # @example
+  #  point_a = Ryo(x: 1, y: 2)
+  #  point_b = Ryo({y: 3}, point_a)
+  #  Ryo.each_ryo(point_b) { |ryo, key, value| p [ryo, key, value] }
+  #  # [point_b, "y", 3]
+  #  # [point_a, "x", 1]
+  #  # [point_a, "y", 2]
+  #
+  # @param [<Ryo::BasicObject, Ryo::Object>] ryo
+  # @param [Integer] ancestors
+  #  "ancestors" is an integer that defines the traversal depth
+  #  of a {Ryo::Enumerable Ryo::Enumerable} method. 0 covers a
+  #  Ryo object, and none of the prototypes in its prototype
+  #  chain. 1 covers a Ryo object, and one of the prototypes
+  #  in its prototype chain - and so on. The default covers
+  #  the entire prototype chain.
+  # @return [<Ryo::BasicObject, Ryo::Object>]
+  def each_ryo(ryo, ancestors: nil)
+    proto_chain = [ryo, *prototype_chain_of(ryo)]
+    ancestors ||= -1
+    proto_chain[0..ancestors].each do |ryo|
+      properties_of(ryo).each do |key|
+        yield(ryo, key, ryo[key])
+      end
+    end
+    ryo
+  end
+
+  ##
+  # The {#map} method creates a copy of a Ryo object,
+  # and then performs a map operation on the copy and
+  # its prototypes
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def map(ryo, ancestors: nil, &b)
+    map!(Ryo.dup(ryo), ancestors:, &b)
+  end
+
+  ##
+  # The {#map!} method performs an in-place map operation
+  # on a Ryo object, and its prototypes
+  #
+  # @example
+  #  point = Ryo(x: 2, y: 4)
+  #  Ryo.map!(point) { _2 * 2 }
+  #  [point.x, point.y]
+  #  # => [4, 8]
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def map!(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
+      ryo[key] = yield(key, value)
+    end
+  end
+
+  ##
+  # The {#select} method creates a copy of a Ryo object, and
+  # then performs a filter operation on the copy and its
+  # prototypes
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def select(ryo, ancestors: nil, &b)
+    select!(Ryo.dup(ryo), ancestors:, &b)
+  end
+
+  ##
+  # The {#select!} method performs an in-place filter operation
+  # on a Ryo object, and its prototypes
+  #
+  # @example
+  #  point_a = Ryo(x: 1, y: 2, z: 3)
+  #  point_b = Ryo({z: 4}, point_a)
+  #  Ryo.select!(point_b) { |key, value| %w(x y).include?(key) }
+  #  [point_b.x, point_b.y, point_b.z]
+  #  # => [1, 2, nil]
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def select!(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
+      delete(ryo, key) unless yield(key, value)
+    end
+  end
+
+  ##
+  # The {#reject} method creates a copy of a Ryo object, and then
+  # performs a filter operation on the copy and its prototypes
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def reject(ryo, ancestors: nil, &b)
+    reject!(Ryo.dup(ryo), ancestors:, &b)
+  end
+
+  ##
+  # The {#reject!} method performs an in-place filter operation
+  # on a Ryo object, and its prototypes
+  #
+  # @example
+  #  point_a = Ryo(x: 1, y: 2, z: 3)
+  #  point_b = Ryo({z: 4}, point_a)
+  #  Ryo.reject!(point_b) { |key, value| value > 2 }
+  #  [point_b.x, point_b.y, point_b.z]
+  #  # => [1, 2, nil]
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  def reject!(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
+      delete(ryo, key) if yield(key, value)
+    end
+  end
+
+  ##
+  # @param (see #each_ryo)
+  # @return [Boolean]
+  #  Returns true when the given block evaluates to
+  #  a truthy value for at least one iteration
+  def any?(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |_, key, value|
+      return true if yield(key, value)
+    end
+    false
+  end
+
+  ##
+  # @param (see #each_ryo)
+  # @return [Boolean]
+  #  Returns true when the given block evaluates to a
+  #  truthy value for every iteration
+  def all?(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |_, key, value|
+      return false unless yield(key, value)
+    end
+    true
+  end
+
+  ##
+  # @example
+  #  point_a = Ryo(x: 5)
+  #  point_b = Ryo({y: 10}, point_a)
+  #  point_c = Ryo({z: 15}, point_b)
+  #  ryo = Ryo.find(point_c) { |key, value| value == 5 }
+  #  ryo == point_a # => true
+  #
+  # @param (see #each_ryo)
+  # @return [<Ryo::Object, Ryo::BasicObject>, nil]
+  #  Returns a Ryo object, or nil
+  def find(ryo, ancestors: nil)
+    each_ryo(ryo, ancestors:) do |ryo, key, value|
+      return ryo if yield(key, value)
+    end
+    nil
+  end
+end

data/bundle/ryo.rb/lib/ryo/function.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Function Ryo::Function} class represents a Ryo
+# function. The class is usually not used directly but through
+# {Ryo::Keywords#fn Ryo.fn}. A Ryo function has a special relationship
+# with Ryo objects: when a Ryo function is assigned as a property
+# on a Ryo object - the "self" of the function becomes bound to the
+# Ryo object.
+class Ryo::Function
+  ##
+  # @param [Proc] body
+  #  The body of the function as a block.
+  #
+  # @return [Ryo::Function]
+  #  Returns an instance of {Ryo::Function Ryo::Function}.
+  def initialize(&body)
+    @body = body
+    @ryo = nil
+    @to_proc = nil
+  end
+
+  ##
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns the object that the function's "self" is bound to.
+  def receiver
+    @ryo
+  end
+  alias_method :self, :receiver
+
+  ##
+  # Change the receiver (self) of the function.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object.
+  #
+  # @return [nil]
+  def bind!(ryo)
+    @ryo = ryo
+    @to_proc = nil
+  end
+
+  ##
+  # Call the function.
+  def call(...)
+    to_proc.call(...)
+  end
+
+  ##
+  # @return [Proc]
+  #  Returns the function as a lambda bound to {#receiver}.
+  def to_proc
+    @to_proc ||= lambda!(@body)
+  end
+
+  private
+
+  def lambda!(body)
+    ryo, lambda = @ryo, nil
+    Module.new do
+      define_method(:__function__, &body)
+      lambda = instance_method(:__function__)
+               .bind(ryo)
+               .to_proc
+    end
+    lambda
+  end
+end

data/bundle/ryo.rb/lib/ryo/json.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::JSON Ryo::JSON} module provides a number of methods
+# for coercing JSON data into a Ryo object. It must be required
+# separately to Ryo (ie: require "ryo/json"), and the methods of
+# this module are then available on the {Ryo Ryo} module.
+module Ryo::JSON
+  require "json"
+  extend self
+
+  ##
+  # @example
+  #   Ryo.from_json(path: "/foo/bar/baz.json")
+  #   Ryo.from_json(string: "[]")
+  #
+  # @param [String] path
+  #  The path to a JSON file
+  #
+  # @param [String] string
+  #  A blob of JSON
+  #
+  # @param [Ryo] object
+  #  {Ryo::Object Ryo::Object}, or {Ryo::BasicObject Ryo::BasicObject}
+  #  Defaults to {Ryo::Object Ryo::Object}
+  #
+  # @raise [SystemCallError]
+  #  Might raise a number of Errno exceptions
+  #
+  # @return [Ryo::Object, Ryo::BasicObject]
+  #  Returns a Ryo object
+  def from_json(path: nil, string: nil, object: Ryo::Object)
+    if path && string
+      raise ArgumentError, "Provide a path or string but not both"
+    elsif path
+      object.from JSON.parse(File.binread(path))
+    elsif string
+      object.from JSON.parse(string)
+    else
+      raise ArgumentError, "No path or string provided"
+    end
+  end
+
+  Ryo.extend(self)
+end

data/bundle/ryo.rb/lib/ryo/keywords.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Keywords Ryo::Keywords} module implements Ryo equivalents
+# for some of JavaScript's keywords (eg: the **in** and **delete** operators).
+# The instance methods of this module are available as singleton
+# methods on the {Ryo} module.
+module Ryo::Keywords
+  ##
+  # @example
+  #   point = Ryo(x: 0, y: 0, print: Ryo.fn { print x, y, "\n" })
+  #   point.print.()
+  #
+  # @param [Proc] b
+  #  The function's body.
+  #
+  # @return [Ryo::Function]
+  #  Returns a Ryo function.
+  #
+  # @see Ryo::Function Ryo::Function
+  def fn(&b)
+    Ryo::Function.new(&b)
+  end
+  alias_method :function, :fn
+
+  ##
+  # Equivalent to JavaScript's **in** operator
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  A property name
+  # @return [Boolean]
+  #  Returns true when **property** is a member of **ryo**, or its prototype chain
+  def in?(ryo, property)
+    return false unless ryo
+    property?(ryo, property) || in?(prototype_of(ryo), property)
+  end
+
+  ##
+  # The {#delete} method deletes a property from a Ryo object
+  # @see Ryo::Reflect#delete!
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  A property name
+  # @param [Integer] ancestors
+  #  The number of prototypes to traverse.
+  #  Defaults to the entire prototype chain.
+  # @return [void]
+  def delete(ryo, property, ancestors: nil)
+    each_ryo(ryo, ancestors:) do
+      Ryo.property?(_1, property) ? table_of(_1).delete(property) : nil
+    end
+  end
+end

data/bundle/ryo.rb/lib/ryo/memo.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Ryo::Memo < Ryo::Function
+end

data/bundle/ryo.rb/lib/ryo/object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+##
+# {Ryo::Object Ryo::Object} is a Ryo object and subclass of
+# Ruby's Object class that can be created by using
+# [Ryo()](https://0x1eef.github.io/x/ryo.rb/top-level-namespace.html#Ryo-instance_method),
+# {Ryo.Object Ryo.Object()}, {Ryo::Object.from Ryo::Object.from},
+# or {Ryo::Object.create Ryo::Object.create}.
+class Ryo::Object
+  ##
+  # @param props (see Ryo::Builder.build)
+  # @param prototype (see Ryo::Builder.build)
+  # @return [Ryo::Object]
+  #  Returns an instance of {Ryo::Object Ryo::Object}
+  def self.create(props, prototype = nil)
+    Ryo::Builder.build(self, props, prototype)
+  end
+
+  ##
+  # Creates a Ryo object by recursively walking a Hash object
+  #
+  # @param props (see Ryo::Builder.recursive_build)
+  # @param prototype (see Ryo::Builder.recursive_build)
+  # @return [Ryo::Object]
+  #  Returns an instance of {Ryo::Object Ryo::Object}.
+  def self.from(props, prototype = nil)
+    Ryo::Builder.recursive_build(self, props, prototype)
+  end
+
+  ##
+  # Duplicates the internals of a Ryo object
+  #
+  # @param [Ryo::Object] ryo
+  #  A Ryo object
+  # @return [Ryo::Object]
+  #  Returns a Ryo object
+  def initialize_dup(ryo)
+    Ryo.set_table_of(self, Ryo.table_of(ryo).dup)
+    Ryo.extend!(self, Ryo)
+  end
+end
+
+##
+# @example
+#  point = Ryo::Object(x: 0, y: 0)
+#  p [point.x, point.y] # => [0, 0]
+#
+# @param props (see Ryo::Builder.build)
+# @param prototype (see Ryo::Builder.build)
+# @return [Ryo::Object]
+#   Returns an instance of {Ryo::Object Ryo::Object}
+def Ryo.Object(props, prototype = nil)
+  Ryo::Object.create(props, prototype)
+end

data/bundle/ryo.rb/lib/ryo/reflect.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Reflect Ryo::Reflect} module mirrors
+# JavaScript's [`Relfect` object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect),
+# and some of the static methods on JavaScript's
+# [`Object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+# as well.
+#
+# {Ryo::Reflect Ryo::Reflect} also implements Ryo-specific
+# reflection features. The instance methods of this module
+# are available as singleton methods on the {Ryo Ryo}
+# module.
+module Ryo::Reflect
+  extend self
+
+  ##
+  # @group JavaScript equivalents (Reflect)
+
+  ##
+  # Equivalent to JavaScript's `Reflect.getPrototypeOf`
+  #
+  # @param [Ryo] ryo
+  #  A Ryo object.
+  #
+  # @return [Ryo, nil]
+  #  Returns the prototype of the *ryo* object.
+  def prototype_of(ryo)
+    kernel(:instance_variable_get)
+      .bind_call(ryo, :@_proto)
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.setPrototypeOf`
+  #
+  # @param [Ryo] ryo
+  #  A Ryo object.
+  #
+  # @param [Ryo] prototype
+  #  The prototype to assign to *ryo*.
+  #
+  # @return [nil]
+  def set_prototype_of(ryo, prototype)
+    kernel(:instance_variable_set)
+      .bind_call(ryo, :@_proto, prototype)
+    nil
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.defineProperty`
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  The name of a property
+  # @param [Object, BasicObject] value
+  #  The property's value
+  # @return [void]
+  def define_property(ryo, property, value)
+    table, property = table_of(ryo), property.to_s
+    kernel(:tap).bind_call(value) { _1.bind!(ryo) if function?(_1) }
+    table[property] = value
+    # Define setter
+    if !setter_defined?(ryo, property) && property[-1] != "?"
+      define_method!(ryo, "#{property}=") { ryo[property] = _1 }
+    end
+    # Define getter
+    return if getter_defined?(ryo, property)
+    define_method!(ryo, property) { |*args, &b|
+      (args.empty? && b.nil?) ? ryo[property] :
+                              super(*args, &b)
+    }
+    nil
+  end
+
+  ##
+  # Equivalent to JavaScript's `Reflect.ownKeys`, and
+  # JavaScript's `Object.keys`
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @return [Array<String>]
+  #  Returns the properties defined on a Ryo object
+  def properties_of(ryo)
+    table_of(ryo).keys
+  end
+
+  # @endgroup
+
+  ##
+  # @group JavaScript equivalents (Object)
+
+  ##
+  # Equivalent to JavaScript's `Object.hasOwn`,
+  # and `Object.prototype.hasOwnProperty`.
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  The name of a property
+  # @return [Boolean]
+  #  Returns true when the property is a member of a Ryo object
+  def property?(ryo, property)
+    table_of(ryo).key?(property.to_s)
+  end
+
+  ##
+  # Equivalent to JavaScript's `Object.assign`.
+  #
+  # @param [Ryo, Hash, #to_hash] target
+  #  The target object
+  # @param [Ryo, Hash, #to_hash] sources
+  #  A variable number of source objects that
+  #  will be merged with the target object
+  # @return [Ryo]
+  #  Returns the modified target object.
+  def assign(target, *sources)
+    sources.each do |source|
+      to_hash(source).each { target[_1.to_s] = _2 }
+    end
+    target
+  end
+  # @endgroup
+
+  ##
+  # @group Ryo-specific
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @return [Array<Ryo::Object, Ryo::BasicObject>]
+  #  Returns the prototype chain of a Ryo object
+  def prototype_chain_of(ryo)
+    prototypes = []
+    loop do
+      ryo = prototype_of(ryo)
+      break unless ryo
+      prototypes.push(ryo)
+    end
+    prototypes
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [Boolean] recursive
+  #  When true, nested Ryo objects are replaced by
+  #  their table as well
+  # @return [Hash]
+  #  Returns the table of a Ryo object
+  def table_of(ryo, recursive: false)
+    table = kernel(:instance_variable_get).bind_call(ryo, :@_table)
+    if recursive
+      table.each do |key, value|
+        if ryo?(value)
+          table[key] = table_of(value, recursive:)
+        elsif value.respond_to?(:each)
+          table[key] = value.respond_to?(:each_pair) ?
+                       value : value.map { table_of(_1, recursive:) }
+        end
+      end
+    end
+    table
+  end
+
+  ##
+  # Sets the table of a Ryo object
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [Hash] table
+  #  The table
+  # @return [nil]
+  def set_table_of(ryo, table)
+    kernel(:instance_variable_set)
+      .bind_call(ryo, :@_table, table)
+    nil
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, Symbol>] method
+  #  The name of a method
+  # @param [::Object, ::BasicObject] args
+  #  Zero or more method arguments
+  # @param [Proc] b
+  #  An optional block
+  # @return [::Object, ::BasicObject]
+  def call_method(ryo, method, *args, &b)
+    kernel(:__send__)
+      .bind_call(ryo, method, *args, &b)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @return [Class]
+  #  Returns the class of a Ryo object
+  def class_of(ryo)
+    kernel(:class).bind_call(ryo)
+  end
+
+  ##
+  # @param [Ryo::Function, Object, BasicObject] obj
+  #  An object
+  # @return [Boolean]
+  #  Returns true when given a Ryo function
+  def function?(obj)
+    Ryo::Function === obj
+  end
+
+  ##
+  # @param [Ryo::Function, Object, BasicObject] obj
+  #  An object
+  # @return [Boolean]
+  #  Returns true when given a Ryo memo
+  def memo?(obj)
+    Ryo::Memo === obj
+  end
+  alias_method :lazy?, :memo?
+
+  ##
+  # @example
+  #  Ryo.ryo?(Ryo::Object(x: 5, y: 12))       # => true
+  #  Ryo.ryo?(Ryo::BasicObject(x: 10, y: 20)) # => true
+  #  Ryo.ryo?(Object.new) # => false
+  #
+  # @param [Object, BasicObject] obj
+  #  An object
+  # @return [Boolean]
+  #  Returns true when given a Ryo object
+  def ryo?(obj)
+    Ryo === obj
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo1
+  #  A Ryo object
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo2
+  #  A Ryo object
+  # @return [Boolean]
+  #  Returns true when the two Ryo objects are strictly equal
+  def equal?(ryo1, ryo2)
+    kernel(:equal?).bind_call(ryo1, ryo2)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @return [String]
+  #  Returns a String representation of a Ryo object
+  def inspect_object(ryo)
+    format(
+      "#<Ryo object=%{object} proto=%{proto} table=%{table}>",
+      object: Object.instance_method(:to_s).bind_call(ryo),
+      proto: prototype_of(ryo).inspect,
+      table: table_of(ryo).inspect
+    )
+  end
+  # @endgroup
+
+  include Ryo::Utils
+end

data/bundle/ryo.rb/lib/ryo/utils.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::Utils Ryo::Utils} module provides utility
+# methods that are internal to Ryo. This module
+# and its methods should not be used directly.
+# @api private
+module Ryo::Utils
+  private
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, Symbol>] method
+  #  The name of a method
+  # @param [Proc] b
+  #  The method's implementation
+  def define_method!(ryo, method, &b)
+    kernel(:define_singleton_method)
+      .bind_call(ryo, method, &b)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  The name of a property
+  # @return [Boolean]
+  #  Returns true for a Ryo property that has a
+  #  corresponding getter method implemented by Ryo
+  def getter_defined?(ryo, property)
+    path = kernel(:method)
+      .bind_call(ryo, property)
+      .source_location
+      &.dig(0)
+    path ? File.dirname(path) == File.dirname(__FILE__) : false
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [<String, #to_s>] property
+  #  The name of a property
+  # @return [Boolean]
+  #  Returns true for a Ryo property that has a
+  #  corresponding setter method implemented by Ryo
+  def setter_defined?(ryo, property)
+    getter_defined?(ryo, "#{property}=")
+  end
+
+  def merge!(obj1, obj2)
+    obj1, obj2 = to_hash(obj1), to_hash(obj2)
+    obj2.each { obj1[_1.to_s] = _2 }
+    obj1
+  end
+
+  def to_hash(obj)
+    if ryo?(obj)
+      table_of(obj)
+    else
+      Hash.try_convert(obj)
+    end
+  end
+
+  def kernel(name)
+    Module.instance_method(name)
+  end
+end

data/bundle/ryo.rb/lib/ryo/version.rb

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

data/bundle/ryo.rb/lib/ryo/yaml.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo::YAML Ryo::YAML} module provides a number of methods
+# for coercing YAML data into a Ryo object. It must be required
+# separately to Ryo (ie: require "ryo/yaml"), and the methods of
+# this module are then available on the {Ryo Ryo} module.
+module Ryo::YAML
+  require "yaml"
+  extend self
+
+  ##
+  # @example
+  #   Ryo.from_yaml(path: "/foo/bar/baz.yaml")
+  #   Ryo.from_yaml(string: "---\nfoo: bar\n")
+  #
+  # @param [String] path
+  #  The path to a YAML file
+  #
+  # @param [String] string
+  #  A blob of YAML
+  #
+  # @param [Ryo] object
+  #  {Ryo::Object Ryo::Object}, or {Ryo::BasicObject Ryo::BasicObject}
+  #  Defaults to {Ryo::Object Ryo::Object}
+  #
+  # @raise [SystemCallError]
+  #  Might raise a number of Errno exceptions
+  #
+  # @return [Ryo::Object, Ryo::BasicObject]
+  #  Returns a Ryo object
+  def from_yaml(path: nil, string: nil, object: Ryo::Object)
+    if path && string
+      raise ArgumentError, "Provide a path or string but not both"
+    elsif path
+      object.from YAML.load_file(path)
+    elsif string
+      object.from YAML.load(string)
+    else
+      raise ArgumentError, "No path or string provided"
+    end
+  end
+
+  Ryo.extend(self)
+end

data/bundle/ryo.rb/lib/ryo.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+##
+# The {Ryo Ryo} module implements most of its behavior as singleton methods
+# that are inherited from the {Ryo::Reflect Ryo::Reflect}, and
+# {Ryo::Keywords Ryo:Keywords} modules.
+#
+# @example
+#   # Ryo.delete
+#   point = Ryo(x: 0, y: 0)
+#   Ryo.delete(point, "x")
+#   point.x # => nil
+#
+#   # Ryo.assign
+#   point = Ryo.assign(Ryo({}), {x: 0}, {y: 0})
+#   point.x # => 0
+module Ryo
+  require_relative "ryo/utils"
+  require_relative "ryo/reflect"
+  require_relative "ryo/keywords"
+  require_relative "ryo/builder"
+  require_relative "ryo/basic_object"
+  require_relative "ryo/object"
+  require_relative "ryo/function"
+  require_relative "ryo/memo"
+  require_relative "ryo/enumerable"
+
+  extend Ryo::Reflect
+  extend Ryo::Keywords
+  extend Ryo::Enumerable
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @param [Module] mod
+  #  The module to extend a Ryo object with
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns an extended Ryo object
+  def self.extend!(ryo, mod)
+    kernel(:extend).bind_call(ryo, mod)
+  end
+
+  ##
+  # Duplicates a Ryo object, and its prototype(s).
+  #
+  # @param [<Ryo::Object, Ryo::BasicObject>] ryo
+  #  A Ryo object
+  # @return [<Ryo::Object, Ryo::BasicObject>]
+  #  Returns a duplicated Ryo object
+  def self.dup(ryo)
+    duplicate = extend!(
+      kernel(:dup).bind_call(ryo),
+      self
+    )
+    if proto = prototype_of(duplicate)
+      set_prototype_of(duplicate, dup(proto))
+    end
+    duplicate
+  end
+
+  ##
+  # Creates a memoized Ryo value
+  #
+  # @param [Proc] b
+  #  A Proc that is memoized after being accessed for the first time
+  # @return [Ryo::Memo]
+  #  Returns an instance of {Ryo::Memo Ryo::Memo}
+  def self.memo(&b)
+    Ryo::Memo.new(&b)
+  end
+  class << Ryo
+    alias_method :lazy, :memo
+  end
+
+  ##
+  # Creates a Ryo object by recursively walking a Hash object
+  #
+  # @param props (see Ryo::Builder.build)
+  # @param prototype (see Ryo::Builder.build)
+  # @return [Ryo::Object]
+  #  Returns an instance of {Ryo::Object Ryo::Object}
+  def self.from(props, prototype = nil)
+    Ryo::Object.from(props, prototype)
+  end
+
+  ##
+  # @return [<Ryo::Object, Ryo::BasicObject>, nil]
+  #  Returns the prototype of self, or nil if self has no prototype
+  def __proto__
+    @_proto
+  end
+
+  ##
+  # @note
+  #  This method will first look for a property on self,
+  #  and if it is not found then it will forward the query
+  #  onto `Ryo#__proto__`
+  # @param [String] property
+  #  The name of a property
+  # @return [<Object, BasicObject>, nil]
+  #  Returns the property's value, or nil
+  def [](property)
+    property = property.to_s
+    if Ryo.property?(self, property)
+      v = @_table[property]
+      Ryo.memo?(v) ? self[property] = v.call : v
+    else
+      return unless @_proto
+      Ryo.call_method(@_proto, property)
+    end
+  end
+
+  ##
+  # Assign a property
+  #
+  # @param [String] property
+  #  The name of a property
+  # @param [<Object,BasicObject>] value
+  # @return [void]
+  def []=(property, value)
+    Ryo.define_property(self, property.to_s, value)
+  end
+
+  ##
+  # @param [<Ryo::Object, Ryo::BasicObject>, Hash, #to_h] other
+  # @return [Boolean]
+  #  Returns true **other** is equal to self
+  def ==(other)
+    if Ryo.ryo?(other)
+      @_table == Ryo.table_of(other)
+    else
+      other = Hash.try_convert(other)
+      return false unless other
+      @_table == other.map { [_1.to_s, _2] }.to_h
+    end
+  end
+  alias_method :eql?, :==
+
+  ##
+  # @return [String]
+  #  Returns a String representation of a Ryo object
+  def inspect
+    Ryo.inspect_object(self)
+  end
+
+  ##
+  # @return [Hash]
+  #  Returns the lookup table of a Ryo object
+  def to_h
+    Ryo.table_of(self, recursive: true)
+  end
+  alias_method :to_hash, :to_h
+
+  ##
+  # @private
+  def pretty_print(q)
+    q.text(inspect)
+  end
+
+  ##
+  # @private
+  def respond_to?(property, include_all = false)
+    respond_to_missing?(property, include_all)
+  end
+
+  ##
+  # @private
+  def respond_to_missing?(property, include_all = false)
+    true
+  end
+
+  ##
+  # @private
+  def method_missing(name, *args, &b)
+    property = name.to_s
+    if property[-1] == "="
+      property = property[0..-2]
+      self[property] = args.first
+    elsif Ryo.property?(self, property)
+      self[property]
+    elsif @_proto
+      Ryo.call_method(@_proto, name, *args, &b)
+         .tap { _1.bind!(self) if Ryo.function?(_1) }
+    end
+  end
+end
+
+##
+# @param props (see Ryo::Builder.build)
+# @param prototype (see Ryo::Builder.build)
+# @return [Ryo::Object]
+#  Returns a Ryo object
+def Ryo(props, prototype = nil)
+  Ryo::Object.create(props, prototype)
+end

data/share/quran-audio/VERSION

@@ -1 +1 @@
-v0.4.1
+v0.4.2

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quran-audio
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - '0x1eef'
@@ -119,6 +119,21 @@ files:
 - LICENSE
 - README.md
 - bin/quran-audio
+- bundle/io-line.rb/lib/io/line.rb
+- bundle/io-line.rb/lib/io/line/multiple.rb
+- bundle/ryo.rb/lib/ryo.rb
+- bundle/ryo.rb/lib/ryo/basic_object.rb
+- bundle/ryo.rb/lib/ryo/builder.rb
+- bundle/ryo.rb/lib/ryo/enumerable.rb
+- bundle/ryo.rb/lib/ryo/function.rb
+- bundle/ryo.rb/lib/ryo/json.rb
+- bundle/ryo.rb/lib/ryo/keywords.rb
+- bundle/ryo.rb/lib/ryo/memo.rb
+- bundle/ryo.rb/lib/ryo/object.rb
+- bundle/ryo.rb/lib/ryo/reflect.rb
+- bundle/ryo.rb/lib/ryo/utils.rb
+- bundle/ryo.rb/lib/ryo/version.rb
+- bundle/ryo.rb/lib/ryo/yaml.rb
 - lib/quran/audio.rb
 - lib/quran/audio/command.rb
 - lib/quran/audio/command/ls.rb