suzuko 0.1.7

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/test_unit_basic.feature

@@ -0,0 +1,34 @@
+@test_unit
+Feature:
+
+  Simply adding the basic simplecov lines to a project should get
+  the user a coverage report after running `rake test`
+
+  Scenario:
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name      | coverage | files |
+      | All Files | 91.38%   | 6     |
+
+    And I should see the source files:
+      | name                                    | coverage |
+      | lib/faked_project.rb                    | 100.0 %  |
+      | lib/faked_project/some_class.rb         | 80.0 %   |
+      | lib/faked_project/framework_specific.rb | 75.0 %   |
+      | lib/faked_project/meta_magic.rb         | 100.0 %  |
+      | test/meta_magic_test.rb                 | 100.0 %  |
+      | test/some_class_test.rb                 | 100.0 %  |
+
+      # Note: faked_test.rb is not appearing here since that's the first unit test file
+      # loaded by Rake, and only there test_helper is required, which then loads simplecov
+      # and triggers tracking of all other loaded files! Solution for this would be to
+      # configure simplecov in this first test instead of test_helper.
+
+    And the report should be based upon:
+      | Unit Tests |

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/test_unit_groups_and_filters_basic.feature

@@ -0,0 +1,29 @@
+@test_unit
+Feature:
+
+  Defining some groups and filters should give a corresponding
+  coverage report that respects those settings after running tests
+
+  Scenario:
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_group 'Libs', 'lib/faked_project/'
+        add_filter '/test/'
+      end
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name      | coverage | files |
+      | All Files | 88.1%    | 4     |
+      | Libs      | 86.11%   | 3     |
+      | Ungrouped | 100.0%   | 1     |
+
+    And I should see the source files:
+      | name                                    | coverage |
+      | lib/faked_project.rb                    | 100.0 %  |
+      | lib/faked_project/some_class.rb         |  80.0 %  |
+      | lib/faked_project/framework_specific.rb |  75.0 %  |
+      | lib/faked_project/meta_magic.rb         | 100.0 %  |

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/test_unit_groups_and_filters_complex.feature

@@ -0,0 +1,35 @@
+@test_unit
+Feature: Sophisticated grouping and filtering on Test/Unit
+
+  Defining groups and filters can be done by passing blocks or strings.
+  Blocks get each SimpleCov::SourceFile instance passed an can use arbitrary
+  and potentially weird conditions to remove files from the report or add them
+  to specific groups.
+
+  Scenario:
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_group 'By block' do |src_file|
+          src_file.filename =~ /MaGiC/i
+        end
+        add_group 'By string', 'project/meta_magic'
+
+        add_filter 'faked_project.rb'
+        # Remove all files that include "describe" in their source
+        add_filter {|src_file| src_file.lines.any? {|line| line.src =~ /TestCase/ } }
+        add_filter {|src_file| src_file.covered_percent < 100 }
+      end
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name      | coverage | files |
+      | All Files | 100.0%   | 1     |
+      | By block  | 100.0%   | 1     |
+      | By string | 100.0%   | 1     |
+
+    And I should see the source files:
+      | name                            | coverage |
+      | lib/faked_project/meta_magic.rb | 100.0 %  |

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/test_unit_groups_using_filter_class.feature

@@ -0,0 +1,40 @@
+@test_unit
+Feature: Grouping on Test/Unit using a custom filter class
+
+  Next to passing a block or a string to define a group, you can also pass
+  a filter class. The filter class inherits from SimpleCov::Filter and
+  must implement the matches? method, which is used to determine whether
+  or not a file should be added to the group.
+
+  Scenario:
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      class CoverageFilter < SimpleCov::Filter
+        def matches?(source_file)
+          source_file.covered_percent < filter_argument
+        end
+      end
+      SimpleCov.start do
+        add_group 'By filter class', CoverageFilter.new(90)
+        add_group 'By string', 'project/meta_magic'
+      end
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name             | coverage | files |
+      | All Files        | 91.38%   | 6     |
+      | By filter class  | 78.26%   | 2     |
+      | By string        | 100.0%   | 1     |
+      | Ungrouped        | 100.0%   | 3     |
+
+    And I should see the source files:
+      | name                                    | coverage |
+      | lib/faked_project/framework_specific.rb | 75.0 %   |
+      | lib/faked_project/some_class.rb         | 80.0 %   |
+      | lib/faked_project.rb                    | 100.0 %  |
+      | lib/faked_project/meta_magic.rb         | 100.0 %  |
+      | test/meta_magic_test.rb                 | 100.0 %  |
+      | test/some_class_test.rb                 | 100.0 %  |
+

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/test_unit_without_simplecov.feature

@@ -0,0 +1,20 @@
+@test_unit
+Feature:
+
+  Running unit tests without simplecov configuration
+
+  Scenario: No config at all
+    When I successfully run `bundle exec rake test`
+    Then no coverage report should have been generated
+
+  Scenario: Configured, but not started
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.configure do
+        add_filter 'somefilter'
+      end
+      """
+
+    When I successfully run `bundle exec rake test`
+    Then no coverage report should have been generated

data/vendor/bundle/ruby/2.0.0/gems/simplecov-0.10.0/features/unicode_compatiblity.feature

@@ -0,0 +1,67 @@
+@test_unit @unicode
+Feature:
+
+  Files with unicode in their source should be no problem at all for
+  generating a proper coverage report.
+
+  Background:
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start 'test_frameworks'
+      """
+
+  Scenario: Snowman inside method string
+    Given a file named "lib/faked_project/unicode.rb" with:
+      """
+      # encoding: UTF-8
+      class SourceCodeWithUnicode
+        def self.yell!
+          puts "☃"
+        end
+      end
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name      | coverage | files |
+      | All Files | 86.67%   | 5     |
+
+    And I should see the source files:
+      | name                                    | coverage |
+      | lib/faked_project.rb                    | 100.0 %  |
+      | lib/faked_project/some_class.rb         | 80.0 %   |
+      | lib/faked_project/framework_specific.rb | 75.0 %   |
+      | lib/faked_project/meta_magic.rb         | 100.0 %  |
+      | lib/faked_project/unicode.rb            | 66.67 %  |
+
+    And the report should be based upon:
+      | Unit Tests |
+
+  Scenario: Author name in comment
+    Given a file named "lib/faked_project/unicode.rb" with:
+      """
+      # encoding: UTF-8
+      # author:  Javiér Hernández
+      class SomeClassWrittenByAForeigner
+        def self.yell!
+          foo
+        end
+      end
+      """
+
+    When I open the coverage report generated with `bundle exec rake test`
+    Then I should see the groups:
+      | name      | coverage | files |
+      | All Files | 86.67%   | 5     |
+
+    And I should see the source files:
+      | name                                    | coverage |
+      | lib/faked_project.rb                    | 100.0 %  |
+      | lib/faked_project/some_class.rb         | 80.0 %   |
+      | lib/faked_project/framework_specific.rb | 75.0 %   |
+      | lib/faked_project/meta_magic.rb         | 100.0 %  |
+      | lib/faked_project/unicode.rb            | 66.67 %  |
+
+    And the report should be based upon:
+      | Unit Tests |

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

@@ -0,0 +1,59 @@
+#
+# Helper that tries to find out what test suite is running (for SimpleCov.command_name)
+#
+module SimpleCov
+  module CommandGuesser
+    class << self
+      # Storage for the original command line call that invoked the test suite.
+      # This has got to be stored as early as possible because i.e. rake and test/unit 2
+      # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
+      # between rails unit/functional/integration tests impossible without this cached
+      # item.
+      attr_accessor :original_run_command
+
+      def guess
+        from_env || from_command_line_options || from_defined_constants
+      end
+
+    private
+
+      def from_env
+        # If being run from inside parallel_tests set the command name according to the process number
+        return unless ENV["PARALLEL_TEST_GROUPS"] && ENV["TEST_ENV_NUMBER"]
+        number = ENV["TEST_ENV_NUMBER"]
+        number = "1" if number.empty?
+        "(#{number}/#{ENV['PARALLEL_TEST_GROUPS']})"
+      end
+
+      def from_command_line_options
+        case original_run_command
+        when /test\/functional\//, /test\/\{.*functional.*\}\//
+          "Functional Tests"
+        when /test\/integration\//
+          "Integration Tests"
+        when /test\//
+          "Unit Tests"
+        when /spec/
+          "RSpec"
+        when /cucumber/, /features/
+          "Cucumber Features"
+        end
+      end
+
+      def from_defined_constants
+        # If the command regexps fail, let's try checking defined constants.
+        if defined?(RSpec)
+          "RSpec"
+        elsif defined?(Test::Unit)
+          "Unit Tests"
+        elsif defined?(MiniTest)
+          "MiniTest"
+        else
+          # TODO: Provide link to docs/wiki article
+          warn "SimpleCov failed to recognize the test framework and/or suite used. Please specify manually using SimpleCov.command_name 'Unit Tests'."
+          "Unknown Test Framework"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,272 @@
+require "fileutils"
+require "docile"
+require "simplecov/formatter/multi_formatter"
+#
+# Bundles the configuration options used for SimpleCov. All methods
+# defined here are usable from SimpleCov directly. Please check out
+# SimpleCov documentation for further info.
+#
+module SimpleCov
+  module Configuration
+    attr_writer :filters, :groups, :formatter
+
+    #
+    # The root for the project. This defaults to the
+    # current working directory.
+    #
+    # Configure with SimpleCov.root('/my/project/path')
+    #
+    def root(root = nil)
+      return @root if defined?(@root) && root.nil?
+      @root = File.expand_path(root || Dir.getwd)
+    end
+
+    #
+    # The name of the output and cache directory. Defaults to 'coverage'
+    #
+    # Configure with SimpleCov.coverage_dir('cov')
+    #
+    def coverage_dir(dir = nil)
+      return @coverage_dir if defined?(@coverage_dir) && dir.nil?
+      @coverage_dir = (dir || "coverage")
+    end
+
+    #
+    # Returns the full path to the output directory using SimpleCov.root
+    # and SimpleCov.coverage_dir, so you can adjust this by configuring those
+    # values. Will create the directory if it's missing
+    #
+    def coverage_path
+      coverage_path = File.expand_path(coverage_dir, root)
+      FileUtils.mkdir_p coverage_path
+      coverage_path
+    end
+
+    #
+    # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
+    #
+    def filters
+      @filters ||= []
+    end
+
+    # The name of the command (a.k.a. Test Suite) currently running. Used for result
+    # merging and caching. It first tries to make a guess based upon the command line
+    # arguments the current test suite is running on and should automatically detect
+    # unit tests, functional tests, integration tests, rpsec and cucumber and label
+    # them properly. If it fails to recognize the current command, the command name
+    # is set to the shell command that the current suite is running on.
+    #
+    # You can specify it manually with SimpleCov.command_name("test:units") - please
+    # also check out the corresponding section in README.rdoc
+    def command_name(name = nil)
+      @name = name unless name.nil?
+      @name ||= SimpleCov::CommandGuesser.guess
+      @name
+    end
+
+    #
+    # Gets or sets the configured formatter.
+    #
+    # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
+    #
+    def formatter(formatter = nil)
+      return @formatter if defined?(@formatter) && formatter.nil?
+      @formatter = formatter
+      fail "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
+      @formatter
+    end
+
+    #
+    # Sets the configured formatters.
+    #
+    def formatters=(formatters)
+      @formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+    end
+
+    #
+    # Gets the configured formatters.
+    #
+    def formatters
+      if @formatter.is_a?(SimpleCov::Formatter::MultiFormatter)
+        @formatter.formatters
+      else
+        Array(formatter)
+      end
+    end
+
+    #
+    # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from
+    # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token
+    # can be configured to be any other string using this.
+    #
+    # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
+    #
+    def nocov_token(nocov_token = nil)
+      return @nocov_token if defined?(@nocov_token) && nocov_token.nil?
+      @nocov_token = (nocov_token || "nocov")
+    end
+    alias_method :skip_token, :nocov_token
+
+    #
+    # Returns the configured groups. Add groups using SimpleCov.add_group
+    #
+    def groups
+      @groups ||= {}
+    end
+
+    #
+    # Returns the hash of available profiles
+    #
+    def profiles
+      @profiles ||= SimpleCov::Profiles.new
+    end
+
+    def adapters
+      warn "method adapters is deprecated. use profiles instead"
+      profiles
+    end
+
+    #
+    # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
+    # you're calling.
+    #
+    # SimpleCov.configure do
+    #   add_filter 'foobar'
+    # end
+    #
+    # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
+    # options at once.
+    #
+    def configure(&block)
+      return false unless SimpleCov.usable?
+      Docile.dsl_eval(self, &block)
+    end
+
+    #
+    # Gets or sets the behavior to process coverage results.
+    #
+    # By default, it will call SimpleCov.result.format!
+    #
+    # Configure with:
+    #   SimpleCov.at_exit do
+    #     puts "Coverage done"
+    #     SimpleCov.result.format!
+    #   end
+    #
+    def at_exit(&block)
+      return proc {} unless running || block_given?
+      @at_exit = block if block_given?
+      @at_exit ||= proc { SimpleCov.result.format! }
+    end
+
+    #
+    # Returns the project name - currently assuming the last dirname in
+    # the SimpleCov.root is this.
+    #
+    def project_name(new_name = nil)
+      return @project_name if defined?(@project_name) && @project_name && new_name.nil?
+      @project_name = new_name if new_name.is_a?(String)
+      @project_name ||= File.basename(root.split("/").last).capitalize.gsub("_", " ")
+    end
+
+    #
+    # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
+    # are joined and combined into a single coverage report
+    #
+    def use_merging(use = nil)
+      @use_merging = use unless use.nil?
+      @use_merging = true unless defined?(@use_merging) && @use_merging == false
+    end
+
+    #
+    # Defines them maximum age (in seconds) of a resultset to still be included in merged results.
+    # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is
+    # more seconds ago than specified here, it won't be taken into account when merging (and is also
+    # purged from the resultset cache)
+    #
+    # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
+    #
+    # Default is 600 seconds (10 minutes)
+    #
+    # Configure with SimpleCov.merge_timeout(3600) # 1hr
+    #
+    def merge_timeout(seconds = nil)
+      @merge_timeout = seconds if seconds.is_a?(Fixnum)
+      @merge_timeout ||= 600
+    end
+
+    #
+    # Defines the minimum overall coverage required for the testsuite to pass.
+    # SimpleCov will return non-zero if the current coverage is below this threshold.
+    #
+    # Default is 0% (disabled)
+    #
+    def minimum_coverage(coverage = nil)
+      @minimum_coverage ||= (coverage || 0).to_f.round(2)
+    end
+
+    #
+    # Defines the maximum coverage drop at once allowed for the testsuite to pass.
+    # SimpleCov will return non-zero if the coverage decreases by more than this threshold.
+    #
+    # Default is 100% (disabled)
+    #
+    def maximum_coverage_drop(coverage_drop = nil)
+      @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
+    end
+
+    #
+    # Refuses any coverage drop. That is, coverage is only allowed to increase.
+    # SimpleCov will return non-zero if the coverage decreases.
+    #
+    def refuse_coverage_drop
+      maximum_coverage_drop 0
+    end
+
+    #
+    # Add a filter to the processing chain.
+    # There are three ways to define a filter:
+    #
+    # * as a String that will then be matched against all source files' file paths,
+    #   SimpleCov.add_filter 'app/models' # will reject all your models
+    # * as a block which will be passed the source file in question and should either
+    #   return a true or false value, depending on whether the file should be removed
+    #   SimpleCov.add_filter do |src_file|
+    #     File.basename(src_file.filename) == 'environment.rb'
+    #   end # Will exclude environment.rb files from the results
+    # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
+    #   on how to define your own filter classes
+    #
+    def add_filter(filter_argument = nil, &filter_proc)
+      filters << parse_filter(filter_argument, &filter_proc)
+    end
+
+    #
+    # Define a group for files. Works similar to add_filter, only that the first
+    # argument is the desired group name and files PASSING the filter end up in the group
+    # (while filters exclude when the filter is applicable).
+    #
+    def add_group(group_name, filter_argument = nil, &filter_proc)
+      groups[group_name] = parse_filter(filter_argument, &filter_proc)
+    end
+
+  private
+
+    #
+    # The actal filter processor. Not meant for direct use
+    #
+    def parse_filter(filter_argument = nil, &filter_proc)
+      if filter_argument.is_a?(SimpleCov::Filter)
+        filter_argument
+      elsif filter_argument.is_a?(String)
+        SimpleCov::StringFilter.new(filter_argument)
+      elsif filter_proc
+        SimpleCov::BlockFilter.new(filter_proc)
+      elsif filter_argument.is_a?(Array)
+        SimpleCov::ArrayFilter.new(filter_argument)
+      else
+        fail ArgumentError, "Please specify either a string or a block to filter with"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# Load default formatter gem
+require "simplecov-html"
+
+SimpleCov.profiles.define "root_filter" do
+  # Exclude all files outside of simplecov root
+  add_filter do |src|
+    !(src.filename =~ /^#{Regexp.escape(SimpleCov.root)}/i)
+  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 "Libraries", "lib"
+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
+  # If we are in a different process than called start, don't interfere.
+  next if SimpleCov.pid != Process.pid
+
+  if $ERROR_INFO # 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)
+    @exit_status = $ERROR_INFO.is_a?(SystemExit) ? $ERROR_INFO.status : SimpleCov::ExitCodes::EXCEPTION
+  else
+    # Store the exit status of the test run since it goes away after calling the at_exit proc...
+    @exit_status = SimpleCov::ExitCodes::SUCCESS
+  end
+
+  SimpleCov.at_exit.call
+
+  if SimpleCov.result? # Result has been computed
+    covered_percent = SimpleCov.result.covered_percent.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 (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
+config_path = File.join(SimpleCov.root, ".simplecov")
+load config_path if File.exist?(config_path)

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

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