dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/defaults.rb

@@ -1,122 +0,0 @@
-# Load default formatter gem
-require "simplecov-html"
-require "pathname"
-
-SimpleCov.profiles.define "root_filter" do
-  # Exclude all files outside of simplecov root
-  root_filter = nil
-  add_filter do |src|
-    root_filter ||= /\A#{Regexp.escape(SimpleCov.root)}/io
-    !(src.filename =~ root_filter)
-  end
-end
-
-SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
-end
-
-SimpleCov.profiles.define "bundler_filter" do
-  add_filter "/vendor/bundle/"
-end
-
-SimpleCov.profiles.define "rails" do
-  load_profile "test_frameworks"
-
-  add_filter "/config/"
-  add_filter "/db/"
-
-  add_group "Controllers", "app/controllers"
-  add_group "Models", "app/models"
-  add_group "Mailers", "app/mailers"
-  add_group "Helpers", "app/helpers"
-  add_group "Jobs", %w(app/jobs app/workers)
-  add_group "Libraries", "lib"
-
-  track_files "{app,lib}/**/*.rb"
-end
-
-# Default configuration
-SimpleCov.configure do
-  formatter SimpleCov::Formatter::HTMLFormatter
-  load_profile "bundler_filter"
-  # Exclude files outside of SimpleCov.root
-  load_profile "root_filter"
-end
-
-# Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
-SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
-
-at_exit do # rubocop:disable Metrics/BlockLength
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
-
-  @exit_status = if $! # was an exception thrown?
-                   # if it was a SystemExit, use the accompanying status
-                   # otherwise set a non-zero status representing termination by
-                   # some other exception (see github issue 41)
-                   $!.is_a?(SystemExit) ? $!.status : SimpleCov::ExitCodes::EXCEPTION
-                 else
-                   # Store the exit status of the test run since it goes away
-                   # after calling the at_exit proc...
-                   SimpleCov::ExitCodes::SUCCESS
-                 end
-
-  SimpleCov.at_exit.call
-
-  if SimpleCov.result? # Result has been computed
-    covered_percent = SimpleCov.result.covered_percent.round(2)
-    covered_percentages = SimpleCov.result.covered_percentages.map { |p| p.round(2) }
-
-    if @exit_status == SimpleCov::ExitCodes::SUCCESS # No other errors
-      if covered_percent < SimpleCov.minimum_coverage # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("Coverage (%.2f%%) is below the expected minimum coverage (%.2f%%).\n", covered_percent, SimpleCov.minimum_coverage)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file } # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("File (%s) is only (%.2f%%) covered. This is below the expected minimum coverage per file of (%.2f%%).\n", SimpleCov.result.least_covered_file, covered_percentages.min, SimpleCov.minimum_coverage_by_file)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif (last_run = SimpleCov::LastRun.read) # rubocop:disable Metrics/BlockNesting
-        diff = last_run["result"]["covered_percent"] - covered_percent
-        if diff > SimpleCov.maximum_coverage_drop # rubocop:disable Metrics/BlockNesting
-          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", diff, SimpleCov.maximum_coverage_drop)
-          @exit_status = SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-        end
-      end
-    end
-
-    SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
-  end
-
-  # Force exit with stored status (see github issue #5)
-  # unless it's nil or 0 (see github issue #281)
-  Kernel.exit @exit_status if @exit_status && @exit_status > 0
-end
-
-# Autoload config from ~/.simplecov if present
-require "etc"
-home_dir = File.expand_path("~") || Etc.getpwuid.dir || (ENV["USER"] && File.expand_path("~#{ENV['USER']}"))
-if home_dir
-  global_config_path = File.join(home_dir, ".simplecov")
-  load global_config_path if File.exist?(global_config_path)
-end
-
-# Autoload config from .simplecov if present
-# Recurse upwards until we find .simplecov or reach the root directory
-
-config_path = Pathname.new(SimpleCov.root)
-loop do
-  filename = config_path.join(".simplecov")
-  if filename.exist?
-    begin
-      load filename
-    rescue LoadError, StandardError
-      $stderr.puts "Warning: Error occurred while trying to load #{filename}. " \
-        "Error message: #{$!.message}"
-    end
-    break
-  end
-  config_path, = config_path.split
-  break if config_path.root?
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/exit_codes.rb

@@ -1,8 +0,0 @@
-module SimpleCov
-  module ExitCodes
-    SUCCESS = 0
-    EXCEPTION = 1
-    MINIMUM_COVERAGE = 2
-    MAXIMUM_COVERAGE_DROP = 3
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/file_list.rb

@@ -1,59 +0,0 @@
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
-module SimpleCov
-  class FileList < Array
-    # Returns the count of lines that have coverage
-    def covered_lines
-      return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(&:+)
-    end
-
-    # Returns the count of lines that have been missed
-    def missed_lines
-      return 0.0 if empty?
-      map { |f| f.missed_lines.count }.inject(&:+)
-    end
-
-    # Returns the count of lines that are not relevant for coverage
-    def never_lines
-      return 0.0 if empty?
-      map { |f| f.never_lines.count }.inject(&:+)
-    end
-
-    # Returns the count of skipped lines
-    def skipped_lines
-      return 0.0 if empty?
-      map { |f| f.skipped_lines.count }.inject(&:+)
-    end
-
-    # Computes the coverage based upon lines covered and lines missed for each file
-    # Returns an array with all coverage percentages
-    def covered_percentages
-      map(&:covered_percent)
-    end
-
-    # Finds the least covered file and returns that file's name
-    def least_covered_file
-      sort_by(&:covered_percent).first.filename
-    end
-
-    # Returns the overall amount of relevant lines of code across all files in this list
-    def lines_of_code
-      covered_lines + missed_lines
-    end
-
-    # Computes the coverage based upon lines covered and lines missed
-    # @return [Float]
-    def covered_percent
-      return 100.0 if empty? || lines_of_code.zero?
-      Float(covered_lines * 100.0 / lines_of_code)
-    end
-
-    # Computes the strength (hits / line) based upon lines covered and lines missed
-    # @return [Float]
-    def covered_strength
-      return 0.0 if empty? || lines_of_code.zero?
-      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(&:+) / lines_of_code)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/filter.rb

@@ -1,54 +0,0 @@
-module SimpleCov
-  #
-  # Base filter class. Inherit from this to create custom filters,
-  # and overwrite the passes?(source_file) instance method
-  #
-  # # A sample class that rejects all source files.
-  # class StupidFilter < SimpleCov::Filter
-  #   def passes?(source_file)
-  #     false
-  #   end
-  # end
-  #
-  class Filter
-    attr_reader :filter_argument
-    def initialize(filter_argument)
-      @filter_argument = filter_argument
-    end
-
-    def matches?(_)
-      raise "The base filter class is not intended for direct use"
-    end
-
-    def passes?(source_file)
-      warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
-      matches?(source_file)
-    end
-  end
-
-  class StringFilter < SimpleCov::Filter
-    # Returns true when the given source file's filename matches the
-    # string configured when initializing this Filter with StringFilter.new('somestring)
-    def matches?(source_file)
-      (source_file.filename =~ /#{filter_argument}/)
-    end
-  end
-
-  class BlockFilter < SimpleCov::Filter
-    # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
-    # returns true for the given source file.
-    def matches?(source_file)
-      filter_argument.call(source_file)
-    end
-  end
-
-  class ArrayFilter < SimpleCov::Filter
-    # Returns true if any of the file paths passed in the given array matches the string
-    # configured when initializing this Filter with StringFilter.new(['some/path', 'other/path'])
-    def matches?(source_files_list)
-      filter_argument.any? do |arg|
-        source_files_list.filename =~ /#{arg}/
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/formatter/multi_formatter.rb

@@ -1,32 +0,0 @@
-module SimpleCov
-  module Formatter
-    class MultiFormatter
-      module InstanceMethods
-        def format(result)
-          formatters.map do |formatter|
-            begin
-              formatter.new.format(result)
-            rescue => e
-              STDERR.puts("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
-              nil
-            end
-          end
-        end
-      end
-
-      def self.new(formatters = nil)
-        Class.new do
-          define_method :formatters do
-            @formatters ||= Array(formatters)
-          end
-          include InstanceMethods
-        end
-      end
-
-      def self.[](*args)
-        warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
-        new(Array([*args]))
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/formatter/simple_formatter.rb

@@ -1,23 +0,0 @@
-#
-# A ridiculously simple formatter for SimpleCov results.
-#
-module SimpleCov
-  module Formatter
-    class SimpleFormatter
-      # Takes a SimpleCov::Result and generates a string out of it
-      def format(result)
-        output = ""
-        result.groups.each do |name, files|
-          output << "Group: #{name}\n"
-          output << "=" * 40
-          output << "\n"
-          files.each do |file|
-            output << "#{file.filename} (coverage: #{file.covered_percent.round(2)}%)\n"
-          end
-          output << "\n"
-        end
-        output
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/formatter.rb

@@ -1,8 +0,0 @@
-module SimpleCov
-  # TODO: Documentation on how to build your own formatters
-  module Formatter
-  end
-end
-
-require "simplecov/formatter/simple_formatter"
-require "simplecov/formatter/multi_formatter"

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/jruby_fix.rb

@@ -1,42 +0,0 @@
-if defined?(JRUBY_VERSION) && JRUBY_VERSION.to_f < 1.7
-  require "jruby"
-  java_import "org.jruby.ast.NodeType"
-
-  # Coverage for JRuby < 1.7.0 does not work correctly
-  #
-  #  - does not distinguish lines that cannot be executed
-  #  - does (partial) coverage for files loaded before `Coverage.start`.
-  #  - does not expand a path like `lib/../spec` to `spec`.
-  #
-  # This monkey patches Coverage to address those issues
-  module Coverage
-    class << self
-      alias __broken_result__ result
-
-      def result # rubocop:disable Metrics/MethodLength
-        fixed = {}
-        __broken_result__.each do |path, executed_lines|
-          next unless File.file? path
-
-          covered_lines = executed_lines.dup
-
-          process = lambda do |node|
-            if node.node_type == NodeType::NEWLINENODE
-              pos = node.position
-              covered_lines[pos.line] ||= 0
-            end
-            node.child_nodes.each(&process)
-          end
-
-          process[JRuby.parse(File.read(path), path)]
-
-          if (first = covered_lines.detect { |x| x }) && first > 0
-            fixed[File.expand_path(path)] = covered_lines
-          end
-        end
-
-        fixed
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/last_run.rb

@@ -1,22 +0,0 @@
-require "json"
-
-module SimpleCov
-  module LastRun
-    class << self
-      def last_run_path
-        File.join(SimpleCov.coverage_path, ".last_run.json")
-      end
-
-      def read
-        return nil unless File.exist?(last_run_path)
-        JSON.parse(File.read(last_run_path))
-      end
-
-      def write(json)
-        File.open(last_run_path, "w+") do |f|
-          f.puts JSON.pretty_generate(json)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/merge_helpers.rb

@@ -1,37 +0,0 @@
-module SimpleCov
-  module ArrayMergeHelper
-    # Merges an array of coverage results with self
-    def merge_resultset(array)
-      new_array = dup
-      array.each_with_index do |element, i|
-        pair = [element, new_array[i]]
-        new_array[i] = if pair.any?(&:nil?) && pair.map(&:to_i).all?(&:zero?)
-                         nil
-                       else
-                         element.to_i + new_array[i].to_i
-                       end
-      end
-      new_array
-    end
-  end
-end
-
-module SimpleCov
-  module HashMergeHelper
-    # Merges the given Coverage.result hash with self
-    def merge_resultset(hash)
-      new_resultset = {}
-      (keys + hash.keys).each do |filename|
-        new_resultset[filename] = nil
-      end
-
-      new_resultset.each_key do |filename|
-        result1 = self[filename]
-        result2 = hash[filename]
-        new_resultset[filename] =
-          result1 && result2 ? result1.extend(ArrayMergeHelper).merge_resultset(result2) : (result1 || result2).dup
-      end
-      new_resultset
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/no_defaults.rb

@@ -1,2 +0,0 @@
-ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
-require "simplecov"

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/profiles.rb

@@ -1,31 +0,0 @@
-#
-# Profiles are SimpleCov configuration procs that can be easily
-# loaded using SimpleCov.start :rails and defined using
-#   SimpleCov.profiles.define :foo do
-#     # SimpleCov configuration here, same as in  SimpleCov.configure
-#   end
-#
-module SimpleCov
-  class Profiles < Hash
-    #
-    # Define a SimpleCov profile:
-    #   SimpleCov.profiles.define 'rails' do
-    #     # Same as SimpleCov.configure do .. here
-    #   end
-    #
-    def define(name, &blk)
-      name = name.to_sym
-      raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
-      self[name] = blk
-    end
-
-    #
-    # Applies the profile of given name on SimpleCov.configure
-    #
-    def load(name)
-      name = name.to_sym
-      raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
-      SimpleCov.configure(&self[name])
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/railtie.rb

@@ -1,7 +0,0 @@
-module SimpleCov
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load "simplecov/railties/tasks.rake"
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/railties/tasks.rake

@@ -1,11 +0,0 @@
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.name = "simplecov"
-  t.loader = :direct # uses require() which skips PWD in Ruby 1.9
-  t.libs.push "test", "spec", Dir.pwd
-  t.test_files = FileList["{test,spec}/**/*_{test,spec}.rb"]
-  t.ruby_opts.push "-r", "simplecov", "-e", "SimpleCov.start(:rails)".inspect
-end
-
-require "rake/clean"
-CLOBBER.include "coverage"

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/result.rb

@@ -1,87 +0,0 @@
-require "digest/sha1"
-require "forwardable"
-
-module SimpleCov
-  #
-  # A simplecov code coverage result, initialized from the Hash Ruby 1.9's built-in coverage
-  # library generates (Coverage.result).
-  #
-  class Result
-    extend Forwardable
-    # Returns the original Coverage.result used for this instance of SimpleCov::Result
-    attr_reader :original_result
-    # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
-    attr_reader :files
-    alias source_files files
-    # Explicitly set the Time this result has been created
-    attr_writer :created_at
-    # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
-    attr_writer :command_name
-
-    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines
-    def_delegator :files, :lines_of_code, :total_lines
-
-    # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
-    # coverage data)
-    def initialize(original_result)
-      original_result = original_result.dup.extend(SimpleCov::HashMergeHelper) unless original_result.is_a? SimpleCov::HashMergeHelper
-      @original_result = original_result.freeze
-      @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)
-      end.compact.sort_by(&:filename))
-      filter!
-    end
-
-    # Returns all filenames for source files contained in this result
-    def filenames
-      files.map(&:filename)
-    end
-
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
-    def groups
-      @groups ||= SimpleCov.grouped(files)
-    end
-
-    # Applies the configured SimpleCov.formatter on this result
-    def format!
-      SimpleCov.formatter.new.format(self)
-    end
-
-    # Defines when this result has been created. Defaults to Time.now
-    def created_at
-      @created_at ||= Time.now
-    end
-
-    # The command name that launched this result.
-    # Delegated to SimpleCov.command_name if not set manually
-    def command_name
-      @command_name ||= SimpleCov.command_name
-    end
-
-    # Returns a hash representation of this Result that can be used for marshalling it into JSON
-    def to_hash
-      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
-    end
-
-    # Loads a SimpleCov::Result#to_hash dump
-    def self.from_hash(hash)
-      command_name, data = hash.first
-      result = SimpleCov::Result.new(data["coverage"])
-      result.command_name = command_name
-      result.created_at = Time.at(data["timestamp"])
-      result
-    end
-
-  private
-
-    def coverage
-      keys = original_result.keys & filenames
-      Hash[keys.zip(original_result.values_at(*keys))]
-    end
-
-    # Applies all configured SimpleCov filters on this result's source files
-    def filter!
-      @files = SimpleCov.filtered(files)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/simplecov-0.13.0/lib/simplecov/result_merger.rb

@@ -1,88 +0,0 @@
-require "json"
-
-#
-# Singleton that is responsible for caching, loading and merging
-# SimpleCov::Results into a single result for coverage analysis based
-# upon multiple test suites.
-#
-module SimpleCov
-  module ResultMerger
-    class << self
-      # The path to the .resultset.json cache file
-      def resultset_path
-        File.join(SimpleCov.coverage_path, ".resultset.json")
-      end
-
-      def resultset_writelock
-        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
-      end
-
-      # Loads the cached resultset from JSON and returns it as a Hash
-      def resultset
-        if stored_data
-          begin
-            JSON.parse(stored_data)
-          rescue
-            {}
-          end
-        else
-          {}
-        end
-      end
-
-      # Returns the contents of the resultset cache as a string or if the file is missing or empty nil
-      def stored_data
-        return unless File.exist?(resultset_path)
-        data = File.read(resultset_path)
-        return if data.nil? || data.length < 2
-        data
-      end
-
-      # Gets the resultset hash and re-creates all included instances
-      # of SimpleCov::Result from that.
-      # All results that are above the SimpleCov.merge_timeout will be
-      # dropped. Returns an array of SimpleCov::Result items.
-      def results
-        results = []
-        resultset.each do |command_name, data|
-          result = SimpleCov::Result.from_hash(command_name => data)
-          # Only add result if the timeout is above the configured threshold
-          if (Time.now - result.created_at) < SimpleCov.merge_timeout
-            results << result
-          end
-        end
-        results
-      end
-
-      #
-      # Gets all SimpleCov::Results from cache, merges them and produces a new
-      # SimpleCov::Result with merged coverage data and the command_name
-      # for the result consisting of a join on all source result's names
-      #
-      def merged_result
-        merged = {}
-        results.each do |result|
-          merged = result.original_result.merge_resultset(merged)
-        end
-        result = SimpleCov::Result.new(merged)
-        # Specify the command name
-        result.command_name = results.map(&:command_name).sort.join(", ")
-        result
-      end
-
-      # Saves the given SimpleCov::Result in the resultset cache
-      def store_result(result)
-        File.open(resultset_writelock, "w+") do |f|
-          f.flock(File::LOCK_EX)
-          new_set = resultset
-          command_name, data = result.to_hash.first
-          new_set[command_name] = data
-          File.open(resultset_path, "w+") do |f_|
-            f_.puts JSON.pretty_generate(new_set)
-          end
-        end
-        true
-      end
-    end
-  end
-end