cute_print 0.1.0

data/features/support/env.rb

@@ -0,0 +1,9 @@
+require "rspec/expectations"
+
+# Instead of letting cucumber load all of the .rb, we configure
+# cucumber to require them (see .config/cucumber.yml).
+glob = File.join(File.dirname(__FILE__), '**/*.rb')
+ruby_paths = Dir[glob].sort
+ruby_paths.each do |path|
+  require path
+end

data/features/support/helpers/example.rb

@@ -0,0 +1,54 @@
+require_relative "../../../test_support/captures_stderr.rb"
+require_relative "../../../test_support/captures_stdout.rb"
+
+require_relative "temp_dir"
+
+class Example
+
+  include CapturesStderr
+  include CapturesStdout
+
+  def initialize(contents, opts = {})
+    @contents = contents
+    @filename = opts.fetch(:filename, "example.rb")
+    @temp_dir = TempDir.new
+    create_file
+  end
+
+  def run
+    @stdout = capture_stdout do
+      @stderr = capture_stderr do
+        load path
+      end
+    end
+  end
+
+  def stderr
+    filter_output(@stderr)
+  end
+
+  def stdout
+    filter_output(@stdout)
+  end
+
+  private
+
+  def create_file
+    File.open(path, 'w') do |file|
+      file.write @contents
+    end
+  end
+
+  def path
+    File.join(@temp_dir.path, @filename)
+  end
+
+  def filter_output(output)
+    redact_tmp_path(output)
+  end
+
+  def redact_tmp_path(output)
+    output.sub(/\/tmp\/.*\//, "/tmp/.../")
+  end
+
+end

data/features/support/helpers/temp_dir.rb

@@ -0,0 +1,15 @@
+require "fileutils"
+require "tmpdir"
+
+require_relative "temp_dir"
+
+class TempDir
+
+  attr_reader :path
+
+  def initialize
+    @path = Dir.mktmpdir
+    at_exit { FileUtils.remove_entry(@path) }
+  end
+
+end

data/features/support/step_definitions.rb

@@ -0,0 +1,23 @@
+require_relative "../../lib/cute_print"
+
+Before do
+  CutePrint.configure { |c| c.reset }
+end
+
+Given(/^a file with:$/) do |contents|
+  @example = Example.new(contents)
+  @example.run
+end
+
+Given(/^a file named "(.*?)" with:$/) do |filename, contents|
+  @example = Example.new(contents, :filename => filename)
+  @example.run
+end
+
+Then(/^stderr should be$/) do |expected|
+  expect(@example.stderr).to eq expected
+end
+
+Then(/^stdout should be$/) do |expected|
+  expect(@example.stdout).to eq expected
+end

data/lib/cute_print/configure.rb

@@ -0,0 +1,37 @@
+require "forwardable"
+
+module CutePrint
+
+  class Configure
+
+    extend Forwardable
+
+    # Configure an instance of printer.
+    # @api private
+    # @param [Printer] printer
+    # @yield [Configure]
+    def initialize(printer)
+      @printer = printer
+      yield self
+    end
+
+    def_delegator :@printer, :set_defaults, :reset
+
+    def self.delegate_accessor(name)
+      def_delegator :@printer, name
+      def_delegator :@printer, "#{name}="
+    end
+
+    # @!attribute [rw] position_format
+    #   @return [String] The position format
+    #   @see Printer#position_format
+    delegate_accessor :position_format
+
+    # @!attribute [rw] out
+    #   @return [#puts] The file to write to
+    #   @see Printer#out
+    delegate_accessor :out
+
+  end
+
+end

data/lib/cute_print/core_ext/object.rb

@@ -0,0 +1,5 @@
+require_relative "../mixin"
+
+class Object
+  include CutePrint::Mixin
+end

data/lib/cute_print/core_ext.rb

@@ -0,0 +1 @@
+require_relative "core_ext/object"

data/lib/cute_print/default_printer.rb

@@ -0,0 +1,14 @@
+require_relative "printer"
+
+module CutePrint
+
+  # @api private
+  class DefaultPrinter
+
+    def self.printer
+      @printer ||= Printer.new
+    end
+
+  end
+
+end

data/lib/cute_print/finds_foreign_caller.rb

@@ -0,0 +1,19 @@
+module CutePrint
+
+  # @api private
+  module FindsForeignCaller
+
+    def nearest_foreign_caller
+      caller.find do |s|
+        path = s.split(":").first
+        !File.expand_path(path).include?(File.expand_path(lib_path))
+      end
+    end
+
+    def lib_path
+      File.dirname(__FILE__)
+    end
+
+  end
+
+end

data/lib/cute_print/mixin.rb

@@ -0,0 +1,44 @@
+require_relative "default_printer"
+require_relative "printer"
+
+module CutePrint
+
+  # Methods mixed into Object, and so available globally.
+  #
+  # @note The methods in this module are part of the public API, but
+  #   the module itself is not.
+
+  module Mixin
+
+    # @see Printer#q
+    def q(*args, &block)
+      CutePrint::DefaultPrinter.printer.q(*args, &block)
+    end
+
+    # @see Printer#ql
+    def ql(*args, &block)
+      CutePrint::DefaultPrinter.printer.ql(*args, &block)
+    end
+
+    # @see Printer#qq
+    def qq(*args, &block)
+      CutePrint::DefaultPrinter.printer.qq(*args, &block)
+    end
+
+    # Debug a call chain by printing self and then returning self.
+    # @return [Object] self
+    def tapq
+      q self
+      self
+    end
+
+    # Debug a call chain by printing self, with source position, and
+    # then returning self.
+    # @return [Object] self
+    def tapql
+      ql self
+      self
+    end
+
+  end
+end

data/lib/cute_print/printer.rb

@@ -0,0 +1,106 @@
+require_relative "finds_foreign_caller"
+require_relative "ruby_parser"
+require_relative "stderr_out"
+
+module CutePrint
+  class Printer
+
+    include FindsForeignCaller
+
+    DEFAULT_POSITION_FORMAT = "%<filename>s:%<line_number>d: "
+
+    # The object to write to.  Defaults to $stderr.
+    # @return [#puts]
+    attr_accessor :out
+
+    # The position format.  To format a position, String#% is called
+    # with a hash having these keys:
+    #
+    # * :path
+    # * :filename
+    # * :line_number
+    #
+    # The default format prints the filename and line number.
+    # @see Printer::DEFAULT_POSITION_FORMAT
+    # @return [String]
+    attr_accessor :position_format
+
+    # Create an instance.  If attributes are supplied, they override
+    # the defaults.  For example:
+    #
+    #     CutePrint.new(:out => $stdout)
+    #
+    # @api private
+    def initialize(attrs = {})
+      set_defaults
+      attrs.each { |name, value| send "#{name}=", value }
+    end
+
+    # Set all attributes to their defaults.
+    def set_defaults
+      @out = StderrOut.new
+      @position_format = DEFAULT_POSITION_FORMAT
+    end
+
+    # Inspect and write one or more objects.
+    #
+    # If called without a block, prints the inspected arguments, one
+    # on a line.
+    #
+    # If called with a block, prints the source code of the block and
+    # the inspected result of the block.
+    def q(*values, &block)
+      print(__method__, values, block) do |line|
+        @out.puts line
+      end
+    end
+
+    # Inspect and write one or more objects, with source position.
+    #
+    # If called without a block, prints the inspected arguments, one
+    # on a line.
+    #
+    # If called with a block, prints the source code of the block and
+    # the inspected result of the block.
+    def ql(*values, &block)
+      path, line_number = nearest_foreign_caller.split(":")
+      line_number = line_number.to_i
+      print(__method__, values, block) do |line|
+        position = format_position(path, line_number)
+        @out.puts "#{position}#{line}"
+      end
+    end
+
+    private
+
+    def print(method, values, block)
+      if block && !values.empty?
+        raise ArgumentError, "arguments and block are mutually exclusive"
+      end
+      if block
+        ruby_parser = RubyParser.from_block(block)
+        parsed_code = ruby_parser.parse
+        method_call = parsed_code.first_call_to_method(method)
+        block_code = method_call.block.to_ruby
+        yield "%s is %s" % [
+          block_code,
+          block.call.inspect,
+        ]
+      else
+        values.each do |value|
+          yield value.inspect
+        end
+      end
+    end
+
+    def format_position(path, line_number)
+      position_values = {
+        path: path,
+        filename: File.basename(path),
+        line_number: line_number,
+      }
+      @position_format % position_values
+    end
+
+  end
+end

data/lib/cute_print/ruby_generator.rb

@@ -0,0 +1,17 @@
+require "ruby2ruby"
+
+require_relative "ruby_generator"
+
+module CutePrint
+
+  # @api private
+  class RubyGenerator
+
+    def self.to_ruby(sexp)
+      sexp = sexp.deep_clone
+      Ruby2Ruby.new.process(sexp)
+    end
+
+  end
+
+end

data/lib/cute_print/ruby_parser/block.rb

@@ -0,0 +1,12 @@
+require_relative "wraps_sexp"
+
+module CutePrint
+  class RubyParser
+
+    # @api private
+    class Block
+      include WrapsSexp
+    end
+
+  end
+end

data/lib/cute_print/ruby_parser/method_call.rb

@@ -0,0 +1,27 @@
+require_relative "block"
+require_relative "wraps_sexp"
+
+module CutePrint
+  class RubyParser
+
+    # @api private
+    class MethodCall
+
+      include WrapsSexp
+
+      def self.call_to_method?(sexp, method_name)
+        call?(sexp) && sexp[1][2] == method_name
+      end
+
+      def self.call?(sexp)
+        sexp[0] == :iter && sexp[1][0] == :call
+      end
+
+      def block
+        Block.new(@sexp[3])
+      end
+
+    end
+
+  end
+end

data/lib/cute_print/ruby_parser/parsed_code.rb

@@ -0,0 +1,38 @@
+require_relative "method_call"
+require_relative "wraps_sexp"
+
+module CutePrint
+  class RubyParser
+
+    # How this class works is cribbed this excellent code:
+    #
+    #     https://github.com/sconover/wrong/blob/30475fc5ac9d0f73135d229b1b44c045156a7e7a/lib/wrong/d.rb
+    #
+    # @api private
+
+    class ParsedCode
+
+      include WrapsSexp
+
+      def first_call_to_method(method_name)
+        MethodCall.new(method_call_node(method_name))
+      end
+
+      private
+
+      def method_call_node(method_name)
+        if MethodCall.call_to_method?(@sexp, method_name)
+          return @sexp
+        end
+        @sexp.each_sexp do |node|
+          if MethodCall.call_to_method?(node, method_name)
+            return node
+          end
+        end
+        raise "Method call not found"
+      end
+
+    end
+
+  end
+end

data/lib/cute_print/ruby_parser/wraps_sexp.rb

@@ -0,0 +1,19 @@
+require_relative "../ruby_generator"
+
+module CutePrint
+  class RubyParser
+
+    # @api private
+    module WrapsSexp
+
+      def initialize(sexp)
+        @sexp = sexp
+      end
+
+      def to_ruby
+        RubyGenerator.to_ruby(@sexp)
+      end
+
+    end
+  end
+end

data/lib/cute_print/ruby_parser.rb

@@ -0,0 +1,60 @@
+require "ruby_parser"
+
+require_relative "ruby_parser/parsed_code"
+
+module CutePrint
+
+  # This class is very much cribbed from this excellent code:
+  #
+  #     https://github.com/sconover/wrong/blob/30475fc5ac9d0f73135d229b1b44c045156a7e7a/lib/wrong/chunk.rb
+  #
+  # @api private
+
+  class RubyParser
+
+    def self.from_block(block)
+      path, line_number = block.to_proc.source_location
+      new(path, line_number, &block)
+    end
+
+    def initialize(path, line_number, &block)
+      @path = path
+      @line_number = line_number
+      @block = block
+    end
+
+    def parse
+      @parsed ||= parse_source(read_source)
+    end
+
+    private
+
+    def read_source
+      File.read(@path)
+    end
+
+    def parser
+      @parser ||= ::RubyParser.new
+    end
+
+    # Try parsing just the starting line.  While that doesn't work,
+    # add another line and try again.
+    def parse_source(source)
+      lines = source.lines.to_a
+      starting_line_index = @line_number - 1
+      ending_line_index = starting_line_index
+      sexp = nil
+      while !sexp && ending_line_index < lines.size
+        begin
+          snippet = lines.to_a[starting_line_index..ending_line_index].join
+          sexp = parser.parse(snippet)
+          return ParsedCode.new(sexp)
+        rescue Racc::ParseError
+          ending_line_index += 1
+          raise if ending_line_index >= lines.size
+        end
+      end
+    end
+
+  end
+end

data/lib/cute_print/stderr_out.rb

@@ -0,0 +1,13 @@
+module CutePrint
+
+  # Writing to an instance of this class, rather than directly to
+  # $stderr, allows the tests to capture output by assigning to
+  # $stderr.
+  class StderrOut
+
+    def puts(*args)
+      $stderr.puts(*args)
+    end
+
+  end
+end

data/lib/cute_print.rb

@@ -0,0 +1,26 @@
+require_relative "cute_print/configure"
+require_relative "cute_print/core_ext"
+require_relative "cute_print/default_printer"
+
+# Like Kernel#p, only fancier.  For example, this code:
+#
+#     require 'cute_print'
+#     q { 1 + 2 }
+#
+# prints this to $stderr:
+#
+#     (1 + 2) is 3
+module CutePrint
+
+  # Configure the library.  For example:
+  #
+  #     CutePrint.configure do |c|
+  #       c.out = $stdout
+  #     end
+  #
+  # @yieldparam config [Configure]
+  def self.configure(&block)
+    Configure.new(DefaultPrinter.printer, &block)
+  end
+
+end

data/spec/cute_print_spec.rb

@@ -0,0 +1,69 @@
+require_relative "spec_helper"
+
+require "stringio"
+
+require "cute_print"
+
+# Test the library as the user uses it.  The other specs test
+# internals.
+
+describe CutePrint do
+
+  before(:each) do
+    CutePrint.configure { |c| c.reset }
+  end
+
+  describe "#q" do
+    When(:stderr) do
+      capture_stderr do
+        q 123
+      end
+    end
+    Then { stderr == "123\n" }
+  end
+
+  describe "#ql" do
+    When(:stderr) do
+      capture_stderr do
+        @location = [File.basename(__FILE__), __LINE__ + 1].join(":")
+        ql 123
+      end
+    end
+    Then { stderr == "#{@location}: 123\n" }
+  end
+
+  describe "#tapq" do
+    When do
+      @stderr = capture_stderr do
+        @result = ["1", "2"].map(&:to_i).tapq.inject(:+)
+      end
+    end
+    Then { @result == 3}
+    Then { @stderr == "[1, 2]\n" }
+  end
+
+  describe "#tapql" do
+    When do
+      @stderr = capture_stderr do
+        @location = [File.basename(__FILE__), __LINE__ + 1].join(":")
+        @result = ["1", "2"].map(&:to_i).tapql.inject(:+)
+      end
+    end
+    Then { @result == 3}
+    Then { @stderr == "#{@location}: [1, 2]\n" }
+  end
+
+  describe 'configure output' do
+    Given(:io) { StringIO.new }
+    Given do
+      CutePrint.configure do |c|
+        c.out = io
+      end
+    end
+    When do
+      q 123
+    end
+    Then { io.string == "123\n" }
+  end
+
+end

data/spec/printer_spec.rb

@@ -0,0 +1,64 @@
+require_relative "spec_helper"
+
+require "cute_print/printer"
+
+module CutePrint
+
+  describe Printer do
+
+    describe "#q" do
+
+      context "single value" do
+        Given(:out) { StringIO.new }
+        Given(:printer) { Printer.new(:out => out) }
+        When { printer.q [1, 2] }
+        Then { out.string == "[1, 2]\n" }
+      end
+
+      context "multiple values" do
+        Given(:out) { StringIO.new }
+        Given(:printer) { Printer.new(:out => out) }
+        When { printer.q 1, 2 }
+        Then { out.string == "1\n2\n" }
+      end
+
+      context "arguments and closure" do
+        Given(:out) { StringIO.new }
+        Given(:printer) { Printer.new(:out => out) }
+        When(:result) { printer.q("foo") {1 + 2} }
+        Then { result == Failure(ArgumentError) }
+      end
+
+      context "closure (one line)" do
+        Given(:out) { StringIO.new }
+        Given(:printer) { Printer.new(:out => out) }
+        When { printer.q {1 + 2} }
+        Then { out.string == "(1 + 2) is 3\n" }
+      end
+
+      context "closure (two lines)" do
+        Given(:out) { StringIO.new }
+        Given(:printer) { Printer.new(:out => out) }
+        When do
+          printer.q do
+            (1 + 2)
+          end
+        end
+        Then { out.string == "(1 + 2) is 3\n" }
+      end
+
+    end
+
+    describe "#ql" do
+      Given(:out) { StringIO.new }
+      Given(:printer) { Printer.new(:out => out) }
+      When do
+        @location = [File.basename(__FILE__), __LINE__ + 1].join(":")
+        printer.ql [1, 2]
+      end
+      Then { out.string == "#{@location}: [1, 2]\n" }
+    end
+
+  end
+
+end