approveapi 1.0.4 → 1.0.5

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/ffi.gemspec

@@ -0,0 +1,36 @@
+require File.expand_path("../lib/#{File.basename(__FILE__, '.gemspec')}/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'ffi'
+  s.version = FFI::VERSION
+  s.author = 'Wayne Meissner'
+  s.email = 'wmeissner@gmail.com'
+  s.homepage = 'http://wiki.github.com/ffi/ffi'
+  s.summary = 'Ruby FFI'
+  s.description = 'Ruby FFI library'
+  s.files = `git ls-files -z`.split("\x0").reject do |f|
+    f =~ /^(bench|gen|libtest|nbproject|spec)/
+  end
+
+  # Add libffi git files
+  lfs = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0")
+  # Add autoconf generated files of libffi
+  lfs += %w[ configure config.guess config.sub install-sh ltmain.sh missing fficonfig.h.in ]
+  # Add automake generated files of libffi
+  lfs += `git --git-dir ext/ffi_c/libffi/.git ls-files -z *.am */*.am`.gsub(".am\0", ".in\0").split("\x0")
+  s.files += lfs.map do |f|
+    File.join("ext/ffi_c/libffi", f)
+  end
+
+  s.extensions << 'ext/ffi_c/extconf.rb'
+  s.has_rdoc = false
+  s.rdoc_options = %w[--exclude=ext/ffi_c/.*\.o$ --exclude=ffi_c\.(bundle|so)$]
+  s.license = 'BSD-3-Clause'
+  s.require_paths << 'ext/ffi_c'
+  s.required_ruby_version = '>= 1.9'
+  s.add_development_dependency 'rake', '~> 10.1'
+  s.add_development_dependency 'rake-compiler', '~> 1.0'
+  s.add_development_dependency 'rake-compiler-dock', '~> 0.6.2'
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+  s.add_development_dependency 'rubygems-tasks', "~> 0.2.4"
+end

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/lib/ffi.rb

@@ -0,0 +1,20 @@
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+  Object.send(:remove_const, :FFI) if defined?(::FFI)
+  begin
+    require RUBY_VERSION.split('.')[0, 2].join('.') + '/ffi_c'
+  rescue Exception
+    require 'ffi_c'
+  end
+
+  require 'ffi/ffi'
+
+elsif defined?(RUBY_ENGINE)
+  # Remove the ffi gem dir from the load path, then reload the internal ffi implementation
+  $LOAD_PATH.delete(File.dirname(__FILE__))
+  $LOAD_PATH.delete(File.join(File.dirname(__FILE__), 'ffi'))
+  unless $LOADED_FEATURES.nil?
+    $LOADED_FEATURES.delete(__FILE__)
+    $LOADED_FEATURES.delete('ffi.rb')
+  end
+  require 'ffi.rb'
+end

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/lib/ffi/autopointer.rb

@@ -0,0 +1,203 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+# Copyright (C) 2008 Mike Dalessio
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * 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.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+
+module FFI
+  class AutoPointer < Pointer
+    extend DataConverter
+
+    # @overload initialize(pointer, method)
+    #   @param pointer [Pointer]
+    #   @param method [Method]
+    #   @return [self]
+    #   The passed Method will be invoked at GC time.
+    # @overload initialize(pointer, proc)
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
+    #   @note WARNING: passing a proc _may_ cause your pointer to never be
+    #     GC'd, unless you're careful to avoid trapping a reference to the
+    #     pointer in the proc. See the test specs for examples.
+    # @overload initialize(pointer) { |p| ... }
+    #   @param pointer [Pointer]
+    #   @yieldparam [Pointer] p +pointer+ passed to the block
+    #   @return [self]
+    #   The passed block will be invoked at GC time.
+    #   @note
+    #     WARNING: passing a block will cause your pointer to never be GC'd.
+    #     This is bad.
+    # @overload initialize(pointer)
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The pointer's release() class method will be invoked at GC time.
+    #
+    # @note The safest, and therefore preferred, calling
+    #  idiom is to pass a Method as the second parameter. Example usage:
+    #
+    #   class PointerHelper
+    #     def self.release(pointer)
+    #       ...
+    #     end
+    #   end
+    #
+    #   p = AutoPointer.new(other_pointer, PointerHelper.method(:release))
+    #
+    #  The above code will cause PointerHelper#release to be invoked at GC time.
+    #
+    # @note
+    #  The last calling idiom (only one parameter) is generally only
+    #  going to be useful if you subclass {AutoPointer}, and override
+    #  #release, which by default does nothing.
+    def initialize(ptr, proc=nil, &block)
+      super(ptr.type_size, ptr)
+      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
+        || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
+
+      @releaser = if proc
+                    if not proc.respond_to?(:call)
+                      raise RuntimeError.new("proc must be callable")
+                    end
+                    CallableReleaser.new(ptr, proc)
+
+                  else
+                    if not self.class.respond_to?(:release)
+                      raise RuntimeError.new("no release method defined")
+                    end
+                    DefaultReleaser.new(ptr, self.class)
+                  end
+
+      ObjectSpace.define_finalizer(self, @releaser)
+      self
+    end
+
+    # @return [nil]
+    # Free the pointer.
+    def free
+      @releaser.free
+    end
+
+    # @param [Boolean] autorelease
+    # @return [Boolean] +autorelease+
+    # Set +autorelease+ property. See {Pointer Autorelease section at Pointer}.
+    def autorelease=(autorelease)
+      @releaser.autorelease=(autorelease)
+    end
+
+    # @return [Boolean] +autorelease+
+    # Get +autorelease+ property. See {Pointer Autorelease section at Pointer}.
+    def autorelease?
+      @releaser.autorelease
+    end
+
+    # @abstract Base class for {AutoPointer}'s releasers.
+    #  
+    #  All subclasses of Releaser should define a +#release(ptr)+ method.
+    # A releaser is an object in charge of release an {AutoPointer}.
+    class Releaser
+      attr_accessor :autorelease
+
+      # @param [Pointer] ptr
+      # @param [#call] proc
+      # @return [nil]
+      # A new instance of Releaser.
+      def initialize(ptr, proc)
+        @ptr = ptr
+        @proc = proc
+        @autorelease = true
+      end
+
+      # @return [nil]
+      # Free pointer.
+      def free
+        if @ptr
+          release(@ptr)
+          @autorelease = false
+          @ptr = nil
+          @proc = nil
+        end
+      end
+
+      # @param args
+      # Release pointer if +autorelease+ is set.
+      def call(*args)
+        release(@ptr) if @autorelease && @ptr
+      end
+    end
+
+    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined
+    # without Proc or Method. In this case, the pointer to release must be of
+    # a class derived from AutoPointer with a {release} class method.
+    class DefaultReleaser < Releaser
+      # @param [Pointer] ptr
+      # @return [nil]
+      # Release +ptr+ using the {release} class method of its class.
+      def release(ptr)
+        @proc.release(ptr)
+      end
+    end
+
+    # CallableReleaser is a {Releaser} used when an {AutoPointer} is defined with a
+    # Proc or a Method.
+    class CallableReleaser < Releaser
+      # Release +ptr+ by using Proc or Method defined at +ptr+
+      # {AutoPointer#initialize initialization}.
+      #
+      # @param [Pointer] ptr
+      # @return [nil]
+      def release(ptr)
+        @proc.call(ptr)
+      end
+    end
+
+    # Return native type of AutoPointer.
+    #
+    # Override {DataConverter#native_type}.
+    # @return [Type::POINTER]
+    # @raise {RuntimeError} if class does not implement a +#release+ method
+    def self.native_type
+      if not self.respond_to?(:release)
+        raise RuntimeError.new("no release method defined for #{self.inspect}")
+      end
+      Type::POINTER
+    end
+
+    # Create a new AutoPointer.
+    #
+    # Override {DataConverter#from_native}.
+    # @overload self.from_native(ptr, ctx)
+    #   @param [Pointer] ptr
+    #   @param ctx not used. Please set +nil+.
+    # @return [AutoPointer]
+    def self.from_native(val, ctx)
+      self.new(val)
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/lib/ffi/buffer.rb

@@ -0,0 +1,4 @@
+#
+# All the code from this file is now implemented in C.  This file remains
+# to satisfy any leftover require 'ffi/buffer' in user code
+#

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/lib/ffi/callback.rb

@@ -0,0 +1,4 @@
+#
+# All the code from this file is now implemented in C.  This file remains
+# to satisfy any leftover require 'ffi/callback' in user code
+#

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/lib/ffi/enum.rb

@@ -0,0 +1,296 @@
+#
+# Copyright (C) 2009, 2010 Wayne Meissner
+# Copyright (C) 2009 Luc Heinrich
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * 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.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+#
+
+module FFI
+
+  # An instance of this class permits to manage {Enum}s. In fact, Enums is a collection of {Enum}s.
+  class Enums
+
+    # @return [nil]
+    def initialize
+      @all_enums = Array.new
+      @tagged_enums = Hash.new
+      @symbol_map = Hash.new
+    end
+
+    # @param [Enum] enum
+    # Add an {Enum} to the collection.
+    def <<(enum)
+      @all_enums << enum
+      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
+      @symbol_map.merge!(enum.symbol_map)
+    end
+
+    # @param query enum tag or part of an enum name
+    # @return [Enum]
+    # Find a {Enum} in collection.
+    def find(query)
+      if @tagged_enums.has_key?(query)
+        @tagged_enums[query]
+      else
+        @all_enums.detect { |enum| enum.symbols.include?(query) }
+      end
+    end
+
+    # @param symbol a symbol to find in merge symbol maps of all enums.
+    # @return a symbol
+    def __map_symbol(symbol)
+      @symbol_map[symbol]
+    end
+
+  end
+
+  # Represents a C enum.
+  #
+  # For a C enum:
+  #  enum fruits {
+  #    apple,
+  #    banana,
+  #    orange,
+  #    pineapple
+  #  };
+  # are defined this vocabulary:
+  # * a _symbol_ is a word from the enumeration (ie. _apple_, by example);
+  # * a _value_ is the value of a symbol in the enumeration (by example, apple has value _0_ and banana _1_).
+  class Enum
+    include DataConverter
+
+    attr_reader :tag
+    attr_reader :native_type
+
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info
+    #   @param [nil, Symbol] tag enum tag
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Enum
+    #   @param [nil, Enumerable] info symbols and values for new Enum
+    #   @param [nil, Symbol] tag name of new Enum
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      info, @tag = *args
+      @kv_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            raise ArgumentError, "duplicate enum key" if @kv_map.has_key?(i)
+            @kv_map[i] = value
+            last_cst = i
+            value += 1
+          when Integer
+            @kv_map[last_cst] = i
+            value = i+1
+          end
+        end
+      end
+      @vk_map = @kv_map.invert
+    end
+
+    # @return [Array] enum symbol names
+    def symbols
+      @kv_map.keys
+    end
+
+    # Get a symbol or a value from the enum.
+    # @overload [](query)
+    #  Get enum value from symbol.
+    #  @param [Symbol] query
+    #  @return [Integer]
+    # @overload [](query)
+    #  Get enum symbol from value.
+    #  @param [Integer] query
+    #  @return [Symbol]
+    def [](query)
+      case query
+      when Symbol
+        @kv_map[query]
+      when Integer
+        @vk_map[query]
+      end
+    end
+    alias find []
+
+    # Get the symbol map.
+    # @return [Hash]
+    def symbol_map
+      @kv_map
+    end
+
+    alias to_h symbol_map
+    alias to_hash symbol_map
+
+    # @param [Symbol, Integer, #to_int] val
+    # @param ctx unused
+    # @return [Integer] value of a enum symbol
+    def to_native(val, ctx)
+      @kv_map[val] || if val.is_a?(Integer)
+        val
+      elsif val.respond_to?(:to_int)
+        val.to_int
+      else
+        raise ArgumentError, "invalid enum value, #{val.inspect}"
+      end
+    end
+
+    # @param val
+    # @return symbol name if it exists for +val+.
+    def from_native(val, ctx)
+      @vk_map[val] || val
+    end
+  end
+
+  # Represents a C enum whose values are power of 2
+  #
+  # @example
+  #  enum {
+  #    red = (1<<0),
+  #    green = (1<<1),
+  #    blue = (1<<2)
+  #  }
+  #
+  # Contrary to classical enums, bitmask values are usually combined
+  # when used.
+  class Bitmask < Enum
+
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Bitmask
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      info, @tag = *args
+      @kv_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            raise ArgumentError, "duplicate bitmask key" if @kv_map.has_key?(i)
+            @kv_map[i] = 1 << value
+            last_cst = i
+            value += 1
+          when Integer
+            raise ArgumentError, "bitmask index should be positive" if i<0
+            @kv_map[last_cst] = 1 << i
+            value = i+1
+          end
+        end
+      end
+      @vk_map = @kv_map.invert
+    end
+
+    # Get a symbol list or a value from the bitmask
+    # @overload [](*query)
+    #  Get bitmask value from symbol list
+    #  @param [Symbol] query
+    #  @return [Integer]
+    # @overload [](query)
+    #  Get bitmaks value from symbol array
+    #  @param [Array<Symbol>] query
+    #  @return [Integer]
+    # @overload [](*query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Integer] query
+    #  @return [Array<Symbol>]
+    # @overload [](query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Array<Integer>] query
+    #  @return [Array<Symbol>]
+    def [](*query)
+      flat_query = query.flatten
+      raise ArgumentError, "query should be homogeneous, #{query.inspect}" unless flat_query.all? { |o| o.is_a?(Symbol) } || flat_query.all? { |o| o.is_a?(Integer) || o.respond_to?(:to_int) }
+      case flat_query[0]
+      when Symbol
+        flat_query.inject(0) do |val, o|
+          v = @kv_map[o]
+          if v then val |= v else val end
+        end
+      when Integer, ->(o) { o.respond_to?(:to_int) }
+        val = flat_query.inject(0) { |mask, o| mask |= o.to_int }
+        @kv_map.select { |_, v| v & val != 0 }.keys
+      end
+    end
+
+    # Get the native value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Symbol, Integer, #to_int] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Array<Symbol, Integer, #to_int>] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    def to_native(query, ctx)
+      return 0 if query.nil?
+      flat_query = [query].flatten
+      flat_query.inject(0) do |val, o|
+        case o
+        when Symbol
+          v = @kv_map[o]
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}" unless v
+          val |= v
+        when Integer
+          val |= o
+        when ->(obj) { obj.respond_to?(:to_int) }
+          val |= o.to_int
+        else
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}"
+        end
+      end
+    end
+
+    # @param [Integer] val
+    # @param ctx unused
+    # @return [Array<Symbol, Integer>] list of symbol names corresponding to val, plus an optional remainder if some bits don't match any constant
+    def from_native(val, ctx)
+      list = @kv_map.select { |_, v| v & val != 0 }.keys
+      # If there are unmatch flags,
+      # return them in an integer,
+      # else information can be lost.
+      # Similar to Enum behavior.
+      remainder = val ^ list.inject(0) do |tmp, o|
+        v = @kv_map[o]
+        if v then tmp |= v else tmp end
+      end
+      list.push remainder unless remainder == 0
+      return list
+    end
+  end
+end