sigterm_extensions 0.0.4

data/lib/sigterm_extensions/interactive_editor.rb

@@ -0,0 +1,120 @@
+# vim: set syntax=ruby :
+# Giles Bowkett, Greg Brown, and several audience members from Giles' Ruby East presentation.
+# http://gilesbowkett.blogspot.com/2007/10/use-vi-or-any-text-editor-from-within.html
+
+require 'irb'
+require 'fileutils'
+require 'tempfile'
+require 'shellwords'
+require 'yaml'
+
+class InteractiveEditor
+  VERSION = '0.0.11'
+  EDITORS = Hash.new { |h,k| h[k] = InteractiveEditor.new(k) }
+
+  attr_accessor :editor
+
+  def initialize(editor)
+    @editor = editor.to_s
+  end
+
+  def edit(object, file=nil)
+    object = object == TOPLEVEL_BINDING.eval('self') ? nil : object
+
+    current_file = if file
+      FileUtils.touch(file) unless File.exist?(file)
+      File.new(file)
+    else
+      if @file && File.exist?(@file.path) && !object
+        @file
+      else
+        Tempfile.new( object ? ["yobj_tempfile", ".yml"] : ["irb_tempfile", ".rb"] )
+      end
+    end
+
+    if object
+      File.open( current_file.path, 'w' ) { |f| f << object.to_yaml }
+    else
+      @file = current_file
+      mtime = File.stat(@file.path).mtime
+    end
+
+    args = Shellwords.shellwords(@editor) #parse @editor as arguments could be complex
+    args << current_file.path
+    current_file.close rescue nil
+    Exec.system(*args)
+
+    if object
+      File.exists?(current_file.path) ? YAML.load_file(current_file.path) : object
+    elsif mtime < File.stat(@file.path).mtime
+      execute
+    end
+  end
+
+  def execute
+    eval(IO.read(@file.path), TOPLEVEL_BINDING)
+  end
+
+  def self.edit(editor, self_, file=nil)
+    find_editor[editor].edit(self_, file)
+  end
+
+  def self.find_editor
+    #maybe serialise last file to disk, for recovery
+    if defined?(Pry) and IRB == Pry
+      IRB.config.interactive_editors ||= EDITORS
+    else
+      IRB.conf[:interactive_editors] ||= EDITORS
+    end
+  end
+
+  module Exec
+    module Java
+      def system(file, *args)
+        require 'spoon'
+        Process.waitpid(Spoon.spawnp(file, *args))
+      rescue Errno::ECHILD => e
+        raise "error exec'ing #{file}: #{e}"
+      end
+    end
+
+    module MRI
+      def system(file, *args)
+        Kernel::system(file, *args) #or raise "error exec'ing #{file}: #{$?}"
+      end
+    end
+
+    extend RUBY_PLATFORM =~ /java/ ? Java : MRI
+  end
+
+  module Editors
+    {
+      :vi    => nil,
+      :vim   => nil,
+      :nvim  => nil,
+      :emacs => nil,
+      :nano  => nil,
+      :mate  => 'mate -w',
+      :subl  => 'subl -wn',
+      :mvim  => 'mvim -g -f' + case ENV['TERM_PROGRAM']
+        when 'iTerm.app';      ' -c "au VimLeave * !open -a iTerm"'
+        when 'Apple_Terminal'; ' -c "au VimLeave * !open -a Terminal"'
+        else '' #don't do tricky things if we don't know the Term
+      end
+    }.each do |k,v|
+      define_method(k) do |*args|
+        InteractiveEditor.edit(v || k, self, *args)
+      end
+    end
+
+    def ed(*args)
+      if ENV['EDITOR'].to_s.size > 0
+        InteractiveEditor.edit(ENV['EDITOR'], self, *args)
+      else
+        raise "You need to set the EDITOR environment variable first"
+      end
+    end
+  end
+end
+
+include InteractiveEditor::Editors

data/lib/sigterm_extensions/lazy.rb

@@ -0,0 +1,34 @@
+module SigtermExtensions
+  # A class that can be wrapped around an expensive method call so it's only
+  # executed when actually needed.
+  #
+  # Usage:
+  #
+  #     object = SigtermExtensions::Lazy.new { some_expensive_work_here }
+  #
+  #     object['foo']
+  #     object.bar
+  class Lazy < BasicObject
+    def initialize(&block)
+      @block = block
+    end
+
+    def method_missing(name, *args, &block)
+      __evaluate__
+
+      @result.__send__(name, *args, &block) # rubocop:disable GitlabSecurity/PublicSend
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      __evaluate__
+
+      @result.respond_to?(name, include_private) || super
+    end
+
+    private
+
+    def __evaluate__
+      @result = @block.call unless defined?(@result)
+    end
+  end
+end

data/lib/sigterm_extensions/lazy_load_hooks.rb

@@ -0,0 +1,79 @@
+module SigtermExtensions
+  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
+  # making the app boot faster. Because of this feature now there is no need to
+  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
+  # configuration. Instead a hook is registered that applies configuration once
+  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
+  # used as example but this feature can be applied elsewhere too.
+  #
+  # Here is an example where +on_load+ method is called to register a hook.
+  #
+  #   initializer 'active_record.initialize_timezone' do
+  #     ActiveSupport.on_load(:active_record) do
+  #       self.time_zone_aware_attributes = true
+  #       self.default_timezone = :utc
+  #     end
+  #   end
+  #
+  # When the entirety of +ActiveRecord::Base+ has been
+  # evaluated then +run_load_hooks+ is invoked. The very last line of
+  # +ActiveRecord::Base+ is:
+  #
+  #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+  module LazyLoadHooks
+    def self.extended(base) # :nodoc:
+      base.class_eval do
+        @load_hooks = Hash.new { |h, k| h[k] = [] }
+        @loaded     = Hash.new { |h, k| h[k] = [] }
+        @run_once   = Hash.new { |h, k| h[k] = [] }
+      end
+    end
+
+    # Declares a block that will be executed when a Rails component is fully
+    # loaded.
+    #
+    # Options:
+    #
+    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
+    # * <tt>:run_once</tt> - Given +block+ will run only once.
+    def on_load(name, options = {}, &block)
+      @loaded[name].each do |base|
+        execute_hook(name, base, options, block)
+      end
+
+      @load_hooks[name] << [block, options]
+    end
+
+    def run_load_hooks(name, base = Object)
+      @loaded[name] << base
+      @load_hooks[name].each do |hook, options|
+        execute_hook(name, base, options, hook)
+      end
+    end
+
+    private
+      def with_execution_control(name, block, once)
+        unless @run_once[name].include?(block)
+          @run_once[name] << block if once
+
+          yield
+        end
+      end
+
+      def execute_hook(name, base, options, block)
+        with_execution_control(name, block, options[:run_once]) do
+          if options[:yield]
+            block.call(base)
+          else
+            if base.is_a?(Module)
+              base.class_eval(&block)
+            else
+              base.instance_eval(&block)
+            end
+          end
+        end
+      end
+  end
+
+  extend LazyLoadHooks
+end

data/lib/sigterm_extensions/option_merger.rb

@@ -0,0 +1,32 @@
+require "sigterm_extensions/core_ext/hash/deep_merge"
+
+module SigtermExtensions
+  class OptionMerger #:nodoc:
+    instance_methods.each do |method|
+      undef_method(method) unless method.match?(/^(__|instance_eval|class|object_id)/)
+    end
+
+    def initialize(context, options)
+      @context, @options = context, options
+    end
+
+    private
+      def method_missing(method, *arguments, &block)
+        options = nil
+        if arguments.first.is_a?(Proc)
+          proc = arguments.pop
+          arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
+        elsif arguments.last.respond_to?(:to_hash)
+          options = @options.deep_merge(arguments.pop)
+        else
+          options = @options
+        end
+
+        if options
+          @context.__send__(method, *arguments, **options, &block)
+        else
+          @context.__send__(method, *arguments, &block)
+        end
+      end
+  end
+end

data/lib/sigterm_extensions/ordered_hash.rb

@@ -0,0 +1,48 @@
+require "yaml"
+
+YAML.add_builtin_type("omap") do |type, val|
+  SigtermExtensions::OrderedHash[val.map { |v| v.to_a.first }]
+end
+
+module SigtermExtensions
+  # DEPRECATED: <tt>SigtermExtensions::OrderedHash</tt> implements a hash that preserves
+  # insertion order.
+  #
+  #   oh = SigtermExtensions::OrderedHash.new
+  #   oh[:a] = 1
+  #   oh[:b] = 2
+  #   oh.keys # => [:a, :b], this order is guaranteed
+  #
+  # Also, maps the +omap+ feature for YAML files
+  # (See https://yaml.org/type/omap.html) to support ordered items
+  # when loading from yaml.
+  #
+  # <tt>SigtermExtensions::OrderedHash</tt> is namespaced to prevent conflicts
+  # with other implementations.
+  class OrderedHash < ::Hash
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def encode_with(coder)
+      coder.represent_seq "!omap", map { |k, v| { k => v } }
+    end
+
+    def select(*args, &block)
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    # Returns true to make sure that this hash is extractable via <tt>Array#extract_options!</tt>
+    def extractable_options?
+      true
+    end
+  end
+end

data/lib/sigterm_extensions/ordered_options.rb

@@ -0,0 +1,83 @@
+require "sigterm_extensions/core_ext/object/blank"
+
+module SigtermExtensions
+  # Usually key value pairs are handled something like this:
+  #
+  #   h = {}
+  #   h[:boy] = 'John'
+  #   h[:girl] = 'Mary'
+  #   h[:boy]  # => 'John'
+  #   h[:girl] # => 'Mary'
+  #   h[:dog]  # => nil
+  #
+  # Using +OrderedOptions+, the above code could be reduced to:
+  #
+  #   h = SigtermExtensions::OrderedOptions.new
+  #   h.boy = 'John'
+  #   h.girl = 'Mary'
+  #   h.boy  # => 'John'
+  #   h.girl # => 'Mary'
+  #   h.dog  # => nil
+  #
+  # To raise an exception when the value is blank, append a
+  # bang to the key name, like:
+  #
+  #   h.dog! # => raises KeyError: :dog is blank
+  #
+  class OrderedOptions < Hash
+    alias_method :_get, :[] # preserve the original #[] method
+    protected :_get # make it protected
+
+    def []=(key, value)
+      super(key.to_sym, value)
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def method_missing(name, *args)
+      name_string = +name.to_s
+      if name_string.chomp!("=")
+        self[name_string] = args.first
+      else
+        bangs = name_string.chomp!("!")
+
+        if bangs
+          self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
+        else
+          self[name_string]
+        end
+      end
+    end
+
+    def respond_to_missing?(name, include_private)
+      true
+    end
+  end
+
+  # +InheritableOptions+ provides a constructor to build an +OrderedOptions+
+  # hash inherited from another hash.
+  #
+  # Use this if you already have some hash and you want to create a new one based on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
+  class InheritableOptions < OrderedOptions
+    def initialize(parent = nil)
+      if parent.kind_of?(OrderedOptions)
+        # use the faster _get when dealing with OrderedOptions
+        super() { |h, k| parent._get(k) }
+      elsif parent
+        super() { |h, k| parent[k] }
+      else
+        super()
+      end
+    end
+
+    def inheritable_copy
+      self.class.new(self)
+    end
+  end
+end

data/lib/sigterm_extensions/paths.rb

@@ -0,0 +1,235 @@
+module SigtermExtensions
+  module Paths
+    # This object is an extended hash that behaves as root of the <tt>SigtermExtensions::Paths</tt> system.
+    # It allows you to collect information about how you want to structure your application
+    # paths through a Hash-like API. It requires you to give a physical path on initialization.
+    #
+    #   root = Root.new "/SigtermExtensions"
+    #   root.add "app/controllers", eager_load: true
+    #
+    # The above command creates a new root object and adds "app/controllers" as a path.
+    # This means we can get a <tt>SigtermExtensions::Paths::Path</tt> object back like below:
+    #
+    #   path = root["app/controllers"]
+    #   path.eager_load?               # => true
+    #   path.is_a?(SigtermExtensions::Paths::Path) # => true
+    #
+    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
+    #
+    #   path.is_a?(Enumerable) # => true
+    #   path.to_ary.inspect    # => ["app/controllers"]
+    #
+    #   path << "lib/controllers"
+    #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
+    #
+    # Notice that when you add a path using +add+, the path object created already
+    # contains the path with the same path value given to +add+. In some situations,
+    # you may not want this behavior, so you can give <tt>:with</tt> as option.
+    #
+    #   root.add "config/routes", with: "config/routes.rb"
+    #   root["config/routes"].inspect # => ["config/routes.rb"]
+    #
+    # The +add+ method accepts the following options as arguments:
+    # eager_load, autoload, autoload_once, and glob.
+    #
+    # Finally, the +Path+ object also provides a few helpers:
+    #
+    #   root = Root.new "/SigtermExtensions"
+    #   root.add "app/controllers"
+    #
+    #   root["app/controllers"].expanded # => ["/SigtermExtensions/app/controllers"]
+    #   root["app/controllers"].existent # => ["/SigtermExtensions/app/controllers"]
+    #
+    # Check the <tt>SigtermExtensions::Paths::Path</tt> documentation for more information.
+    class Root
+      attr_accessor :path
+
+      def initialize(path)
+        @path = path
+        @root = {}
+      end
+
+      def []=(path, value)
+        glob = self[path] ? self[path].glob : nil
+        add(path, with: value, glob: glob)
+      end
+
+      def add(path, options = {})
+        with = Array(options.fetch(:with, path))
+        @root[path] = Path.new(self, path, with, options)
+      end
+
+      def [](path)
+        @root[path]
+      end
+
+      def values
+        @root.values
+      end
+
+      def keys
+        @root.keys
+      end
+
+      def values_at(*list)
+        @root.values_at(*list)
+      end
+
+      def all_paths
+        values.tap(&:uniq!)
+      end
+
+      def autoload_once
+        filter_by(&:autoload_once?)
+      end
+
+      def eager_load
+        filter_by(&:eager_load?)
+      end
+
+      def autoload_paths
+        filter_by(&:autoload?)
+      end
+
+      def load_paths
+        filter_by(&:load_path?)
+      end
+
+    private
+      def filter_by(&block)
+        all_paths.find_all(&block).flat_map { |path|
+          paths = path.existent
+          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
+        }.uniq
+      end
+    end
+
+    def new_root(r)
+      Root.new(r)
+    end
+
+    class Path
+      include Enumerable
+
+      attr_accessor :glob
+
+      def initialize(root, current, paths, options = {})
+        @paths   = paths
+        @current = current
+        @root    = root
+        @glob    = options[:glob]
+        @exclude = options[:exclude]
+
+        options[:autoload_once] ? autoload_once! : skip_autoload_once!
+        options[:eager_load]    ? eager_load!    : skip_eager_load!
+        options[:autoload]      ? autoload!      : skip_autoload!
+        options[:load_path]     ? load_path!     : skip_load_path!
+      end
+
+      def absolute_current # :nodoc:
+        File.expand_path(@current, @root.path)
+      end
+
+      def children
+        keys = @root.keys.find_all { |k|
+          k.start_with?(@current) && k != @current
+        }
+        @root.values_at(*keys.sort)
+      end
+
+      def first
+        expanded.first
+      end
+
+      def last
+        expanded.last
+      end
+
+      %w(autoload_once eager_load autoload load_path).each do |m|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{m}!        # def eager_load!
+            @#{m} = true   #   @eager_load = true
+          end              # end
+                           #
+          def skip_#{m}!   # def skip_eager_load!
+            @#{m} = false  #   @eager_load = false
+          end              # end
+                           #
+          def #{m}?        # def eager_load?
+            @#{m}          #   @eager_load
+          end              # end
+        RUBY
+      end
+
+      def each(&block)
+        @paths.each(&block)
+      end
+
+      def <<(path)
+        @paths << path
+      end
+      alias :push :<<
+
+      def concat(paths)
+        @paths.concat paths
+      end
+
+      def unshift(*paths)
+        @paths.unshift(*paths)
+      end
+
+      def to_ary
+        @paths
+      end
+
+      def extensions # :nodoc:
+        $1.split(",") if @glob =~ /\{([\S]+)\}/
+      end
+
+      # Expands all paths against the root and return all unique values.
+      def expanded
+        raise "You need to set a path root" unless @root.path
+        result = []
+
+        each do |path|
+          path = File.expand_path(path, @root.path)
+
+          if @glob && File.directory?(path)
+            result.concat files_in(path)
+          else
+            result << path
+          end
+        end
+
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent
+        expanded.select do |f|
+          does_exist = File.exist?(f)
+
+          if !does_exist && File.symlink?(f)
+            raise "File #{f.inspect} is a symlink that does not point to a valid file"
+          end
+          does_exist
+        end
+      end
+
+      def existent_directories
+        expanded.select { |d| File.directory?(d) }
+      end
+
+      alias to_a expanded
+
+      private
+        def files_in(path)
+          files = Dir.glob(@glob, base: path)
+          files -= @exclude if @exclude
+          files.map! { |file| File.join(path, file) }
+          files.sort
+        end
+    end
+  end
+end