wallee-ruby-sdk 3.0.5 → 3.1.2

data/vendor/bundle/ruby/2.4.0/gems/power_assert-2.0.1/lib/power_assert/parser.rb

@@ -0,0 +1,251 @@
+require 'ripper'
+
+module PowerAssert
+  class Parser
+    Ident = Struct.new(:type, :name, :column)
+
+    attr_reader :line, :path, :lineno, :binding
+
+    def initialize(line, path, lineno, binding, assertion_method_name = nil, assertion_proc = nil)
+      @line = line
+      @line_for_parsing = (valid_syntax?(line) ? line : slice_expression(line)).b
+      @path = path
+      @lineno = lineno
+      @binding = binding
+      @proc_local_variables = binding.eval('local_variables').map(&:to_s)
+      @assertion_method_name = assertion_method_name
+      @assertion_proc = assertion_proc
+    end
+
+    def idents
+      @idents ||= extract_idents(Ripper.sexp(@line_for_parsing))
+    end
+
+    def call_paths
+      collect_paths(idents).uniq
+    end
+
+    def method_id_set
+      methods = idents.flatten.find_all {|i| i.type == :method }
+      @method_id_set ||= methods.map(&:name).map(&:to_sym).each_with_object({}) {|i, h| h[i] = true }
+    end
+
+    private
+
+    def valid_syntax?(str)
+      return true unless defined?(RubyVM)
+      begin
+        verbose, $VERBOSE = $VERBOSE, nil
+        RubyVM::InstructionSequence.compile(str)
+        true
+      rescue SyntaxError
+        false
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+
+    def slice_expression(str)
+      str = str.chomp
+      str.sub!(/\A\s*(?:if|unless|elsif|case|while|until) /) {|i| ' ' * i.length }
+      str.sub!(/\A\s*(?:\}|\]|end)?\./) {|i| ' ' * i.length }
+      str.sub!(/[\{\.\\]\z/, '')
+      str.sub!(/(?:&&|\|\|)\z/, '')
+      str.sub!(/ (?:do|and|or)\z/, '')
+      str
+    end
+
+    class Branch < Array
+    end
+
+    AND_OR_OPS = %i(and or && ||)
+
+    #
+    # Returns idents as graph structure.
+    #
+    #                                                  +--c--b--+
+    #  extract_idents(Ripper.sexp('a&.b(c).d')) #=> a--+        +--d
+    #                                                  +--------+
+    #
+    def extract_idents(sexp)
+      tag, * = sexp
+      case tag
+      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal, :return
+        extract_idents(sexp[1])
+      when :assign, :massign
+        extract_idents(sexp[2])
+      when :opassign
+        _, _, (_, op_name, (_, op_column)), s0 = sexp
+        extract_idents(s0) + [Ident[:method, op_name.sub(/=\z/, ''), op_column]]
+      when :dyna_symbol
+        if sexp[1][0].kind_of?(Symbol)
+          # sexp[1] can be [:string_content, [..]] while parsing { "a": 1 }
+          extract_idents(sexp[1])
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
+        end
+      when :assoclist_from_args, :bare_assoc_hash, :paren, :string_embexpr,
+        :regexp_literal, :xstring_literal
+        sexp[1].flat_map {|s| extract_idents(s) }
+      when :command
+        [sexp[2], sexp[1]].flat_map {|s| extract_idents(s) }
+      when :assoc_new, :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
+        op = sexp[2]
+        if AND_OR_OPS.include?(op)
+          extract_idents(sexp[1]) + [Branch[extract_idents(sexp[3]), []]]
+        else
+          handle_columnless_ident(extract_idents(sexp[1]), op, extract_idents(sexp[3]))
+        end
+      when :call
+        _, recv, (op_sym, op_name, _), method = sexp
+        with_safe_op = ((op_sym == :@op and op_name == '&.') or op_sym == :"&.")
+        if method == :call
+          handle_columnless_ident(extract_idents(recv), :call, [], with_safe_op)
+        else
+          extract_idents(recv) + (with_safe_op ? [Branch[extract_idents(method), []]] : extract_idents(method))
+        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
+          if idents[-1].kind_of?(Branch) and idents[-1][1].empty?
+            # Safe navigation operator is used. See :call clause also.
+            idents[0..-2] + [Branch[extract_idents(sexp[2]) + idents[-1][0], []]]
+          else
+            idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
+          end
+        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
+          _, (s0, *) = sexp
+          extract_idents(s0)
+        end
+      when :ifop
+        _, s0, s1, s2 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), extract_idents(s2)]]
+      when :if, :unless
+        _, s0, ss0, (_, ss1) = sexp
+        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, ss1 ? ss1.flat_map {|s| extract_idents(s) } : []]]
+      when :if_mod, :unless_mod
+        _, s0, s1 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), []]]
+      when :var_ref, :var_field
+        _, (tag, ref_name, (_, column)) = sexp
+        case tag
+        when :@kw
+          if ref_name == 'self'
+            [Ident[:ref, 'self', column]]
+          else
+            []
+          end
+        when :@ident, :@const, :@cvar, :@ivar, :@gvar
+          [Ident[:ref, ref_name, column]]
+        else
+          []
+        end
+      when :@ident, :@const, :@op
+        _, 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, with_safe_op = false)
+      left_max = left_idents.flatten.max_by(&:column)
+      right_min = right_idents.flatten.min_by(&:column)
+      bg = left_max ? left_max.column + left_max.name.length : 0
+      ed = right_min ? right_min.column - 1 : @line_for_parsing.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_for_parsing, re, bg, ed)
+      if indices.length == 1 or !(right_idents.empty? and left_idents.empty?)
+        ident = Ident[:method, mname, right_idents.empty? ? indices.first : indices.last]
+        left_idents + right_idents + (with_safe_op ? [Branch[[ident], []]] : [ident])
+      else
+        left_idents + right_idents
+      end
+    end
+
+    def collect_paths(idents, prefixes = [[]], index = 0)
+      if index < idents.length
+        node = idents[index]
+        if node.kind_of?(Branch)
+          prefixes = node.flat_map {|n| collect_paths(n, prefixes, 0) }
+        else
+          prefixes = prefixes.map {|prefix| prefix + [node] }
+        end
+        collect_paths(idents, prefixes, index + 1)
+      else
+        prefixes
+      end
+    end
+
+    class DummyParser < Parser
+      def initialize
+        super('', nil, nil, TOPLEVEL_BINDING)
+      end
+
+      def idents
+        []
+      end
+
+      def call_paths
+        []
+      end
+    end
+    DUMMY = DummyParser.new
+  end
+  private_constant :Parser
+end

data/vendor/bundle/ruby/2.4.0/gems/power_assert-2.0.1/lib/power_assert/version.rb

@@ -0,0 +1,3 @@
+module PowerAssert
+  VERSION = "2.0.1"
+end

data/vendor/bundle/ruby/2.4.0/gems/power_assert-2.0.1/lib/power_assert.rb

@@ -0,0 +1,91 @@
+# power_assert.rb
+#
+# Copyright (C) 2014 Kazuki Tsujimoto
+
+begin
+  unless defined?(Byebug)
+    captured = false
+    TracePoint.new(:return, :c_return) do |tp|
+      captured = true
+      unless tp.binding and tp.return_value and tp.callee_id
+        raise ''
+      end
+    end.enable { __id__ }
+    raise '' unless captured
+  end
+rescue
+  raise LoadError, 'Fully compatible TracePoint API required'
+end
+
+require 'power_assert/context'
+require 'power_assert/configuration'
+require 'power_assert/version'
+
+module PowerAssert
+  POWER_ASSERT_LIB_DIR = File.dirname(caller_locations(1, 1).first.path)
+  INTERNAL_LIB_DIRS = {PowerAssert => POWER_ASSERT_LIB_DIR}
+  private_constant :POWER_ASSERT_LIB_DIR, :INTERNAL_LIB_DIRS
+
+  class << self
+    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 BlockContext.new(assertion_proc_or_source, assertion_method, source_binding)
+    end
+
+    def trace(frame)
+      begin
+        raise 'Byebug is not started yet' unless Byebug.started?
+      rescue NameError
+        raise "PowerAssert.#{__method__} requires Byebug"
+      end
+      ctx = TraceContext.new(frame._binding)
+      ctx.enable
+      ctx
+    end
+
+    def app_caller_locations
+      caller_locations.drop_while {|i| internal_file?(i.path) }.take_while {|i| ! internal_file?(i.path) }
+    end
+
+    def app_context?
+      top_frame = caller_locations.drop_while {|i| i.path.start_with?(POWER_ASSERT_LIB_DIR) }.first
+      top_frame and ! internal_file?(top_frame.path)
+    end
+
+    private
+
+    def internal_file?(file)
+      setup_internal_lib_dir(Byebug, :attach, 2) if defined?(Byebug)
+      setup_internal_lib_dir(PryByebug, :start_with_pry_byebug, 2, Pry) if defined?(PryByebug)
+      INTERNAL_LIB_DIRS.find do |_, dir|
+        file.start_with?(dir)
+      end
+    end
+
+    def setup_internal_lib_dir(lib, mid, depth, lib_obj = lib)
+      unless INTERNAL_LIB_DIRS.key?(lib)
+        INTERNAL_LIB_DIRS[lib] = lib_dir(lib_obj, mid, depth)
+      end
+    rescue NameError
+    end
+
+    def lib_dir(obj, mid, depth)
+      File.expand_path('../' * depth, obj.method(mid).source_location[0])
+    end
+
+    if defined?(RubyVM)
+      CLEAR_CACHE_ISEQ = RubyVM::InstructionSequence.compile('using PowerAssert.const_get(:Empty)')
+      private_constant :CLEAR_CACHE_ISEQ
+
+      def clear_global_method_cache
+        CLEAR_CACHE_ISEQ.eval
+      end
+    end
+  end
+
+  module Empty
+  end
+  private_constant :Empty
+end

data/vendor/bundle/ruby/2.4.0/gems/power_assert-2.0.1/power_assert.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'power_assert/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'power_assert'
+  s.version     = PowerAssert::VERSION
+  s.authors     = ['Kazuki Tsujimoto']
+  s.email       = ['kazuki@callcc.net']
+  s.homepage    = 'https://github.com/ruby/power_assert'
+  s.summary     = "Power Assert for Ruby"
+  s.description = "Power Assert shows each value of variables and method calls in the expression. It is useful for testing, providing which value wasn't correct when the condition is not satisfied."
+
+  s.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{\A(?:test|spec|features|benchmark|bin)/})
+  end
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'irb', '>= 1.3.1'
+  s.add_development_dependency 'byebug'
+  s.add_development_dependency 'benchmark-ips'
+  s.extra_rdoc_files = ['README.md']
+  s.rdoc_options     = ['--main', 'README.md']
+  s.licenses         = ['BSD-2-Clause', "Ruby"]
+end

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: "rubygems/public_suffix"
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with a single custom sponsorship URL

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "04:00"
+  open-pull-requests-limit: 10

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.github/workflows/release.yml

@@ -0,0 +1,16 @@
+name: release
+
+on:
+  push:
+    tags:
+      - v*.*.*
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Release Gem
+        uses: cadwallion/publish-rubygems-action@8f9e0538302643309e4e43bf48cd34173ca48cfc
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          RELEASE_COMMAND: rake release

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.github/workflows/tests.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        ruby-version:
+          - "2.6"
+          - "2.7"
+          - "3.0"
+          - "3.1"
+        platform: [ubuntu-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.gitignore

@@ -0,0 +1,8 @@
+# Bundler
+/.bundle
+/Gemfile.lock
+/pkg/*
+
+# YARD
+/.yardoc
+/yardoc/

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.rubocop.yml

@@ -0,0 +1,36 @@
+inherit_from:
+  - .rubocop_opinionated.yml
+
+AllCops:
+  Exclude:
+    # Exclude .gemspec files because they are generally auto-generated
+    - '*.gemspec'
+    # Exclude vendored folders
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+    # Exclude artifacts
+    - 'pkg/**/*'
+    # Other
+    - 'test/benchmarks/**/*'
+    - 'test/profilers/**/*'
+
+# I often use @_variable to avoid clashing.
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+
+# Dear Rubocop, I don't want to use String#strip_heredoc
+Layout/HeredocIndentation:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: false
+  MinSize: 3
+
+Style/SymbolArray:
+  Enabled: false
+  MinSize: 3

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.rubocop_opinionated.yml

@@ -0,0 +1,163 @@
+AllCops:
+  Exclude:
+    # Exclude .gemspec files because they are generally auto-generated
+    - '*.gemspec'
+    # Exclude vendored folders
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+  NewCops: enable
+
+# [codesmell]
+Layout/LineLength:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+  Max: 100
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'Rakefile'
+    - 'spec/**/*'
+    - 'test/**/*'
+
+# [codesmell]
+Metrics/AbcSize:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+
+# [codesmell]
+Metrics/BlockLength:
+  Enabled: false
+
+# [codesmell]
+Metrics/CyclomaticComplexity:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+
+# [codesmell]
+Metrics/ClassLength:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+
+# [codesmell]
+Metrics/MethodLength:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+  Max: 10
+
+# [codesmell]
+Metrics/ModuleLength:
+  Enabled: false
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - 'test/**/*_test.rb'
+
+# [codesmell]
+Metrics/ParameterLists:
+  Enabled: false
+  Max: 5
+
+# [codesmell]
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+# Do not use "and" or "or" in conditionals, but for readability we can use it
+# to chain executions. Just beware of operator order.
+Style/AndOr:
+  EnforcedStyle: conditionals
+
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+
+# Double empty lines are useful to separate conceptually different methods
+# in the same class or module.
+Layout/EmptyLines:
+  Enabled: false
+
+# In most cases, a space is nice. Sometimes, it's not.
+# Just be consistent with the rest of the surrounding code.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+
+# In most cases, a space is nice. Sometimes, it's not.
+# Just be consistent with the rest of the surrounding code.
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# This is quite buggy, as it doesn't recognize double lines.
+# Double empty lines are useful to separate conceptually different methods
+# in the same class or module.
+Layout/EmptyLineBetweenDefs:
+  Enabled: false
+
+# I personally don't care about the format style.
+# In most cases I like to use %, but not at the point I want to enforce it
+# as a convention in the entire code.
+Style/FormatString:
+  Enabled: false
+
+# Annotated tokens (like %<foo>s) are a good thing, but in most cases we don't need them.
+# %s is a simpler and straightforward version that works in almost all cases. So don't complain.
+Style/FormatStringToken:
+  Enabled: false
+
+# unless is not always cool.
+Style/NegatedIf:
+  Enabled: false
+
+# For years, %w() has been the de-facto standard. A lot of libraries are using ().
+# Switching to [] would be a nightmare.
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+# There are cases were the inline rescue is ok. We can either downgrade the severity,
+# or rely on the developer judgement on a case-by-case basis.
+Style/RescueModifier:
+  Enabled: false
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+# Sorry, but using trailing spaces helps readability.
+#
+#   %w( foo bar )
+#
+# looks better to me than
+#
+#   %w( foo bar )
+#
+Layout/SpaceInsidePercentLiteralDelimiters:
+  Enabled: false
+
+# Hate It or Love It, I prefer double quotes as this is more consistent
+# with several other programming languages and the output of puts and inspect.
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# It's nice to be consistent. The trailing comma also allows easy reordering,
+# and doesn't cause a diff in Git when you add a line to the bottom.
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrivialAccessors:
+  # IgnoreClassMethods because I want to be able to define class-level accessors
+  # that sets an instance variable on the metaclass, such as:
+  #
+  #    def self.default=(value)
+  #      @default = value
+  #    end
+  #
+  IgnoreClassMethods: true

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/.yardopts

@@ -0,0 +1 @@
+--title 'Ruby Public Suffix API Documentation'