win32-api 1.6.0-universal-mingw32 → 1.6.1.beta1-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/BSDL

@@ -1,22 +0,0 @@
-Copyright (C) 2014-2016 Kazuki Tsujimoto, All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/COPYING

@@ -1,57 +0,0 @@
-Copyright (C) 2014-2016 Kazuki Tsujimoto, All rights reserved.
-
-You can redistribute it and/or modify it under either the terms of the
-2-clause BSDL (see the file BSDL), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-	  modifications to Usenet or an equivalent medium, or by allowing
-	  the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or binary form,
-     provided that you do at least ONE of the following:
-
-       a) distribute the binaries and library files of the software,
-	  together with instructions (in the manual page or equivalent)
-	  on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-	  the software.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     software (possibly commercial).  But some files in the distribution
-     are not written by the author, so that they are not under these terms.
-
-     For the list of those files and their copying conditions, see the
-     file LEGAL.
-
-  5. The scripts and library files supplied as input to or produced as
-     output from the software do not automatically fall under the
-     copyright of the software, but belong to whomever generated them,
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/Gemfile

@@ -1,9 +0,0 @@
-source "http://rubygems.org"
-
-gemspec
-
-# https://github.com/redmine/redmine/blob/3.0.4/Gemfile#L101
-local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
-if File.exist?(local_gemfile)
-  eval_gemfile local_gemfile
-end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/LEGAL

@@ -1,4 +0,0 @@
-LEGAL NOTICE INFORMATION
-------------------------
-
-All the files in this distribution are written by the author.

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/README.rdoc

@@ -1,19 +0,0 @@
-= power_assert
-== About
-Power Assert for Ruby.
-
-== Related Projects
-* {test-unit}[https://github.com/test-unit/test-unit](>= 3.0.0)
-* {test-unit-power_assert}[https://github.com/k-tsj/test-unit-power_assert]
-* {minitest-power_assert}[https://github.com/hsbt/minitest-power_assert]
-* {pry-power_assert}[https://github.com/yui-knk/pry-power_assert]
-* {rspec-power_assert}[https://github.com/joker1007/rspec-power_assert]
-* {power_p}[https://github.com/k-tsj/power_p]
-
-== Requirement
-* CRuby 2.0.0 or later
-
-== Reference
-* {Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck}[https://speakerdeck.com/k_tsj/power-assert-in-ruby]
-
-== Travis Build Status {<img src="https://secure.travis-ci.org/k-tsj/power_assert.png?branch=master"/>}[http://travis-ci.org/k-tsj/power_assert]

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/Rakefile

@@ -1,16 +0,0 @@
-require "bundler/gem_tasks"
-
-require "rake/testtask"
-task :default => :test
-Rake::TestTask.new do |t|
-  # helper(simplecov) must be required before loading power_assert
-  t.ruby_opts = ["-w", "-r./test/helper"]
-  t.test_files = FileList["test/test_*.rb"]
-end
-
-desc "Run the benchmark suite"
-task('benchmark') do
-  Dir.glob('benchmarks/bm_*.rb').each do |f|
-    load(f)
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/benchmarks/bm_yhpg.rb

@@ -1,59 +0,0 @@
-# Yhpg
-#   https://gist.github.com/yancya/37d79e02a91afcfdeed1
-#
-# Auhtor: yancya
-
-require_relative 'helper'
-
-class Yhpg
-  MAPPING = [*'0'..'9', *'A'..'Z', *'a'..'z']
-
-  def initialize(data)
-    @n, @list = data.split(":").tap { |n, list| break [n.to_i, list.split(",").map { |str| Yhpg.decode(str) }] }
-    x_nominee = @list.map { |x, _| x }.map { |x| [x, x + 1] }.flatten.tap { |a| a.push(*[0, 62])}.uniq
-    y_nominee = @list.map { |_, y| y }.map { |y| [y, y + 1] }.flatten.tap { |a| a.push(*[0, 62])}.uniq
-    x_range_patterns = x_nominee.combination(2).map { |a| (a.min..a.max) }
-    y_range_patterns = y_nominee.combination(2).map { |a| (a.min..a.max) }
-    squares = x_range_patterns.product(y_range_patterns)
-    targets = squares.select { |xrange, yrange| @list.select { |p| check(xrange, yrange, p) }.size == @n }
-    @areas = targets.map { |x, y| [(x.max - x.min) * (y.max - y.min), x, y] }
-  end
-
-  def debug
-    p [@areas.min_by(&:first), @areas.max_by(&:first)]
-  end
-
-  def Yhpg.decode(str)
-    str.chars.map { |w| MAPPING.index(w) }
-  end
-
-  def check(xrange, yrange, target)
-    x, y = target
-    (xrange.include?(x) && xrange.include?(x + 1)) &&
-      (yrange.include?(y) && yrange.include?(y + 1))
-  end
-
-  def output
-    case res = [@areas.map(&:first).min, @areas.map(&:first).max].join(',')
-    when ','
-      '-'
-    else
-      res
-    end
-  end
-end
-
-[
-  ["4:00,11,zz,yy,1y,y1", "3600,3721"], # /*05*/
-].each do |(actual, expect)|
-  Benchmark.bm(30) do |x|
-    x.report("expr") { Yhpg.new(actual).output == expect }
-    x.report("TracePoint.trace { expr }") { TracePoint.new(:return, :c_return) {}.enable { Yhpg.new(actual).output == expect } }
-    x.report("assertion_message { expr }") {
-      assertion_message { Yhpg.new(actual).output == expect }
-    }
-    x.report("assertion_message { !expr }") {
-      assertion_message { not Yhpg.new(actual).output == expect }
-    }
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/benchmarks/helper.rb

@@ -1,8 +0,0 @@
-require 'benchmark'
-require 'power_assert'
-
-def assertion_message(source = nil, source_binding = TOPLEVEL_BINDING, &blk)
-  ::PowerAssert.start(source || blk, assertion_method: __callee__, source_binding: source_binding) do |pa|
-    pa.message unless pa.yield
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/lib/power_assert.rb

@@ -1,338 +0,0 @@
-# power_assert.rb
-#
-# Copyright (C) 2014-2016 Kazuki Tsujimoto, All rights reserved.
-
-begin
-  captured = false
-  TracePoint.new(:return, :c_return) do |tp|
-    captured = true
-    unless tp.binding and tp.return_value
-      raise
-    end
-  end.enable { __id__ }
-  raise unless captured
-rescue
-  raise LoadError, 'Fully compatible TracePoint API required'
-end
-
-require 'power_assert/version'
-require 'power_assert/enable_tracepoint_events'
-require 'ripper'
-
-module PowerAssert
-  class << self
-    def configuration
-      @configuration ||= Configuration[false, false]
-    end
-
-    def configure
-      yield configuration
-    end
-
-    def start(assertion_proc_or_source, assertion_method: nil, source_binding: TOPLEVEL_BINDING)
-      if respond_to?(:clear_global_method_cache, true)
-        clear_global_method_cache
-      end
-      yield Context.new(assertion_proc_or_source, assertion_method, source_binding)
-    end
-
-    private
-
-    if defined?(RubyVM)
-      def clear_global_method_cache
-        eval('using PowerAssert.const_get(:Empty)', TOPLEVEL_BINDING)
-      end
-    end
-  end
-
-  Configuration = Struct.new(:lazy_inspection, :_trace_alias_method)
-  private_constant :Configuration
-
-  module Empty
-  end
-  private_constant :Empty
-
-  class InspectedValue
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      @value
-    end
-  end
-  private_constant :InspectedValue
-
-  class SafeInspectable
-    def initialize(value)
-      @value = value
-    end
-
-    def inspect
-      inspected = @value.inspect
-      if Encoding.compatible?(Encoding.default_external, inspected)
-        inspected
-      else
-        begin
-          "#{inspected.encode(Encoding.default_external)}(#{inspected.encoding})"
-        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          inspected.force_encoding(Encoding.default_external)
-        end
-      end
-    rescue => e
-      "InspectionFailure: #{e.class}: #{e.message.each_line.first}"
-    end
-  end
-  private_constant :SafeInspectable
-
-  class Context
-    Value = Struct.new(:name, :value, :column)
-    Ident = Struct.new(:type, :name, :column)
-
-    TARGET_CALLER_DIFF = {return: 5, c_return: 4}
-    TARGET_INDEX_OFFSET = 2
-
-    attr_reader :message_proc
-
-    def initialize(assertion_proc_or_source, assertion_method, source_binding)
-      if assertion_proc_or_source.kind_of?(Proc)
-        @assertion_proc = assertion_proc_or_source
-        @line = nil
-      else
-        @assertion_proc = source_binding.eval "Proc.new {#{assertion_proc_or_source}}"
-        @line = assertion_proc_or_source
-      end
-      path = nil
-      lineno = nil
-      methods = nil
-      refs = nil
-      method_ids = nil
-      return_values = []
-      @base_caller_length = -1
-      @assertion_method_name = assertion_method.to_s
-      @message_proc = -> {
-        raise RuntimeError, 'call #yield at first' if @base_caller_length < 0
-        @message ||= build_assertion_message(@line || '', methods || [], return_values, refs || [], @assertion_proc.binding).freeze
-      }
-      @proc_local_variables = @assertion_proc.binding.eval('local_variables').map(&:to_s)
-      target_thread = Thread.current
-      @trace_call = TracePoint.new(:call, :c_call) do |tp|
-        next if @base_caller_length < 0
-        locs = caller_locations
-        if locs.length >= @base_caller_length+TARGET_INDEX_OFFSET and Thread.current == target_thread
-          idx = -(@base_caller_length+TARGET_INDEX_OFFSET)
-          path = locs[idx].path
-          lineno = locs[idx].lineno
-          @line ||= open(path).each_line.drop(lineno - 1).first
-          idents = extract_idents(Ripper.sexp(@line))
-          methods, refs = idents.partition {|i| i.type == :method }
-          method_ids = methods.map(&:name).map(&:to_sym).each_with_object({}) {|i, h| h[i] = true }
-          @trace_call.disable
-        end
-      end
-      trace_alias_method = PowerAssert.configuration._trace_alias_method
-      @trace = TracePoint.new(:return, :c_return) do |tp|
-        method_id = (trace_alias_method &&
-                     tp.event == :return &&
-                     tp.binding.eval('::Kernel.__callee__')) || tp.method_id
-        next if method_ids and ! method_ids[method_id]
-        next unless tp.binding # workaround for ruby 2.2
-        if tp.event == :c_return
-          loc = tp.binding.eval('[__LINE__, __FILE__]')
-          next unless lineno == loc[0] and path == loc[1]
-        end
-        locs = tp.binding.eval('::Kernel.caller_locations')
-        current_diff = locs.length - @base_caller_length
-        if current_diff <= TARGET_CALLER_DIFF[tp.event] and Thread.current == target_thread
-          idx = -(@base_caller_length+TARGET_INDEX_OFFSET)
-          if path == locs[idx].path and lineno == locs[idx].lineno
-            val = PowerAssert.configuration.lazy_inspection ?
-              tp.return_value :
-              InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
-            return_values << Value[method_id.to_s, val, nil]
-          end
-        end
-      end
-    end
-
-    def yield
-      @trace_call.enable do
-        do_yield(&@assertion_proc)
-      end
-    end
-
-    def message
-      @message_proc.()
-    end
-
-    private
-
-    def do_yield
-      @trace.enable do
-        @base_caller_length = caller_locations.length
-        yield
-      end
-    end
-
-    def build_assertion_message(line, methods, return_values, refs, proc_binding)
-      set_column(methods, return_values)
-      ref_values = refs.map {|i| Value[i.name, proc_binding.eval(i.name), i.column] }
-      vals = (return_values + ref_values).find_all(&:column).sort_by(&:column).reverse
-      if vals.empty?
-        return line
-      end
-      fmt = (0..vals[0].column).map {|i| vals.find {|v| v.column == i } ? "%<#{i}>s" : ' '  }.join
-      lines = []
-      lines << line.chomp
-      lines << sprintf(fmt, vals.each_with_object({}) {|v, h| h[v.column.to_s.to_sym] = '|' }).chomp
-      vals.each do |i|
-        inspected_vals = vals.each_with_object({}) do |j, h|
-          h[j.column.to_s.to_sym] = [SafeInspectable.new(i.value).inspect, '|', ' '][i.column <=> j.column]
-        end
-        lines << encoding_safe_rstrip(sprintf(fmt, inspected_vals))
-      end
-      lines.join("\n")
-    end
-
-    def set_column(methods, return_values)
-      methods = methods.dup
-      return_values.each do |val|
-        idx = methods.index {|method| method.name == val.name }
-        if idx
-          val.column = methods.delete_at(idx).column
-        end
-      end
-    end
-
-    def encoding_safe_rstrip(str)
-      str.rstrip
-    rescue ArgumentError, Encoding::CompatibilityError
-      enc = str.encoding
-      if enc.ascii_compatible?
-        str.b.rstrip.force_encoding(enc)
-      else
-        str
-      end
-    end
-
-    def extract_idents(sexp)
-      tag, * = sexp
-      case tag
-      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal
-        extract_idents(sexp[1])
-      when :assign, :massign
-        extract_idents(sexp[2])
-      when :assoclist_from_args, :bare_assoc_hash, :dyna_symbol, :paren, :string_embexpr,
-        :regexp_literal, :xstring_literal
-        sexp[1].flat_map {|s| extract_idents(s) }
-      when :assoc_new, :command, :dot2, :dot3, :string_content
-        sexp[1..-1].flat_map {|s| extract_idents(s) }
-      when :unary
-        handle_columnless_ident([], sexp[1], extract_idents(sexp[2]))
-      when :binary
-        handle_columnless_ident(extract_idents(sexp[1]), sexp[2], extract_idents(sexp[3]))
-      when :call
-        if sexp[3] == :call
-          handle_columnless_ident(extract_idents(sexp[1]), :call, [])
-        else
-          [sexp[1], sexp[3]].flat_map {|s| extract_idents(s) }
-        end
-      when :array
-        sexp[1] ? sexp[1].flat_map {|s| extract_idents(s) } : []
-      when :command_call
-        [sexp[1], sexp[4], sexp[3]].flat_map {|s| extract_idents(s) }
-      when :aref
-        handle_columnless_ident(extract_idents(sexp[1]), :[], extract_idents(sexp[2]))
-      when :method_add_arg
-        idents = extract_idents(sexp[1])
-        if idents.empty?
-          # idents may be empty(e.g. ->{}.())
-          extract_idents(sexp[2])
-        else
-          idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
-        end
-      when :args_add_block
-        _, (tag, ss0, *ss1), _ = sexp
-        if tag == :args_add_star
-          (ss0 + ss1).flat_map {|s| extract_idents(s) }
-        else
-          sexp[1].flat_map {|s| extract_idents(s) }
-        end
-      when :vcall
-        _, (tag, name, (_, column)) = sexp
-        if tag == :@ident
-          [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
-        else
-          []
-        end
-      when :program
-        _, ((tag0, (tag1, (tag2, (tag3, mname, _)), _), (tag4, _, ss))) = sexp
-        if tag0 == :method_add_block and tag1 == :method_add_arg and tag2 == :fcall and
-            (tag3 == :@ident or tag3 == :@const) and mname == @assertion_method_name and (tag4 == :brace_block or tag4 == :do_block)
-          ss.flat_map {|s| extract_idents(s) }
-        else
-          _, (s, *) = sexp
-          extract_idents(s)
-        end
-      when :var_ref
-        _, (tag, ref_name, (_, column)) = sexp
-        case tag
-        when :@kw
-          if ref_name == 'self'
-            [Ident[:ref, 'self', column]]
-          else
-            []
-          end
-        when :@const, :@cvar, :@ivar, :@gvar
-          [Ident[:ref, ref_name, column]]
-        else
-          []
-        end
-      when :@ident, :@const
-        _, method_name, (_, column) = sexp
-        [Ident[:method, method_name, column]]
-      else
-        []
-      end
-    end
-
-    def str_indices(str, re, offset, limit)
-      idx = str.index(re, offset)
-      if idx and idx <= limit
-        [idx, *str_indices(str, re, idx + 1, limit)]
-      else
-        []
-      end
-    end
-
-    MID2SRCTXT = {
-      :[] => '[',
-      :+@ => '+',
-      :-@ => '-',
-      :call => '('
-    }
-
-    def handle_columnless_ident(left_idents, mid, right_idents)
-      left_max = left_idents.max_by(&:column)
-      right_min = right_idents.min_by(&:column)
-      bg = left_max ? left_max.column + left_max.name.length : 0
-      ed = right_min ? right_min.column - 1 : @line.length - 1
-      mname = mid.to_s
-      srctxt = MID2SRCTXT[mid] || mname
-      re = /
-        #{'\b' if /\A\w/ =~ srctxt}
-        #{Regexp.escape(srctxt)}
-        #{'\b' if /\w\z/ =~ srctxt}
-      /x
-      indices = str_indices(@line, re, bg, ed)
-      if left_idents.empty? and right_idents.empty?
-        left_idents + right_idents
-      elsif left_idents.empty?
-        left_idents + right_idents + [Ident[:method, mname, indices.last]]
-      else
-        left_idents + right_idents + [Ident[:method, mname, indices.first]]
-      end
-    end
-  end
-  private_constant :Context
-end