tdiary 5.0.6 → 5.0.7

data/vendor/bundle/gems/pry-0.11.0/lib/pry/core_extensions.rb

@@ -1,141 +0,0 @@
-class Pry
-  # @return [Array] Code of the method used when implementing Pry's
-  #   __binding__, along with line indication to be used with instance_eval (and
-  #   friends).
-  #
-  # @see Object#__binding__
-  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
-    # Get a binding with 'self' set to self, and no locals.
-    #
-    # The default definee is determined by the context in which the
-    # definition is eval'd.
-    #
-    # Please don't call this method directly, see {__binding__}.
-    #
-    # @return [Binding]
-    def __pry__
-      binding
-    end
-  METHOD
-end
-
-class Object
-  # Start a Pry REPL on self.
-  #
-  # If `self` is a Binding then that will be used to evaluate expressions;
-  # otherwise a new binding will be created.
-  #
-  # @param [Object] object  the object or binding to pry
-  #                         (__deprecated__, use `object.pry`)
-  # @param [Hash] hash  the options hash
-  # @example With a binding
-  #    binding.pry
-  # @example On any object
-  #   "dummy".pry
-  # @example With options
-  #   def my_method
-  #     binding.pry :quiet => true
-  #   end
-  #   my_method()
-  # @see Pry.start
-  def pry(object=nil, hash={})
-    if object.nil? || Hash === object
-      Pry.start(self, object || {})
-    else
-      Pry.start(object, hash)
-    end
-  end
-
-  # Return a binding object for the receiver.
-  #
-  # The `self` of the binding is set to the current object, and it contains no
-  # local variables.
-  #
-  # The default definee (http://yugui.jp/articles/846) is set such that:
-  #
-  # * If `self` is a class or module, then new methods created in the binding
-  #   will be defined in that class or module (as in `class Foo; end`).
-  # * If `self` is a normal object, then new methods created in the binding will
-  #   be defined on its singleton class (as in `class << self; end`).
-  # * If `self` doesn't have a  real singleton class (i.e. it is a Fixnum, Float,
-  #   Symbol, nil, true, or false), then new methods will be created on the
-  #   object's class (as in `self.class.class_eval{ }`)
-  #
-  # Newly created constants, including classes and modules, will also be added
-  # to the default definee.
-  #
-  # @return [Binding]
-  def __binding__
-    # If you ever feel like changing this method, be careful about variables
-    # that you use. They shouldn't be inserted into the binding that will
-    # eventually be returned.
-
-    # When you're cd'd into a class, methods you define should be added to it.
-    if is_a?(Module)
-      # A special case, for JRuby.
-      # Module.new.class_eval("binding") has different behaviour than CRuby,
-      # where this is not needed: class_eval("binding") vs class_eval{binding}.
-      # Using a block works around the difference of behaviour on JRuby.
-      # The scope is clear of local variabless. Don't add any.
-      #
-      # This fixes the following two spec failures, at https://travis-ci.org/pry/pry/jobs/274470002
-      # 1) ./spec/pry_spec.rb:360:in `block in (root)'
-      # 2) ./spec/pry_spec.rb:366:in `block in (root)'
-      return class_eval {binding} if Pry::Helpers::BaseHelpers.jruby? and self.name == nil
-      # class_eval sets both self and the default definee to this class.
-      return class_eval("binding")
-    end
-
-    unless respond_to?(:__pry__)
-      # The easiest way to check whether an object has a working singleton class
-      # is to try and define a method on it. (just checking for the presence of
-      # the singleton class gives false positives for `true` and `false`).
-      # __pry__ is just the closest method we have to hand, and using
-      # it has the nice property that we can memoize this check.
-      begin
-        # instance_eval sets the default definee to the object's singleton class
-        instance_eval(*Pry::BINDING_METHOD_IMPL)
-
-      # If we can't define methods on the Object's singleton_class. Then we fall
-      # back to setting the default definee to be the Object's class. That seems
-      # nicer than having a REPL in which you can't define methods.
-      rescue TypeError, Pry::FrozenObjectException
-        # class_eval sets the default definee to self.class
-        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
-      end
-    end
-
-    __pry__
-  end
-end
-
-class BasicObject
-  # Return a binding object for the receiver.
-  #
-  # The `self` of the binding is set to the current object, and it contains no
-  # local variables.
-  #
-  # The default definee (http://yugui.jp/articles/846) is set such that new
-  # methods defined will be added to the singleton class of the BasicObject.
-  #
-  # @return [Binding]
-  def __binding__
-    # BasicObjects don't have respond_to?, so we just define the method
-    # every time. As they also don't have `.freeze`, this call won't
-    # fail as it can for normal Objects.
-    (class << self; self; end).class_eval <<-EOF, __FILE__, __LINE__ + 1
-      # Get a binding with 'self' set to self, and no locals.
-      #
-      # The default definee is determined by the context in which the
-      # definition is eval'd.
-      #
-      # Please don't call this method directly, see {__binding__}.
-      #
-      # @return [Binding]
-      def __pry__
-        ::Kernel.binding
-      end
-    EOF
-    self.__pry__
-  end
-end

data/vendor/bundle/gems/pry-0.11.0/lib/pry/editor.rb

@@ -1,135 +0,0 @@
-class Pry
-  class Editor
-    include Pry::Helpers::BaseHelpers
-    include Pry::Helpers::CommandHelpers
-
-    attr_reader :_pry_
-
-    def initialize(_pry_)
-      @_pry_ = _pry_
-    end
-
-    def edit_tempfile_with_content(initial_content, line=1)
-      temp_file do |f|
-        f.puts(initial_content)
-        f.flush
-        f.close(false)
-        invoke_editor(f.path, line, true)
-        File.read(f.path)
-      end
-    end
-
-    def invoke_editor(file, line, blocking=true)
-      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
-
-      editor_invocation = build_editor_invocation_string(file, line, blocking)
-      return nil unless editor_invocation
-
-      if jruby?
-        open_editor_on_jruby(editor_invocation)
-      else
-        open_editor(editor_invocation)
-      end
-    end
-
-    private
-
-    # Generate the string that's used to start the editor. This includes
-    # all the flags we want as well as the file and line number we
-    # want to open at.
-    def build_editor_invocation_string(file, line, blocking)
-
-      if _pry_.config.editor.respond_to?(:call)
-        args = [file, line, blocking][0...(_pry_.config.editor.arity)]
-        _pry_.config.editor.call(*args)
-      else
-        sanitized_file = if windows?
-                            file
-                          else
-                            Shellwords.escape(file)
-                          end
-
-        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
-      end
-    end
-
-    # Start the editor running, using the calculated invocation string
-    def open_editor(editor_invocation)
-      # Note we dont want to use Pry.config.system here as that
-      # may be invoked non-interactively (i.e via Open4), whereas we want to
-      # ensure the editor is always interactive
-      system(*Shellwords.split(editor_invocation)) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
-    end
-
-    # We need JRuby specific code here cos just shelling out using
-    # system() appears to be pretty broken :/
-    def open_editor_on_jruby(editor_invocation)
-      begin
-        require 'spoon'
-        pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
-        Process.waitpid(pid)
-      rescue FFI::NotFoundError
-        system(editor_invocation)
-      end
-    end
-
-    # Some editors that run outside the terminal allow you to control whether or
-    # not to block the process from which they were launched (in this case, Pry).
-    # For those editors, return the flag that produces the desired behavior.
-    def blocking_flag_for_editor(blocking)
-      case editor_name
-      when /^emacsclient/
-        '--no-wait' unless blocking
-      when /^[gm]vim/
-        '--nofork' if blocking
-      when /^jedit/
-        '-wait' if blocking
-      when /^mate/, /^subl/, /^redcar/
-        '-w' if blocking
-      end
-    end
-
-    # Return the syntax for a given editor for starting the editor
-    # and moving to a particular line within that file
-    def start_line_syntax_for_editor(file_name, line_number)
-      # special case for 1st line
-      return file_name if line_number <= 1
-
-      case editor_name
-      when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-        "+#{line_number} #{file_name}"
-      when /^mate/, /^geany/
-        "-l #{line_number} #{file_name}"
-      when /^subl/
-        "#{file_name}:#{line_number}"
-      when /^uedit32/
-        "#{file_name}/#{line_number}"
-      when /^jedit/
-        "#{file_name} +line:#{line_number}"
-      when /^redcar/
-        "-l#{line_number} #{file_name}"
-      else
-        if windows?
-          "#{file_name}"
-        else
-          "+#{line_number} #{file_name}"
-        end
-      end
-    end
-
-    # Get the name of the binary that Pry.config.editor points to.
-    #
-    # This is useful for deciding which flags we pass to the editor as
-    # we can just use the program's name and ignore any absolute paths.
-    #
-    # @example
-    #   Pry.config.editor="/home/conrad/bin/textmate -w"
-    #   editor_name
-    #   # => textmate
-    #
-    def editor_name
-      File.basename(_pry_.config.editor).split(" ").first
-    end
-
-  end
-end

data/vendor/bundle/gems/pry-0.11.0/lib/pry/exceptions.rb

@@ -1,78 +0,0 @@
-class Pry
-
-  # As a REPL, we often want to catch any unexpected exceptions that may have
-  # been raised; however we don't want to go overboard and prevent the user
-  # from exiting Pry when they want to.
-  module RescuableException
-    def self.===(exception)
-      case exception
-        # Catch when the user hits ^C (Interrupt < SignalException), and assume
-        # that they just wanted to stop the in-progress command (just like bash
-        # etc.)
-      when Interrupt
-        true
-        # Don't catch signals (particularly not SIGTERM) as these are unlikely
-        # to be intended for pry itself. We should also make sure that
-        # Kernel#exit works.
-      when *Pry.config.exception_whitelist
-        false
-        # All other exceptions will be caught.
-      else
-        true
-      end
-    end
-  end
-
-  # Catches SecurityErrors if $SAFE is set
-  module Pry::TooSafeException
-    def self.===(exception)
-      $SAFE > 0 && SecurityError === exception
-    end
-  end
-
-  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
-  # in a more user-friendly manner. This should be used when the exception
-  # happens within Pry itself as a direct consequence of the user typing
-  # something wrong.
-  #
-  # This allows us to distinguish between the user typing:
-  #
-  # pry(main)> def )
-  # SyntaxError: unexpected )
-  #
-  # pry(main)> method_that_evals("def )")
-  # SyntaxError: (eval):1: syntax error, unexpected ')'
-  # from ./a.rb:2 in `eval'
-  module UserError; end
-
-  # When we try to get a binding for an object, we try to define a method on
-  # that Object's singleton class. This doesn't work for "frozen" Object's, and
-  # the exception is just a vanilla RuntimeError.
-  module FrozenObjectException
-    def self.===(exception)
-      ["can't modify frozen class/module",
-       "can't modify frozen Class",
-       "can't modify frozen object",
-      ].include?(exception.message)
-    end
-  end
-
-  # Don't catch these exceptions
-  DEFAULT_EXCEPTION_WHITELIST = [SystemExit,
-                                 SignalException,
-                                 Pry::TooSafeException]
-
-  # CommandErrors are caught by the REPL loop and displayed to the user. They
-  # indicate an exceptional condition that's fatal to the current command.
-  class CommandError < StandardError; end
-  class MethodNotFound < CommandError; end
-
-  # indicates obsolete API
-  class ObsoleteError < StandardError; end
-
-  # This is to keep from breaking under Rails 3.2 for people who are doing that
-  # IRB = Pry thing.
-  module ExtendCommandBundle
-  end
-
-end

data/vendor/bundle/gems/pry-0.11.0/lib/pry/forwardable.rb

@@ -1,23 +0,0 @@
-class Pry
-  module Forwardable
-    require 'forwardable'
-    include ::Forwardable
-
-    #
-    # Since Ruby 2.4, Forwardable will print a warning when
-    # calling a method that is private on a delegate, and
-    # in the future it could be an error: https://bugs.ruby-lang.org/issues/12782#note-3
-    #
-    # That's why we revert to a custom implementation for delegating one
-    # private method to another.
-    #
-    def def_private_delegators(target, *private_delegates)
-      private_delegates.each do |private_delegate|
-        define_method(private_delegate) do |*a, &b|
-          instance_variable_get(target).__send__(private_delegate, *a, &b)
-        end
-      end
-      class_eval { private(*private_delegates) }
-    end
-  end
-end

data/vendor/bundle/gems/pry-0.11.0/lib/pry/helpers.rb

@@ -1,5 +0,0 @@
-require "pry/helpers/base_helpers"
-require "pry/helpers/options_helpers"
-require "pry/helpers/command_helpers"
-require "pry/helpers/text"
-require "pry/helpers/table"

data/vendor/bundle/gems/pry-0.11.0/lib/pry/helpers/base_helpers.rb

@@ -1,109 +0,0 @@
-class Pry
-  module Helpers
-
-    module BaseHelpers
-
-      module_function
-
-      def silence_warnings
-        old_verbose = $VERBOSE
-        $VERBOSE = nil
-        begin
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
-      end
-
-      # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance hierarchy.
-      # This is required to introspect methods on objects like Net::HTTP::Get that
-      # have overridden the `method` method.
-      def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
-      end
-      public :safe_send
-
-      def find_command(name, set = Pry::Commands)
-        command_match = set.find do |_, command|
-          (listing = command.options[:listing]) == name && listing != nil
-        end
-        command_match.last if command_match
-      end
-
-      def not_a_real_file?(file)
-        file =~ /^(\(.*\))$|^<.*>$/ || file =~ /__unknown__/ || file == "" || file == "-e"
-      end
-
-      def command_dependencies_met?(options)
-        return true if !options[:requires_gem]
-        Array(options[:requires_gem]).all? do |g|
-          Rubygem.installed?(g)
-        end
-      end
-
-      def use_ansi_codes?
-        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
-      end
-
-      def colorize_code(code)
-        CodeRay.scan(code, :ruby).term
-      end
-
-      def highlight(string, regexp, highlight_color=:bright_yellow)
-        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
-      end
-
-      # formatting
-      def heading(text)
-        text = "#{text}\n--"
-        "\e[1m#{text}\e[0m"
-      end
-
-      # have fun on the Windows platform.
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      end
-
-      # are we able to use ansi on windows?
-      def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
-      end
-
-      def jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-
-      def jruby_19?
-        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
-      end
-
-      def rbx?
-        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
-      end
-
-      def mri?
-        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      def mri_19?
-        mri? && RUBY_VERSION =~ /^1\.9/
-      end
-
-      def mri_2?
-        mri? && RUBY_VERSION =~ /^2/
-      end
-
-      # Send the given text through the best available pager (if Pry.config.pager is
-      # enabled). Infers where to send the output if used as a mixin.
-      # DEPRECATED.
-      def stagger_output(text, out = nil)
-        if _pry_
-          _pry_.pager.page text
-        else
-          Pry.new.pager.page text
-        end
-      end
-    end
-  end
-end