dirwatch 0.0.8 → 0.0.9

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.8.0/lib/rspec/support/ruby_features.rb

@@ -0,0 +1,176 @@
+require 'rbconfig'
+RSpec::Support.require_rspec_support "comparable_version"
+
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different OS or OS features.
+    module OS
+      module_function
+
+      def windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
+      end
+
+      def windows_file_path?
+        ::File::ALT_SEPARATOR == '\\'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for different rubies
+    module Ruby
+      module_function
+
+      def jruby?
+        RUBY_PLATFORM == 'java'
+      end
+
+      def jruby_version
+        @jruby_version ||= ComparableVersion.new(JRUBY_VERSION)
+      end
+
+      def jruby_9000?
+        jruby? && JRUBY_VERSION >= '9.0.0.0'
+      end
+
+      def rbx?
+        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      end
+
+      def non_mri?
+        !mri?
+      end
+
+      def mri?
+        !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for ruby features that differ among
+    # implementations.
+    module RubyFeatures
+      module_function
+
+      if Ruby.jruby?
+        # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
+        # but when you try to fork, it raises an error:
+        #   NotImplementedError: fork is not available on this platform
+        #
+        # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
+        # this special case.
+        def fork_supported?
+          false
+        end
+      else
+        def fork_supported?
+          Process.respond_to?(:fork)
+        end
+      end
+
+      def optional_and_splat_args_supported?
+        Method.method_defined?(:parameters)
+      end
+
+      def caller_locations_supported?
+        respond_to?(:caller_locations, true)
+      end
+
+      if Exception.method_defined?(:cause)
+        def supports_exception_cause?
+          true
+        end
+      else
+        def supports_exception_cause?
+          false
+        end
+      end
+
+      ripper_requirements = [ComparableVersion.new(RUBY_VERSION) >= '1.9.2']
+
+      ripper_requirements.push(false) if Ruby.rbx?
+
+      if Ruby.jruby?
+        ripper_requirements.push(Ruby.jruby_version >= '1.7.5')
+        # Ripper on JRuby 9.0.0.0.rc1 - 9.1.8.0 reports wrong line number
+        # or cannot parse source including `:if`.
+        ripper_requirements.push(!Ruby.jruby_version.between?('9.0.0.0.rc1', '9.1.8.0'))
+      end
+
+      if ripper_requirements.all?
+        def ripper_supported?
+          true
+        end
+      else
+        def ripper_supported?
+          false
+        end
+      end
+
+      if Ruby.mri?
+        def kw_args_supported?
+          RUBY_VERSION >= '2.0.0'
+        end
+
+        def required_kw_args_supported?
+          RUBY_VERSION >= '2.1.0'
+        end
+
+        def supports_rebinding_module_methods?
+          RUBY_VERSION.to_i >= 2
+        end
+      else
+        # RBX / JRuby et al support is unknown for keyword arguments
+        begin
+          eval("o = Object.new; def o.m(a: 1); end;"\
+               " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
+
+          def kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          eval("o = Object.new; def o.m(a: ); end;"\
+               "raise SyntaxError unless o.method(:m).parameters.include?([:keyreq, :a])")
+
+          def required_kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def required_kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          Module.new { def foo; end }.instance_method(:foo).bind(Object.new)
+
+          def supports_rebinding_module_methods?
+            true
+          end
+        rescue TypeError
+          def supports_rebinding_module_methods?
+            false
+          end
+        end
+      end
+
+      def module_refinement_supported?
+        Module.method_defined?(:refine) || Module.private_method_defined?(:refine)
+      end
+
+      def module_prepends_supported?
+        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.8.0/lib/rspec/support/source.rb

@@ -0,0 +1,75 @@
+RSpec::Support.require_rspec_support 'encoded_string'
+RSpec::Support.require_rspec_support 'ruby_features'
+
+module RSpec
+  module Support
+    # @private
+    # Represents a Ruby source file and provides access to AST and tokens.
+    class Source
+      attr_reader :source, :path
+
+      def self.from_file(path)
+        source = File.read(path)
+        new(source, path)
+      end
+
+      if String.method_defined?(:encoding)
+        def initialize(source_string, path=nil)
+          @source = RSpec::Support::EncodedString.new(source_string, Encoding.default_external)
+          @path = path ? File.expand_path(path) : '(string)'
+        end
+      else # for 1.8.7
+        # :nocov:
+        def initialize(source_string, path=nil)
+          @source = RSpec::Support::EncodedString.new(source_string)
+          @path = path ? File.expand_path(path) : '(string)'
+        end
+        # :nocov:
+      end
+
+      def lines
+        @lines ||= source.split("\n")
+      end
+
+      def inspect
+        "#<#{self.class} #{path}>"
+      end
+
+      if RSpec::Support::RubyFeatures.ripper_supported?
+        RSpec::Support.require_rspec_support 'source/node'
+        RSpec::Support.require_rspec_support 'source/token'
+
+        def ast
+          @ast ||= begin
+            require 'ripper'
+            sexp = Ripper.sexp(source)
+            raise SyntaxError unless sexp
+            Node.new(sexp)
+          end
+        end
+
+        def tokens
+          @tokens ||= begin
+            require 'ripper'
+            tokens = Ripper.lex(source)
+            Token.tokens_from_ripper_tokens(tokens)
+          end
+        end
+
+        def nodes_by_line_number
+          @nodes_by_line_number ||= begin
+            nodes_by_line_number = ast.select(&:location).group_by { |node| node.location.line }
+            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+          end
+        end
+
+        def tokens_by_line_number
+          @tokens_by_line_number ||= begin
+            nodes_by_line_number = tokens.group_by { |token| token.location.line }
+            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.8.0/lib/rspec/support/source/location.rb

@@ -0,0 +1,21 @@
+module RSpec
+  module Support
+    class Source
+      # @private
+      # Represents a source location of node or token.
+      Location = Struct.new(:line, :column) do
+        include Comparable
+
+        def self.location?(array)
+          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
+        end
+
+        def <=>(other)
+          line_comparison = (line <=> other.line)
+          return line_comparison unless line_comparison == 0
+          column <=> other.column
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.8.0/lib/rspec/support/source/node.rb

@@ -0,0 +1,110 @@
+RSpec::Support.require_rspec_support 'source/location'
+
+module RSpec
+  module Support
+    class Source
+      # @private
+      # A wrapper for Ripper AST node which is generated with `Ripper.sexp`.
+      class Node
+        include Enumerable
+
+        attr_reader :sexp, :parent
+
+        def self.sexp?(array)
+          array.is_a?(Array) && array.first.is_a?(Symbol)
+        end
+
+        def initialize(ripper_sexp, parent=nil)
+          @sexp = ripper_sexp.freeze
+          @parent = parent
+        end
+
+        def type
+          sexp[0]
+        end
+
+        def args
+          @args ||= raw_args.map do |raw_arg|
+            if Node.sexp?(raw_arg)
+              Node.new(raw_arg, self)
+            elsif Location.location?(raw_arg)
+              Location.new(*raw_arg)
+            elsif raw_arg.is_a?(Array)
+              ExpressionSequenceNode.new(raw_arg, self)
+            else
+              raw_arg
+            end
+          end.freeze
+        end
+
+        def children
+          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
+        end
+
+        def location
+          @location ||= args.find { |arg| arg.is_a?(Location) }
+        end
+
+        # We use a loop here (instead of recursion) to prevent SystemStackError
+        def each
+          return to_enum(__method__) unless block_given?
+
+          node_queue = []
+          node_queue << self
+
+          while (current_node = node_queue.shift)
+            yield current_node
+            node_queue.concat(current_node.children)
+          end
+        end
+
+        def each_ancestor
+          return to_enum(__method__) unless block_given?
+
+          current_node = self
+
+          while (current_node = current_node.parent)
+            yield current_node
+          end
+        end
+
+        def inspect
+          "#<#{self.class} #{type}>"
+        end
+
+      private
+
+        def raw_args
+          sexp[1..-1] || []
+        end
+      end
+
+      # @private
+      # Basically `Ripper.sexp` generates arrays whose first element is a symbol (type of sexp),
+      # but it exceptionally generates typeless arrays for expression sequence:
+      #
+      # Ripper.sexp('foo; bar')
+      # => [
+      #      :program,
+      #      [ # Typeless array
+      #        [:vcall, [:@ident, "foo", [1, 0]]],
+      #        [:vcall, [:@ident, "bar", [1, 5]]]
+      #      ]
+      #    ]
+      #
+      # We wrap typeless arrays in this pseudo type node
+      # so that it can be handled in the same way as other type node.
+      class ExpressionSequenceNode < Node
+        def type
+          :_expression_sequence
+        end
+
+      private
+
+        def raw_args
+          sexp
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.8.0/lib/rspec/support/source/token.rb

@@ -0,0 +1,87 @@
+RSpec::Support.require_rspec_support 'source/location'
+
+module RSpec
+  module Support
+    class Source
+      # @private
+      # A wrapper for Ripper token which is generated with `Ripper.lex`.
+      class Token
+        CLOSING_TYPES_BY_OPENING_TYPE = {
+          :on_lbracket    => :on_rbracket,
+          :on_lparen      => :on_rparen,
+          :on_lbrace      => :on_rbrace,
+          :on_heredoc_beg => :on_heredoc_end
+        }.freeze
+
+        CLOSING_KEYWORDS_BY_OPENING_KEYWORD = {
+          'def' => 'end',
+          'do'  => 'end',
+        }.freeze
+
+        attr_reader :token
+
+        def self.tokens_from_ripper_tokens(ripper_tokens)
+          ripper_tokens.map { |ripper_token| new(ripper_token) }.freeze
+        end
+
+        def initialize(ripper_token)
+          @token = ripper_token.freeze
+        end
+
+        def location
+          @location ||= Location.new(*token[0])
+        end
+
+        def type
+          token[1]
+        end
+
+        def string
+          token[2]
+        end
+
+        def ==(other)
+          token == other.token
+        end
+
+        alias_method :eql?, :==
+
+        def inspect
+          "#<#{self.class} #{type} #{string.inspect}>"
+        end
+
+        def keyword?
+          type == :on_kw
+        end
+
+        def opening?
+          opening_delimiter? || opening_keyword?
+        end
+
+        def closed_by?(other)
+          closed_by_delimiter?(other) || closed_by_keyword?(other)
+        end
+
+      private
+
+        def opening_delimiter?
+          CLOSING_TYPES_BY_OPENING_TYPE.key?(type)
+        end
+
+        def opening_keyword?
+          return false unless keyword?
+          CLOSING_KEYWORDS_BY_OPENING_KEYWORD.key?(string)
+        end
+
+        def closed_by_delimiter?(other)
+          other.type == CLOSING_TYPES_BY_OPENING_TYPE[type]
+        end
+
+        def closed_by_keyword?(other)
+          return false unless other.keyword?
+          other.string == CLOSING_KEYWORDS_BY_OPENING_KEYWORD[string]
+        end
+      end
+    end
+  end
+end