windows-pr 1.2.4 → 1.2.5

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/BSDL

@@ -0,0 +1,22 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/COPYING

@@ -0,0 +1,57 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/Gemfile

@@ -0,0 +1,9 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/LEGAL

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

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/README.rdoc

@@ -0,0 +1,19 @@
+= 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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/Rakefile

@@ -0,0 +1,16 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/benchmarks/bm_yhpg.rb

@@ -0,0 +1,59 @@
+# 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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/benchmarks/helper.rb

@@ -0,0 +1,8 @@
+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/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/lib/power_assert.rb

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