universalid 0.0.1 → 0.1.0

data/lib/universal_id/message_pack_types/ruby/scalars/range.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Range,
+  recreate_pool: false,
+  packer: ->(obj, packer) do
+    packer.write obj.first
+    packer.write obj.to_s.scan(/\.{2,3}/).first
+    packer.write obj.last
+  end,
+  unpacker: ->(unpacker) do
+    first = unpacker.read
+    operator = unpacker.read
+    last = unpacker.read
+    case operator
+    when ".." then first..last
+    when "..." then first...last
+    end
+  end
+)

data/lib/universal_id/message_pack_types/ruby/scalars/rational.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Rational,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_s },
+  unpacker: ->(unpacker) { Kernel.Rational unpacker.read }
+)

data/lib/universal_id/message_pack_types/ruby/scalars/regexp.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: Regexp,
+  recreate_pool: false,
+  packer: ->(obj, packer) do
+    packer.write obj.source
+    packer.write obj.options
+  end,
+  unpacker: ->(unpacker) do
+    source = unpacker.read
+    options = unpacker.read
+    Regexp.new source, options
+  end
+)

data/lib/universal_id/message_pack_types/uri/uid/type.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+UniversalID::MessagePackFactory.register(
+  type: URI::UID,
+  recreate_pool: false,
+  packer: ->(obj, packer) { packer.write obj.to_s },
+  unpacker: ->(unpacker) { URI::UID.parse unpacker.read }
+)

data/lib/universal_id/message_pack_types.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# A list of all MessagePack types in the preferred registration order
+#
+# IMPORTANT: More specific types should be registered before more general types
+#            because MessagePack will use the first registered type that matches
+#            MessagePack scans registered type in linear order and first match wins
+
+require_relative "contrib"
+
+paths = %w[
+  message_pack_types/uri/uid/type.rb
+  message_pack_types/ruby/composites/set.rb
+  message_pack_types/ruby/composites/open_struct.rb
+  message_pack_types/ruby/composites/struct.rb
+  message_pack_types/ruby/scalars/complex.rb
+  message_pack_types/ruby/scalars/rational.rb
+  message_pack_types/ruby/scalars/date_time.rb
+  message_pack_types/ruby/scalars/date.rb
+  message_pack_types/ruby/scalars/range.rb
+  message_pack_types/ruby/scalars/regexp.rb
+]
+
+paths.each { |path| require_relative path }
+
+UniversalID::MessagePackFactory.create_msgpack_pool

data/lib/universal_id/prepack_database_options.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class UniversalID::PrepackDatabaseOptions
+  def initialize(settings)
+    @settings = settings
+  end
+
+  def to_h
+    @settings.to_h
+  end
+
+  def include_keys?
+    !!@settings.include_keys
+  end
+
+  def exclude_keys?
+    !include_keys?
+  end
+
+  def include_timestamps?
+    !!@settings.include_timestamps
+  end
+
+  def exclude_timestamps?
+    !include_timestamps?
+  end
+
+  def include_unsaved_changes?
+    !!@settings.include_unsaved_changes
+  end
+
+  def exclude_unsaved_changes?
+    !include_unsaved_changes?
+  end
+
+  def descendant_depth
+    @settings.descendant_depth ||= 0
+  end
+
+  attr_writer :current_depth
+
+  def current_depth
+    @settings.current_depth ||= 0
+  end
+
+  def increment_current_depth!
+    @settings.current_depth ||= 0
+    @settings.current_depth = @settings.current_depth += 1
+  end
+
+  def decrement_current_depth!
+    @settings.current_depth ||= 0
+    @settings.current_depth = @settings.current_depth -= 1
+  end
+
+  def include_descendants?
+    !!@settings.include_descendants
+  end
+
+  def exclude_descentants?
+    !include_descendants?
+  end
+end

data/lib/universal_id/prepack_options.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "prepack_database_options"
+
+class UniversalID::PrepackOptions
+  attr_reader :excludes, :includes, :database_options
+
+  def initialize(options = {})
+    options ||= {}
+    @settings = UniversalID::Settings.build(**options).prepack
+    @database_options = UniversalID::PrepackDatabaseOptions.new(@settings.database)
+    @references = Set.new
+    @excludes ||= @settings.exclude.to_h { |key| [key.to_s, true] }
+    @includes ||= @settings.include.to_h { |key| [key.to_s, true] }
+  end
+
+  def to_h
+    @settings.to_h
+  end
+
+  def prevent_self_reference!(object)
+    raise UniversalID::Prepacker::CircularReferenceError if @references.include?(object.object_id)
+    @references << object.object_id
+  end
+
+  def include_blank?
+    !!@settings.include_blank
+  end
+
+  def exclude_blank?
+    !include_blank?
+  end
+
+  def keep_key?(key)
+    return false if excludes[key.to_s]
+    includes.none? || includes[key.to_s]
+  end
+
+  def reject_key?(key)
+    excludes[key.to_s]
+  end
+
+  def keep_value?(value)
+    include_blank? || present?(value)
+  end
+
+  def reject_value?(value)
+    !keep_value?(value)
+  end
+
+  def keep_keypair?(key, value)
+    keep_key?(key) && keep_value?(value)
+  end
+
+  def reject_keypair?(key, value)
+    reject_key?(key) || reject_value?(value)
+  end
+
+  def blank?(value)
+    return true if value.nil?
+    return false if !!value == value # booleans
+
+    result = false
+    result ||= value.empty? if value.respond_to?(:empty?)
+    result ||= value.blank? if value.respond_to?(:blank?)
+    result ||= value.strip.empty? if value.is_a?(String)
+    result ||= value.compact.empty? if value.is_a?(Array) || value.is_a?(Hash)
+    result
+  end
+
+  def present?(value)
+    !blank?(value)
+  end
+end

data/lib/universal_id/prepacker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "refinements"
+
+class UniversalID::Prepacker
+  using UniversalID::Refinements::KernelRefinement
+  using UniversalID::Refinements::ArrayRefinement
+  using UniversalID::Refinements::HashRefinement
+  using UniversalID::Refinements::SetRefinement
+  using UniversalID::Refinements::OpenStructRefinement
+
+  class CircularReferenceError < StandardError
+    def initialize(message = "Prepacking not supported on self referencing objects!")
+      super
+    end
+  end
+
+  class << self
+    def prepack(object, options = {})
+      options = UniversalID::PrepackOptions.new(options) unless options.is_a?(UniversalID::PrepackOptions)
+
+      return object.prepack(options) if object.respond_to?(:prepack)
+
+      object.instance_variable_set(:@_uid_prepack_options, options) unless object.frozen?
+      object
+    end
+  end
+end

data/lib/universal_id/refinements/array_refinement.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements::ArrayRefinement
+  refine Array do
+    def prepack(options)
+      options.prevent_self_reference! self
+
+      copy = each_with_object([]) do |val, memo|
+        val = UniversalID::Prepacker.prepack(val, options)
+        memo << val if options.keep_value?(val)
+      end
+
+      copy.compact! if options.exclude_blank?
+      copy
+    end
+  end
+end

data/lib/universal_id/refinements/hash_refinement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements::HashRefinement
+  refine Hash do
+    using UniversalID::Refinements::ArrayRefinement
+
+    def prepack(options)
+      options.prevent_self_reference! self
+
+      copy = each_with_object({}) do |(key, val), memo|
+        next unless options.keep_keypair?(key, val)
+        memo[key] = UniversalID::Prepacker.prepack(val, options)
+      end
+
+      copy.compact! if options.exclude_blank?
+      copy
+    end
+  end
+end

data/lib/universal_id/refinements/kernel_refinement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements::KernelRefinement
+  refine Kernel do
+    # Finds a constant by name, starting at the root namespace (i.e. ::Object)
+    def const_find(name)
+      return nil unless name.is_a?(String)
+      names = name.split("::")
+      constant = Object
+
+      while names.any?
+        value = names.shift
+        constant = constant.const_get(value) if constant.const_defined?(value)
+      end
+
+      (constant.name == name) ? constant : nil
+    end
+  end
+end

data/lib/universal_id/refinements/open_struct_refinement.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements::OpenStructRefinement
+  refine OpenStruct do
+    using UniversalID::Refinements::HashRefinement
+
+    def prepack(options)
+      options.prevent_self_reference! self
+      OpenStruct.new to_h.prepack(options)
+    end
+  end
+end

data/lib/universal_id/refinements/set_refinement.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements::SetRefinement
+  refine Set do
+    using UniversalID::Refinements::ArrayRefinement
+
+    def prepack(options)
+      options.prevent_self_reference! self
+      Set.new to_a.prepack(options)
+    end
+  end
+end

data/lib/universal_id/refinements.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module UniversalID::Refinements; end
+
+require_relative "refinements/kernel_refinement"
+require_relative "refinements/array_refinement"
+require_relative "refinements/hash_refinement"
+require_relative "refinements/set_refinement"
+require_relative "refinements/open_struct_refinement"

data/lib/universal_id/settings.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "singleton"
+require "config"
+
+class UniversalID::Settings
+  include MonitorMixin
+  include Singleton
+
+  DEFAULT_FILE_PATH = File.expand_path("../../config/default.yml", __dir__)
+
+  class << self
+    def build(**options)
+      instance.default_copy.tap do |settings|
+        options.each { |key, val| assign key, val, to: settings }
+      end
+    end
+
+    def register(...)
+      instance.register(...)
+    end
+
+    def [](key)
+      instance[key]
+    end
+
+    private
+
+    def assign(key, value, to:)
+      return if value.nil?
+
+      case {key.to_sym => value}
+      in prepack: prepack then prepack.each { |k, v| assign k, v, to: to }
+      in exclude: exclude then to.prepack.exclude = exclude
+      in include: inc then to.prepack.include = inc
+      in include_blank: include_blank then to.prepack.include_blank = !!include_blank
+      in database: database then database.each { |k, v| assign k, v, to: to }
+      in include_keys: include_keys then to.prepack.database.include_keys = !!include_keys
+      in include_timestamps: include_timestamps then to.prepack.database.include_timestamps = !!include_timestamps
+      in include_unsaved_changes: include_unsaved_changes then to.prepack.database.include_unsaved_changes = !!include_unsaved_changes
+      in include_descendants: include_descendants then to.prepack.database.include_descendants = !!include_descendants
+      in descendant_depth: descendant_depth then to.prepack.database.descendant_depth = descendant_depth
+      else # ignore key
+      end
+    end
+  end
+
+  def register(key, options = {})
+    key = key.to_s.strip.downcase.to_sym
+    synchronize do
+      raise ArgumentError, "Already registered! key: #{key}" if registry.key? key
+      config = case options
+      when String then Config.load_files(options)
+      when Hash then Config::Options.new(options)
+      when Config::Options then options
+      else raise ArgumentError, "Invalid options! Must be a String, Hash, or Config::Options."
+      end
+
+      config = self.class.build(**config) unless key == :default
+      registry[key] = config
+      self.class.define_method(key) { config }
+      self.class.define_method("#{key}_copy") { Marshal.load Marshal.dump(config) }
+      self.class.define_singleton_method(key) { instance.public_send key }
+      [key, config]
+    end
+  end
+
+  def [](key)
+    registry[key.to_sym]
+  end
+
+  private
+
+  attr_reader :registry
+
+  def initialize
+    super
+    @registry = {}
+    register :default, DEFAULT_FILE_PATH
+  end
+end

data/lib/universal_id/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module UniversalID
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/universal_id.rb

@@ -1,13 +1,26 @@
 # frozen_string_literal: true
 
-require "base64"
-require "zlib"
-require "globalid"
-require "active_model"
-require "active_support/all"
+require "date"
+require "forwardable"
+require "ostruct"
+require "uri"
+
 require_relative "universal_id/version"
-require_relative "universal_id/errors"
-require_relative "universal_id/config"
-require_relative "universal_id/portable"
-require_relative "universal_id/portable_hash"
-require_relative "universal_id/active_model_serializer"
+require_relative "universal_id/settings"
+require_relative "universal_id/encoder"
+require_relative "uri/uid"
+require_relative "universal_id/prepacker"
+require_relative "universal_id/prepack_options"
+require_relative "universal_id/message_pack_factory"
+
+UniversalID::Settings.instance # initialize settings
+
+module UniversalID
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : Logger.new(File::NULL)
+    end
+  end
+end

data/lib/uri/uid.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+unless defined?(::URI::UID) || ::URI.scheme_list.include?("UID")
+
+  module URI
+    class UID < ::URI::Generic
+      extend Forwardable
+
+      SCHEME = "uid"
+      HOST = "universal-id"
+
+      class << self
+        def parse(value)
+          components = ::URI.split(value.to_s)
+          new(*components)
+        end
+
+        def build_string(payload)
+          "#{SCHEME}://#{HOST}/#{payload}"
+        end
+
+        def build(object, options = {})
+          path = "/#{UniversalID::Encoder.encode(object, options)}"
+          parse "#{SCHEME}://#{HOST}#{path}"
+        end
+
+        # Creates a new URI::UID with the given URI components.
+        # SEE: https://ruby-doc.org/3.2.2/stdlibs/uri/URI/Generic.html#method-c-new
+        #
+        # @param scheme [String] the scheme component.
+        # @param userinfo [String] the userinfo component.
+        # @param host [String] the host component.
+        # @param port [Integer] the port component.
+        # @param registry [String] the registry component.
+        # @param path [String] the path component.
+        # @param opaque [String] the opaque component.
+        # @param query [String] the query component.
+        # @param fragment [String] the fragment component.
+        # @param parser [URI::Parser] the parser to use for the URI, defaults to DEFAULT_PARSER.
+        # @param arg_check [Boolean] whether to check arguments, defaults to false.
+        # @return [URI::UID] the new URI::UID instance.
+        # # @raise [URI::InvalidURIError] if the URI is malformed.
+        # @raise [ArgumentError] if the number of arguments is incorrect or an argument is of the wrong type.
+        # @raise [TypeError] if an argument is not of the expected type.
+        # @raise [URI::InvalidComponentError] if a component of the URI is not valid.
+        # @raise [URI::BadURIError] if the URI is in a bad or unexpected state.
+        def new(...)
+          super.tap do |uri|
+            if uri.invalid?
+              raise ::URI::InvalidComponentError, "Scheme must be `#{SCHEME}`" if uri.scheme != SCHEME
+              raise ::URI::InvalidComponentError, "Host must be `#{HOST}`" if uri.host != HOST
+              raise ::URI::InvalidComponentError, "Unable to parse `payload` from the path component!" if uri.payload.strip.empty?
+            end
+          end
+        end
+      end
+
+      def payload(truncate: false)
+        (truncate && path.length > 80) ? "#{path[1..77]}..." : path[1..]
+      end
+
+      def valid?
+        case self
+        in scheme: SCHEME, host: HOST, path: p if p.size >= 8 then return true
+        else false
+        end
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def decode
+        UniversalID::Encoder.decode(payload) if valid?
+      end
+
+      def deconstruct_keys(_keys)
+        {scheme: scheme, host: host, path: path}
+      end
+
+      def inspect
+        "#<URI::UID scheme=#{scheme}, host=#{host}, payload=#{payload truncate: true}>"
+      end
+    end
+
+    # Register the URI scheme
+    if ::URI.respond_to? :register_scheme
+      ::URI.register_scheme "UID", UID unless ::URI.scheme_list.include?("UID")
+    else
+      # shenanigans to support Ruby 3.0.X
+      ::URI::UID = UID unless defined?(::URI::UID)
+      ::URI.scheme_list["UID"] = UID
+    end
+  end
+end