foobara-util 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d375fa882a7b34d39a4188c9c99b821770ab1edd6e843b78b9c4b5e3d755b4a
+  data.tar.gz: 4d8e3d0edd444bbc78139507cf8b7158e9d947717dd8dc1b83777393e62b3ca9
+SHA512:
+  metadata.gz: 9fc109812e2f721642f6e9728f0cf942b5a75179f0b86e5cd8aeaac7a71339e07571aa055d8da7992bc87f411e42f5a7115a789fdf89daf38093264e3173ab2b
+  data.tar.gz: db0ac6f424dd18fdbf4a675d67caec1ac46b001513cc19278e7ead296f667331371d98850f6024e65f63b33b60c4304ae60d51808d717900df2f4bdbc1f5a6df

data/LICENSE.txt

@@ -0,0 +1,8 @@
+foobara-util is dual licensed under your choice of the Apache-2.0 license and the MIT license.
+
+Apache-2.0 License: LICENSE-APACHE.txt or https://www.apache.org/licenses/LICENSE-2.0.txt
+MIT License: LICENSE-MIT.txt or https://opensource.org/licenses/MIT
+
+This is equivalent to the following SPDX License Expression: Apache-2.0 OR MIT
+
+Copyright (c) 2023 Miles Georgi

data/lib/foobara/truncated_inspect.rb

@@ -0,0 +1,65 @@
+module Foobara
+  module TruncatedInspect
+    class << self
+      attr_accessor :truncated
+
+      def truncating(object)
+        if truncated
+          if truncated.include?(object)
+            "..."
+          else
+            truncated << object
+            yield
+          end
+        else
+          begin
+            self.truncated = Set[object]
+            yield
+          ensure
+            self.truncated = nil
+          end
+        end
+      end
+    end
+
+    MAX_LENGTH = 200
+
+    def inspect
+      TruncatedInspect.truncating(self) do
+        instance_vars = instance_variables.map do |var|
+          truncate = false
+
+          value = instance_variable_get(var)
+
+          is_array = value.is_a?(::Array)
+          is_hash = value.is_a?(::Hash)
+
+          if is_array
+            truncate = value.size > 10 || value.any? { |v| v.is_a?(::Array) || v.is_a?(::Hash) }
+          elsif is_hash
+            truncate = value.size > 10 || value.keys.any? { |k| !k.is_a?(::Symbol) && !k.is_a?(::String) }
+            truncate ||= value.values.any? { |v| v.is_a?(::Array) || v.is_a?(::Hash) }
+          end
+
+          value = if truncate
+                    is_array ? "[...]" : "{...}"
+                  else
+                    value.inspect
+                  end
+
+          "#{var}=#{value}"
+        end
+
+        instance_vars = instance_vars.join(", ")
+
+        result = "#<#{self.class.name}:0x#{object_id.to_s(16)} #{instance_vars}>"
+
+        if result.size > MAX_LENGTH
+          result = "#{result[0..(MAX_LENGTH - 5)]}...>"
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/foobara/util/args.rb

@@ -0,0 +1,105 @@
+module Foobara
+  module Util
+    module_function
+
+    def args_and_opts_to_opts(args, opts)
+      unless args.is_a?(::Array)
+        # :nocov:
+        raise ArgumentError, "args must be an array of 0 or 1 hashes but received #{args}"
+        # :nocov:
+      end
+
+      unless opts.is_a?(::Hash)
+        # :nocov:
+        raise ArgumentError, "opts must be a hash not a #{opts.class}"
+        # :nocov:
+      end
+
+      case args.size
+      when 0
+        opts
+      when 1
+        arg = args.first
+
+        if opts && !opts.empty?
+          unless arg.is_a?(::Hash)
+            # :nocov:
+            raise ArgumentError, "opts must be a hash not a #{arg.class}"
+            # :nocov:
+          end
+
+          arg.merge(opts)
+        else
+          arg
+        end
+      else
+        # :nocov:
+        raise ArgumentError, "args must be an array of 0 or 1 hashes but received #{args}"
+        # :nocov:
+      end
+    end
+
+    def arg_and_opts_to_arg(arg, opts)
+      if arg && !arg.empty?
+        if opts && !opts.empty?
+          unless opts.is_a?(::Hash)
+            # :nocov:
+            raise ArgumentError, "opts must be a hash not a #{opts}"
+            # :nocov:
+          end
+
+          unless arg.is_a?(::Hash)
+            # :nocov:
+            raise ArgumentError, "arg must be a hash if present when opts is present"
+            # :nocov:
+          end
+
+          arg.merge(opts)
+        else
+          arg
+        end
+      elsif opts && !opts.empty?
+        opts
+      end
+    end
+
+    # Strange utility method here...
+    # idea is there's a method that takes 0 or 1 arguments which may or may not be a hash.
+    # To make sure we don't act like there's an argument when there's not or fail to combine
+    # parts of the hash that wind up in opts, this method comines it into an array of 0 or 1
+    # argument with stuff merged into the argument if needed.
+    def args_and_opts_to_args(args, opts)
+      unless args.is_a?(::Array)
+        # :nocov:
+        raise ArgumentError, "args must be an array of 0 or 1 hashes but received #{args}"
+        # :nocov:
+      end
+
+      case args.size
+      when 0
+        Util.array(arg_and_opts_to_arg(nil, opts))
+      when 1
+        # Do not go from 1 argument to 0. ie, [nil] should return [nil] not [].
+        if opts && !opts.empty?
+          arg = args.first
+
+          unless arg.is_a?(::Hash)
+            # :nocov:
+            raise ArgumentError, "Expected #{arg.inspect} to be a Hash"
+            # :nocov:
+          end
+
+          [arg_and_opts_to_arg(args.first, opts)]
+        else
+          args
+        end
+
+        [arg_and_opts_to_arg(args.first, opts)]
+      else
+        # :nocov:
+        raise ArgumentError, "args must be an array of 0 or 1 hashes but received #{args}"
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/foobara/util/array.rb

@@ -0,0 +1,40 @@
+module Foobara
+  module Util
+    module_function
+
+    def power_set(array)
+      return [[]] if array.empty?
+
+      head, *tail = array
+      subsets = power_set(tail)
+      subsets + subsets.map { |subset| [head, *subset] }
+    end
+
+    def array(object)
+      case object
+      when nil
+        []
+      when Array
+        object
+      else
+        [object]
+      end
+    end
+
+    def all_symbolic_elements?(array)
+      array.all? { |key| key.is_a?(Symbol) || key.is_a?(String) }
+    end
+
+    def all_symbolizable_elements?(array)
+      array.all? { |key| key.is_a?(Symbol) || key.is_a?(String) }
+    end
+
+    def all_blank_or_false?(array)
+      array.all? do |element|
+        element.nil? || element == false || (
+          (element.is_a?(::Hash) || element.is_a?(::Array) || element.is_a?(::String)) && element.empty?
+        )
+      end
+    end
+  end
+end

data/lib/foobara/util/class.rb

@@ -0,0 +1,33 @@
+module Foobara
+  module Util
+    module_function
+
+    def descendants(klass)
+      all = Set.new
+
+      klass.subclasses.each do |subclass|
+        all << subclass
+        all |= descendants(subclass)
+      end
+
+      all
+    end
+
+    # WARNING: This approach is known as being slow. Probably better for you class to track its own instances
+    # if this is being used for smoething more than debugging.
+    def instances(klass)
+      ObjectSpace.each_object(klass).to_a
+    end
+
+    # Kind of surprising that Ruby doesn't have a built in way to do this.
+    def super_method_of(current_instance, from_class, method_name)
+      method = current_instance.method(method_name)
+      method = method.super_method until method.owner == from_class
+      method.super_method
+    end
+
+    def super_method_takes_parameters?(current_instance, from_class, method_name)
+      super_method_of(current_instance, from_class, method_name).parameters.any?
+    end
+  end
+end

data/lib/foobara/util/hash.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module Util
+    module_function
+
+    def symbolize_keys(hash)
+      unless all_symbolizable_keys?(hash)
+        # :nocov:
+        raise "Cannot symbolize keys for #{hash} because they are not all symbolizable"
+        # :nocov:
+      end
+
+      hash.transform_keys(&:to_sym)
+    end
+
+    def symbolize_keys!(hash)
+      unless all_symbolizable_keys?(hash)
+        # :nocov:
+        raise "Cannot symbolize keys for #{hash} because they are not all symbolizable"
+        # :nocov:
+      end
+
+      hash.transform_keys!(&:to_sym)
+    end
+
+    def all_symbolic_keys?(hash)
+      all_symbolic_elements?(hash.keys)
+    end
+
+    def all_symbolizable_keys?(hash)
+      all_symbolizable_elements?(hash.keys)
+    end
+
+    def remove_empty(hash)
+      hash.reject { |_k, v| (v.is_a?(::Hash) || v.is_a?(::Array)) && v.empty? }
+    end
+
+    def remove_blank(hash)
+      remove_empty(hash).compact
+    end
+  end
+end

data/lib/foobara/util/meta.rb

@@ -0,0 +1,83 @@
+module Foobara
+  module Util
+    class ParentModuleDoesNotExistError < StandardError
+      attr_reader :name, :parent_name
+
+      def initialize(name:, parent_name:)
+        @name = name
+        @parent_name = parent_name
+
+        super("Parent module #{parent_name} does not exist for #{name}.")
+      end
+    end
+
+    module_function
+
+    def make_class(name, superclass = nil, which: :class, tag: false, &block)
+      name = name.to_s if name.is_a?(::Symbol)
+
+      if superclass.is_a?(Class)
+        superclass = superclass.name
+      end
+
+      inherit = superclass ? " < ::#{superclass}" : ""
+
+      superclass ||= :Object
+
+      name = name[2..] if name.start_with?("::")
+
+      already_exists = Object.const_defined?(name, false)
+
+      if !already_exists && tag
+        should_tag = true
+      end
+
+      parent_name = parent_module_name_for(name)
+
+      if parent_name && !Object.const_defined?(parent_name, false)
+        raise ParentModuleDoesNotExistError.new(name:, parent_name:)
+      end
+
+      unless already_exists
+        # rubocop:disable Security/Eval, Style/DocumentDynamicEvalDefinition
+        eval(<<~RUBY, binding, __FILE__, __LINE__ + 1)
+          #{which} ::#{name}#{inherit}
+          end
+        RUBY
+        # rubocop:enable Security/Eval, Style/DocumentDynamicEvalDefinition
+      end
+
+      klass = Object.const_get(name, false)
+
+      if should_tag
+        klass.instance_variable_set(:@foobara_created_via_make_class, true)
+      end
+
+      if block
+        if klass.is_a?(::Class)
+          klass.class_eval(&block)
+        else
+          klass.module_eval(&block)
+        end
+      end
+
+      klass
+    end
+
+    def make_class_p(name, superclass = nil, which: :class, tag: false, &)
+      make_class(name, superclass, which:, tag:, &)
+    rescue ParentModuleDoesNotExistError => e
+      make_class_p(e.parent_name, which: :module, tag:, &)
+      make_class(name, superclass, which:, tag:, &)
+    end
+
+    # TODO: Kind of weird that make_module is implemented in terms of make_class instead of the other way around
+    def make_module(name, &)
+      make_class(name, which: :module, &)
+    end
+
+    def make_module_p(name, tag: false, &)
+      make_class_p(name, which: :module, tag:, &)
+    end
+  end
+end

data/lib/foobara/util/module.rb

@@ -0,0 +1,94 @@
+module Foobara
+  module Util
+    module_function
+
+    def module_for(mod)
+      name = mod.name
+
+      return unless name
+
+      name = parent_module_name_for(mod.name)
+      Object.const_get(name) if name
+    end
+
+    def parent_module_name_for(module_name)
+      module_name[/(.*)::/, 1]
+    end
+
+    def non_full_name(mod)
+      name = if mod.is_a?(::String)
+               mod
+             else
+               mod.name
+             end
+
+      name&.[](/([^:]+)\z/, 1)
+    end
+
+    def non_full_name_underscore(mod)
+      underscore(non_full_name(mod))
+    end
+
+    def constant_value(mod, constant, inherit: false)
+      if mod.constants(inherit).include?(constant.to_sym)
+        mod.const_get(constant, inherit)
+      end
+    end
+
+    def constant_values(mod, is_a: nil, extends: nil, inherit: false)
+      if inherit && !mod.is_a?(Class)
+        # :nocov:
+        raise "Cannot pass inherit: true for something that is not a Class"
+        # :nocov:
+      end
+
+      if inherit
+        superklass = mod.superclass
+        values = constant_values(mod, is_a:, extends:)
+        if superklass == Object
+          values
+        else
+          [
+            *values,
+            *constant_values(superklass, is_a:, extends:, inherit:)
+          ]
+        end
+      else
+        is_a = Util.array(is_a)
+        extends = Util.array(extends)
+
+        mod.constants.map { |const| constant_value(mod, const) }.select do |object|
+          (is_a.nil? || is_a.empty? || is_a.any? { |klass| object.is_a?(klass) }) &&
+            (extends.nil? || extends.empty? || (object.is_a?(Class) && extends.any? do |klass|
+              object.ancestors.include?(klass)
+            end))
+        end.compact
+      end
+    end
+
+    def const_get_up_hierarchy(mod, name)
+      mod.const_get(name)
+    rescue NameError => e
+      if mod == Object || e.message !~ /uninitialized constant (.*::)?#{name}\z/
+        # :nocov:
+        raise
+        # :nocov:
+      end
+
+      mod = if mod.name&.include?("::")
+              module_for(mod)
+            else
+              Object
+            end
+
+      const_get_up_hierarchy(mod, name)
+    end
+
+    def remove_constant(const_name)
+      *path, name = const_name.split("::")
+      mod = path.inject(Object) { |m, constant| m.const_get(constant) }
+
+      mod.send(:remove_const, name)
+    end
+  end
+end

data/lib/foobara/util/require.rb

@@ -0,0 +1,23 @@
+module Foobara
+  module Util
+    module_function
+
+    def require_directory(directory)
+      require_pattern("#{directory}/**/*.rb")
+    end
+
+    def require_pattern(glob)
+      files = Dir[glob]
+
+      if files.empty?
+        # :nocov:
+        raise "Didn't find anything to require for #{glob}"
+        # :nocov:
+      end
+
+      files.sort_by { |file| [file.count("/"), file.length] }.reverse.each do |f|
+        require f
+      end
+    end
+  end
+end

data/lib/foobara/util/string.rb

@@ -0,0 +1,125 @@
+module Foobara
+  module Util
+    module_function
+
+    def classify(string)
+      camelize(string, true)
+    end
+
+    def camelize(string, upcase_first = false)
+      return nil if string.nil?
+
+      if string.is_a?(::Symbol)
+        string = string.to_s
+      end
+
+      retval = ""
+
+      string.each_char do |char|
+        if char == "_"
+          upcase_first = true
+        elsif upcase_first
+          retval << char.upcase
+          upcase_first = false
+        else
+          retval << char.downcase
+        end
+      end
+
+      retval
+    end
+
+    IS_CAP = /[A-Z]/
+    IS_IDENTIFIER_CHARACTER = /\w/
+
+    def constantify(string)
+      return nil if string.nil?
+
+      if string.is_a?(::Symbol)
+        string = string.to_s
+      end
+
+      if string =~ /\A[A-Z_]*\z/
+        string.dup
+      else
+        underscore(string).upcase
+      end
+    end
+
+    def constantify_sym(string)
+      constantify(string)&.to_sym
+    end
+
+    def underscore(string)
+      return nil if string.nil?
+
+      if string.is_a?(::Symbol)
+        string = string.to_s
+      end
+
+      return "" if string.empty?
+
+      retval = ""
+      is_start = true
+
+      string.each_char do |char|
+        if IS_IDENTIFIER_CHARACTER =~ char
+          if IS_CAP =~ char
+            char = char.downcase
+            char = "_#{char}" unless is_start
+            is_start = false
+          elsif char == "_"
+            is_start = true
+          else
+            is_start = false
+          end
+        else
+          is_start = true
+        end
+
+        retval << char
+      end
+
+      retval
+    end
+
+    def kebab_case(string)
+      underscore(string)&.gsub("_", "-")
+    end
+
+    def underscore_sym(string)
+      underscore(string)&.to_sym
+    end
+
+    def to_sentence(strings, connector = ", ", last_connector = ", and ")
+      return "" if strings.empty?
+
+      *strings, last = strings
+
+      if strings.empty?
+        last
+      else
+        [strings.join(connector), last].join(last_connector)
+      end
+    end
+
+    def to_or_sentence(strings, connector = ", ")
+      to_sentence(strings, connector, ", or ")
+    end
+
+    def humanize(string)
+      return nil if string.nil?
+
+      if string.is_a?(::Symbol)
+        string = string.to_s
+      end
+
+      return "" if string.empty?
+
+      string = string.gsub("_", " ")
+      string[0] = string[0].upcase
+
+      string
+    end
+  end
+end

data/lib/foobara/util/structured.rb

@@ -0,0 +1,33 @@
+module Foobara
+  module Util
+    module_function
+
+    def deep_stringify_keys(object)
+      case object
+      when ::Array
+        object.map { |element| deep_stringify_keys(element) }
+      when ::Hash
+        object.to_h do |k, v|
+          [k.is_a?(::Symbol) ? k.to_s : k, deep_stringify_keys(v)]
+        end
+      else
+        object
+      end
+    end
+
+    def deep_dup(object)
+      case object
+      when ::Array
+        object.map { |element| deep_dup(element) }
+      when ::Hash
+        object.to_h { |k, v| [deep_dup(k), deep_dup(v)] }
+      when ::String
+        # Important to not dup ::Module... but going to exclude everything but String for now to prevent that issue
+        # and others.
+        object.dup
+      else
+        object
+      end
+    end
+  end
+end

data/lib/foobara/util/version.rb

@@ -0,0 +1,5 @@
+module Foobara
+  module Util
+    VERSION = "0.0.4".freeze
+  end
+end

data/lib/foobara/util.rb

@@ -0,0 +1 @@
+Dir["#{__dir__}/../**/*.rb"].each { |f| require f }

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: foobara-util
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Miles Georgi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-05-31 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- azimux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/foobara/truncated_inspect.rb
+- lib/foobara/util.rb
+- lib/foobara/util/args.rb
+- lib/foobara/util/array.rb
+- lib/foobara/util/class.rb
+- lib/foobara/util/hash.rb
+- lib/foobara/util/meta.rb
+- lib/foobara/util/module.rb
+- lib/foobara/util/require.rb
+- lib/foobara/util/string.rb
+- lib/foobara/util/structured.rb
+- lib/foobara/util/version.rb
+homepage: https://github.com/foobara/util
+licenses:
+- Apache-2.0
+- MIT
+metadata:
+  homepage_uri: https://github.com/foobara/util
+  source_code_uri: https://github.com/foobara/util
+  changelog_uri: https://github.com/foobara/util/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Utility functions used across various Foobara projects
+test_files: []