sigterm_extensions 0.0.4

data/lib/sigterm_extensions/concern.rb

@@ -0,0 +1,169 @@
+module SigtermExtensions
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>SigtermExtensions::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'sigterm_extensions/concern'
+  #
+  #   module M
+  #     extend SigtermExtensions::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>SigtermExtensions::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'sigterm_extensions/concern'
+  #
+  #   module Foo
+  #     extend SigtermExtensions::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend SigtermExtensions::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base) #:nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.include(dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +included+ block, it raises an exception.
+    def included(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_included_block)
+          if @_included_block.source_location != block.source_location
+            raise MultipleIncludedBlocks
+          end
+        else
+          @_included_block = block
+        end
+      else
+        super
+      end
+    end
+
+    # Define class methods from given block.
+    # You can define private class methods as well.
+    #
+    #   module Example
+    #     extend ActiveSupport::Concern
+    #
+    #     class_methods do
+    #       def foo; puts 'foo'; end
+    #
+    #       private
+    #         def bar; puts 'bar'; end
+    #     end
+    #   end
+    #
+    #   class Buzz
+    #     include Example
+    #   end
+    #
+    #   Buzz.foo # => "foo"
+    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end

data/lib/sigterm_extensions/configurable.rb

@@ -0,0 +1,38 @@
+module SigtermExtensions
+  module Configurable
+    def self.with(*attrs)
+      not_provided = Object.new
+
+      config_class = Class.new do
+        attrs.each do |attr|
+          define_method attr do |value = not_provided, &block|
+            if value === not_provided && block.nil?
+              result = instance_variable_get("@#{attr}")
+              result.is_a?(Proc) ? instance_eval(&result) : result
+            else
+              instance_variable_set("@#{attr}", block || value)
+            end
+          end
+        end
+
+        attr_writer *attrs
+      end
+
+      class_methods = Module.new do
+        define_method :config do
+          @config ||= config_class.new
+        end
+
+        def configure(&block)
+          config.instance_eval(&block)
+        end
+      end
+
+      Module.new do
+        singleton_class.send :define_method, :included do |host_class|
+          host_class.extend class_methods
+        end
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/core_ext.rb

@@ -0,0 +1,4 @@
+
+Dir[File.expand_path("core_ext/**/*.rb", __dir__)].each do |path|
+  require path
+end

data/lib/sigterm_extensions/core_ext/array.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.expand_path('array/*.rb', __dir__)).each do |path|
+  require path
+end

data/lib/sigterm_extensions/core_ext/array/extract.rb

@@ -0,0 +1,19 @@
+class Array
+  # Removes and returns the elements for which the block returns a true value.
+  # If no block is given, an Enumerator is returned instead.
+  #
+  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+  #   numbers # => [0, 2, 4, 6, 8]
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if yield(element)
+    end
+
+    extracted_elements
+  end
+end

data/lib/sigterm_extensions/core_ext/array/extract_options.rb

@@ -0,0 +1,29 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/sigterm_extensions/core_ext/class.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.expand_path('class/*.rb', __dir__)).each do |path|
+  require path
+end

data/lib/sigterm_extensions/core_ext/class/attribute.rb

@@ -0,0 +1,139 @@
+require "sigterm_extensions/core_ext/kernel/singleton_class"
+require "sigterm_extensions/core_ext/module/redefine_method"
+require "sigterm_extensions/core_ext/array/extract_options"
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  # ==== Options
+  #
+  # * <tt>:instance_reader</tt> - Sets the instance reader method (defaults to true).
+  # * <tt>:instance_writer</tt> - Sets the instance writer method (defaults to true).
+  # * <tt>:instance_accessor</tt> - Sets both instance methods (defaults to true).
+  # * <tt>:instance_predicate</tt> - Sets a predicate method (defaults to true).
+  # * <tt>:default</tt> - Sets a default value for the attribute (defaults to nil).
+  #
+  # ==== Examples
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_</tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in place. Instead use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  #
+  # To set a default value for the attribute, pass <tt>default:</tt>, like so:
+  #
+  #   class_attribute :settings, default: {}
+  def class_attribute(
+    *attrs,
+    instance_accessor: true,
+    instance_reader: instance_accessor,
+    instance_writer: instance_accessor,
+    instance_predicate: true,
+    default: nil
+  )
+    attrs.each do |name|
+      singleton_class.silence_redefinition_of_method(name)
+      define_singleton_method(name) { default }
+
+      singleton_class.silence_redefinition_of_method("#{name}?")
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}".to_sym
+
+      singleton_class.silence_redefinition_of_method("#{name}=")
+      define_singleton_method("#{name}=") do |val|
+        redefine_singleton_method(name) { val }
+
+        if singleton_class?
+          class_eval do
+            redefine_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        redefine_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+
+        redefine_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      if instance_writer
+        redefine_method("#{name}=") do |val|
+          instance_variable_set ivar, val
+        end
+      end
+    end
+  end
+end

data/lib/sigterm_extensions/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,4 @@
+# cattr_* became mattr_* aliases in 7dfbd91b0780fbd6a1dd9bfbc176e10894871d2d,
+# but we keep this around for libraries that directly require it knowing they
+# want cattr_*. No need to deprecate.
+require "sigterm_extensions/core_ext/module/attribute_accessors"

data/lib/sigterm_extensions/core_ext/class/subclasses.rb

@@ -0,0 +1,52 @@
+class Class
+  begin
+    # Test if this Ruby supports each_object against singleton_class
+    ObjectSpace.each_object(Numeric.singleton_class) { }
+
+    # Returns an array with all classes that are < than its receiver.
+    #
+    #   class C; end
+    #   C.descendants # => []
+    #
+    #   class B < C; end
+    #   C.descendants # => [B]
+    #
+    #   class A < B; end
+    #   C.descendants # => [B, A]
+    #
+    #   class D < C; end
+    #   C.descendants # => [B, A, D]
+    def descendants
+      descendants = []
+      ObjectSpace.each_object(singleton_class) do |k|
+        next if k.singleton_class?
+        descendants.unshift k unless k == self
+      end
+      descendants
+    end
+  rescue StandardError # JRuby 9.0.4.0 and earlier
+    def descendants
+      descendants = []
+      ObjectSpace.each_object(Class) do |k|
+        descendants.unshift k if k < self
+      end
+      descendants.uniq!
+      descendants
+    end
+  end
+
+  # Returns an array with the direct children of +self+.
+  #
+  #   class Foo; end
+  #   class Bar < Foo; end
+  #   class Baz < Bar; end
+  #
+  #   Foo.subclasses # => [Bar]
+  def subclasses
+    subclasses, chain = [], descendants
+    chain.each do |k|
+      subclasses << k unless chain.any? { |c| c > k }
+    end
+    subclasses
+  end
+end