cute_print 1.1.4 → 1.2.0

data/spec/format/inspect_spec.rb

@@ -1,20 +0,0 @@
-require_relative "../spec_helper"
-
-require "cute_print/format/inspect"
-
-module CutePrint
-  module Format
-    describe Inspect do
-
-      let(:width) { 80 }
-      let(:value) { (1..5).to_a }
-      subject { Inspect.new.format(width, value) }
-      specify do
-        expect(subject).to eq [
-          "[1, 2, 3, 4, 5]\n",
-        ]
-      end
-
-    end
-  end
-end

data/spec/format/pretty_print_spec.rb

@@ -1,36 +0,0 @@
-require_relative "../spec_helper"
-
-require "cute_print/format/pretty_print"
-
-module CutePrint
-  module Format
-    describe PrettyPrint do
-
-      let(:value) { (1..5).to_a }
-      subject { PrettyPrint.new.format(width, value).to_a }
-
-      context "fits on one line" do
-        let(:width) { 80 }
-        specify do
-          expect(subject).to eq [
-            "[1, 2, 3, 4, 5]\n",
-          ]
-        end
-      end
-
-      context "needs multiple lines" do
-        let(:width) { 5 }
-        specify do
-          expect(subject).to eq [
-            "[1,\n",
-            " 2,\n",
-            " 3,\n",
-            " 4,\n",
-            " 5]\n",
-          ]
-        end
-      end
-
-    end
-  end
-end

data/spec/inline_labeler_spec.rb

@@ -1,39 +0,0 @@
-require_relative "spec_helper"
-
-require "cute_print/inline_labeler"
-
-module CutePrint
-  describe InlineLabeler do
-
-    let(:label) { "foo.rb:1: " }
-    let(:value) { [1, 2, 3, 4, 5] }
-    subject { InlineLabeler.label(formatter, width, label, value) }
-
-    context "single line" do
-      let(:formatter) { Format::Inspect.new }
-      let(:width) { 80 }
-      specify do
-        expect(subject).to eq [
-          "foo.rb:1:\n",
-          "  [1, 2, 3, 4, 5]\n",
-        ]
-      end
-    end
-
-    context "multiple lines" do
-      let(:formatter) { Format::PrettyPrint.new }
-      let(:width) { 4 }
-      specify do
-        expect(subject).to eq [
-          "foo.rb:1:\n",
-          "  [1,\n",
-          "   2,\n",
-          "   3,\n",
-          "   4,\n",
-          "   5]\n",
-        ]
-      end
-    end
-
-  end
-end

data/spec/irb_spec.rb

@@ -1,25 +0,0 @@
-require_relative "spec_helper"
-
-require "irb"
-require "open3"
-require "stringio"
-
-require "cute_print"
-
-describe CutePrint do
-
-  it "should be able to inspect source when called from irb" do
-    lib_path = File.join(File.dirname(__FILE__), "../lib/cute_print")
-    _stdout_output, stderr_output =
-      Open3.popen3("irb") do |stdin, stdout, stderr, wait_thr|
-      stdin.puts "require #{lib_path.inspect}"
-      stdin.puts "def foo"
-      stdin.puts "end"
-      stdin.puts "q {1 + 2}"
-      stdin.close
-      [stdout.read, stderr.read]
-    end
-    expect(stderr_output).to eq "(1 + 2) is 3\n"
-  end
-
-end

data/spec/labeler_spec.rb

@@ -1,97 +0,0 @@
-require_relative "spec_helper"
-
-require "cute_print/labeler"
-
-module CutePrint
-  describe Labeler do
-
-    WIDTH = 5
-    WIDTHS = {
-      fits: WIDTH,
-      too_wide: WIDTH + 1,
-      way_too_wide: WIDTH + 2,
-    }
-
-    def make_lines(opts)
-      size = opts.fetch(:size)
-      width = WIDTHS.fetch(opts.fetch(:width))
-      line = ('x' * width) + "\n"
-      Array.new(size, line)
-    end
-
-    let(:format) {double "format" }
-    let(:label) { double "label" }
-    let(:value) { double "value" }
-    before(:each) do
-      allow(OutlineLabeler)
-        .to receive(:label)
-        .with(format, WIDTH, label, value)
-        .and_return(outlined_lines)
-      allow(InlineLabeler)
-        .to receive(:label)
-        .with(format, WIDTH, label, value)
-        .and_return(inlined_lines)
-    end
-    subject { Labeler.label(format, WIDTH, label, value) }
-
-    context "the inline format fits on one line" do
-      let(:outlined_lines) { make_lines(size: 1, width: :fits) }
-      let(:inlined_lines) { double "inlined lines" }
-      it "should return inline lines" do
-        expect(subject).to equal outlined_lines
-      end
-      it "should not compute outlined lines" do
-        expect(OutlineLabeler).to_not have_received(:label)
-      end
-    end
-
-    context "both formats fit in the width; the inlined has fewer lines" do
-      let(:outlined_lines) { make_lines(size: 3, width: :fits) }
-      let(:inlined_lines) { make_lines(size: 2, width: :fits) }
-      it "should return inlined lines" do
-        expect(subject).to equal inlined_lines
-      end
-    end
-
-    context "both formats fit in the width, are multiline, and have same size" do
-      let(:outlined_lines) { make_lines(size: 2, width: :fits) }
-      let(:inlined_lines) { make_lines(size: 2, width: :fits) }
-      it "should return inline lines" do
-        expect(subject).to equal outlined_lines
-      end
-    end
-
-    context "inlined format fits in the width; inline format does not" do
-      let(:outlined_lines) { make_lines(size: 2, width: :too_wide) }
-      let(:inlined_lines) { make_lines(size: 2, width: :fits) }
-      it "should return inlined lines" do
-        expect(subject).to equal inlined_lines
-      end
-    end
-
-    context "inlined format does not fits in the width; inline format does" do
-      let(:outlined_lines) { make_lines(size: 2, width: :fits) }
-      let(:inlined_lines) { make_lines(size: 2, width: :too_wide) }
-      it "should return inline lines" do
-        expect(subject).to equal outlined_lines
-      end
-    end
-
-    context "neither format fits in the width; inlined is narrower" do
-      let(:outlined_lines) { make_lines(size: 2, width: :way_too_wide) }
-      let(:inlined_lines) { make_lines(size: 2, width: :too_wide) }
-      it "should return inlined lines" do
-        expect(subject).to equal inlined_lines
-      end
-    end
-
-    context "neither format fits in width; are same width; inlined is shorter" do
-      let(:outlined_lines) { make_lines(size: 3, width: :too_wide) }
-      let(:inlined_lines) { make_lines(size: 2, width: :too_wide) }
-      it "should return inlined lines" do
-        expect(subject).to equal inlined_lines
-      end
-    end
-
-  end
-end

data/spec/outline_labeler_spec.rb

@@ -1,37 +0,0 @@
-require_relative "spec_helper"
-
-require "cute_print/outline_labeler"
-
-module CutePrint
-  describe OutlineLabeler do
-
-    let(:label) { "foo.rb:1: " }
-    let(:value) { [1, 2, 3, 4, 5] }
-    subject { OutlineLabeler.label(formatter, width, label, value) }
-
-    context "single line" do
-      let(:formatter) { Format::Inspect.new }
-      let(:width) { 80 }
-      specify do
-        expect(subject).to eq [
-          "foo.rb:1: [1, 2, 3, 4, 5]\n",
-        ]
-      end
-    end
-
-    context "multiple lines" do
-      let(:formatter) { Format::PrettyPrint.new }
-      let(:width) { 4 }
-      specify do
-        expect(subject).to eq [
-          "foo.rb:1: [1,\n",
-          "           2,\n",
-          "           3,\n",
-          "           4,\n",
-          "           5]\n",
-        ]
-      end
-    end
-
-  end
-end

data/spec/printer_spec.rb

@@ -1,79 +0,0 @@
-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
-
-      context "multiple threads" do
-        Given(:out) { ThreadUnsafeStringIO.new }
-        Given(:printer) { Printer.new(out: out) }
-        When do
-          10.times.map do
-            Thread.new do
-              10.times do
-                printer.q "foo"
-              end
-            end
-          end.map(&:join)
-        end
-        Then { expect(out.string).to match(/\A("foo"\n)+\Z/) }
-      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

data/spec/silence_warnings.rb

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-# From [Ruby verbose mode and how it's broken][1] by Mislav Marohnić
-# [1]: http://mislav.uniqpath.com/2011/06/ruby-verbose-mode/
-#
-# Silence Ruby verbose output.  Use this to quiet warnings from
-# a third-party library:
-#
-#     silence_warnings do
-#       require "library_with_many_warnings"
-#     end
-module Kernel
-
-  def silence_warnings
-    with_warnings(nil) { yield }
-  end
-
-  def with_warnings(flag)
-    old_verbose, $VERBOSE = $VERBOSE, flag
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-
-end unless Kernel.respond_to? :silence_warnings

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-$VERBOSE=true
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require_relative "silence_warnings"
-
-require "pp"
-require "rspec"
-silence_warnings do
-  require "rspec-given"
-end
-
-globs = [
-  "../test_support",
-  "support",
-].map do |dir|
-  File.join(File.dirname(__FILE__), dir, '**/*.rb')
-end
-Dir[*globs].each do |path|
-  require path
-end

data/spec/support/captures_stderr.rb

@@ -1,3 +0,0 @@
-RSpec.configure do |c|
-  c.include CapturesStderr
-end

data/tasks/cucumber.rake

@@ -1,8 +0,0 @@
-require "cucumber/rake/task"
-
-Cucumber::Rake::Task.new "test:cucumber" do |t|
-  t.fork = true
-  t.cucumber_opts = "--format progress"
-end
-
- task "cucumber" => ["test:cucumber"]

data/tasks/default.rake

@@ -1 +0,0 @@
-task :default => [:test]

data/tasks/jeweler.rake

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require 'jeweler'
-
-def readme
-  File.read(File.join(File.dirname(__FILE__), '../README.md'))
-end
-
-def remove_badges(s)
-  s.gsub(/^\[![^\n]+\n/, '')
-end
-
-def join_lines(s)
-  s.gsub(/\n/, ' ').strip
-end
-
-def description
-  unless (desc = readme[/\A#[^\n]*\n*(.*?)\n*^#/m, 1])
-    raise "Failed to extract description from readme"
-  end
-  desc = remove_badges(desc)
-  desc = join_lines(desc)
-  desc
-end
-
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see
-  # http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = 'cute_print'
-  gem.homepage = 'http://github.com/wconrad/cute_print'
-  gem.license = 'MIT'
-  gem.summary = %Q{print debug to stderr, with flair}
-  gem.description = description
-  gem.email = 'wconrad@yagni.com'
-  gem.authors = ['Wayne Conrad']
-  # dependencies defined in Gemfile
-end
-
-Jeweler::RubygemsDotOrgTasks.new