familia 2.0.0.pre15 → 2.0.0.pre17

data/lib/familia/data_type/types/sorted_set.rb

@@ -8,6 +8,8 @@ module Familia
       dbclient.zcard dbkey
     end
     alias size element_count
+    alias length element_count
+    alias count element_count
 
     def empty?
       element_count.zero?
@@ -24,14 +26,13 @@ module Familia
     # @return [Integer] Returns 1 if the element is new and added, 0 if the
     #   element already existed and the score was updated.
     #
-    # @example
-    #   sorted_set << "new_element"
+    # @example sorted_set << "new_element"
     #
     # @note This is a non-standard operation for sorted sets as it doesn't allow
     #   specifying a custom score. Use `add` or `[]=` for more control.
     #
     def <<(val)
-      add(Time.now.to_i, val)
+      add(val)
     end
 
     # NOTE: The argument order is the reverse of #add. We do this to
@@ -42,14 +43,88 @@ module Familia
     #     obj.metrics[VALUE]  # => SCORE
     #
     def []=(val, score)
-      add score, val
+      add val, score
     end
 
-    def add(score, val)
-      ret = dbclient.zadd dbkey, score, serialize_value(val)
+    # Adds an element to the sorted set with an optional score and ZADD options.
+    #
+    # This method supports Redis ZADD options for conditional adds and updates:
+    # - **NX**: Only add new elements (don't update existing)
+    # - **XX**: Only update existing elements (don't add new)
+    # - **GT**: Only update if new score > current score
+    # - **LT**: Only update if new score < current score
+    # - **CH**: Return changed count (new + updated) instead of just new count
+    #
+    # @param val [Object] The value to add to the sorted set
+    # @param score [Numeric, nil] The score for ranking (defaults to current timestamp)
+    # @param nx [Boolean] Only add new elements, don't update existing (default: false)
+    # @param xx [Boolean] Only update existing elements, don't add new (default: false)
+    # @param gt [Boolean] Only update if new score > current score (default: false)
+    # @param lt [Boolean] Only update if new score < current score (default: false)
+    # @param ch [Boolean] Return changed count instead of added count (default: false)
+    #
+    # @return [Boolean] Returns the return value from the redis gem's ZADD
+    #   command. Returns true if element was added or changed (with CH option),
+    #   false if element score was updated without change tracking or no
+    #   operation occurred due to option constraints (NX, XX, GT, LT).
+    #
+    # @raise [ArgumentError] If mutually exclusive options are specified together
+    #   (NX+XX, GT+LT, NX+GT, NX+LT)
+    #
+    # @example Add new element with timestamp
+    #   metrics.add('pageview', Time.now.to_f)  #=> true
+    #
+    # @example Preserve original timestamp on subsequent saves
+    #   index.add(email, Time.now.to_f, nx: true)  #=> true
+    #   index.add(email, Time.now.to_f, nx: true)  #=> false (unchanged)
+    #
+    # @example Update timestamp only for existing entries
+    #   index.add(email, Time.now.to_f, xx: true)  #=> false (if doesn't exist)
+    #
+    # @example Only update if new score is higher (leaderboard)
+    #   scores.add(player, 1000, gt: true)  #=> true (new entry)
+    #   scores.add(player, 1500, gt: true)  #=> false (updated)
+    #   scores.add(player, 1200, gt: true)  #=> false (not updated, score lower)
+    #
+    # @example Track total changes for analytics
+    #   changed = metrics.add(user, score, ch: true)  #=> true (new or updated)
+    #
+    # @example Combined options: only update existing, only if score increases
+    #   index.add(key, new_score, xx: true, gt: true)
+    #
+    # @note GT and LT options do NOT prevent adding new elements, they only
+    #   affect update behavior for existing elements.
+    #
+    # @note Default behavior (no options) adds new elements and updates existing
+    #   ones unconditionally, matching standard Redis ZADD semantics.
+    #
+    # @note INCR option is not supported. Use the increment method for ZINCRBY operations.
+    #
+    def add(val, score = nil, nx: false, xx: false, gt: false, lt: false, ch: false)
+      score ||= Familia.now
+
+      # Validate mutual exclusivity
+      validate_zadd_options!(nx: nx, xx: xx, gt: gt, lt: lt)
+
+      # Build options hash for redis gem
+      opts = {}
+      opts[:nx] = true if nx
+      opts[:xx] = true if xx
+      opts[:gt] = true if gt
+      opts[:lt] = true if lt
+      opts[:ch] = true if ch
+
+      # Pass options to ZADD
+      ret = if opts.empty?
+        dbclient.zadd(dbkey, score, serialize_value(val))
+      else
+        dbclient.zadd(dbkey, score, serialize_value(val), **opts)
+      end
+
       update_expiration
       ret
     end
+    alias add_element add
 
     def score(val)
       ret = dbclient.zscore dbkey, serialize_value(val, strict_values: false)
@@ -58,7 +133,7 @@ module Familia
     alias [] score
 
     def member?(val)
-      Familia.trace :MEMBER, dbclient, "#{val}<#{val.class}>", caller(1..1) if Familia.debug?
+      Familia.trace :MEMBER, nil, "#{val}<#{val.class}>" if Familia.debug?
       !rank(val).nil?
     end
     alias include? member?
@@ -132,7 +207,7 @@ module Familia
     end
 
     def range(sidx, eidx, opts = {})
-      echo :range, caller(1..1).first if Familia.debug
+      echo :range, Familia.pretty_stack(limit: 1) if Familia.debug
       elements = rangeraw(sidx, eidx, opts)
       deserialize_values(*elements)
     end
@@ -149,7 +224,7 @@ module Familia
     end
 
     def revrange(sidx, eidx, opts = {})
-      echo :revrange, caller(1..1).first if Familia.debug
+      echo :revrange, Familia.pretty_stack(limit: 1) if Familia.debug
       elements = revrangeraw(sidx, eidx, opts)
       deserialize_values(*elements)
     end
@@ -160,25 +235,25 @@ module Familia
 
     # e.g. obj.metrics.rangebyscore (now-12.hours), now, :limit => [0, 10]
     def rangebyscore(sscore, escore, opts = {})
-      echo :rangebyscore, caller(1..1).first if Familia.debug
+      echo :rangebyscore, Familia.pretty_stack(limit: 1) if Familia.debug
       elements = rangebyscoreraw(sscore, escore, opts)
       deserialize_values(*elements)
     end
 
     def rangebyscoreraw(sscore, escore, opts = {})
-      echo :rangebyscoreraw, caller(1..1).first if Familia.debug
+      echo :rangebyscoreraw, Familia.pretty_stack(limit: 1) if Familia.debug
       dbclient.zrangebyscore(dbkey, sscore, escore, **opts)
     end
 
     # e.g. obj.metrics.revrangebyscore (now-12.hours), now, :limit => [0, 10]
     def revrangebyscore(sscore, escore, opts = {})
-      echo :revrangebyscore, caller(1..1).first if Familia.debug
+      echo :revrangebyscore, Familia.pretty_stack(limit: 1) if Familia.debug
       elements = revrangebyscoreraw(sscore, escore, opts)
       deserialize_values(*elements)
     end
 
     def revrangebyscoreraw(sscore, escore, opts = {})
-      echo :revrangebyscoreraw, caller(1..1).first if Familia.debug
+      echo :revrangebyscoreraw, Familia.pretty_stack(limit: 1) if Familia.debug
       opts[:with_scores] = true if opts[:withscores]
       dbclient.zrevrangebyscore(dbkey, sscore, escore, opts)
     end
@@ -207,7 +282,7 @@ module Familia
     # @param value The value to remove from the sorted set
     # @return [Integer] The number of members that were removed (0 or 1)
     def remove_element(value)
-      Familia.trace :REMOVE_ELEMENT, dbclient, "#{value}<#{value.class}>", caller(1..1) if Familia.debug?
+      Familia.trace :REMOVE_ELEMENT, nil, "#{value}<#{value.class}>" if Familia.debug?
       # We use `strict_values: false` here to allow for the deletion of values
       # that are in the sorted set. If it's a horreum object, the value is
       # the identifier and not a serialized version of the object. So either
@@ -231,6 +306,45 @@ module Familia
       at(-1)
     end
 
+
+    private
+
+    # Validates that mutually exclusive ZADD options are not specified together.
+    #
+    # @param nx [Boolean] NX option flag
+    # @param xx [Boolean] XX option flag
+    # @param gt [Boolean] GT option flag
+    # @param lt [Boolean] LT option flag
+    #
+    # @raise [ArgumentError] If mutually exclusive options are specified
+    #
+    # @note Valid combinations: XX+GT, XX+LT
+    # @note Invalid combinations: NX+XX, GT+LT, NX+GT, NX+LT
+    #
+    def validate_zadd_options!(nx:, xx:, gt:, lt:)
+      # NX and XX are mutually exclusive
+      if nx && xx
+        raise ArgumentError, "ZADD options NX and XX are mutually exclusive"
+      end
+
+      # GT and LT are mutually exclusive
+      if gt && lt
+        raise ArgumentError, "ZADD options GT and LT are mutually exclusive"
+      end
+
+      # NX is mutually exclusive with GT
+      if nx && gt
+        raise ArgumentError, "ZADD options NX and GT are mutually exclusive"
+      end
+
+      # NX is mutually exclusive with LT
+      if nx && lt
+        raise ArgumentError, "ZADD options NX and LT are mutually exclusive"
+      end
+
+      # Note: XX + GT and XX + LT are valid combinations
+    end
+
     Familia::DataType.register self, :sorted_set
     Familia::DataType.register self, :zset
   end

data/lib/familia/data_type/types/{string.rb → stringkey.rb}

@@ -1,7 +1,7 @@
-# lib/familia/data_type/types/string.rb
+# lib/familia/data_type/types/stringkey.rb
 
 module Familia
-  class String < DataType
+  class StringKey < DataType
     def init; end
 
     # Returns the number of elements in the list
@@ -10,13 +10,14 @@ module Familia
       to_s.size
     end
     alias size char_count
+    alias length char_count
 
     def empty?
       char_count.zero?
     end
 
     def value
-      echo :value, caller(0..0) if Familia.debug
+      echo :value, Familia.pretty_stack(limit: 1) if Familia.debug
       dbclient.setnx dbkey, @opts[:default] if @opts[:default]
       deserialize_value dbclient.get(dbkey)
     end
@@ -30,7 +31,7 @@ module Familia
     end
 
     def to_i
-      value&.to_i || 0
+      value.to_i
     end
 
     def value=(val)
@@ -113,14 +114,11 @@ module Familia
       ret.positive?
     end
 
-    def nil?
-      value.nil?
-    end
-
     Familia::DataType.register self, :string
+    Familia::DataType.register self, :stringkey
   end
 end
 
-# Both subclass String
+# Both subclass StringKey
 require_relative 'lock'
 require_relative 'counter'

data/lib/familia/data_type/types/unsorted_set.rb

@@ -1,13 +1,17 @@
 # lib/familia/data_type/types/unsorted_set.rb
 
 module Familia
-  class Set < DataType
+  # Familia::UnsortedSet
+  #
+  class UnsortedSet < DataType
     # Returns the number of elements in the unsorted set
     # @return [Integer] number of elements
     def element_count
       dbclient.scard dbkey
     end
     alias size element_count
+    alias length element_count
+    alias count element_count
 
     def empty?
       element_count.zero?
@@ -18,13 +22,14 @@ module Familia
       update_expiration
       self
     end
+    alias add_element add
 
     def <<(v)
       add v
     end
 
     def members
-      echo :members, caller(1..1).first if Familia.debug
+      echo :members, Familia.pretty_stack(limit: 1) if Familia.debug
       elements = membersraw
       deserialize_values(*elements)
     end
@@ -92,35 +97,23 @@ module Familia
       dbclient.smove dbkey, dstkey, val
     end
 
-    def random
-      deserialize_value randomraw
+    # Get one or more random members from the set
+    # @param count [Integer] Number of random members to return (default: 1)
+    # @return [Array] Array of deserialized random members
+    def sample(count = 1)
+      deserialize_values(*sampleraw(count))
     end
+    alias random sample
 
-    def randomraw
-      dbclient.srandmember(dbkey)
+    # Get one or more random members from the set without deserialization
+    # @param count [Integer] Number of random members to return (default: 1)
+    # @return [Array] Array of raw random members
+    def sampleraw(count = 1)
+      dbclient.srandmember(dbkey, count) || []
     end
-
-    ## Make the value stored at KEY identical to the given list
-    # define_method :"#{name}_sync" do |*latest|
-    #  latest = latest.flatten.compact
-    #  # Do nothing if we're given an empty Array.
-    #  # Otherwise this would clear all current values
-    #  if latest.empty?
-    #    false
-    #  else
-    #    # Convert to a list of index values if we got the actual objects
-    #    latest = latest.collect { |obj| obj.index } if klass === latest.first
-    #    current = send("#{name_plural}raw")
-    #    added = latest-current
-    #    removed = current-latest
-    #    #Familia.info "#{self.index}: adding: #{added}"
-    #    added.each { |v| self.send("add_#{name_singular}", v) }
-    #    #Familia.info "#{self.index}: removing: #{removed}"
-    #    removed.each { |v| self.send("remove_#{name_singular}", v) }
-    #    true
-    #  end
-    # end
+    alias random sampleraw
 
     Familia::DataType.register self, :set
+    Familia::DataType.register self, :unsorted_set
   end
 end

data/lib/familia/data_type.rb

@@ -1,5 +1,8 @@
 # lib/familia/data_type.rb
 
+require_relative 'data_type/class_methods'
+require_relative 'data_type/settings'
+require_relative 'data_type/connection'
 require_relative 'data_type/commands'
 require_relative 'data_type/serialization'
 
@@ -9,72 +12,27 @@ module Familia
   # DataType - Base class for Database data type wrappers
   #
   # This class provides common functionality for various Database data types
-  # such as String, List, Set, SortedSet, and HashKey.
+  # such as String, List, UnsortedSet, SortedSet, and HashKey.
   #
   # @abstract Subclass and implement Database data type specific methods
   class DataType
     include Familia::Base
+    extend ClassMethods
     extend Familia::Features
 
     using Familia::Refinements::TimeLiterals
 
     @registered_types = {}
-    @valid_options = %i[class parent default_expiration default logical_database dbkey dbclient suffix prefix]
+    @valid_options = %i[class parent default_expiration default logical_database dbkey dbclient suffix prefix].freeze
     @logical_database = nil
 
     feature :expiration
     feature :quantization
 
     class << self
-      attr_reader :registered_types, :valid_options, :has_relations
-      attr_accessor :parent
-      attr_writer :logical_database, :uri
+      attr_reader :registered_types, :valid_options, :has_related_fields
     end
 
-    # DataType::ClassMethods
-    #
-    module ClassMethods
-      # To be called inside every class that inherits DataType
-      # +methname+ is the term used for the class and instance methods
-      # that are created for the given +klass+ (e.g. set, list, etc)
-      def register(klass, methname)
-        Familia.trace :REGISTER, nil, "[#{self}] Registering #{klass} as #{methname.inspect}", caller(1..1) if Familia.debug?
-
-        @registered_types[methname] = klass
-      end
-
-      def logical_database(val = nil)
-        @logical_database = val unless val.nil?
-        @logical_database || parent&.logical_database
-      end
-
-      def uri(val = nil)
-        @uri = val unless val.nil?
-        @uri || (parent ? parent.uri : Familia.uri)
-      end
-
-      def inherited(obj)
-        Familia.trace :DATATYPE, nil, "#{obj} is my kinda type", caller(1..1) if Familia.debug?
-        obj.logical_database = logical_database
-        obj.default_expiration = default_expiration # method added via Features::Expiration
-        obj.uri = uri
-        obj.parent = self
-        super
-      end
-
-      def valid_keys_only(opts)
-        opts.slice(*DataType.valid_options)
-      end
-
-      def relations?
-        @has_relations ||= false # rubocop:disable ThreadSafety/ClassInstanceVariable
-      end
-    end
-    extend ClassMethods
-
-    attr_reader :keystring, :opts
-    attr_writer :dump_method, :load_method
-
     # +keystring+: If parent is set, this will be used as the suffix
     # for dbkey. Otherwise this becomes the value of the key.
     # If this is an Array, the elements will be joined.
@@ -94,10 +52,6 @@ module Familia
     #
     # :default => the default value (String-only)
     #
-    # :logical_database => the logical database index to use (ignored if :dbclient is used).
-    #
-    # :dbclient => an instance of database client.
-    #
     # :dbkey => a hardcoded key to use instead of the deriving the from
     # the name and parent (e.g. a derived key: customer:custid:secret_counter).
     #
@@ -111,138 +65,25 @@ module Familia
       @keystring = @keystring.join(Familia.delim) if @keystring.is_a?(Array)
 
       # Remove all keys from the opts that are not in the allowed list
-      @opts = opts || {}
-      @opts = DataType.valid_keys_only(@opts)
+      @opts = DataType.valid_keys_only(opts || {})
 
       # Apply the options to instance method setters of the same name
       @opts.each do |k, v|
-        # Bewarde logging :parent instance here implicitly calls #to_s which for
-        # some classes could include the identifier which could still be nil at
-        # this point. This would result in a Familia::Problem being raised. So
-        # to be on the safe-side here until we have a better understanding of
-        # the issue, we'll just log the class name for each key-value pair.
-        Familia.trace :SETTING, nil, " [setting] #{k} #{v.class}", caller(1..1) if Familia.debug?
         send(:"#{k}=", v) if respond_to? :"#{k}="
       end
 
       init if respond_to? :init
     end
 
-    def dbclient
-      return Fiber[:familia_transaction] if Fiber[:familia_transaction]
-      return @dbclient if @dbclient
-
-      parent? ? parent.dbclient : Familia.dbclient(opts[:logical_database])
-    end
-
-    # Produces the full dbkey for this object.
-    #
-    # @return [String] The full dbkey.
-    #
-    # This method determines the appropriate dbkey based on the context of the DataType object:
-    #
-    # 1. If a hardcoded key is set in the options, it returns that key.
-    # 2. For instance-level DataType objects, it uses the parent instance's dbkey method.
-    # 3. For class-level DataType objects, it uses the parent class's dbkey method.
-    # 4. For standalone DataType objects, it uses the keystring as the full dbkey.
-    #
-    # For class-level DataType objects (parent_class? == true):
-    # - The suffix is optional and used to differentiate between different types of objects.
-    # - If no suffix is provided, the class's default suffix is used (via the self.suffix method).
-    # - If a nil suffix is explicitly passed, it won't appear in the resulting dbkey.
-    # - Passing nil as the suffix is how class-level DataType objects are created without
-    #   the global default 'object' suffix.
-    #
-    # @example Instance-level DataType
-    #   user_instance.some_datatype.dbkey  # => "user:123:some_datatype"
-    #
-    # @example Class-level DataType
-    #   User.some_datatype.dbkey  # => "user:some_datatype"
-    #
-    # @example Standalone DataType
-    #   DataType.new("mykey").dbkey  # => "mykey"
-    #
-    # @example Class-level DataType with explicit nil suffix
-    #   User.dbkey("123", nil)  # => "user:123"
-    #
-    def dbkey
-      # Return the hardcoded key if it's set. This is useful for
-      # support legacy keys that aren't derived in the same way.
-      return opts[:dbkey] if opts[:dbkey]
-
-      if parent_instance?
-        # This is an instance-level datatype object so the parent instance's
-        # dbkey method is defined in Familia::Horreum::InstanceMethods.
-        parent.dbkey(keystring)
-      elsif parent_class?
-        # This is a class-level datatype object so the parent class' dbkey
-        # method is defined in Familia::Horreum::DefinitionMethods.
-        parent.dbkey(keystring, nil)
-      else
-        # This is a standalone DataType object where it's keystring
-        # is the full database key (dbkey).
-        keystring
-      end
-    end
-
-    def class?
-      !@opts[:class].to_s.empty? && @opts[:class].is_a?(Familia)
-    end
-
-    def parent_instance?
-      parent.is_a?(Familia::Horreum)
-    end
-
-    def parent_class?
-      parent.is_a?(Class) && parent <= Familia::Horreum
-    end
-
-    def parent?
-      parent_class? || parent_instance?
-    end
-
-    def parent
-      @opts[:parent]
-    end
-
-
-    def logical_database
-      @opts[:logical_database] || self.class.logical_database
-    end
-
-    def uri
-      # If a specific URI is set in opts, use it
-      return @opts[:uri] if @opts[:uri]
-
-      # If parent has a DB set, create a URI with that DB
-      if parent? && parent.respond_to?(:logical_database) && parent.logical_database
-        base_uri = self.class.uri || Familia.uri
-        if base_uri
-          uri_with_db = base_uri.dup
-          uri_with_db.db = parent.logical_database
-          return uri_with_db
-        end
-      end
-
-      # Otherwise fall back to class URI
-      self.class.uri
-    end
-
-    def dump_method
-      @dump_method || self.class.dump_method
-    end
-
-    def load_method
-      @load_method || self.class.load_method
-    end
-
+    include Settings
+    include Connection
     include Commands
     include Serialization
   end
 
-  require_relative 'data_type/types/list'
+  require_relative 'data_type/types/listkey'
   require_relative 'data_type/types/unsorted_set'
   require_relative 'data_type/types/sorted_set'
   require_relative 'data_type/types/hashkey'
-  require_relative 'data_type/types/string'
+  require_relative 'data_type/types/stringkey'
 end

data/lib/familia/distinguisher.rb

@@ -0,0 +1,85 @@
+# lib/familia/distinguisher.rb
+
+module Familia
+  module Distinguisher
+    # This method determines the appropriate transformation to apply based on
+    # the class of the input argument.
+    #
+    # @param [Object] value_to_distinguish The value to be processed. Keep in
+    #   mind that all data is stored as a string so whatever the type
+    #   of the value, it will be converted to a string.
+    # @param [Boolean] strict_values Whether to enforce strict value handling.
+    #   Defaults to true.
+    # @return [String, nil] The processed value as a string or nil for unsupported
+    #   classes.
+    #
+    # The method uses a case statement to handle different classes:
+    # - For `Symbol`, `String`, `Integer`, and `Float` classes, it traces the
+    #   operation and converts the value to a string.
+    # - For `Familia::Horreum` class, it traces the operation and returns the
+    #   identifier of the value.
+    # - For `TrueClass`, `FalseClass`, and `NilClass`, it traces the operation and
+    #   converts the value to a string ("true", "false", or "").
+    # - For any other class, it traces the operation and returns nil.
+    #
+    # Alternative names for `value_to_distinguish` could be `input_value`, `value`,
+    # or `object`.
+    #
+    def distinguisher(value_to_distinguish, strict_values: true)
+      case value_to_distinguish
+      when ::Symbol, ::String, ::Integer, ::Float
+        Familia.trace :TOREDIS_DISTINGUISHER, nil, 'string' if Familia.debug?
+
+        # Symbols and numerics are naturally serializable to strings
+        # so it's a relatively low risk operation.
+        value_to_distinguish.to_s
+
+      when ::TrueClass, ::FalseClass, ::NilClass
+        Familia.trace :TOREDIS_DISTINGUISHER, nil, 'true/false/nil' if Familia.debug?
+
+        # TrueClass, FalseClass, and NilClass are considered high risk because their
+        # original types cannot be reliably determined from their serialized string
+        # representations. This can lead to unexpected behavior during deserialization.
+        # For instance, a TrueClass value serialized as "true" might be deserialized as
+        # a String, causing application errors. Even more problematic, a NilClass value
+        # serialized as an empty string makes it impossible to distinguish between a
+        # nil value and an empty string upon deserialization. Such scenarios can result
+        # in subtle, hard-to-diagnose bugs. To mitigate these risks, we raise an
+        # exception when encountering these types unless the strict_values option is
+        # explicitly set to false.
+        #
+        raise Familia::NotDistinguishableError, value_to_distinguish if strict_values
+
+        value_to_distinguish.to_s #=> "true", "false", ""
+
+      when Familia::Base, Class
+        Familia.trace :TOREDIS_DISTINGUISHER, nil, 'base' if Familia.debug?
+
+        # When called with a class we simply transform it to its name. For
+        # instances of Familia class, we store the identifier.
+        if value_to_distinguish.is_a?(Class)
+          value_to_distinguish.name
+        else
+          value_to_distinguish.identifier
+        end
+
+      else
+        Familia.trace :TOREDIS_DISTINGUISHER, nil, "else1 #{strict_values}" if Familia.debug?
+
+        if value_to_distinguish.class.ancestors.member?(Familia::Base)
+          Familia.trace :TOREDIS_DISTINGUISHER, nil, 'isabase' if Familia.debug?
+
+          value_to_distinguish.identifier
+
+        else
+          Familia.trace :TOREDIS_DISTINGUISHER, nil, "else2 #{strict_values}" if Familia.debug?
+          raise Familia::NotDistinguishableError, value_to_distinguish if strict_values
+
+          nil
+        end
+      end
+    end
+  end
+
+  extend Distinguisher
+end