alloy_sdk 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb

@@ -0,0 +1,102 @@
+RSpec::Support.require_rspec_core "formatters/base_formatter"
+require 'json'
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class JsonFormatter < BaseFormatter
+        Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :seed, :close
+
+        attr_reader :output_hash
+
+        def initialize(output)
+          super
+          @output_hash = {
+            :version => RSpec::Core::Version::STRING
+          }
+        end
+
+        def message(notification)
+          (@output_hash[:messages] ||= []) << notification.message
+        end
+
+        def dump_summary(summary)
+          @output_hash[:summary] = {
+            :duration => summary.duration,
+            :example_count => summary.example_count,
+            :failure_count => summary.failure_count,
+            :pending_count => summary.pending_count,
+            :errors_outside_of_examples_count => summary.errors_outside_of_examples_count
+          }
+          @output_hash[:summary_line] = summary.totals_line
+        end
+
+        def stop(notification)
+          @output_hash[:examples] = notification.examples.map do |example|
+            format_example(example).tap do |hash|
+              e = example.exception
+              if e
+                hash[:exception] =  {
+                  :class => e.class.name,
+                  :message => e.message,
+                  :backtrace => e.backtrace,
+                }
+              end
+            end
+          end
+        end
+
+        def seed(notification)
+          return unless notification.seed_used?
+          @output_hash[:seed] = notification.seed
+        end
+
+        def close(_notification)
+          output.write @output_hash.to_json
+        end
+
+        def dump_profile(profile)
+          @output_hash[:profile] = {}
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+        # @api private
+        def dump_profile_slowest_examples(profile)
+          @output_hash[:profile] = {}
+          @output_hash[:profile][:examples] = profile.slowest_examples.map do |example|
+            format_example(example).tap do |hash|
+              hash[:run_time] = example.execution_result.run_time
+            end
+          end
+          @output_hash[:profile][:slowest] = profile.slow_duration
+          @output_hash[:profile][:total] = profile.duration
+        end
+
+        # @api private
+        def dump_profile_slowest_example_groups(profile)
+          @output_hash[:profile] ||= {}
+          @output_hash[:profile][:groups] = profile.slowest_groups.map do |loc, hash|
+            hash.update(:location => loc)
+          end
+        end
+
+      private
+
+        def format_example(example)
+          {
+            :id => example.id,
+            :description => example.description,
+            :full_description => example.full_description,
+            :status => example.execution_result.status.to_s,
+            :file_path => example.metadata[:file_path],
+            :line_number  => example.metadata[:line_number],
+            :run_time => example.execution_result.run_time,
+            :pending_message => example.execution_result.pending_message,
+          }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb

@@ -0,0 +1,68 @@
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      # Formatter for providing profile output.
+      class ProfileFormatter
+        Formatters.register self, :dump_profile
+
+        def initialize(output)
+          @output = output
+        end
+
+        # @private
+        attr_reader :output
+
+        # @api public
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [ProfileNotification] containing duration,
+        #   slowest_examples and slowest_example_groups
+        def dump_profile(profile)
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+      private
+
+        def dump_profile_slowest_examples(profile)
+          @output.puts "\nTop #{profile.slowest_examples.size} slowest " \
+            "examples (#{Helpers.format_seconds(profile.slow_duration)} " \
+            "seconds, #{profile.percentage}% of total time):\n"
+
+          profile.slowest_examples.each do |example|
+            @output.puts "  #{example.full_description}"
+            @output.puts "    #{bold(Helpers.format_seconds(example.execution_result.run_time))} " \
+                         "#{bold("seconds")} #{format_caller(example.location)}"
+          end
+        end
+
+        def dump_profile_slowest_example_groups(profile)
+          return if profile.slowest_groups.empty?
+
+          @output.puts "\nTop #{profile.slowest_groups.size} slowest example groups:"
+          profile.slowest_groups.each do |loc, hash|
+            average = "#{bold(Helpers.format_seconds(hash[:average]))} #{bold("seconds")} average"
+            total   = "#{Helpers.format_seconds(hash[:total_time])} seconds"
+            count   = Helpers.pluralize(hash[:count], "example")
+            @output.puts "  #{hash[:description]}"
+            @output.puts "    #{average} (#{total} / #{count}) #{loc}"
+          end
+        end
+
+        def format_caller(caller_info)
+          RSpec.configuration.backtrace_formatter.backtrace_line(
+            caller_info.to_s.split(':in `block').first)
+        end
+
+        def bold(text)
+          ConsoleCodes.wrap(text, :bold)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb

@@ -0,0 +1,29 @@
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class ProgressFormatter < BaseTextFormatter
+        Formatters.register self, :example_passed, :example_pending, :example_failed, :start_dump
+
+        def example_passed(_notification)
+          output.print ConsoleCodes.wrap('.', :success)
+        end
+
+        def example_pending(_notification)
+          output.print ConsoleCodes.wrap('*', :pending)
+        end
+
+        def example_failed(_notification)
+          output.print ConsoleCodes.wrap('F', :failure)
+        end
+
+        def start_dump(_notification)
+          output.puts
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/protocol.rb

@@ -0,0 +1,182 @@
+module RSpec
+  module Core
+    module Formatters
+      # This class isn't loaded at runtime but serves to document all of the
+      # notifications implemented as part of the standard interface. The
+      # reporter will issue these during a normal test suite run, but a
+      # formatter will only receive those notifications it has registered
+      # itself to receive. To register a formatter call:
+      #
+      # `::RSpec::Core::Formatters.register class, :list, :of, :notifications`
+      #
+      # e.g.
+      #
+      # `::RSpec::Core::Formatters.register self, :start, :example_started`
+      #
+      # @see RSpec::Core::Formatters::BaseFormatter
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      class Protocol
+        # @method initialize(output)
+        # @api public
+        #
+        # @param output [IO] the formatter output
+
+        # @method start(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones).
+        #
+        # This will only be invoked once, and the next one to be invoked
+        # is {#example_group_started}.
+        #
+        # @param notification [Notifications::StartNotification]
+
+        # @method example_group_started(notification)
+        # @api public
+        # @group Group Notifications
+        #
+        # This method is invoked at the beginning of the execution of each
+        # example group.
+        #
+        # The next method to be invoked after this is {#example_passed},
+        # {#example_pending}, or {#example_group_finished}.
+        #
+        # @param notification [Notifications::GroupNotification] containing example_group
+        #   subclass of {ExampleGroup}
+
+        # @method example_group_finished(notification)
+        # @api public
+        # @group Group Notifications
+        #
+        # Invoked at the end of the execution of each example group.
+        #
+        # @param notification [Notifications::GroupNotification] containing example_group
+        #   subclass of {ExampleGroup}
+
+        # @method example_started(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the beginning of the execution of each example.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_finished(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the end of the execution of each example.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_passed(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example passes.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_pending(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example is pending.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_failed(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example fails.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method message(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param notification [Notifications::MessageNotification] containing message
+
+        # @method stop(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked after all examples have executed, before dumping post-run
+        # reports.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method start_dump(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after all of the examples have executed. The
+        # next method to be invoked after this one is {#dump_failures}
+        # (BaseTextFormatter then calls {#dump_failures} once for each failed
+        # example).
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method dump_failures(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method dump_summary(summary)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping of examples and failures.
+        # Each parameter is assigned to a corresponding attribute.
+        #
+        # @param summary [Notifications::SummaryNotification] containing duration,
+        #   example_count, failure_count and pending_count
+
+        # @method dump_profile(profile)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [Notifications::ProfileNotification] containing duration,
+        #   slowest_examples and slowest_example_groups
+
+        # @method dump_pending(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Outputs a report of pending examples. This gets invoked
+        # after the summary if option is set to do so.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method close(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked at the end of a suite run. Allows the formatter to do any
+        # tidying up, but be aware that formatter output streams may be used
+        # elsewhere so don't actually close them.
+        #
+        # @param notification [Notifications::NullNotification]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb

@@ -0,0 +1,134 @@
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class SnippetExtractor
+        NoSuchFileError = Class.new(StandardError)
+        NoSuchLineError = Class.new(StandardError)
+
+        def self.extract_line_at(file_path, line_number)
+          source = source_from_file(file_path)
+          line = source.lines[line_number - 1]
+          raise NoSuchLineError unless line
+          line
+        end
+
+        def self.source_from_file(path)
+          raise NoSuchFileError unless File.exist?(path)
+          RSpec.world.source_from_file(path)
+        end
+
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          NoExpressionAtLineError = Class.new(StandardError)
+
+          attr_reader :source, :beginning_line_number, :max_line_count
+
+          def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=nil)
+            if max_line_count == 1
+              [extract_line_at(file_path, beginning_line_number)]
+            else
+              source = source_from_file(file_path)
+              new(source, beginning_line_number, max_line_count).expression_lines
+            end
+          end
+
+          def initialize(source, beginning_line_number, max_line_count=nil)
+            @source = source
+            @beginning_line_number = beginning_line_number
+            @max_line_count = max_line_count
+          end
+
+          def expression_lines
+            line_range = line_range_of_expression
+
+            if max_line_count && line_range.count > max_line_count
+              line_range = (line_range.begin)..(line_range.begin + max_line_count - 1)
+            end
+
+            source.lines[(line_range.begin - 1)..(line_range.end - 1)]
+          rescue SyntaxError, NoExpressionAtLineError
+            [self.class.extract_line_at(source.path, beginning_line_number)]
+          end
+
+          private
+
+          def line_range_of_expression
+            @line_range_of_expression ||= begin
+              line_range = line_range_of_location_nodes_in_expression
+              initial_unclosed_tokens = unclosed_tokens_in_line_range(line_range)
+              unclosed_tokens = initial_unclosed_tokens
+
+              until (initial_unclosed_tokens & unclosed_tokens).empty?
+                line_range = (line_range.begin)..(line_range.end + 1)
+                unclosed_tokens = unclosed_tokens_in_line_range(line_range)
+              end
+
+              line_range
+            end
+          end
+
+          def unclosed_tokens_in_line_range(line_range)
+            tokens = FlatMap.flat_map(line_range) do |line_number|
+              source.tokens_by_line_number[line_number]
+            end
+
+            tokens.each_with_object([]) do |token, unclosed_tokens|
+              if token.opening?
+                unclosed_tokens << token
+              else
+                index = unclosed_tokens.rindex do |unclosed_token|
+                  unclosed_token.closed_by?(token)
+                end
+                unclosed_tokens.delete_at(index) if index
+              end
+            end
+          end
+
+          def line_range_of_location_nodes_in_expression
+            line_numbers = expression_node.each_with_object(Set.new) do |node, set|
+              set << node.location.line if node.location
+            end
+
+            line_numbers.min..line_numbers.max
+          end
+
+          def expression_node
+            raise NoExpressionAtLineError if location_nodes_at_beginning_line.empty?
+
+            @expression_node ||= begin
+              common_ancestor_nodes = location_nodes_at_beginning_line.map do |node|
+                node.each_ancestor.to_a
+              end.reduce(:&)
+
+              common_ancestor_nodes.find { |node| expression_outmost_node?(node) }
+            end
+          end
+
+          def expression_outmost_node?(node)
+            return true unless node.parent
+            return false if node.type.to_s.start_with?('@')
+            ![node, node.parent].all? do |n|
+              # See `Ripper::PARSER_EVENTS` for the complete list of sexp types.
+              type = n.type.to_s
+              type.end_with?('call') || type.start_with?('method_add_')
+            end
+          end
+
+          def location_nodes_at_beginning_line
+            source.nodes_by_line_number[beginning_line_number]
+          end
+        else
+          # :nocov:
+          def self.extract_expression_lines_at(file_path, beginning_line_number, *)
+            [extract_line_at(file_path, beginning_line_number)]
+          end
+          # :nocov:
+        end
+
+        def self.least_indentation_from(lines)
+          lines.map { |line| line[/^[ \t]*/] }.min
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb

@@ -0,0 +1,91 @@
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      # Provides terminal syntax highlighting of code snippets
+      # when coderay is available.
+      class SyntaxHighlighter
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def highlight(lines)
+          implementation.highlight_syntax(lines)
+        end
+
+        # rubocop:disable Lint/RescueException
+        # rubocop:disable Lint/HandleExceptions
+        def self.attempt_to_add_rspec_terms_to_coderay_keywords
+          CodeRay::Scanners::Ruby::Patterns::IDENT_KIND.add(%w[
+            describe context
+            it specify
+            before after around
+            let subject
+            expect allow
+          ], :keyword)
+        rescue Exception
+          # Mutating CodeRay's contants like this is not a public API
+          # and might not always work. If we cannot add our keywords
+          # to CodeRay it is not a big deal and not worth raising an
+          # error over, so we ignore it.
+        end
+      # rubocop:enable Lint/HandleExceptions
+      # rubocop:enable Lint/RescueException
+
+      private
+
+        if RSpec::Support::OS.windows?
+          # :nocov:
+          def implementation
+            WindowsImplementation
+          end
+          # :nocov:
+        else
+          def implementation
+            return color_enabled_implementation if @configuration.color_enabled?
+            NoSyntaxHighlightingImplementation
+          end
+        end
+
+        def color_enabled_implementation
+          @color_enabled_implementation ||= begin
+            require 'coderay'
+            self.class.attempt_to_add_rspec_terms_to_coderay_keywords
+            CodeRayImplementation
+          rescue LoadError
+            NoSyntaxHighlightingImplementation
+          end
+        end
+
+        # @private
+        module CodeRayImplementation
+          RESET_CODE = "\e[0m"
+
+          def self.highlight_syntax(lines)
+            highlighted = begin
+              CodeRay.encode(lines.join("\n"), :ruby, :terminal)
+            rescue Support::AllExceptionsExceptOnesWeMustNotRescue
+              return lines
+            end
+
+            highlighted.split("\n").map do |line|
+              line.sub(/\S/) { |char| char.insert(0, RESET_CODE) }
+            end
+          end
+        end
+
+        # @private
+        module NoSyntaxHighlightingImplementation
+          def self.highlight_syntax(lines)
+            lines
+          end
+        end
+
+        # @private
+        # Not sure why, but our code above (and/or coderay itself) does not work
+        # on Windows, so we disable the feature on Windows.
+        WindowsImplementation = NoSyntaxHighlightingImplementation
+      end
+    end
+  end
+end