peeek 1.0.1 → 1.0.2

data/lib/peeek/version.rb

@@ -1,3 +1,3 @@
 class Peeek
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/peeek.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
   spec.test_files            = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths         = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
 end

data/spec/peeek/call_spec.rb

@@ -19,60 +19,39 @@ def sample_exception
   Peeek::Call::Exception.new(:exception)
 end
 
-describe Peeek::Call, '#initialize' do
-  it 'raises ArgumentError if the result is invalid' do
-    lambda { sample_call(:result => :result) }.should raise_error(ArgumentError, 'invalid as result')
-  end
-end
-
-describe Peeek::Call, '#hook' do
-  it 'returns the value when constructed the call' do
-    hook = :hook
-    call = sample_call(:hook => hook)
-    call.hook.should == hook
-  end
-end
-
-describe Peeek::Call, '#backtrace' do
-  it 'returns the value when constructed the call' do
-    call = sample_call
-    call.backtrace.should == sample_backtrace
-  end
-end
-
-describe Peeek::Call, '#file' do
-  it 'returns name of top file on the backtrace' do
-    call = sample_call
-    call.file.should == 'koyomi.rb'
+describe Peeek::Call do
+  describe '#initialize' do
+    it do
+      expect {
+        described_class.new(:hook, ["koyomi.rb:7:in `print'"], '%s (%d)', ['Koyomi', 18], :result)
+      }.to raise_error(ArgumentError, 'invalid as result')
+    end
   end
-end
 
-describe Peeek::Call, '#line' do
-  it 'returns top line number on the backtrace' do
-    call = sample_call
-    call.line.should == 7
-  end
-end
+  context 'basic instance attributes' do
+    subject {
+      described_class.new(
+        :hook,
+        ["koyomi.rb:7:in `print'", "koyomi.rb:21:in `<main>'"],
+        '%s (%d)',
+        ['Koyomi', 18],
+        Peeek::Call::ReturnValue.new('Koyomi (18)')
+      )
+    }
 
-describe Peeek::Call, '#receiver' do
-  it 'returns the value when constructed the call' do
-    call = sample_call
-    call.receiver.should == '%s (%d)'
+    its(:hook)      { should == :hook }
+    its(:backtrace) { should == ["koyomi.rb:7:in `print'", "koyomi.rb:21:in `<main>'"] }
+    its(:file)      { should == 'koyomi.rb' }
+    its(:line)      { should == 7 }
+    its(:receiver)  { should == '%s (%d)' }
+    its(:arguments) { should == ['Koyomi', 18] }
+    its(:result)    { should == Peeek::Call::ReturnValue.new('Koyomi (18)') }
   end
 end
 
-describe Peeek::Call, '#arguments' do
-  it 'returns the value when constructed the call' do
-    call = sample_call
-    call.arguments.should == ['Koyomi', 18]
-  end
-end
-
-describe Peeek::Call, '#result' do
-  it 'returns the value when constructed the call' do
-    result = sample_return_value
-    call = sample_call(:result => result)
-    call.result.should == result
+describe Peeek::Call, '#initialize' do
+  it 'raises ArgumentError if the result is invalid' do
+    lambda { sample_call(:result => :result) }.should raise_error(ArgumentError, 'invalid as result')
   end
 end
 

data/spec/peeek/cli/options_spec.rb

@@ -0,0 +1,331 @@
+require 'peeek/cli/options'
+
+describe Peeek::CLI::Options do
+  let(:default_options) { described_class.new }
+
+  describe 'deafult options' do
+    subject { default_options }
+
+    context 'encoding options', :if => described_class.encoding_options_enabled? do
+      its(:external_encoding) { should == Encoding.default_external }
+      its(:internal_encoding) { should == Encoding.default_internal }
+    end
+
+    its(:debug)               { should be_false }
+    its(:verbose)             { should be_false }
+    its(:working_directory)   { should be_nil }
+    its(:directories_to_load) { should == [] }
+    its(:required_libraries)  { should == [] }
+    its(:hook_targets)        { should == [] }
+    its(:command)             { should == '' }
+    its(:arguments)           { should == [] }
+
+    it { should_not be_version_requested }
+    it { should_not be_command_given }
+    it { should_not be_arguments_given }
+    it { should be_continued }
+  end
+
+  subject { described_class.new(argv) }
+
+  describe '-C option' do
+    let(:argv) { %w(-C directory) }
+
+    its(:working_directory) { should == 'directory' }
+  end
+
+  shared_examples_for 'accepting debug option' do
+    let(:argv) { [option] }
+
+    its(:debug) { should be_true }
+  end
+
+  describe '-d option' do
+    it_behaves_like 'accepting debug option' do
+      let(:option) { '-d' }
+    end
+  end
+
+  describe '--debug option' do
+    it_behaves_like 'accepting debug option' do
+      let(:option) { '--debug' }
+    end
+  end
+
+  describe '-e option' do
+    let(:option) { '-e' }
+
+    context 'when a command is specified' do
+      let(:argv) { [option, 'puts "%s (%d)" % ["Koyomi", 18]'] }
+
+      it { should be_command_given }
+      its(:command) { should == 'puts "%s (%d)" % ["Koyomi", 18]' }
+    end
+
+    context 'when multiple commands are specified' do
+      let(:argv) { [option, 'format = "%s (%d)"', option, 'puts format % ["Koyomi", 18]'] }
+
+      it { should be_command_given }
+      its(:command) { should == 'format = "%s (%d)"; puts format % ["Koyomi", 18]' }
+    end
+
+    context 'when commands is omitted' do
+      let(:argv) { [option] }
+
+      it do
+        lambda { subject }.should raise_error(OptionParser::MissingArgument)
+      end
+    end
+  end
+
+  shared_examples_for 'accepting encoding option' do
+    let(:utf_8)    { Encoding::UTF_8    }
+    let(:us_ascii) { Encoding::US_ASCII }
+
+    context 'when both external encoding and internal encoding are specifid' do
+      let(:argv) { [option, 'utf-8:us-ascii'] }
+
+      its(:external_encoding) { should == utf_8 }
+      its(:internal_encoding) { should == us_ascii }
+    end
+
+    context 'when external encoding only is specified' do
+      let(:argv) { [option, 'utf-8'] }
+
+      its(:external_encoding) { should == utf_8 }
+      its(:internal_encoding) { should == default_options.internal_encoding }
+    end
+
+    context 'when internal encoding only is specified' do
+      let(:argv) { [option, ':us-ascii'] }
+
+      its(:external_encoding) { should == default_options.external_encoding }
+      its(:internal_encoding) { should == us_ascii }
+    end
+
+    context 'when external encoding is unknown encoding name' do
+      let(:argv) { [option, 'undefined-encoding'] }
+
+      it do
+        lambda { subject }.should raise_error(ArgumentError, 'unknown encoding name - undefined-encoding')
+      end
+    end
+
+    context 'when internal encoding is unknown encoding name' do
+      let(:argv) { [option, ':undefined-encoding'] }
+
+      it do
+        lambda { subject }.should raise_error(ArgumentError, 'unknown encoding name - undefined-encoding')
+      end
+    end
+
+    context 'when encodings is omitted' do
+      let(:argv) { [option] }
+
+      it do
+        lambda { subject }.should raise_error(OptionParser::MissingArgument)
+      end
+    end
+  end
+
+  describe '-E option', :if => described_class.encoding_options_enabled? do
+    it_behaves_like 'accepting encoding option' do
+      let(:option) { '-E' }
+    end
+  end
+
+  describe '--encoding option', :if => described_class.encoding_options_enabled? do
+    it_behaves_like 'accepting encoding option' do
+      let(:option) { '--encoding' }
+    end
+  end
+
+  describe '-H option' do
+    let(:option) { '-H' }
+
+    context 'when a hook specifier is specified' do
+      let(:argv) { [option, 'String#%'] }
+
+      its(:hook_targets) {
+        should == [Peeek::Hook::Specifier.new('String', '#', :%)]
+      }
+    end
+
+    context 'when multiple hook specifiers is specified' do
+      let(:argv) { [option, 'String#%', option, 'String#index'] }
+
+      its(:hook_targets) {
+        should == [
+          Peeek::Hook::Specifier.new('String', '#', :%),
+          Peeek::Hook::Specifier.new('String', '#', :index)
+        ]
+      }
+    end
+
+    context 'when hook specifiers is duplicated' do
+      let(:argv) { [option, 'String#%', option, 'String#%'] }
+
+      its(:hook_targets) {
+        should == [Peeek::Hook::Specifier.new('String', '#', :%)]
+      }
+    end
+
+    context 'when hook specifiers is omitted' do
+      let(:argv) { [option] }
+
+      it do
+        lambda { subject }.should raise_error(OptionParser::MissingArgument)
+      end
+    end
+  end
+
+  shared_examples_for 'accepting multiple values' do |attr|
+    context 'when a value is specified' do
+      let(:argv) { [option, 'value'] }
+
+      its(attr) { should == %w(value) }
+    end
+
+    context 'when multiple values is specified' do
+      let(:argv) { [option, 'value1', option, 'value2'] }
+
+      its(attr) { should == %w(value1 value2) }
+    end
+
+    context 'when values is duplicated' do
+      let(:argv) { [option, 'value', option, 'value'] }
+
+      its(attr) { should == %w(value) }
+    end
+
+    context 'when value is omitted' do
+      let(:argv) { [option] }
+
+      it do
+        lambda { subject }.should raise_error(OptionParser::MissingArgument)
+      end
+    end
+  end
+
+  describe '-I option' do
+    it_behaves_like 'accepting multiple values', :directories_to_load do
+      let(:option) { '-I' }
+    end
+  end
+
+  describe '-r option' do
+    it_behaves_like 'accepting multiple values', :required_libraries do
+      let(:option) { '-r' }
+    end
+  end
+
+  shared_examples_for 'accepting version option' do
+    let(:argv) { [option] }
+
+    it { should be_version_requested }
+  end
+
+  describe '-v option' do
+    let(:argv) { %w(-v) }
+
+    it { should be_version_requested }
+    its(:verbose) { should be_true }
+  end
+
+  shared_examples_for 'accepting verbose option' do
+    let(:argv) { [option] }
+
+    its(:verbose) { should be_true }
+  end
+
+  describe '-w option' do
+    it_behaves_like 'accepting verbose option' do
+      let(:option) { '-w' }
+    end
+  end
+
+  describe '--verbose option' do
+    it_behaves_like 'accepting verbose option' do
+      let(:option) { '--verbose' }
+    end
+  end
+
+  describe '-W option' do
+    let(:option) { '-W' }
+
+    context 'when the leve is 0' do
+      let(:argv) { ["#{option}0"] }
+
+      its(:verbose) { should be_nil }
+    end
+
+    context 'when the level is 1' do
+      let(:argv) { ["#{option}1"] }
+
+      its(:verbose) { should be_false }
+    end
+
+    context 'when the leve is 2' do
+      let(:argv) { ["#{option}2"] }
+
+      its(:verbose) { should be_true }
+    end
+
+    context 'when the level is other' do
+      let(:argv) { ["#{option}3"] }
+
+      it do
+        lambda { subject }.should raise_error(ArgumentError, 'invalid warning level - 3')
+      end
+    end
+
+    context 'when a level is omitted' do
+      let(:argv) { [option] }
+
+      its(:verbose) { should be_true }
+    end
+  end
+
+  describe '--version option' do
+    let(:argv) { %w(--version) }
+
+    it { should be_version_requested }
+    it { should_not be_continued }
+  end
+
+  shared_examples_for 'accepting help option' do
+    let(:argv) { [option] }
+
+    it do
+      lambda { subject }.should raise_error(Peeek::CLI::Help, /^Usage: peeek/)
+    end
+  end
+
+  describe '-h option' do
+    it_behaves_like 'accepting help option' do
+      let(:option) { '-h' }
+    end
+  end
+
+  describe '--help option' do
+    it_behaves_like 'accepting help option' do
+      let(:option) { '--help' }
+    end
+  end
+
+  describe 'extra options' do
+    context 'when extra options is specified' do
+      let(:argv) { %w(-HString#% example.rb) }
+
+      it { should be_arguments_given }
+      its(:arguments) { should == %w(example.rb) }
+    end
+
+    context 'when extra options is omitted' do
+      let(:argv) { ['-HString#%', %(-e'puts "%s (%d)" % ["Koyomi", 18]')] }
+
+      it { should_not be_arguments_given }
+      its(:arguments) { should be_empty }
+    end
+  end
+end

data/spec/peeek/cli_sample.rb

@@ -0,0 +1,2 @@
+puts "#{File.basename(__FILE__)} here"
+puts ARGV

data/spec/peeek/cli_spec.rb

@@ -0,0 +1,254 @@
+require 'peeek/cli'
+require 'stringio'
+require 'pathname'
+
+describe Peeek::CLI do
+  let(:test_input)  { StringIO.new }
+  let(:test_output) { StringIO.new }
+
+  describe '#initialize' do
+    it "calls #{described_class}::Options.new with the argv" do
+      Peeek::CLI::Options.should_receive(:new).with(['-v'])
+      described_class.new(test_input, test_output, ['-v'])
+    end
+
+    context 'when need help' do
+      it 'writes the help message to the output IO' do
+        begin
+          described_class.new(test_input, test_output, ['-h'])
+        rescue SystemExit
+        end
+
+        test_output.string.should =~ /^Usage: peeek/
+      end
+
+      it 'raises SystemExit' do
+        raised = begin
+                   described_class.new(test_input, test_output, ['-h'])
+                   false
+                 rescue SystemExit
+                   true
+                 end
+
+        raised.should be_true
+      end
+    end
+  end
+
+  describe '#options' do
+    before { Peeek::CLI::Options.stub!(:new => 'options') }
+
+    subject { described_class.new(test_input, test_output, ['-v']).options }
+
+    it 'returns the options that was set when construct' do
+      should == 'options'
+    end
+  end
+
+  describe '#run' do
+    def cli(command = nil)
+      argv = command ? ['-e', command] : []
+      cli = Peeek::CLI.new(test_input, test_output, argv)
+      yield cli.options if block_given?
+      cli
+    end
+
+    def local(expr)
+      value = eval(expr)
+      yield
+      eval("#{expr} = value")
+    end
+
+    it 'sets options.external_encoding to Encoding.default_external', :if => Peeek::CLI::Options.encoding_options_enabled? do
+      cli = cli('print Encoding.default_external') do |options|
+        options.external_encoding = 'utf-8'
+      end
+
+      local 'Encoding.default_external' do
+        cli.run(binding)
+        test_output.string.should == 'UTF-8'
+      end
+    end
+
+    it 'sets options.internal_encoding to Encoding.default_internal', :if => Peeek::CLI::Options.encoding_options_enabled? do
+      cli = cli('print Encoding.default_internal') do |options|
+        options.internal_encoding = 'us-ascii'
+      end
+
+      local 'Encoding.default_internal' do
+        cli.run(binding)
+        test_output.string.should == 'US-ASCII'
+      end
+    end
+
+    it 'sets false to $DEBUG if options.debug is false' do
+      cli = cli('print $DEBUG.inspect') do |options|
+        options.debug = false
+      end
+
+      local '$DEBUG' do
+        cli.run(binding)
+        test_output.string.should == 'false'
+      end
+    end
+
+    it 'sets true to $DEBUG if options.debug is true' do
+      cli = cli('print $DEBUG.inspect') do |options|
+        options.debug = true
+      end
+
+      local '$DEBUG' do
+        cli.run(binding)
+        test_output.string.should == 'true'
+      end
+    end
+
+    it 'sets nil to $VERBOSE if options.verbose is nil' do
+      cli = cli('print $VERBOSE.inspect') do |options|
+        options.verbose = nil
+      end
+
+      local '$VERBOSE' do
+        cli.run(binding)
+        test_output.string.should == 'nil'
+      end
+    end
+
+    it 'sets false to $VERBOSE if options.verbose is false' do
+      cli = cli('print $VERBOSE.inspect') do |options|
+        options.verbose = false
+      end
+
+      local '$VERBOSE' do
+        cli.run(binding)
+        test_output.string.should == 'false'
+      end
+    end
+
+    it 'sets true to $VERBOSE if options.verbose is true' do
+      cli = cli('print $VERBOSE.inspect') do |options|
+        options.verbose = true
+      end
+
+      local '$VERBOSE' do
+        cli.run(binding)
+        test_output.string.should == 'true'
+      end
+    end
+
+    it 'changes current directory to options.working_directory' do
+      cli = cli('print Dir.pwd') do |options|
+        options.working_directory = '..'
+      end
+
+      current_dir = Pathname(Dir.pwd)
+      cli.run(binding)
+      test_output.string.should == current_dir.parent.to_s
+      Dir.chdir(current_dir.to_s)
+    end
+
+    it 'adds options.directories_to_load to head of $LOAD_PATH' do
+      cli = cli('puts $LOAD_PATH') do |options|
+        options.directories_to_load = %w(.. ../..)
+      end
+
+      output = StringIO.new
+      output.puts('..')
+      output.puts('../..')
+      output.puts($LOAD_PATH)
+
+      cli.run(binding)
+      test_output.string.should == output.string
+      2.times { $LOAD_PATH.shift }
+    end
+
+    it 'loads options.required_libraries' do
+      cli = cli('print defined? Net::HTTP') do |options|
+        options.required_libraries = %w(net/http)
+      end
+
+      defined?(Net::HTTP).should be_nil # assert
+      cli.run(binding)
+      test_output.string.should_not be_nil
+    end
+
+    it 'prints version' do
+      cli = cli('puts "peeek"') do |options|
+        options.stub!(:version_requested? => true)
+      end
+
+      output = StringIO.new
+      output.puts("peeek-#{Peeek::VERSION}")
+      output.puts('peeek')
+
+      cli.run(binding)
+      test_output.string.should == output.string
+    end
+
+    it 'hooks options.hook_targets' do
+      cli = cli('print Peeek.current.hooks.inspect') do |options|
+        options.hook_targets = [Peeek::Hook::Specifier.new('String', '#', :%)]
+      end
+
+      cli.run(binding)
+      test_output.string.should == '[#<Peeek::Hook String#% (linked)>]'
+    end
+
+    it 'sets options.arguments to ARGV' do
+      cli = cli('puts ARGV') do |options|
+        options.arguments = %w(arg1 arg2)
+      end
+
+      output = StringIO.new
+      output.puts('arg1')
+      output.puts('arg2')
+
+      cli.run(binding)
+      test_output.string.should == output.string
+    end
+
+    it 'aborts process if options.continued? is false' do
+      cli = cli('puts "peeek"') do |options|
+        options.stub!(:version_requested? => true, :continued? => false)
+      end
+
+      output = StringIO.new
+      output.puts("peeek-#{Peeek::VERSION}")
+
+      cli.run(binding)
+      test_output.string.should == output.string
+    end
+
+    it 'loads head of options.arguments as program file with tail of options.arguments' do
+      cli = cli do |options|
+        options.arguments = [File.join(File.dirname(__FILE__), 'cli_sample.rb'), *%w(arg1 arg2)]
+      end
+
+      output = StringIO.new
+      output.puts('cli_sample.rb here')
+      output.puts('arg1')
+      output.puts('arg2')
+
+      cli.run(binding)
+      test_output.string.should == output.string
+    end
+
+    it 'evaluates content of input' do
+      cli = cli()
+      test_input.print('print "peeek"')
+      test_input.rewind
+      cli.run(binding)
+      test_output.string.should == 'peeek'
+    end
+
+    it 'removes information about peeek gem from the backtrace of the raised exception' do
+      cli = cli('fail')
+
+      begin
+        line = __LINE__; cli.run(binding)
+      rescue => e
+        e.backtrace[1].should =~ /#{__FILE__}:#{line}/
+      end
+    end
+  end
+end