win32-api 1.5.3-universal-mingw32 → 1.6.0-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/code-snippet-fetcher.rb

@@ -0,0 +1,58 @@
+module Test
+  module Unit
+    class CodeSnippetFetcher
+      def initialize
+        @sources = {}
+      end
+
+      def fetch(path, line, options={})
+        n_context_line = options[:n_context_line] || 3
+        lines = source(path)
+        return [] if lines.nil?
+        min_line = [line - n_context_line, 1].max
+        max_line = [line + n_context_line, lines.length].min
+        window = min_line..max_line
+        window.collect do |n|
+          attributes = {:target_line? => (n == line)}
+          [n, lines[n - 1].chomp, attributes]
+        end
+      end
+
+      def source(path)
+        @sources[path] ||= read_source(path)
+      end
+
+      private
+      def read_source(path)
+        return nil unless File.exist?(path)
+        lines = []
+        File.open(path) do |file|
+          first_line = file.gets
+          break if first_line.nil?
+          encoding = detect_encoding(first_line)
+          if encoding
+            first_line.force_encoding(encoding)
+            file.set_encoding(encoding, encoding)
+          end
+          lines << first_line
+          lines.concat(file.readlines)
+        end
+        lines
+      end
+
+      def detect_encoding(first_line)
+        return nil unless first_line.respond_to?(:ascii_only?)
+        return nil unless first_line.ascii_only?
+        if /\b(?:en)?coding[:=]\s*([a-z\d_-]+)/i =~ first_line
+          begin
+            Encoding.find($1)
+          rescue ArgumentError
+            nil
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/collector.rb

@@ -0,0 +1,73 @@
+module Test
+  module Unit
+    module Collector
+      def initialize
+        @filters = []
+      end
+
+      def filter=(filters)
+        @filters = case(filters)
+          when Proc
+            [filters]
+          when Array
+            filters
+        end
+      end
+
+      def add_suite(destination, suite)
+        to_delete = suite.tests.find_all do |test|
+          test.is_a?(TestCase) and !include?(test)
+        end
+        suite.delete_tests(to_delete)
+        destination << suite unless suite.empty?
+      end
+
+      def add_test_cases(suite, test_cases)
+        children_map = {}
+        test_cases.each do |test_case|
+          ancestor_classes = test_case.ancestors.find_all do |ancestor|
+            ancestor.is_a?(Class)
+          end
+          parent = ancestor_classes[1]
+          children_map[parent] ||= []
+          children_map[parent] << test_case
+        end
+
+        root_test_cases = children_map.keys - test_cases
+        root_test_cases.each do |root_test_case|
+          add_test_case(suite, root_test_case, children_map)
+        end
+      end
+
+      def include?(test)
+        return true if(@filters.empty?)
+        @filters.each do |filter|
+          return false if filter[test] == false
+        end
+        true
+      end
+
+      def sort(suites)
+        suites.sort_by do |suite|
+          [suite.priority, suite.name || suite.to_s]
+        end
+      end
+
+      private
+      def add_test_case(suite, test_case, children_map)
+        children = children_map[test_case]
+        return if children.nil?
+
+        sub_suites = []
+        children.each do |child|
+          sub_suite = child.suite
+          add_test_case(sub_suite, child, children_map)
+          add_suite(sub_suites, sub_suite)
+        end
+        sort(sub_suites).each do |sub_suite|
+          suite << sub_suite
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/collector/descendant.rb

@@ -0,0 +1,19 @@
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Descendant
+        include Collector
+
+        NAME = 'collected from the subclasses of TestCase'
+
+        def collect(name=NAME)
+          suite = TestSuite.new(name)
+          add_test_cases(suite, TestCase::DESCENDANTS)
+          suite
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/collector/dir.rb

@@ -0,0 +1,108 @@
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Dir
+        include Collector
+
+        attr_reader :pattern, :exclude
+        attr_accessor :base
+
+        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
+          super()
+          @dir = dir
+          @file = file
+          @object_space = object_space
+          @req = req
+          @pattern = [/\btest_.*\.rb\Z/m]
+          @exclude = []
+          @base = nil
+        end
+
+        def collect(*from)
+          basedir = @base
+          $:.push(basedir) if basedir
+          if(from.empty?)
+            recursive_collect('.', find_test_cases)
+          elsif(from.size == 1)
+            recursive_collect(from.first, find_test_cases)
+          else
+            suites = []
+            from.each do |f|
+              suite = recursive_collect(f, find_test_cases)
+              suites << suite unless(suite.tests.empty?)
+            end
+            suite = TestSuite.new("[#{from.join(', ')}]")
+            sort(suites).each{|s| suite << s}
+            suite
+          end
+        ensure
+          $:.delete_at($:.rindex(basedir)) if basedir
+        end
+
+        def find_test_cases(ignore=[])
+          cases = []
+          @object_space.each_object(Class) do |c|
+            cases << c if(c < TestCase && !ignore.include?(c))
+          end
+          ignore.concat(cases)
+          cases
+        end
+
+        def recursive_collect(name, already_gathered)
+          sub_suites = []
+          path = realdir(name)
+          if @file.directory?(path)
+            dir_name = name unless name == '.'
+            @dir.entries(path).each do |e|
+              next if(e == '.' || e == '..')
+              e_name = dir_name ? @file.join(dir_name, e) : e
+              if @file.directory?(realdir(e_name))
+                next if /\A(?:CVS|\.svn|\.git)\z/ =~ e
+                sub_suite = recursive_collect(e_name, already_gathered)
+                sub_suites << sub_suite unless(sub_suite.empty?)
+              else
+                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
+                if @pattern and !@pattern.empty?
+                  next unless @pattern.any? {|pat| pat =~ e_name}
+                end
+                if @exclude and !@exclude.empty?
+                  next if @exclude.any? {|pat| pat =~ e_name}
+                end
+                collect_file(e_name, sub_suites, already_gathered)
+              end
+            end
+          else
+            collect_file(name, sub_suites, already_gathered)
+          end
+          suite = TestSuite.new(@file.basename(name))
+          sort(sub_suites).each{|s| suite << s}
+          suite
+        end
+
+        def collect_file(name, suites, already_gathered)
+          dir = @file.dirname(@file.expand_path(name, @base))
+          $:.unshift(dir)
+          if(@req)
+            @req.require(name)
+          else
+            require(name)
+          end
+          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
+        ensure
+          $:.delete_at($:.rindex(dir)) if(dir)
+        end
+
+        def realdir(path)
+          if @base
+            @file.join(@base, path)
+          else
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/test-unit-3.1.9/lib/test/unit/collector/load.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+
+require 'test/unit/testsuite'
+require 'test/unit/collector'
+
+module Test
+  module Unit
+    module Collector
+      class Load
+        include Collector
+
+        attr_reader :patterns, :excludes, :base
+        attr_reader :default_test_paths
+
+        def initialize
+          super
+          @system_excludes = [/~\z/, /\A\.\#/]
+          @system_directory_excludes = [/\A(?:CVS|\.svn|\.git)\z/]
+          @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
+          @excludes = []
+          @base = nil
+          @default_test_paths = []
+          @require_failed_infos = []
+        end
+
+        def base=(base)
+          base = Pathname(base) unless base.nil?
+          @base = base
+        end
+
+        def default_test_paths=(paths)
+          @default_test_paths = paths.collect do |path|
+            Pathname(path)
+          end
+        end
+
+        def collect(*froms)
+          add_load_path(@base) do
+            froms = @default_test_paths if froms.empty?
+            froms = ["."] if froms.empty?
+            test_suites = []
+            already_gathered = find_test_cases
+            froms.each do |from|
+              from = resolve_path(from)
+              if from.directory?
+                test_suite = collect_recursive(from, already_gathered)
+                test_suites << test_suite unless test_suite.tests.empty?
+              else
+                collect_file(from, test_suites, already_gathered)
+              end
+            end
+            add_require_failed_test_suite(test_suites)
+
+            if test_suites.size > 1
+              test_suite = TestSuite.new("[#{froms.join(', ')}]")
+              sort(test_suites).each do |sub_test_suite|
+                test_suite << sub_test_suite
+              end
+            else
+              test_suite = test_suites.first
+            end
+
+            test_suite
+          end
+        end
+
+        def find_test_cases(ignore=[])
+          test_cases = []
+          TestCase::DESCENDANTS.each do |test_case|
+            test_cases << test_case unless ignore.include?(test_case)
+          end
+          ignore.concat(test_cases)
+          test_cases
+        end
+
+        private
+        def collect_recursive(path, already_gathered)
+          sub_test_suites = []
+
+          if path.directory?
+            directories, files = path.children.partition do |child|
+              child.directory?
+            end
+
+            files.each do |child|
+              next if excluded_file?(child.basename.to_s)
+              collect_file(child, sub_test_suites, already_gathered)
+            end
+
+            directories.each do |child|
+              next if excluded_directory?(child.basename.to_s)
+              sub_test_suite = collect_recursive(child, already_gathered)
+              sub_test_suites << sub_test_suite unless sub_test_suite.empty?
+            end
+          else
+            unless excluded_file?(path.basename.to_s)
+              collect_file(path, sub_test_suites, already_gathered)
+            end
+          end
+
+          test_suite = TestSuite.new(path.basename.to_s)
+          sort(sub_test_suites).each do |sub_test_suite|
+            test_suite << sub_test_suite
+          end
+          test_suite
+        end
+
+        def collect_file(path, test_suites, already_gathered)
+          @program_file ||= File.expand_path($0)
+          expanded_path = path.expand_path
+          return if @program_file == expanded_path.to_s
+          add_load_path(expanded_path.dirname) do
+            begin
+              require(path.basename.to_s)
+            rescue LoadError
+              @require_failed_infos << {:path => expanded_path, :exception => $!}
+            end
+            add_test_cases(test_suites, find_test_cases(already_gathered))
+          end
+        end
+
+        def resolve_path(path)
+          if @base
+            @base + path
+          else
+            Pathname(path)
+          end
+        end
+
+        def add_load_path(path)
+          return yield if path.nil?
+
+          path = path.to_s
+          return yield if $LOAD_PATH.index(path)
+
+          begin
+            $LOAD_PATH.unshift(path)
+            yield
+          ensure
+            index = $LOAD_PATH.index(path)
+            $LOAD_PATH.delete_at(index) if index
+          end
+        end
+
+        def excluded_directory?(base)
+          @system_directory_excludes.any? {|pattern| pattern =~ base}
+        end
+
+        def excluded_file?(base)
+          return true if @system_excludes.any? {|pattern| pattern =~ base}
+
+          patterns = @patterns || []
+          unless patterns.empty?
+            return true unless patterns.any? {|pattern| pattern =~ base}
+          end
+
+          excludes = @excludes || []
+          unless excludes.empty?
+            return true if excludes.any? {|pattern| pattern =~ base}
+          end
+
+          false
+        end
+
+        def add_require_failed_test_suite(test_suites)
+          return if @require_failed_infos.empty?
+
+          require_failed_infos = @require_failed_infos
+          require_failed_omissions = Class.new(Test::Unit::TestCase)
+          require_failed_omissions.class_eval do
+            class << self
+              def name
+                "RequireFailedOmissions"
+              end
+            end
+
+            require_failed_infos.each do |info|
+              path = info[:path]
+              normalized_path = path.to_s.gsub(/[^a-z0-9\_]+/i, '_')
+              normalized_path = normalized_path.gsub(/\A_+/, '')
+              exception = info[:exception]
+              define_method("test_require_#{normalized_path}") do
+                @require_failed_exception = exception
+                omit("failed to load: <#{path}>: <#{exception.message}>")
+              end
+            end
+
+            def priority
+              100
+            end
+
+            def filter_backtrace(location)
+              super(@require_failed_exception.backtrace)
+            end
+          end
+
+          add_suite(test_suites, require_failed_omissions.suite)
+        end
+      end
+    end
+  end
+end