sleeping_king_studios-tools 0.7.0.rc.0 → 1.0.0

data/lib/sleeping_king_studios/tools/toolbox/configuration.rb

@@ -1,207 +0,0 @@
-# lib/sleeping_king_studios/tools/toolbox/configuration.rb
-
-require 'sleeping_king_studios/tools/toolbox'
-
-module SleepingKingStudios::Tools::Toolbox
-  class Configuration
-    module ClassMethods
-      DEFAULT_OPTION = Object.new.freeze
-
-      # Defines a nested namespace for the configuration object.
-      def namespace namespace_name, &block
-        namespace =
-          (@namespaces ||= {}).fetch(namespace_name) do
-            @namespaces[namespace_name] = define_namespace namespace_name
-          end # fetch
-
-        namespace.instance_exec namespace, &block if block_given?
-
-        namespace
-      end # method namespace
-
-      # Defines an option for the configuration object.
-      def option option_name, allow_nil: false, default: DEFAULT_OPTION, enum: nil
-        options = {
-          :allow_nil => allow_nil,
-          :default   => default,
-          :enum      => enum
-        } # end hash
-
-        define_accessor option_name, options
-        define_mutator  option_name, options
-      end # class method option
-
-      private
-
-      def define_accessor option_name, options
-        define_method option_name do
-          __get_value__(option_name, options)
-        end # method option_name
-      end # method define_accessor
-
-      def define_mutator option_name, options
-        writer_name = :"#{option_name}="
-
-        define_method writer_name do |value|
-          __set_value__(option_name, value, options)
-        end # method option_name=
-      end # method define_mutator
-
-      def define_namespace namespace_name
-        namespace =
-          Class.new(SleepingKingStudios::Tools::Toolbox::Configuration)
-
-        define_method namespace_name do |&block|
-          if instance_variable_defined?(:"@#{namespace_name}")
-            config = instance_variable_get(:"@#{namespace_name}")
-          else
-            data   = __get_value__(namespace_name, :default => Object.new)
-            config = namespace.new(data)
-
-            config.__root_namespace__ = __root_namespace__ || self
-
-            instance_variable_set(:"@#{namespace_name}", config)
-          end # if
-
-          block.call(config) if block
-
-          config
-        end # method namespace_name
-
-        namespace
-      end # method define_namespace
-    end # module
-    extend ClassMethods
-
-    DEFAULT_OPTION = ClassMethods::DEFAULT_OPTION
-
-    # @param data [Hash, Object] The data source used to populate configuration
-    #   values. Can be a Hash or a data object. If the data source is nil, or no
-    #   data source is given, values will be set to their respective defaults.
-    def initialize data = nil
-      @__data__           = __objectify_data__(data)
-      @__root_namespace__ = self
-
-      yield(singleton_class) if block_given?
-    end # constructor
-
-    def [] key
-      send(key) if respond_to?(key)
-    end # method []
-
-    def []= key, value
-      send(:"#{key}=", value)
-    end # method []=
-
-    def dig *keys
-      keys.reduce(self) do |hsh, key|
-        value = hsh[key]
-
-        return value if value.nil?
-
-        value
-      end # reduce
-    end # method dig
-
-    def fetch key, default = DEFAULT_OPTION
-      return send(key) if respond_to?(key)
-
-      return default unless default == DEFAULT_OPTION
-
-      return yield if block_given?
-
-      raise KeyError, 'key not found'
-    end # method fetch
-
-    protected
-
-    attr_accessor :__root_namespace__
-
-    private
-
-    attr_reader :__data__
-
-    def __blank_value__ value
-      value.nil? || (value.respond_to?(:empty?) && value.empty?)
-    end # method __blank_value__
-
-    def __evaluate_default__ default
-      default.is_a?(Proc) ? __root_namespace__.instance_exec(&default) : default
-    end # method __evaluate_default__
-
-    def __get_value__ name, options
-      default_given = options[:default] != DEFAULT_OPTION
-
-      if __data__.respond_to?(name)
-        value = __data__.send name
-
-        if value.nil? && default_given
-          value = __evaluate_default__(options[:default])
-        end # if
-
-        __validate_value__ value, options
-
-        value
-      elsif instance_variable_defined?(:"@#{name}")
-        # Recall values locally if data source is immutable.
-        return instance_variable_get(:"@#{name}")
-      elsif default_given
-        value = __evaluate_default__(options[:default])
-
-        __validate_value__ value, options
-
-        value
-      else
-        __validate_value__ nil, options
-
-        nil
-      end # if-else
-    end # method __get_value__
-
-    def __objectify_data__ data
-      return data unless data.is_a?(Hash)
-
-      return Object.new if data.empty?
-
-      obj = Struct.new(*data.keys).new
-
-      data.each do |key, value|
-        val = value.is_a?(Hash) ? __objectify_data__(value) : value
-
-        obj.send :"#{key}=", val
-      end # each
-
-      obj
-    end # method __objectify_data__
-
-    def __set_value__ name, value, options
-      writer_name = :"#{name}="
-
-      __validate_value__ value, options
-
-      if __data__.respond_to?(writer_name)
-        __data__.send(writer_name, value)
-      else
-        # Store values locally if data source is immutable.
-        instance_variable_set(:"@#{name}", value)
-      end # if-else
-    end # method __set_value__
-
-    def __validate_value__ value, options
-      return if __blank_value__(value) && options[:allow_nil]
-
-      if options[:enum] && !options[:enum].include?(value)
-        array_tools   = ::SleepingKingStudios::Tools::ArrayTools
-        valid_options =
-          array_tools.
-            humanize_list(
-              options[:enum].map(&:inspect),
-              :last_separator => ' or '
-            ) # end humanize_list
-
-        raise RuntimeError,
-          "expected option to be #{valid_options}, but was #{value.inspect}"
-      end # if
-    end # method __validate_value__
-  end # class
-end # module

data/lib/sleeping_king_studios/tools/toolbox/delegator.rb

@@ -1,175 +0,0 @@
-# lib/sleeping_king_studios/tools/toolbox/delegator.rb
-
-require 'sleeping_king_studios/tools/toolbox'
-
-module SleepingKingStudios::Tools::Toolbox
-  # Module for extending classes with basic delegation. Supports passing
-  # arguments, keywords, and blocks to the delegated method.
-  #
-  # @example
-  #   class MyClass
-  #     extend SleepingKingStudios::Tools::Delegator
-  #
-  #     delegate :my_method, :to => MyService
-  #   end # class
-  module Delegator
-    # Defines a wrapper method to delegate implementation of the specified
-    # method or methods to an object, to the object at another specified method,
-    # or to the object at a specified instance variable.
-    #
-    # @example Delegate to an object
-    #   class MyModule
-    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
-    #
-    #     delegate :my_method, :to => MyService
-    #   end # class
-    #
-    # @example Delegate to a method
-    #   class MyModule
-    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
-    #
-    #     def my_service
-    #       MyService.new
-    #     end # method my_service
-    #
-    #     delegate :my_method, :to => :my_service
-    #   end # class
-    #
-    # @example Delegate to an instance variable
-    #   class MyModule
-    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
-    #
-    #     def initialize
-    #       @my_service = MyService.new
-    #     end # constructor
-    #
-    #     delegate :my_method, :to => :@my_service
-    #   end # class
-    #
-    # @param method_names [Array<String, Symbol>] The names of the methods to
-    #   delegate.
-    # @param to [Object, String, Symbol] The object, method, or instance
-    #   variable to delegate to. If the object is not a string or symbol, the
-    #   generated method will call `method_name` on the object. If the object is
-    #   a string or symbol, but does not start with an `@`, the generated method
-    #   will call the method of that name on the instance, and then call
-    #   `method_name` on the result. If the object is a string or symbol and
-    #   does start with an `@`, the generated method will get the instance
-    #   variable of that name and call `method_name` on the result.
-    #
-    # @raise ArgumentError if no delegate is specified.
-    def delegate *method_names, to: nil, allow_nil: false
-      raise ArgumentError.new('must specify a delegate') if to.nil? && !allow_nil
-
-      method_names.each do |method_name|
-        delegate_method method_name, to, { :allow_nil => !!allow_nil }
-      end # each
-    end # method delegate
-
-    # Wraps a delegate object by automatically delegating each method that is
-    # defined on the delegate class from the instance to the delegate. The
-    # delegate can be specified with an object literal or with the name of an
-    # instance method or instance variable.
-    #
-    # Only methods that are defined at the time #wrap_delegate is called will be
-    # delegated, so make sure to call #wrap_delegate after loading any gems or
-    # libraries that extend your delegate class, such as ActiveSupport.
-    #
-    # @example Create a class that wraps a Hash
-    #   class Errors
-    #     extend SleepingKingStudios::Tools::Delegator
-    #
-    #     wrap_delegate Hash.new { |hsh, key| hsh[key] = Errors.new }, :klass => Hash
-    #
-    #     def messages
-    #       @messages ||= []
-    #     end # method messages
-    #   end # class
-    #
-    #   errors = Errors.new
-    #   errors[:post].messages << "title can't be blank"
-    #
-    # @param target [Object, String, Symbol] The object, method, or instance
-    #   variable to delegate to. If the object is not a string or symbol, the
-    #   generated method will call each method on the object. If the object is
-    #   a string or symbol, but does not start with an `@`, the generated method
-    #   will call the method of that name on the instance, and then call
-    #   each method on the result. If the object is a string or symbol and
-    #   does start with an `@`, the generated method will get the instance
-    #   variable of that name and call each method on the result.
-    # @param klass [Module] The class or module whose methods are delegated to
-    #   the target. If target is the name of an instance variable or an instance
-    #   method, the klass must be specified. If target is an object literal, the
-    #   klass is optional, in which case all methods from the target will be
-    #   delegated to the target.
-    # @param except [Array<String, Symbol>] An optional list of method names.
-    #   Any names on the list will not be delegated, even if the method is
-    #   defined by the klass or defined on the target literal.
-    # @param only [Array<String, Symbol>] An optional list of method names.
-    #   Only names on the list will be delegated, and only if the method is
-    #   defined by the klass or defined on the target literal.
-    #
-    # @raise ArgumentError if no delegate is specified.
-    # @raise ArgumentError if the target is the name of an instance method or an
-    #   instance variable and no klass is specified.
-    # @raise ArgumentError if the target is an object literal that does not
-    #   belong to the specified klass.
-    #
-    # @see #delegate
-    def wrap_delegate target, klass: nil, except: [], only: []
-      if klass.is_a?(Module)
-        unless target.is_a?(String) || target.is_a?(Symbol) || target.is_a?(klass)
-          raise ArgumentError.new "expected delegate to be a #{klass.name}"
-        end # unless
-
-        method_names = klass.instance_methods - Object.instance_methods
-      elsif target.is_a?(String) || target.is_a?(Symbol)
-        raise ArgumentError.new 'must specify a delegate class'
-      else
-        method_names = target.methods - Object.new.methods
-      end # if-elsif-else
-
-      if except.is_a?(Array) && !except.empty?
-        method_names = method_names - except.map(&:intern)
-      end # if
-
-      if only.is_a?(Array) && !only.empty?
-        method_names = method_names & only.map(&:intern)
-      end # if
-
-      delegate *method_names, :to => target
-    end # method wrap_delegate
-
-    private
-
-    def delegate_method method_name, target, options = {}
-      if target.is_a?(String) || target.is_a?(Symbol)
-        target = target.intern
-
-        if target.to_s =~ /\A@/
-          define_method method_name do |*args, &block|
-            receiver = instance_variable_get(target)
-
-            return nil if receiver.nil? && options[:allow_nil]
-
-            receiver.send(method_name, *args, &block)
-          end # define_method
-        else
-          define_method method_name do |*args, &block|
-            receiver = send(target)
-
-            return nil if receiver.nil? && options[:allow_nil]
-
-            receiver.send(method_name, *args, &block)
-          end # define_method
-        end # if-else
-      else
-        define_method method_name do |*args, &block|
-          return nil if target.nil? && options[:allow_nil]
-
-          target.send(method_name, *args, &block)
-        end # define_method
-      end # if
-    end # method delegate_method
-  end # module
-end # module