suzuko 0.1.7

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/file_list.rb

@@ -0,0 +1,48 @@
+# 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
+
+    # 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.0.0/gems/simplecov-0.10.0/lib/simplecov/filter.rb

@@ -0,0 +1,54 @@
+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?(_)
+      fail "The base filter class is not intended for direct use"
+    end
+
+    def passes?(source_file)
+      warn "DEPRECATION: SimpleCov::Filter#passes?(x) has been renamed to #matches?. Please update your custom filters accordingly!"
+      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.0.0/gems/simplecov-0.10.0/lib/simplecov/formatter/multi_formatter.rb

@@ -0,0 +1,28 @@
+module SimpleCov
+  module Formatter
+    class MultiFormatter
+      def self.[](*args)
+        Class.new(self) do
+          define_method :formatters do
+            @formatters ||= args
+          end
+        end
+      end
+
+      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
+
+      def formatters
+        @formatters ||= []
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/formatter/simple_formatter.rb

@@ -0,0 +1,23 @@
+#
+# 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.0.0/gems/simplecov-0.10.0/lib/simplecov/formatter.rb

@@ -0,0 +1,8 @@
+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.0.0/gems/simplecov-0.10.0/lib/simplecov/jruby_fix.rb

@@ -0,0 +1,42 @@
+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_method :__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.0.0/gems/simplecov-0.10.0/lib/simplecov/last_run.rb

@@ -0,0 +1,22 @@
+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.0.0/gems/simplecov-0.10.0/lib/simplecov/merge_helpers.rb

@@ -0,0 +1,38 @@
+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|
+        if element.nil? && new_array[i].nil?
+          new_array[i] = nil
+        else
+          local_value = element || 0
+          other_value = new_array[i] || 0
+          new_array[i] = local_value + other_value
+        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] = []
+      end
+
+      new_resultset.each_key do |filename|
+        new_resultset[filename] = (self[filename] || []).merge_resultset(hash[filename] || [])
+      end
+      new_resultset
+    end
+  end
+end
+
+Array.send :include, SimpleCov::ArrayMergeHelper
+Hash.send :include, SimpleCov::HashMergeHelper

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/no_defaults.rb

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

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/profiles.rb

@@ -0,0 +1,31 @@
+#
+# 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
+      fail "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
+      fail "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      SimpleCov.configure(&self[name])
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/railtie.rb

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

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/railties/tasks.rake

@@ -0,0 +1,11 @@
+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.0.0/gems/simplecov-0.10.0/lib/simplecov/result.rb

@@ -0,0 +1,81 @@
+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_method :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_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.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" => original_result.reject { |filename, _| !filenames.include?(filename) }, "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
+
+    # 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.0.0/gems/simplecov-0.10.0/lib/simplecov/result_merger.rb

@@ -0,0 +1,88 @@
+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

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/lib/simplecov/source_file.rb

@@ -0,0 +1,187 @@
+module SimpleCov
+  #
+  # Representation of a source file including it's coverage data, source code,
+  # source lines and featuring helpers to interpret that data.
+  #
+  class SourceFile
+    # Representation of a single line in a source file including
+    # this specific line's source code, line_number and code coverage,
+    # with the coverage being either nil (coverage not applicable, e.g. comment
+    # line), 0 (line not covered) or >1 (the amount of times the line was
+    # executed)
+    class Line
+      # The source code for this line. Aliased as :source
+      attr_reader :src
+      # The line number in the source file. Aliased as :line, :number
+      attr_reader :line_number
+      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
+      attr_reader :coverage
+      # Whether this line was skipped
+      attr_reader :skipped
+
+      # Lets grab some fancy aliases, shall we?
+      alias_method :source, :src
+      alias_method :line, :line_number
+      alias_method :number, :line_number
+
+      def initialize(src, line_number, coverage)
+        fail ArgumentError, "Only String accepted for source" unless src.is_a?(String)
+        fail ArgumentError, "Only Fixnum accepted for line_number" unless line_number.is_a?(Fixnum)
+        fail ArgumentError, "Only Fixnum and nil accepted for coverage" unless coverage.is_a?(Fixnum) || coverage.nil?
+        @src, @line_number, @coverage = src, line_number, coverage
+        @skipped = false
+      end
+
+      # Returns true if this is a line that should have been covered, but was not
+      def missed?
+        !never? && !skipped? && coverage.zero?
+      end
+
+      # Returns true if this is a line that has been covered
+      def covered?
+        !never? && !skipped? && coverage > 0
+      end
+
+      # Returns true if this line is not relevant for coverage
+      def never?
+        !skipped? && coverage.nil?
+      end
+
+      # Flags this line as skipped
+      def skipped!
+        @skipped = true
+      end
+
+      # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
+      # # :nocov: comment lines.
+      def skipped?
+        !!skipped
+      end
+
+      # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
+      # as a css class in report generation
+      def status
+        return "skipped" if skipped?
+        return "never" if never?
+        return "missed" if missed?
+        return "covered" if covered?
+      end
+    end
+
+    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+    attr_reader :filename
+    # The array of coverage data received from the Coverage.result
+    attr_reader :coverage
+    # The source code for this file. Aliased as :source
+    attr_reader :src
+    alias_method :source, :src
+
+    def initialize(filename, coverage)
+      @filename, @coverage = filename, coverage
+      File.open(filename, "rb") { |f| @src = f.readlines }
+    end
+
+    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+    # and thus including coverage data. Aliased as :source_lines
+    def lines
+      return @lines if defined? @lines
+
+      # Warning to identify condition from Issue #56
+      if coverage.size > src.size
+        $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.size}] exceeds number of lines in #{filename} [#{src.size}]"
+      end
+
+      # Initialize lines
+      @lines = []
+      src.each_with_index do |src, i|
+        @lines << SimpleCov::SourceFile::Line.new(src, i + 1, coverage[i])
+      end
+      process_skipped_lines!
+      @lines
+    end
+    alias_method :source_lines, :lines
+
+    # Access SimpleCov::SourceFile::Line source lines by line number
+    def line(number)
+      lines[number - 1]
+    end
+
+    # The coverage for this file in percent. 0 if the file has no relevant lines
+    def covered_percent
+      return 100.0 if lines.length.zero? || lines.length == never_lines.count
+      relevant_lines = lines.count - never_lines.count - skipped_lines.count
+      if relevant_lines.zero?
+        0.0
+      else
+        Float((covered_lines.count) * 100.0 / relevant_lines.to_f)
+      end
+    end
+
+    def covered_strength
+      return 0.0 if lines.length.zero? || lines.length == never_lines.count
+
+      lines_strength = 0
+      lines.each do |c|
+        lines_strength += c.coverage if c.coverage
+      end
+
+      effective_lines_count = Float(lines.count - never_lines.count - skipped_lines.count)
+
+      if effective_lines_count.zero?
+        0.0
+      else
+        strength = lines_strength / effective_lines_count
+        round_float(strength, 1)
+      end
+    end
+
+    # Returns all covered lines as SimpleCov::SourceFile::Line
+    def covered_lines
+      @covered_lines ||= lines.select(&:covered?)
+    end
+
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
+    def missed_lines
+      @missed_lines ||= lines.select(&:missed?)
+    end
+
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
+    def never_lines
+      @never_lines ||= lines.select(&:never?)
+    end
+
+    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+    def skipped_lines
+      @skipped_lines ||= lines.select(&:skipped?)
+    end
+
+    # Returns the number of relevant lines (covered + missed)
+    def lines_of_code
+      covered_lines.count + missed_lines.count
+    end
+
+    # Will go through all source files and mark lines that are wrapped within # :nocov: comment blocks
+    # as skipped.
+    def process_skipped_lines!
+      skipping = false
+      lines.each do |line|
+        if line.src =~ /^([\s]*)#([\s]*)(\:#{SimpleCov.nocov_token}\:)/
+          skipping = !skipping
+        else
+          line.skipped! if skipping
+        end
+      end
+    end
+
+  private
+
+    # ruby 1.9 could use Float#round(places) instead
+    # @return [Float]
+    def round_float(float, places)
+      factor = Float(10 * places)
+      Float((float * factor).round / factor)
+    end
+  end
+end