ddtrace 0.20.0 → 0.21.0

data/lib/ddtrace/contrib/configuration/option_definition_set.rb

@@ -1,20 +0,0 @@
-require 'ddtrace/configuration/resolver'
-
-module Datadog
-  module Contrib
-    module Configuration
-      # Represents a set of configuration option definitions for an integration
-      class OptionDefinitionSet < Hash
-        def dependency_order
-          Datadog::Configuration::Resolver.new(dependency_graph).call
-        end
-
-        def dependency_graph
-          each_with_object({}) do |(name, option), graph|
-            graph[name] = option.depends_on
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/configuration/option_set.rb

@@ -1,8 +0,0 @@
-module Datadog
-  module Contrib
-    module Configuration
-      class OptionSet < Hash
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/configuration/options.rb

@@ -1,95 +0,0 @@
-require 'ddtrace/contrib/configuration/option'
-require 'ddtrace/contrib/configuration/option_set'
-require 'ddtrace/contrib/configuration/option_definition'
-require 'ddtrace/contrib/configuration/option_definition_set'
-
-module Datadog
-  module Contrib
-    module Configuration
-      # Behavior for a configuration object that has options
-      module Options
-        def self.included(base)
-          base.send(:extend, ClassMethods)
-          base.send(:include, InstanceMethods)
-        end
-
-        # Class behavior for a configuration object with options
-        module ClassMethods
-          def options
-            @options ||= begin
-              # Allows for class inheritance of option definitions
-              superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
-            end
-          end
-
-          protected
-
-          def option(name, meta = {}, &block)
-            options[name] = OptionDefinition.new(name, meta, &block).tap do
-              define_option_accessors(name)
-            end
-          end
-
-          private
-
-          def define_option_accessors(name)
-            option_name = name
-
-            define_method(option_name) do
-              get_option(option_name)
-            end
-
-            define_method("#{option_name}=") do |value|
-              set_option(option_name, value)
-            end
-          end
-        end
-
-        # Instance behavior for a configuration object with options
-        module InstanceMethods
-          def options
-            @options ||= OptionSet.new
-          end
-
-          def set_option(name, value)
-            add_option(name) unless options.key?(name)
-            options[name].set(value)
-          end
-
-          def get_option(name)
-            add_option(name) unless options.key?(name)
-            options[name].get
-          end
-
-          def to_h
-            options.each_with_object({}) do |(key, _), hash|
-              hash[key] = get_option(key)
-            end
-          end
-
-          def reset_options!
-            options.values.each(&:reset)
-          end
-
-          private
-
-          def add_option(name)
-            assert_valid_option!(name)
-            definition = self.class.options[name]
-            Option.new(definition, self).tap do |option|
-              options[name] = option
-            end
-          end
-
-          def assert_valid_option!(name)
-            unless self.class.options.key?(name)
-              raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
-            end
-          end
-        end
-
-        InvalidOptionError = Class.new(StandardError)
-      end
-    end
-  end
-end

data/lib/ddtrace/registry.rb

@@ -1,42 +0,0 @@
-require_relative 'registry/registerable'
-
-module Datadog
-  # Registry provides insertion/retrieval capabilities for integrations
-  class Registry
-    include Enumerable
-
-    Entry = Struct.new(:name, :klass, :auto_patch)
-
-    def initialize
-      @data = {}
-      @mutex = Mutex.new
-    end
-
-    def add(name, klass, auto_patch = false)
-      @mutex.synchronize do
-        @data[name] = Entry.new(name, klass, auto_patch).freeze
-      end
-    end
-
-    def each
-      @mutex.synchronize do
-        @data.each { |_, entry| yield(entry) }
-      end
-    end
-
-    def [](name)
-      @mutex.synchronize do
-        entry = @data[name]
-        entry.klass if entry
-      end
-    end
-
-    def to_h
-      @mutex.synchronize do
-        @data.each_with_object({}) do |(_, entry), hash|
-          hash[entry.name] = entry.auto_patch
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/registry/registerable.rb

@@ -1,20 +0,0 @@
-module Datadog
-  class Registry
-    # Registerable provides a convenience method for self-registering
-    module Registerable
-      def self.included(base)
-        base.singleton_class.send(:include, ClassMethods)
-      end
-
-      # ClassMethods
-      module ClassMethods
-        def register_as(name, options = {})
-          registry = options.fetch(:registry, Datadog.registry)
-          auto_patch = options.fetch(:auto_patch, false)
-
-          registry.add(name, self, auto_patch)
-        end
-      end
-    end
-  end
-end