puppet-repl 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d8ce23921a5f416b32187a87b404f5175f4bd37
-  data.tar.gz: a510663097037ec81141e66552f253817cb6d9c3
+  metadata.gz: ca90b4e2bd2667abaceead15b141c87b712aea32
+  data.tar.gz: 20aedb19e5dd5e93b62faf0438f47d7619a20e5a
 SHA512:
-  metadata.gz: 125c9d2e1024849306165a4371d5468f39179c6adb660cbefe0801343111ae85bb25a1070b8f669893a8efc4d26cd34432192ac1d971bf7ae68c6c803d577b90
-  data.tar.gz: 48d7203e5f8db5a73cc76e4ce3b3be1af12b935955d24a349ef19379e961f36791366fb1fd7a650b818f705ed5092be2264d6095c554fa9206ba99cd9e2af4ac
+  metadata.gz: 9dc96e79ff9bd8a348b0cf64d81cb857a38656e4d19a91e6d8a7d325eff7e5c6fa11f0ac3e01fcc178348986d5701f0677b0a1f84d3d502b66ddf2b07cc9da24
+  data.tar.gz: 3a5f8b6056dcf2d63101c25ea30765bf74a63a158211f72d8f3be45289683cdb5a8d653a768cad6b991ada7a5c353acaabdb8a19463295baef1155fc35455646

data/.gitlab-ci.yml

@@ -16,6 +16,8 @@ web_trigger_staging:
   type: web_deploy
   variables:
     REF: staging
+  only:
+    - master
   script:
     - "curl -X POST -F token=$PREPL_BUILD_TRIGGER_TOKEN -F ref=$REF https://gitlab.com/api/v3/projects/1146764/trigger/builds"
 

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+## 0.3.2
+  * Fixes #31 - adds ability to show surrounding code
 ## 0.3.1
   * Fixes #28 - puppet 4.6 support
   * Fixes #27 - repl should throw puppet error message instead of stacktrace

data/Gemfile.lock

@@ -21,7 +21,8 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    puppet (4.6.0)
+    puppet (4.7.0)
+      CFPropertyList (~> 2.2.6)
       facter (> 2.0, < 4)
       hiera (>= 2.0, < 4)
       json_pure (~> 1.8)
@@ -64,4 +65,4 @@ DEPENDENCIES
   simplecov
 
 BUNDLED WITH
-   1.12.5
+   1.13.1

data/lib/puppet-repl.rb

@@ -4,6 +4,8 @@ require 'awesome_print'
 require_relative 'awesome_print/ext/awesome_puppet'
 require_relative 'trollop'
 require 'puppet/util/log'
+require_relative 'puppet-repl/repl_code'
+
 require_relative 'puppet-repl/support/errors'
 # monkey patch in some color effects string methods
 class String
@@ -39,7 +41,6 @@ Puppet::Util::Log.newdesttype :buffer do
       :crit    => { :name => 'Critical',  :color => :hred,  :stream => err_buffer },
       :err     => { :name => 'Error',     :color => :hred,  :stream => err_buffer },
       :warning => { :name => 'Warning',   :color => :hred,  :stream => err_buffer },
-
       :notice  => { :name => 'Notice',    :color => :reset, :stream => out_buffer },
       :info    => { :name => 'Info',      :color => :green, :stream => out_buffer },
       :debug   => { :name => 'Debug',     :color => :cyan,  :stream => out_buffer },

data/lib/puppet-repl/cli.rb

@@ -13,13 +13,14 @@ module PuppetRepl
       @log_level = 'notice'
       @out_buffer = options[:out_buffer] || $stdout
       @html_mode = options[:html_mode] || false
+      @source_file = options[:source_file] || nil
+      @source_line_num = options[:source_line] || nil
       @in_buffer = options[:in_buffer] || $stdin
       comp = Proc.new do |s|
         key_words.grep(/^#{Regexp.escape(s)}/)
       end
       Readline.completion_append_character = ""
       Readline.basic_word_break_characters = " "
-
       Readline.completion_proc = comp
       AwesomePrint.defaults = {
         :html => @html_mode,
@@ -91,11 +92,10 @@ module PuppetRepl
     #
     def handle_input(input)
         raise ArgumentError unless input.instance_of?(String)
-
         begin
           output = ''
           case input
-          when /^play|^classification|^facterdb_filter|^facts|^vars|^functions|^classes|^resources|^krt|^environment|^reset|^help/
+          when /^play|^classification|^whereami|^facterdb_filter|^facts|^vars|^functions|^classes|^resources|^krt|^environment|^reset|^help/
             args = input.split(' ')
             command = args.shift.to_sym
             if self.respond_to?(command)
@@ -149,7 +149,7 @@ Ruby Version: #{RUBY_VERSION}
 Puppet Version: #{Puppet.version}
 Puppet Repl Version: #{PuppetRepl::VERSION}
 Created by: NWOps <corey@nwops.io>
-Type "exit", "functions", "vars", "krt", "facts", "resources", "classes",
+Type "exit", "functions", "vars", "krt", "whereami", "facts", "resources", "classes",
      "play", "classification", "reset", or "help" for more information.
 
       EOT
@@ -194,10 +194,28 @@ Type "exit", "functions", "vars", "krt", "facts", "resources", "classes",
       end
     end
 
+    # used to start a repl without attempting to read from stdin
+    # or
+    # @param [Hash] must contain at least the puppet scope object
+    def self.start_without_stdin(options={:scope => nil})
+      puts print_repl_desc unless options[:quiet]
+      repl_obj = PuppetRepl::Cli.new(options)
+      repl_obj.remote_node_name = options[:node_name] if options[:node_name]
+      repl_obj.initialize_from_scope(options[:scope])
+      puts repl_obj.whereami if options[:source_file] and options[:source_line]
+      # helper code to make tests exit the loop
+      repl_obj.read_loop unless options[:run_once]
+      if options[:play]
+        repl_obj.play_back(options)
+      else
+        repl_obj.read_loop
+      end
+    end
+
     # start reads from stdin or from a file
     # if from stdin, the repl will process the input and exit
     # if from a file, the repl will process the file and continue to prompt
-    # @param [Scope] puppet scope object
+    # @param [Hash] puppet scope object
     def self.start(options={:scope => nil})
       opts = Trollop::options do
         opt :play, "Url or file to load from", :required => false, :type => String
@@ -207,7 +225,7 @@ Type "exit", "functions", "vars", "krt", "facts", "resources", "classes",
       end
       options = opts.merge(options)
       puts print_repl_desc unless options[:quiet]
-      repl_obj = PuppetRepl::Cli.new
+      repl_obj = PuppetRepl::Cli.new(options)
       repl_obj.remote_node_name = opts[:node_name] if opts[:node_name]
       repl_obj.initialize_from_scope(options[:scope])
       if options[:play]

data/lib/puppet-repl/code/code_file.rb

@@ -0,0 +1,98 @@
+
+class CodeFile
+  class SourceNotFound < Exception
+  end
+
+    DEFAULT_EXT = '.pp'
+
+    # List of all supported languages.
+    # @return [Hash]
+    EXTENSIONS = {
+      %w(.py)        => :python,
+      %w(.js)        => :javascript,
+      %w(.pp)        => :puppet,
+      %w(.css)       => :css,
+      %w(.xml)       => :xml,
+      %w(.php)       => :php,
+      %w(.html)      => :html,
+      %w(.diff)      => :diff,
+      %w(.java)      => :java,
+      %w(.json)      => :json,
+      %w(.c .h)      => :c,
+      %w(.rhtml)     => :rhtml,
+      %w(.yaml .yml) => :yaml,
+      %w(.cpp .hpp .cc .h cxx) => :cpp,
+      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
+    }
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_reader :code_type
+
+    # @param [String] filename The name of a file with code to be detected
+    # @param [Symbol] code_type The type of code the `filename` contains
+    def initialize(filename, code_type = type_from_filename(filename))
+      @filename = filename
+      @code_type = code_type
+    end
+
+    # @return [String] The code contained in the current `@filename`.
+    def code
+      path = abs_path
+      @code_type = type_from_filename(path)
+      File.read(path)
+    end
+
+    private
+
+    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
+    #   readable for some reason.
+    # @return [String] absolute path for the given `filename`.
+    def abs_path
+      code_path.detect { |path| readable?(path) } or
+        raise SourceNotFound,
+              "Cannot open #{ @filename.inspect } for reading."
+    end
+
+    # @param [String] path
+    # @return [Boolean] if the path, with or without the default ext,
+    #   is a readable file then `true`, otherwise `false`.
+    def readable?(path)
+      File.readable?(path) && !File.directory?(path) or
+        File.readable?(path << DEFAULT_EXT)
+    end
+
+    # @return [Array] All the paths that contain code that Pry can use for its
+    #   API's. Skips directories.
+    def code_path
+      [from_pwd, from_pry_init_pwd, *from_load_path]
+    end
+
+    # @param [String] filename
+    # @param [Symbol] default (:unknown) the file type to assume if none could be
+    #   detected.
+    # @return [Symbol, nil] The CodeRay type of a file from its extension, or
+    #   `nil` if `:unknown`.
+    def type_from_filename(filename, default = :unknown)
+      _, @code_type = EXTENSIONS.find do |k, _|
+        k.any? { |ext| ext == File.extname(filename) }
+      end
+
+      code_type || default
+    end
+
+    # @return [String]
+    def from_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_pry_init_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_load_path
+      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
+    end
+
+  end

data/lib/puppet-repl/code/code_range.rb

@@ -0,0 +1,69 @@
+  class ReplCode
+
+    # Represents a range of lines in a code listing.
+    #
+    # @api private
+    class CodeRange
+
+      # @param [Integer] start_line
+      # @param [Integer?] end_line
+      def initialize(start_line, end_line = nil)
+        @start_line = start_line
+        @end_line   = end_line
+        force_set_end_line
+      end
+
+      # @param [Array<LOC>] lines
+      # @return [Range]
+      def indices_range(lines)
+        Range.new(*indices(lines))
+      end
+
+      private
+
+      def start_line; @start_line; end
+      def end_line; @end_line; end
+
+      # If `end_line` is equal to `nil`, then calculate it from the first
+      # parameter, `start_line`. Otherwise, leave it as it is.
+      # @return [void]
+      def force_set_end_line
+        if start_line.is_a?(Range)
+          set_end_line_from_range
+        else
+          @end_line ||= start_line
+        end
+      end
+
+      # Finds indices of `start_line` and `end_line` in the given Array of
+      # +lines+.
+      #
+      # @param [Array<LOC>] lines
+      # @return [Array<Integer>]
+      def indices(lines)
+        [find_start_index(lines), find_end_index(lines)]
+      end
+
+      # @return [Integer]
+      def find_start_index(lines)
+        return start_line if start_line < 0
+        lines.index { |loc| loc.lineno >= start_line } || lines.length
+      end
+
+      # @return [Integer]
+      def find_end_index(lines)
+        return end_line if end_line < 0
+        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
+      end
+
+      # For example, if the range is 4..10, then `start_line` would be equal to
+      # 4 and `end_line` to 10.
+      # @return [void]
+      def set_end_line_from_range
+        @end_line = start_line.last
+        @end_line -= 1 if start_line.exclude_end?
+        @start_line = start_line.first
+      end
+    end
+
+  end

data/lib/puppet-repl/code/loc.rb

@@ -0,0 +1,80 @@
+  class ReplCode
+
+    # Represents a line of code. A line of code is a tuple, which consists of a
+    # line and a line number. A `LOC` object's state (namely, the line
+    # parameter) can be changed via instance methods. `Pry::Code` heavily uses
+    # this class.
+    #
+    # @api private
+    # @example
+    #   loc = LOC.new("def example\n  :example\nend", 1)
+    #   puts loc.line
+    #   def example
+    #     :example
+    #   end
+    #   #=> nil
+    #
+    #   loc.indent(3)
+    #   loc.line #=> "   def example\n  :example\nend"
+    class LOC
+
+      # @return [Array<String, Integer>]
+      attr_reader :tuple
+
+      # @param [String] line The line of code.
+      # @param [Integer] lineno The position of the +line+.
+      def initialize(line, lineno)
+        @tuple = [line.chomp, lineno.to_i]
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.tuple == tuple
+      end
+
+      def dup
+        self.class.new(line, lineno)
+      end
+
+      # @return [String]
+      def line
+        tuple.first
+      end
+
+      # @return [Integer]
+      def lineno
+        tuple.last
+      end
+
+      #Prepends the line number `lineno` to the `line`.
+      # @param [Integer] max_width
+      # @return [void]
+      def add_line_number(max_width = 0)
+        padded = lineno.to_s.rjust(max_width)
+        tuple[0] = "#{ padded }: #{ line }"
+      end
+
+      # Prepends a marker "=>" or an empty marker to the +line+.
+      #
+      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
+      #   prepend a hashrocket. Otherwise, an empty marker.
+      # @return [void]
+      def add_marker(marker_lineno)
+        tuple[0] =
+          if lineno == marker_lineno
+            " => #{ line }".cyan
+          else
+            "    #{ line }"
+          end
+      end
+
+      # Indents the `line` with +distance+ spaces.
+      #
+      # @param [Integer] distance
+      # @return [void]
+      def indent(distance)
+        tuple[0] = "#{ ' ' * distance }#{ line }"
+      end
+    end
+
+  end

data/lib/puppet-repl/repl_code.rb

@@ -0,0 +1,312 @@
+require_relative 'code/loc'
+require_relative 'code/code_range'
+require_relative 'code/code_file'
+
+  # `Pry::Code` is a class that encapsulates lines of source code and their
+  # line numbers and formats them for terminal output. It can read from a file
+  # or method definition or be instantiated with a `String` or an `Array`.
+  #
+  # In general, the formatting methods in `Code` return a new `Code` object
+  # which will format the text as specified when `#to_s` is called. This allows
+  # arbitrary chaining of formatting methods without mutating the original
+  # object.
+  class ReplCode
+    class << self
+     # include MethodSource::CodeHelpers
+
+      # Instantiate a `Code` object containing code loaded from a file or
+      # Pry's line buffer.
+      #
+      # @param [String] filename The name of a file, or "(pry)".
+      # @param [Symbol] code_type The type of code the file contains.
+      # @return [Code]
+      def from_file(filename, code_type = nil)
+        if filename == :code
+          new(Puppet[:code], 1, code_type)
+        else
+          code_file = CodeFile.new(filename, code_type)
+          new(code_file.code, 1, code_file.code_type)
+        end
+      end
+    end
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_accessor :code_type
+
+    # Instantiate a `Code` object containing code from the given `Array`,
+    # `String`, or `IO`. The first line will be line 1 unless specified
+    # otherwise. If you need non-contiguous line numbers, you can create an
+    # empty `Code` object and then use `#push` to insert the lines.
+    #
+    # @param [Array<String>, String, IO] lines
+    # @param [Integer?] start_line
+    # @param [Symbol?] code_type
+    def initialize(lines = [], start_line = 1, code_type = :ruby)
+      if lines.is_a? String
+        lines = lines.lines
+      end
+      @lines = lines.each_with_index.map { |line, lineno|
+        LOC.new(line, lineno + start_line.to_i) }
+      @code_type = code_type
+
+      @with_marker = @with_indentation = nil
+    end
+
+    # Append the given line. +lineno+ is one more than the last existing
+    # line, unless specified otherwise.
+    #
+    # @param [String] line
+    # @param [Integer?] lineno
+    # @return [String] The inserted line.
+    def push(line, lineno = nil)
+      if lineno.nil?
+        lineno = @lines.last.lineno + 1
+      end
+      @lines.push(LOC.new(line, lineno))
+      line
+    end
+    alias << push
+
+    # Filter the lines using the given block.
+    #
+    # @yield [LOC]
+    # @return [Code]
+    def select(&block)
+      alter do
+        @lines = @lines.select(&block)
+      end
+    end
+
+    # Remove all lines that aren't in the given range, expressed either as a
+    # `Range` object or a first and last line number (inclusive). Negative
+    # indices count from the end of the array of lines.
+    #
+    # @param [Range, Integer] start_line
+    # @param [Integer?] end_line
+    # @return [Code]
+    def between(start_line, end_line = nil)
+      return self unless start_line
+
+      code_range = CodeRange.new(start_line, end_line)
+
+      alter do
+        @lines = @lines[code_range.indices_range(@lines)] || []
+      end
+    end
+
+    # Take `num_lines` from `start_line`, forward or backwards.
+    #
+    # @param [Integer] start_line
+    # @param [Integer] num_lines
+    # @return [Code]
+    def take_lines(start_line, num_lines)
+      start_idx =
+        if start_line >= 0
+          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
+        else
+          [@lines.length + start_line, 0].max
+        end
+
+      alter do
+        @lines = @lines.slice(start_idx, num_lines)
+      end
+    end
+
+    # Remove all lines except for the +lines+ up to and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def before(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno < lineno
+      end
+    end
+
+    # Remove all lines except for the +lines+ on either side of and including
+    # +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def around(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines except for the +lines+ after and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def after(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno > lineno && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines that don't match the given `pattern`.
+    #
+    # @param [Regexp] pattern
+    # @return [Code]
+    def grep(pattern)
+      return self unless pattern
+      pattern = Regexp.new(pattern)
+
+      select do |loc|
+        loc.line =~ pattern
+      end
+    end
+
+    # Format output with line numbers next to it, unless `y_n` is falsy.
+    #
+    # @param [Boolean?] y_n
+    # @return [Code]
+    def with_line_numbers(y_n = true)
+      alter do
+        @with_line_numbers = y_n
+      end
+    end
+
+    # Format output with a marker next to the given +lineno+, unless +lineno+ is
+    # falsy.
+    #
+    # @param [Integer?] lineno
+    # @return [Code]
+    def with_marker(lineno = 1)
+      alter do
+        @with_marker   = !!lineno
+        @marker_lineno = lineno
+      end
+    end
+
+    # Format output with the specified number of spaces in front of every line,
+    # unless `spaces` is falsy.
+    #
+    # @param [Integer?] spaces
+    # @return [Code]
+    def with_indentation(spaces = 0)
+      alter do
+        @with_indentation = !!spaces
+        @indentation_num  = spaces
+      end
+    end
+
+    # @return [String]
+    def inspect
+      Object.instance_method(:to_s).bind(self).call
+    end
+
+    # @return [Integer] the number of digits in the last line.
+    def max_lineno_width
+      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+    end
+
+    # @return [String] a formatted representation (based on the configuration of
+    #   the object).
+    def to_s
+      print_to_output("", false)
+    end
+
+    # @return [String] a (possibly highlighted) copy of the source code.
+    def highlighted
+      print_to_output("", true)
+    end
+
+    # Writes a formatted representation (based on the configuration of the
+    # object) to the given output, which must respond to `#<<`.
+    def print_to_output(output, color=false)
+      @lines.each do |loc|
+        loc = loc.dup
+        loc.add_line_number(max_lineno_width) if @with_line_numbers
+        loc.add_marker(@marker_lineno)        if @with_marker
+        loc.indent(@indentation_num)          if @with_indentation
+        output << loc.line
+        output << "\n"
+      end
+      output
+    end
+
+    # Get the comment that describes the expression on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def comment_describing(line_number)
+      self.class.comment_describing(raw, line_number)
+    end
+
+    # Get the multiline expression that starts on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def expression_at(line_number, consume = 0)
+      self.class.expression_at(raw, line_number, :consume => consume)
+    end
+
+    # Get the multiline expression that starts on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def self.expression_at(raw, line_number, consume = 0)
+      #self.class.expression_at(raw, line_number, :consume => consume)
+      raw
+    end
+
+    # Get the (approximate) Module.nesting at the give line number.
+    #
+    # @param [Integer] line_number line number starting from 1
+    # @param [Module] top_module the module in which this code exists
+    # @return [Array<Module>] a list of open modules.
+    def nesting_at(line_number, top_module = Object)
+      Indent.nesting_at(raw, line_number)
+    end
+
+    # Return an unformatted String of the code.
+    #
+    # @return [String]
+    def raw
+      @lines.map(&:line).join("\n") << "\n"
+    end
+
+    # Return the number of lines stored.
+    #
+    # @return [Integer]
+    def length
+      @lines ? @lines.length : 0
+    end
+
+    # Two `Code` objects are equal if they contain the same lines with the same
+    # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
+    #
+    # @param [Code, Object] other
+    # @return [Boolean]
+    def ==(other)
+      if other.is_a?(Code)
+        other_lines = other.instance_variable_get(:@lines)
+        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
+      else
+        to_s.chomp == other.to_s.chomp
+      end
+    end
+
+    # Forward any missing methods to the output of `#to_s`.
+    def method_missing(name, *args, &block)
+      to_s.send(name, *args, &block)
+    end
+    undef =~
+
+    protected
+
+    # An abstraction of the `dup.instance_eval` pattern used throughout this
+    # class.
+    def alter(&block)
+      dup.tap { |o| o.instance_eval(&block) }
+    end
+  end

data/lib/puppet-repl/support/input_responders.rb

@@ -4,10 +4,22 @@ module PuppetRepl
 
       def static_responder_list
         ["exit", "functions", "classification","vars", 'facterdb_filter', "krt", "facts",
-         "resources", "classes", "play","reset", "help"
+         "resources", "classes", "whereami", "play","reset", "help"
         ]
       end
 
+      # @source_file and @source_line_num instance variables must be set for this
+      # method to show the surrounding code
+      # @return [String] - string output of the code surrounded by the breakpoint or nil if file or line_num do not exist
+      def whereami(command=nil, args=nil)
+        file=@source_file
+        line_num=@source_line_num
+        if file and line_num
+          code = ReplCode.from_file(file, :puppet)
+          return code.with_marker(line_num).around(line_num, 5).with_line_numbers.with_indentation(5).to_s
+        end
+      end
+
       def facterdb_filter(args=[])
         dynamic_facterdb_filter.ai
       end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module PuppetRepl
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/puppet-repl.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if s.respond_to?(:metadata)
-    s.metadata['allowed_push_host'] = "'http://mygemserver.com'"
+    s.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
     raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end

data/spec/fixtures/sample_start_repl.pp

@@ -0,0 +1,12 @@
+class sample_test_breakpoint(
+
+) {
+
+  include stdlib
+  file{'/tmp/test':
+    ensure => present,
+  }
+  range(1,5).map | $num | {
+    start_repl()
+  }
+}

data/spec/puppet-repl_spec.rb

@@ -15,7 +15,11 @@ describe "PuppetRepl" do
   end
 
   let(:repl) do
-    PuppetRepl::Cli.new(:out_buffer => output)
+    PuppetRepl::Cli.new({:out_buffer => output}.merge(options))
+  end
+
+  let(:options) do
+    {}
   end
 
   let(:input) do
@@ -178,7 +182,7 @@ describe "PuppetRepl" do
       'help'
     end
     it 'can show the help screen' do
-      expected_repl_output = /Type \"exit\", \"functions\", \"vars\", \"krt\", \"facts\", \"resources\", \"classes\",\n     \"play\", \"classification\", \"reset\", or \"help\" for more information.\n\n/
+      expected_repl_output = /Type \"exit\", \"functions\", \"vars\", \"krt\", \"whereami\", \"facts\", \"resources\", \"classes\",\n     \"play\", \"classification\", \"reset\", or \"help\" for more information.\n\n/
       repl.handle_input(input)
       expect(output.string).to match(/Ruby Version: #{RUBY_VERSION}\n/)
       expect(output.string).to match(/Puppet Version: \d.\d.\d\n/)
@@ -445,12 +449,31 @@ describe "PuppetRepl" do
     end
   end
 
+  describe 'whereami' do
+    let(:input) do
+      File.expand_path File.join(fixtures_dir, 'sample_start_repl.pp')
+    end
+    let(:options) do
+      {
+          source_file: input,
+          source_line: 10,
+      }
+    end
+
+    it 'runs' do
+      expect(repl.whereami).to match(/\s+5/)
+    end
+    it 'contains marker' do
+      expect(repl.whereami).to match(/\s+=>\s10/)
+    end
+
+  end
+
   describe 'error message' do
     let(:input) do
       "file{'/tmp/test': ensure => present, contact => 'blah'}"
     end
-    p_version = ENV['PUPPET_GEM_VERSION'].split(' ').last
-    if Gem::Version.new(p_version) >= Gem::Version.new('4.0')
+    if Gem::Version.new(Puppet.version) >= Gem::Version.new('4.0')
       it 'show error message' do
         repl_output =  /no\ parameter\ named\ 'contact'/
         repl.handle_input(input)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puppet-repl
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Corey Osman
@@ -90,6 +90,10 @@ files:
 - lib/awesome_print/ext/awesome_puppet.rb
 - lib/puppet-repl.rb
 - lib/puppet-repl/cli.rb
+- lib/puppet-repl/code/code_file.rb
+- lib/puppet-repl/code/code_range.rb
+- lib/puppet-repl/code/loc.rb
+- lib/puppet-repl/repl_code.rb
 - lib/puppet-repl/support.rb
 - lib/puppet-repl/support/compiler.rb
 - lib/puppet-repl/support/environment.rb
@@ -109,6 +113,7 @@ files:
 - spec/fixtures/invalid_node_obj.yaml
 - spec/fixtures/node_obj.yaml
 - spec/fixtures/sample_manifest.pp
+- spec/fixtures/sample_start_repl.pp
 - spec/prepl_spec.rb
 - spec/puppet-repl_spec.rb
 - spec/remote_node_spec.rb
@@ -119,7 +124,7 @@ homepage: http://github.com/nwops/puppet-repl
 licenses:
 - MIT
 metadata:
-  allowed_push_host: "'http://mygemserver.com'"
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
 require_paths: