sigterm_extensions 0.0.4

data/lib/git/remote.rb

@@ -0,0 +1,36 @@
+module Git
+  class Remote < Path
+    
+    attr_accessor :name, :url, :fetch_opts
+    
+    def initialize(base, name)
+      @base = base
+      config = @base.lib.config_remote(name)
+      @name = name
+      @url = config['url']
+      @fetch_opts = config['fetch']
+    end
+    
+    def fetch(opts={})
+      @base.fetch(@name, opts)
+    end
+    
+    # merge this remote locally
+    def merge(branch = 'master')
+      @base.merge("#{@name}/#{branch}")
+    end
+    
+    def branch(branch = 'master')
+      Git::Branch.new(@base, "#{@name}/#{branch}")
+    end
+    
+    def remove
+      @base.lib.remote_remove(@name)     
+    end
+    
+    def to_s
+      @name
+    end
+    
+  end
+end

data/lib/git/repository.rb

@@ -0,0 +1,6 @@
+module Git
+
+  class Repository < Path
+  end
+
+end

data/lib/git/stash.rb

@@ -0,0 +1,27 @@
+module Git
+  class Stash
+    
+    def initialize(base, message, existing=false)
+      @base = base
+      @message = message
+      save unless existing
+    end
+    
+    def save
+      @saved = @base.lib.stash_save(@message)
+    end
+    
+    def saved?
+      @saved
+    end
+    
+    def message
+      @message
+    end
+    
+    def to_s
+      message
+    end
+    
+  end
+end

data/lib/git/stashes.rb

@@ -0,0 +1,55 @@
+module Git
+  
+  # object that holds all the available stashes
+  class Stashes
+    include Enumerable
+    
+    def initialize(base)
+      @stashes = []
+      
+      @base = base
+            
+      @base.lib.stashes_all.each do |id, message|
+        @stashes.unshift(Git::Stash.new(@base, message, true))
+      end
+    end
+
+    #
+    # Returns an multi-dimensional Array of elements that have been stash saved.
+    # Array is based on position and name. See Example
+    #
+    # @example Returns Array of items that have been stashed
+    #     .all - [0, "testing-stash-all"]]
+    # @return [Array]
+    def all
+      @base.lib.stashes_all
+    end
+    
+    def save(message)
+      s = Git::Stash.new(@base, message)
+      @stashes.unshift(s) if s.saved?
+    end
+    
+    def apply(index=nil)
+      @base.lib.stash_apply(index)
+    end
+    
+    def clear
+      @base.lib.stash_clear
+      @stashes = []
+    end
+
+    def size
+      @stashes.size
+    end
+    
+    def each(&block)
+      @stashes.each(&block)
+    end
+    
+    def [](index)
+      @stashes[index.to_i]
+    end
+    
+  end
+end

data/lib/git/status.rb

@@ -0,0 +1,199 @@
+module Git
+  #
+  # A class for git status
+  #
+  class Status
+    include Enumerable
+
+    def initialize(base)
+      @base = base
+      construct_status
+    end
+
+    #
+    # Returns an Enumerable containing files that have changed from the
+    # git base directory
+    #
+    # @return [Enumerable]
+    def changed
+      @files.select { |_k, f| f.type == 'M' }
+    end
+
+    #
+    # Determines whether the given file has been changed.
+    # File path starts at git base directory
+    #
+    # @param file [String] The name of the file.
+    # @example Check if lib/git.rb has changed.
+    #     changed?('lib/git.rb')
+    # @return [Boolean]
+    def changed?(file)
+      changed.member?(file)
+    end
+
+    #
+    # Returns an Enumerable containing files that have been added.
+    # File path starts at git base directory
+    #
+    # @return [Enumerable]
+    def added
+      @files.select { |_k, f| f.type == 'A' }
+    end
+
+    #
+    # Determines whether the given file has been added to the repository
+    # File path starts at git base directory
+    #
+    # @param file [String] The name of the file.
+    # @example Check if lib/git.rb is added.
+    #     added?('lib/git.rb')
+    # @return [Boolean]
+    def added?(file)
+      added.member?(file)
+    end
+
+    #
+    # Returns an Enumerable containing files that have been deleted.
+    # File path starts at git base directory
+    #
+    # @return [Enumerable]
+    def deleted
+      @files.select { |_k, f| f.type == 'D' }
+    end
+
+    #
+    # Determines whether the given file has been deleted from the repository
+    # File path starts at git base directory
+    #
+    # @param file [String] The name of the file.
+    # @example Check if lib/git.rb is deleted.
+    #     deleted?('lib/git.rb')
+    # @return [Boolean]
+    def deleted?(file)
+      deleted.member?(file)
+    end
+
+    #
+    # Returns an Enumerable containing files that are not tracked in git.
+    # File path starts at git base directory
+    #
+    # @return [Enumerable]
+    def untracked
+      @files.select { |_k, f| f.untracked }
+    end
+
+    #
+    # Determines whether the given file has is tracked by git.
+    # File path starts at git base directory
+    #
+    # @param file [String] The name of the file.
+    # @example Check if lib/git.rb is an untracked file.
+    #     untracked?('lib/git.rb')
+    # @return [Boolean]
+    def untracked?(file)
+      untracked.member?(file)
+    end
+
+    def pretty
+      out = ''
+      each do |file|
+        out << pretty_file(file)
+      end
+      out << "\n"
+      out
+    end
+
+    def pretty_file(file)
+      <<-FILE.strip_heredoc
+        #{file.path}
+        \tsha(r) #{file.sha_repo} #{file.mode_repo}
+        \tsha(i) #{file.sha_index} #{file.mode_index}
+        \ttype   #{file.type}
+        \tstage  #{file.stage}
+        \tuntrac #{file.untracked}
+      FILE
+    end
+
+    # enumerable method
+
+    def [](file)
+      @files[file]
+    end
+
+    def each(&block)
+      @files.values.each(&block)
+    end
+
+    # subclass that does heavy lifting
+    class StatusFile
+      attr_accessor :path, :type, :stage, :untracked
+      attr_accessor :mode_index, :mode_repo
+      attr_accessor :sha_index, :sha_repo
+
+      def initialize(base, hash)
+        @base = base
+        @path = hash[:path]
+        @type = hash[:type]
+        @stage = hash[:stage]
+        @mode_index = hash[:mode_index]
+        @mode_repo = hash[:mode_repo]
+        @sha_index = hash[:sha_index]
+        @sha_repo = hash[:sha_repo]
+        @untracked = hash[:untracked]
+      end
+
+      def blob(type = :index)
+        if type == :repo
+          @base.object(@sha_repo)
+        else
+          begin
+            @base.object(@sha_index)
+          rescue
+            @base.object(@sha_repo)
+          end
+        end
+      end
+    end
+
+    private
+
+    def construct_status
+      @files = @base.lib.ls_files
+
+      fetch_untracked
+      fetch_modified
+      fetch_added
+
+      @files.each do |k, file_hash|
+        @files[k] = StatusFile.new(@base, file_hash)
+      end
+    end
+
+    def fetch_untracked
+      ignore = @base.lib.ignored_files
+
+      Dir.chdir(@base.dir.path) do
+        Dir.glob('**/*', File::FNM_DOTMATCH) do |file|
+          next if @files[file] || File.directory?(file) ||
+                  ignore.include?(file) || file =~ %r{^.git\/.+}
+
+          @files[file] = { path: file, untracked: true }
+        end
+      end
+    end
+
+    def fetch_modified
+      # find modified in tree
+      @base.lib.diff_files.each do |path, data|
+        @files[path] ? @files[path].merge!(data) : @files[path] = data
+      end
+    end
+
+    def fetch_added
+      # find added but not committed - new files
+      @base.lib.diff_index('HEAD').each do |path, data|
+        @files[path] ? @files[path].merge!(data) : @files[path] = data
+      end
+    end
+  end
+end

data/lib/git/version.rb

@@ -0,0 +1,5 @@
+module Git
+  # The current gem version
+  # @return [String] the current gem version.
+  VERSION='1.5.0'
+end

data/lib/git/working_directory.rb

@@ -0,0 +1,4 @@
+module Git
+  class WorkingDirectory < Git::Path
+  end
+end

data/lib/sigterm_extensions.rb

@@ -0,0 +1,75 @@
+require 'erb'
+require 'yaml'
+require 'ostruct'
+require 'rake'
+require 'awesome_print'
+require 'pry'
+require 'logger'
+
+Rake.application.options.trace = true
+ENV['EDITOR'] = 'vim' if ENV['EDITOR'].nil?
+ENV['SHELL'] = '/bin/bash' if ENV['SHELL'].nil?
+
+module SigtermExtensions
+  def self.root_path(*args)
+    File.join File.expand_path('../', __dir__), *args
+  end
+
+  def self.ext_path(*args)
+    File.join SigtermExtensions.root_path, 'lib/sigterm_extensions', args
+  end
+
+  def self.revision
+    `git log --pretty=format:%h --abbrev=11 -n 1`
+  end
+
+  alias :orig_require :require
+  def self.require s
+    print "Requires #{s}\n" if orig_require(s)
+  end
+
+  def self.get_classes_from mod
+    mod.constants.select { |k| mod.const_get(k).instance_of? Class }
+  end
+
+  autoload :BacktraceCleaner, SigtermExtensions.ext_path('backtrace_cleaner')
+  autoload :Callbacks, SigtermExtensions.ext_path('callbacks')
+  autoload :Concern, SigtermExtensions.ext_path('concern')
+  autoload :Configurable, SigtermExtensions.ext_path('configurable')
+  autoload :DescendantsTracker, SigtermExtensions.ext_path('descendants_tracker')
+  autoload :GemMethods, SigtermExtensions.ext_path('gem_methods')
+  autoload :Git, SigtermExtensions.root_path('lib/git')
+  autoload :HashBinding, SigtermExtensions.ext_path('hash_binding')
+  autoload :Inflector, SigtermExtensions.ext_path('inflector')
+  autoload :Lazy, SigtermExtensions.ext_path('lazy')
+  autoload :Paths, SigtermExtensions.ext_path('paths')
+  autoload :ProxyObject, SigtermExtensions.ext_path('proxy_object')
+  autoload :Wrappable, SigtermExtensions.ext_path('wrappable')
+
+  def self.all_requirements
+    $LOADED_FEATURES.
+      select { |feature| feature.include? 'gems' }.
+      map { |feature| File.dirname(feature) }.
+      map { |feature| feature.split('/').last }.
+      uniq.sort
+  end
+
+  def self.all_required_unfiltered
+    $LOADED_FEATURES
+  end
+
+  class RuntimeClassBase
+    attr_accessor :settings
+  end
+
+  class RuntimeClass
+    def self.new(base=RuntimeClassBase, options={}, &block)
+      base = Class.new(base)
+      base.class_eval(&block) if block_given?
+      base
+    end
+  end
+end
+
+require_relative 'sigterm_extensions/all'
+

data/lib/sigterm_extensions/all.rb

@@ -0,0 +1,12 @@
+require_relative 'core_ext'
+require_relative 'version'
+require_relative 'lazy_load_hooks'
+
+lib_dir = File.expand_path('..', __dir__)
+$:.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+staging_dir = File.expand_path('staging', __dir__)
+Dir["#{staging_dir}/*.rb"].each do |ext|
+  require ext
+end
+

data/lib/sigterm_extensions/backtrace_cleaner.rb

@@ -0,0 +1,129 @@
+module SigtermExtensions
+  # Backtraces often include many lines that are not relevant for the context
+  # under review. This makes it hard to find the signal amongst the backtrace
+  # noise, and adds debugging time. With a BacktraceCleaner, filters and
+  # silencers are used to remove the noisy lines, so that only the most relevant
+  # lines remain.
+  #
+  # Filters are used to modify lines of data, while silencers are used to remove
+  # lines entirely. The typical filter use case is to remove lengthy path
+  # information from the start of each line, and view file paths relevant to the
+  # app directory instead of the file system root. The typical silencer use case
+  # is to exclude the output of a noisy library from the backtrace, so that you
+  # can focus on the rest.
+  #
+  #   bc = SigtermExtensions::BacktraceCleaner.new
+  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
+  #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
+  #   bc.clean(exception.backtrace) # perform the cleanup
+  #
+  # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+  # and show as much data as possible, you can always call
+  # <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the
+  # backtrace to a pristine state. If you need to reconfigure an existing
+  # BacktraceCleaner so that it does not filter or modify the paths of any lines
+  # of the backtrace, you can call <tt>BacktraceCleaner#remove_filters!</tt>
+  # These two methods will give you a completely untouched backtrace.
+  #
+  # Inspired by the Quiet Backtrace gem by thoughtbot.
+  class BacktraceCleaner
+    def initialize
+      @filters, @silencers = [], []
+      add_gem_filter
+      add_gem_silencer
+      add_stdlib_silencer
+    end
+
+    # Returns the backtrace after all filters and silencers have been run
+    # against it. Filters run first, then silencers.
+    def clean(backtrace, kind = :silent)
+      filtered = filter_backtrace(backtrace)
+
+      case kind
+      when :silent
+        silence(filtered)
+      when :noise
+        noise(filtered)
+      else
+        filtered
+      end
+    end
+    alias :filter :clean
+
+    # Adds a filter from the block provided. Each line in the backtrace will be
+    # mapped against this filter.
+    #
+    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
+    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+    def add_filter(&block)
+      @filters << block
+    end
+
+    # Adds a silencer from the block provided. If the silencer returns +true+
+    # for a given line, it will be excluded from the clean backtrace.
+    #
+    #   # Will reject all lines that include the word "puma", like "/gems/puma/server.rb" or "/app/my_puma_server/rb"
+    #   backtrace_cleaner.add_silencer { |line| /puma/.match?(line) }
+    def add_silencer(&block)
+      @silencers << block
+    end
+
+    # Removes all silencers, but leaves in the filters. Useful if your
+    # context of debugging suddenly expands as you suspect a bug in one of
+    # the libraries you use.
+    def remove_silencers!
+      @silencers = []
+    end
+
+    # Removes all filters, but leaves in the silencers. Useful if you suddenly
+    # need to see entire filepaths in the backtrace that you had already
+    # filtered out.
+    def remove_filters!
+      @filters = []
+    end
+
+    private
+      FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
+
+      def add_gem_filter
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        return if gems_paths.empty?
+
+        gems_regexp = %r{(#{gems_paths.join('|')})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
+        gems_result = '\3 (\4) \5'
+        add_filter { |line| line.sub(gems_regexp, gems_result) }
+      end
+
+      def add_gem_silencer
+        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
+      end
+
+      def add_stdlib_silencer
+        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
+      end
+
+      def filter_backtrace(backtrace)
+        @filters.each do |f|
+          backtrace = backtrace.map { |line| f.call(line) }
+        end
+
+        backtrace
+      end
+
+      def silence(backtrace)
+        @silencers.each do |s|
+          backtrace = backtrace.reject { |line| s.call(line) }
+        end
+
+        backtrace
+      end
+
+      def noise(backtrace)
+        backtrace.select do |line|
+          @silencers.any? do |s|
+            s.call(line)
+          end
+        end
+      end
+  end
+end