comidita_ull 0.1.0

data/vendor/bundle/ruby/2.3.0/gems/pry-0.11.2/lib/pry/repl.rb

@@ -0,0 +1,232 @@
+class Pry
+  class REPL
+    extend Pry::Forwardable
+    def_delegators :@pry, :input, :output
+
+    # @return [Pry] The instance of {Pry} that the user is controlling.
+    attr_accessor :pry
+
+    # Instantiate a new {Pry} instance with the given options, then start a
+    # {REPL} instance wrapping it.
+    # @option options See {Pry#initialize}
+    def self.start(options)
+      new(Pry.new(options)).start
+    end
+
+    # Create an instance of {REPL} wrapping the given {Pry}.
+    # @param [Pry] pry The instance of {Pry} that this {REPL} will control.
+    # @param [Hash] options Options for this {REPL} instance.
+    # @option options [Object] :target The initial target of the session.
+    def initialize(pry, options = {})
+      @pry    = pry
+      @indent = Pry::Indent.new
+
+      @readline_output = nil
+
+      if options[:target]
+        @pry.push_binding options[:target]
+      end
+    end
+
+    # Start the read-eval-print loop.
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def start
+      prologue
+      Pry::InputLock.for(:all).with_ownership { repl }
+    ensure
+      epilogue
+    end
+
+    private
+
+    # Set up the repl session.
+    # @return [void]
+    def prologue
+      pry.exec_hook :before_session, pry.output, pry.current_binding, pry
+
+      # Clear the line before starting Pry. This fixes issue #566.
+      if pry.config.correct_indent
+        Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
+      end
+    end
+
+    # The actual read-eval-print loop.
+    #
+    # The {REPL} instance is responsible for reading and looping, whereas the
+    # {Pry} instance is responsible for evaluating user input and printing
+    # return values and command output.
+    #
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def repl
+      loop do
+        case val = read
+        when :control_c
+          output.puts ""
+          pry.reset_eval_string
+        when :no_more_input
+          output.puts "" if output.tty?
+          break
+        else
+          output.puts "" if val.nil? && output.tty?
+          return pry.exit_value unless pry.eval(val)
+        end
+      end
+    end
+
+    # Clean up after the repl session.
+    # @return [void]
+    def epilogue
+      pry.exec_hook :after_session, pry.output, pry.current_binding, pry
+    end
+
+    # Read a line of input from the user.
+    # @return [String] The line entered by the user.
+    # @return [nil] On `<Ctrl-D>`.
+    # @return [:control_c] On `<Ctrl+C>`.
+    # @return [:no_more_input] On EOF.
+    def read
+      @indent.reset if pry.eval_string.empty?
+      current_prompt = pry.select_prompt
+      indentation = pry.config.auto_indent ? @indent.current_prefix : ''
+
+      val = read_line("#{current_prompt}#{indentation}")
+
+      # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
+      return val unless String === val
+
+      if pry.config.auto_indent
+        original_val = "#{indentation}#{val}"
+        indented_val = @indent.indent(val)
+
+        if output.tty? && pry.config.correct_indent && Pry::Helpers::BaseHelpers.use_ansi_codes?
+          output.print @indent.correct_indentation(
+            current_prompt, indented_val,
+            original_val.length - indented_val.length
+          )
+          output.flush
+        end
+      else
+        indented_val = val
+      end
+
+      indented_val
+    end
+
+    # Manage switching of input objects on encountering `EOFError`s.
+    # @return [Object] Whatever the given block returns.
+    # @return [:no_more_input] Indicates that no more input can be read.
+    def handle_read_errors
+      should_retry = true
+      exception_count = 0
+
+      begin
+        yield
+      rescue EOFError
+        pry.config.input = Pry.config.input
+        if !should_retry
+          output.puts "Error: Pry ran out of things to read from! " \
+            "Attempting to break out of REPL."
+          return :no_more_input
+        end
+        should_retry = false
+        retry
+
+      # Handle <Ctrl+C> like Bash: empty the current input buffer, but don't
+      # quit.  This is only for MRI 1.9; other versions of Ruby don't let you
+      # send Interrupt from within Readline.
+      rescue Interrupt
+        return :control_c
+
+      # If we get a random error when trying to read a line we don't want to
+      # automatically retry, as the user will see a lot of error messages
+      # scroll past and be unable to do anything about it.
+      rescue RescuableException => e
+        puts "Error: #{e.message}"
+        output.puts e.backtrace
+        exception_count += 1
+        if exception_count < 5
+          retry
+        end
+        puts "FATAL: Pry failed to get user input using `#{input}`."
+        puts "To fix this you may be able to pass input and output file " \
+          "descriptors to pry directly. e.g."
+        puts "  Pry.config.input = STDIN"
+        puts "  Pry.config.output = STDOUT"
+        puts "  binding.pry"
+        return :no_more_input
+      end
+    end
+
+    # Returns the next line of input to be sent to the {Pry} instance.
+    # @param [String] current_prompt The prompt to use for input.
+    # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
+    def read_line(current_prompt)
+      handle_read_errors do
+        if coolline_available?
+          input.completion_proc = proc do |cool|
+            completions = @pry.complete cool.completed_word
+            completions.compact
+          end
+        elsif input.respond_to? :completion_proc=
+          input.completion_proc = proc do |inp|
+            @pry.complete inp
+          end
+        end
+
+        if readline_available?
+          set_readline_output
+          input_readline(current_prompt, false) # false since we'll add it manually
+        elsif coolline_available?
+          input_readline(current_prompt)
+        else
+          if input.method(:readline).arity == 1
+            input_readline(current_prompt)
+          else
+            input_readline
+          end
+        end
+      end
+    end
+
+    def input_readline(*args)
+      Pry::InputLock.for(:all).interruptible_region do
+        input.readline(*args)
+      end
+    end
+
+    def readline_available?
+      defined?(Readline) && input == Readline
+    end
+
+    def coolline_available?
+      defined?(Coolline) && input.is_a?(Coolline)
+    end
+
+    # If `$stdout` is not a tty, it's probably a pipe.
+    # @example
+    #   # `piping?` returns `false`
+    #   % pry
+    #   [1] pry(main)
+    #
+    #   # `piping?` returns `true`
+    #   % pry | tee log
+    def piping?
+      return false unless $stdout.respond_to?(:tty?)
+      !$stdout.tty? && $stdin.tty? && !Pry::Helpers::BaseHelpers.windows?
+    end
+
+    # @return [void]
+    def set_readline_output
+      return if @readline_output
+      if piping?
+        @readline_output = (Readline.output = Pry.config.output)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.11.2/lib/pry/repl_file_loader.rb

@@ -0,0 +1,74 @@
+class Pry
+
+  # A class to manage the loading of files through the REPL loop.
+  # This is an interesting trick as it processes your file as if it
+  # was user input in an interactive session. As a result, all Pry
+  # commands are available, and they are executed non-interactively. Furthermore
+  # the session becomes interactive when the repl loop processes a
+  # 'make-interactive' command in the file. The session also becomes
+  # interactive when an exception is encountered, enabling you to fix
+  # the error before returning to non-interactive processing with the
+  # 'make-non-interactive' command.
+
+  class REPLFileLoader
+    def initialize(file_name)
+      full_name = File.expand_path(file_name)
+      raise RuntimeError, "No such file: #{full_name}" if !File.exist?(full_name)
+
+      define_additional_commands
+      @content = File.read(full_name)
+    end
+
+    # Switch to interactive mode, i.e take input from the user
+    # and use the regular print and exception handlers.
+    # @param [Pry] _pry_ the Pry instance to make interactive.
+    def interactive_mode(_pry_)
+      _pry_.config.input = Pry.config.input
+      _pry_.config.print = Pry.config.print
+      _pry_.config.exception_handler = Pry.config.exception_handler
+      Pry::REPL.new(_pry_).start
+    end
+
+    # Switch to non-interactive mode. Essentially
+    # this means there is no result output
+    # and that the session becomes interactive when an exception is encountered.
+    # @param [Pry] _pry_ the Pry instance to make non-interactive.
+    def non_interactive_mode(_pry_, content)
+      _pry_.print = proc {}
+      _pry_.exception_handler = proc do |o, e, _p_|
+        _p_.run_command "cat --ex"
+        o.puts "...exception encountered, going interactive!"
+        interactive_mode(_pry_)
+      end
+
+      content.lines.each do |line|
+        break unless _pry_.eval line, :generated => true
+      end
+
+      unless _pry_.eval_string.empty?
+        _pry_.output.puts "#{_pry_.eval_string}...exception encountered, going interactive!"
+        interactive_mode(_pry_)
+      end
+    end
+
+    # Define a few extra commands useful for flipping back & forth
+    # between interactive/non-interactive modes
+    def define_additional_commands
+      s = self
+
+      Pry::Commands.command "make-interactive", "Make the session interactive" do
+        s.interactive_mode(_pry_)
+      end
+
+      Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
+        s.non_interactive_mode(_pry_, File.read(File.expand_path(file_name)))
+      end
+    end
+
+    # Actually load the file through the REPL by setting file content
+    # as the REPL input stream.
+    def load
+      non_interactive_mode(Pry.new, @content)
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.11.2/lib/pry/rubygem.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+
+class Pry
+  module Rubygem
+
+    class << self
+      def installed?(name)
+        if Gem::Specification.respond_to?(:find_all_by_name)
+          Gem::Specification.find_all_by_name(name).any?
+        else
+          Gem.source_index.find_name(name).first
+        end
+      end
+
+      # Get the gem spec object for the given gem name.
+      #
+      # @param [String] name
+      # @return [Gem::Specification]
+      def spec(name)
+        specs = if Gem::Specification.respond_to?(:each)
+                  Gem::Specification.find_all_by_name(name)
+                else
+                  Gem.source_index.find_name(name)
+                end
+
+        first_spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.last
+
+        first_spec or raise CommandError, "Gem `#{name}` not found"
+      end
+
+      # List gems matching a pattern.
+      #
+      # @param [Regexp] pattern
+      # @return [Array<Gem::Specification>]
+      def list(pattern = /.*/)
+        if Gem::Specification.respond_to?(:each)
+          Gem::Specification.select{|spec| spec.name =~ pattern }
+        else
+          Gem.source_index.gems.values.select{|spec| spec.name =~ pattern }
+        end
+      end
+
+      # Completion function for gem-cd and gem-open.
+      #
+      # @param [String] so_far what the user's typed so far
+      # @return [Array<String>] completions
+      def complete(so_far)
+        if so_far =~ / ([^ ]*)\z/
+          self.list(%r{\A#{$2}}).map(&:name)
+        else
+          self.list.map(&:name)
+        end
+      end
+
+      # Installs a gem with all its dependencies.
+      #
+      # @param [String] name
+      # @return [void]
+      def install(name)
+        require 'rubygems/dependency_installer'
+        gem_config = Gem.configuration['gem']
+        gemrc_opts = (gem_config.nil? ? "" : gem_config.split(' '))
+        destination = if gemrc_opts.include?('--user-install')
+                        Gem.user_dir
+                      elsif File.writable?(Gem.dir)
+                        Gem.dir
+                      else
+                        Gem.user_dir
+                      end
+        installer = Gem::DependencyInstaller.new(:install_dir => destination)
+        installer.install(name)
+      rescue Errno::EACCES
+        raise CommandError,
+          "Insufficient permissions to install #{ Pry::Helpers::Text.green(name) }."
+      rescue Gem::GemNotFoundException
+        raise CommandError,
+          "Gem #{ Pry::Helpers::Text.green(name) } not found. Aborting installation."
+      else
+        Gem.refresh
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.11.2/lib/pry/slop/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Lee Jarvis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/2.3.0/gems/pry-0.11.2/lib/pry/slop/commands.rb

@@ -0,0 +1,196 @@
+class Pry::Slop
+  class Commands
+    include Enumerable
+
+    attr_reader :config, :commands, :arguments
+    attr_writer :banner
+
+    # Create a new instance of Slop::Commands and optionally build
+    # Slop instances via a block. Any configuration options used in
+    # this method will be the default configuration options sent to
+    # each Slop object created.
+    #
+    # config - An optional configuration Hash.
+    # block  - Optional block used to define commands.
+    #
+    # Examples:
+    #
+    #   commands = Slop::Commands.new do
+    #     on :new do
+    #       on '-o', '--outdir=', 'The output directory'
+    #       on '-v', '--verbose', 'Enable verbose mode'
+    #     end
+    #
+    #     on :generate do
+    #       on '--assets', 'Generate assets', :default => true
+    #     end
+    #
+    #     global do
+    #       on '-D', '--debug', 'Enable debug mode', :default => false
+    #     end
+    #   end
+    #
+    #   commands[:new].class #=> Slop
+    #   commands.parse
+    #
+    def initialize(config = {}, &block)
+      @config = config
+      @commands = {}
+      @banner = nil
+      @triggered_command = nil
+
+      warn "[DEPRECATED] Slop::Commands is deprecated and will be removed in "\
+        "Slop version 4. Check out http://injekt.github.com/slop/#commands for "\
+        "a new implementation of commands."
+
+      if block_given?
+        block.arity == 1 ? yield(self) : instance_eval(&block)
+      end
+    end
+
+    # Optionally set the banner for this command help output.
+    #
+    # banner - The String text to set the banner.
+    #
+    # Returns the String banner if one is set.
+    def banner(banner = nil)
+      @banner = banner if banner
+      @banner
+    end
+
+    # Add a Slop instance for a specific command.
+    #
+    # command - A String or Symbol key used to identify this command.
+    # config  - A Hash of configuration options to pass to Slop.
+    # block   - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to command.
+    def on(command, config = {}, &block)
+      commands[command.to_s] = Slop.new(@config.merge(config), &block)
+    end
+
+    # Add a Slop instance used when no other commands exist.
+    #
+    # config - A Hash of configuration options to pass to Slop.
+    # block  - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to default.
+    def default(config = {}, &block)
+      on('default', config, &block)
+    end
+
+    # Add a global Slop instance.
+    #
+    # config - A Hash of configuration options to pass to Slop.
+    # block  - An optional block used to pass options to Slop.
+    #
+    # Returns the newly created Slop instance mapped to global.
+    def global(config = {}, &block)
+      on('global', config, &block)
+    end
+
+    # Fetch the instance of Slop tied to a command.
+    #
+    # key - The String or Symbol key used to locate this command.
+    #
+    # Returns the Slop instance if this key is found, nil otherwise.
+    def [](key)
+      commands[key.to_s]
+    end
+    alias get []
+
+    # Check for a command presence.
+    #
+    # Examples:
+    #
+    #   cmds.parse %w( foo )
+    #   cmds.present?(:foo) #=> true
+    #   cmds.present?(:bar) #=> false
+    #
+    # Returns true if the given key is present in the parsed arguments.
+    def present?(key)
+      key.to_s == @triggered_command
+    end
+
+    # Enumerable interface.
+    def each(&block)
+      @commands.each(&block)
+    end
+
+    # Parse a list of items.
+    #
+    # items - The Array of items to parse.
+    #
+    # Returns the original Array of items.
+    def parse(items = ARGV)
+      parse! items.dup
+      items
+    end
+
+    # Parse a list of items, removing any options or option arguments found.
+    #
+    # items - The Array of items to parse.
+    #
+    # Returns the original Array of items with options removed.
+    def parse!(items = ARGV)
+      if opts = commands[items[0].to_s]
+        @triggered_command = items.shift
+        execute_arguments! items
+        opts.parse! items
+        execute_global_opts! items
+      else
+        if opts = commands['default']
+          opts.parse! items
+        else
+          if config[:strict] && items[0]
+            raise InvalidCommandError, "Unknown command `#{items[0]}`"
+          end
+        end
+        execute_global_opts! items
+      end
+      items
+    end
+
+    # Returns a nested Hash with Slop options and values. See Slop#to_hash.
+    def to_hash
+      Hash[commands.map { |k, v| [k.to_sym, v.to_hash] }]
+    end
+
+    # Returns the help String.
+    def to_s
+      defaults = commands.delete('default')
+      globals = commands.delete('global')
+      helps = commands.reject { |_, v| v.options.none? }
+      if globals && globals.options.any?
+        helps.merge!('Global options' => globals.to_s)
+      end
+      if defaults && defaults.options.any?
+        helps.merge!('Other options' => defaults.to_s)
+      end
+      banner = @banner ? "#{@banner}\n" : ""
+      banner + helps.map { |key, opts| "  #{key}\n#{opts}" }.join("\n\n")
+    end
+    alias help to_s
+
+    # Returns the inspection String.
+    def inspect
+      "#<Slop::Commands #{config.inspect} #{commands.values.map(&:inspect)}>"
+    end
+
+    private
+
+    # Returns nothing.
+    def execute_arguments!(items)
+      @arguments = items.take_while { |arg| !arg.start_with?('-') }
+      items.shift @arguments.size
+    end
+
+    # Returns nothing.
+    def execute_global_opts!(items)
+      if global_opts = commands['global']
+        global_opts.parse! items
+      end
+    end
+
+  end
+end