peeek 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d9163af655c3a81a95497b5b85dbba4806d38a8
-  data.tar.gz: 94d66998484a454134c8c41041e593f4b458b458
+  metadata.gz: 90ae3ee8f84b1d47140d8ebd28943835875550be
+  data.tar.gz: 8a7bdc5de0df596be2e309ee950112e89ff94166
 SHA512:
-  metadata.gz: e4593100bd8419742be0174883536e40f7628211411f124259eef776481968486a387a2916dc958510239a7be27b266ce004f094a8b5fc87d059095d435f51cf
-  data.tar.gz: 2263f4beddadacbc497b4cc1c47a076b34c755c8ef9e8cda003b7e8ad55d7eef423fdbd427bfe014a5314bbf456feb905fd52e5fb49e76d894162221e2fc7ae6
+  metadata.gz: f6ffdc7048653dc766511b66272c730a1f37ac04a1aa7efe35efa4a834916f758d5766ad5c07da75954cb5a63c4a067788014514ca2edcd94756654f5b13dc75
+  data.tar.gz: d32b0ca28b0520cf773aa1f1f22c678168cdf6211dcac657796d1dc73fd85819db714df49e7e2ca8c4a9cd8fa78b1a62f80818afbddd3fb9c786c44649ef55e3

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head

data/Rakefile

@@ -1 +1,6 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/peeek

@@ -1,16 +1,8 @@
 #!/usr/bin/env ruby
-require 'stringio'
-require 'peeek'
+require 'peeek/cli'
 
-path = ARGV.first
-
-original_stdout = $stdout
-$stdout = StringIO.new
-
-calls = begin
-          Peeek.capture(String => :%) { load path } # want to be you can specify
-        ensure
-          $stdout = original_stdout
-        end
-
-puts calls
+begin
+  puts Peeek::CLI.new($stdin, $stdout, ARGV).run(binding)
+rescue => e
+  puts "peeek: #{e.message} (#{e.class})"
+end

data/lib/peeek.rb

@@ -7,12 +7,14 @@ require 'peeek/calls'
 class Peeek
 
   # @attribute [r] global
+  # @scope class
   # @return [Peeek] the global Peeek object
   def self.global
     @global ||= new
   end
 
   # @attribute [r] current
+  # @scope class
   # @return [Peeek] the current Peeek object
   #
   # @see Peeek.local
@@ -44,16 +46,15 @@ class Peeek
 
   # Capture all calls to hook targets.
   #
-  # @param [Hash{Module, Class, Object => String, Array<String>, Symbol, Array<Symbol>}]
-  #   object_and_method_specs an object and method specification(s) that be
-  #                           target of hook
+  # @param [Hash{Module, Class, Object => String, Array<String>, Symbol, Array<Symbol>}] hook_targets
+  #   an object and method specifier(s) that be target of hook
   # @yield any process that want to run to capture
   # @return [Peeek::Calls] calls that were captured in the block
-  def self.capture(object_and_method_specs)
+  def self.capture(hook_targets)
     raise ArgumentError, 'block not supplied' unless block_given?
 
     local do
-      object_and_method_specs.each { |object, method_specs| current.hook(object, *method_specs) }
+      hook_targets.each { |object, method_specs| current.hook(object, *method_specs) }
       yield
       current.calls
     end
@@ -80,8 +81,8 @@ class Peeek
   # Register a hook to methods of an object.
   #
   # @param [Module, Class, Object] object a target object that hook
-  # @param [Array<String>, Array<Symbol>] method_specs method specifications of
-  #   the object. see also examples of {Peeek::Hook.create}
+  # @param [Array<String>, Array<Symbol>] method_specs method specifiers of the
+  #   object. see also examples of {Peeek::Hook.create}
   # @yield [call] process a call to the methods. give optionally
   # @yieldparam [Peeek::Call] call a call to the methods
   # @return [Peeek::Hooks] registered hooks at calling
@@ -130,8 +131,8 @@ class Peeek
 
     # Register a hook to methods of self to the current Peeek object.
     #
-    # @param [Array<String>, Array<Symbol>] method_specs method specifications
-    #   of the object. see also examples of {Peeek::Hook.create}
+    # @param [Array<String>, Array<Symbol>] method_specs method specifiers of
+    #   the object. see also examples of {Peeek::Hook.create}
     # @yield [call] process a call to the methods. give optionally
     # @yieldparam [Peeek::Call] call a call to the methods
     #

data/lib/peeek/cli.rb

@@ -0,0 +1,99 @@
+require 'peeek/cli/options'
+require 'peeek'
+
+class Peeek
+  class CLI
+
+    # Initialize the CLI object.
+    #
+    # @param [IO] input source to input
+    # @param [IO] output destination to output the execution result
+    # @param [Array<String>] argv arguments that is given from command line
+    def initialize(input, output, argv)
+      @input   = input
+      @output  = output
+      @options = Options.new(argv)
+    rescue Help => e
+      output.puts(e.message)
+      exit
+    end
+
+    # @attribute [r] options
+    # @return [Peeek::CLI::Options] options to run from CLI
+    attr_reader :options
+
+    # Run the command or the program file with a binding. And capture calls
+    # that raised when running it.
+    #
+    # @param [Binding] binding context that runs the command or the program file
+    # @return [Peeek::Calls] captured calls
+    def run(binding)
+      if Options.encoding_options_enabled?
+        Encoding.default_external = @options.external_encoding
+        Encoding.default_internal = @options.internal_encoding
+      end
+
+      $DEBUG   = @options.debug
+      $VERBOSE = @options.verbose
+
+      Dir.chdir(@options.working_directory) if @options.working_directory
+      $LOAD_PATH.unshift(*@options.directories_to_load)
+      @options.required_libraries.each(&method(:require))
+
+      hook_targets = materialize_hook_targets(binding)
+      process = setup_to_execute(binding)
+
+      @output.puts("peeek-#{VERSION}") if @options.version_requested?
+
+      original_stdout = $stdout
+      $stdout = @output
+
+      begin
+        Peeek.capture(hook_targets, &process)
+      rescue => e
+        e.set_backtrace(e.backtrace.reject { |line| line =~ %r{lib/peeek} })
+        raise e
+      ensure
+        $stdout = original_stdout
+      end
+    end
+
+    private
+
+    def materialize_hook_targets(binding)
+      hook_targets = @options.hook_targets.inject({}) do |hook_targets, hook_spec|
+        hook_targets[hook_spec.object_name] ||= []
+        hook_targets[hook_spec.object_name] << hook_spec.method_specifier
+        hook_targets
+      end
+
+      hook_targets = hook_targets.map do |object_name, method_specs|
+        type = binding.eval("defined? #{object_name}")
+        raise "#{object_name} is undefined" if type.nil?
+        raise "#{object_name} isn't a constant or a global variable" unless type == 'constant' || type == 'global-variable'
+        [binding.eval(object_name), method_specs]
+      end
+
+      Hash[hook_targets]
+    end
+
+    def setup_to_execute(binding)
+      if @options.command_given? and @options.continued?
+        process_for { binding.eval(@options.command, '-e', 1) }
+      elsif @options.arguments_given? and @options.continued?
+        path, *argv = @options.arguments
+        process_for(argv) { load path }
+      elsif @options.version_requested?
+        process_for { }
+      else
+        process_for { binding.eval(@input.read, '-', 1) }
+      end
+    end
+
+    def process_for(argv = @options.arguments.dup, &process)
+      ARGV[0, ARGV.length] = argv
+      process
+    end
+
+  end
+end

data/lib/peeek/cli/options.rb

@@ -0,0 +1,212 @@
+require 'optparse'
+require 'stringio'
+require 'peeek/hook/specifier'
+
+class Peeek
+  class CLI
+    class Help < StandardError; end
+
+    module EncodingOptions
+
+      # @attribute external_encoding
+      # @return [Encoding] external character encoding
+      attr_reader :external_encoding
+
+      def external_encoding=(encoding)
+        @external_encoding = Encoding.find(encoding)
+      end
+
+      # @attribute internal_encoding
+      # @return [Encoding] internal character encoding
+      attr_reader :internal_encoding
+
+      def internal_encoding=(encoding)
+        @internal_encoding = Encoding.find(encoding)
+      end
+
+    end
+
+    class Options
+
+      SILENCE = 0
+      MEDIUM  = 1
+      VERBOSE = 2
+
+      include EncodingOptions if defined? Encoding
+
+      # Determine if CLI options class has enable encoding options.
+      #
+      # @return whether CLI options class has enable encoding options
+      def self.encoding_options_enabled?
+        include?(EncodingOptions)
+      end
+
+      # Initialize the CLI options.
+      #
+      # @param [Array<String>] argv arguments that is given from command line
+      def initialize(argv = [])
+        @debug             = $DEBUG
+        @verbose           = $VERBOSE
+        @version_requested = false
+
+        opt = OptionParser.new
+        opt.banner = 'Usage: peeek [switches] [--] [programfile] [arguments]'
+        opt.summary_indent = ' ' * 2
+        opt.summary_width = 15
+
+        @working_directory = nil
+
+        opt.on('-Cdirectory', 'cd to directory before executing your script') do |directory|
+          @working_directory = directory
+        end
+
+        opt.on('-d', '--debug', 'set debugging flags (set $DEBUG to true)') do
+          @debug = true
+          @verbose = verbose_by(VERBOSE)
+        end
+
+        commands = []
+
+        opt.on("-e 'command'", "one line of script. Several -e's allowed. Omit [programfile]") do |command|
+          commands << command
+        end
+
+        if self.class.encoding_options_enabled?
+          @external_encoding = Encoding.default_external
+          @internal_encoding = Encoding.default_internal
+
+          opt.on('-Eex[:in]', '--encoding=ex[:in]', 'specify the default external and internal character encodings') do |encodings|
+            external_encoding, internal_encoding = parse_encodings(encodings)
+            @external_encoding = external_encoding if external_encoding
+            @internal_encoding = internal_encoding
+          end
+        end
+
+        @hook_targets = []
+
+        opt.on('-Hstring', 'object and method name that is target of hook') do |string|
+          hook_spec = Hook::Specifier.parse(string)
+          @hook_targets << hook_spec unless @hook_targets.include?(hook_spec)
+        end
+
+        @directories_to_load = []
+
+        opt.on('-Idirectory', 'specify $LOAD_PATH directory (may be used more than once)') do |directory|
+          @directories_to_load << directory unless @directories_to_load.include?(directory)
+        end
+
+        @required_libraries = []
+
+        opt.on('-rlibrary', 'require the library before executing your script') do |library|
+          @required_libraries << library unless @required_libraries.include?(library)
+        end
+
+        opt.on('-v', 'print version number, then turn on verbose mode') do
+          @version_requested = true
+          @verbose = verbose_by(VERBOSE)
+        end
+
+        opt.on('-w', '--verbose', 'turn warnings on for your script') do
+          @verbose = verbose_by(VERBOSE)
+        end
+
+        level_strings = [:SILENCE, :MEDIUM, :VERBOSE].map do |const_name|
+          "#{self.class.const_get(const_name)}=#{const_name.to_s.downcase}"
+        end
+
+        opt.on("-W[level=#{VERBOSE}]", "set warning level; #{level_strings * ', '}", Integer) do |level|
+          @verbose = verbose_by(level || VERBOSE)
+        end
+
+        @continued = true
+
+        opt.on('--version', 'print the version') do
+          @version_requested = true
+          @continued = false
+        end
+
+        opt.on_tail('-h', '--help', 'show this message') do
+          raise Help, opt.help
+        end
+
+        @arguments = opt.order(argv)
+        @command = commands * '; '
+      end
+
+      # @attribute debug
+      # @return [Boolean] debugging flags
+      attr_accessor :debug
+
+      # @attribute verbose
+      # @return [Boolean, nil] verbose mode
+      attr_accessor :verbose
+
+      # @attribute working_directory
+      # @return [String] current directory at executing
+      attr_accessor :working_directory
+
+      # @attribute directories_to_load
+      # @return [Array<String>] directories that adds to $LOAD_PATH
+      attr_accessor :directories_to_load
+
+      # @attribute required_libraries
+      # @return [Array<String>] libraries to require
+      attr_accessor :required_libraries
+
+      # @attribute hook_targets
+      # @return [Array<Peeek::Hook::Specifier>] targets to hook
+      attr_accessor :hook_targets
+
+      # @attribute command
+      # @return [String] Ruby code to execute
+      attr_accessor :command
+
+      # @attribute arguments
+      # @return [Array<String>] arguments at executing
+      attr_accessor :arguments
+
+      # Determine if print of the version requested.
+      #
+      # @return whether print of the version requested
+      def version_requested?
+        @version_requested
+      end
+
+      # Determine if a command given.
+      #
+      # @return whether a command given
+      def command_given?
+        !@command.empty?
+      end
+
+      # Determine if arguments given.
+      #
+      # @return whether arguments given
+      def arguments_given?
+        !@arguments.empty?
+      end
+
+      # Determine if continue process.
+      #
+      # @return whether continue process
+      def continued?
+        @continued
+      end
+
+      private
+
+      def parse_encodings(encodings)
+        encodings = encodings.split(':')
+        encodings.map { |encoding| encoding.empty? ? nil : Encoding.find(encoding) }
+      end
+
+      def verbose_by(level)
+        verbose = {0 => nil, 1 => false, 2 => true}
+        raise ArgumentError, "invalid warning level - #{level}" unless verbose.key?(level)
+        verbose[level]
+      end
+
+    end
+
+  end
+end

data/lib/peeek/hook.rb

@@ -33,7 +33,7 @@ class Peeek
     #     # => #<Peeek::Hook #<IO:<STDOUT>>.puts>
     #
     # @param [Module, Class, Object] object a target object that hook
-    # @param [String, Symbol] method_spec method specification of the object
+    # @param [String, Symbol] method_spec method specifier of the object
     # @yield [call] process a call to the method. give optionally
     # @yieldparam [Peeek::Call] call a call to the method
     # @return [Peeek::Hook] a hook to the method of the object

data/lib/peeek/hook/linker.rb

@@ -6,6 +6,7 @@ class Peeek
       class << self
 
         # @attribute [r] classes
+        # @scope class
         # @return [Array<Class>] classes valid as linker
         attr_reader :classes
 

data/lib/peeek/hook/specifier.rb

@@ -0,0 +1,99 @@
+require 'peeek/hook'
+
+class Peeek
+  class Hook
+    class Specifier
+
+      # Parse a string as hook specifier.
+      #
+      # @param [String] string string to parse as hook specifier
+      # @return [Peeek::Hook::Specifier] a hook specifier
+      def self.parse(string)
+        method_prefixes = METHOD_PREFIXES.sort_by(&:length).reverse.map do |method_prefix|
+          index = string.rindex(method_prefix)
+          priority = index ? [index + method_prefix.length, method_prefix.length] : nil
+          [method_prefix, index, priority]
+        end
+
+        method_prefixes = method_prefixes.select(&:last)
+        raise ArgumentError, "method name that is target of hook isn't specified in #{string.inspect}" if method_prefixes.empty?
+        method_prefix, index = method_prefixes.max_by(&:last)
+        method_prefix_range = index..(index + method_prefix.length - 1)
+        string_range = 0..(string.length - 1)
+        raise ArgumentError, "object name should not be empty for #{string.inspect}" unless string_range.begin < method_prefix_range.begin
+        raise ArgumentError, "method name should not be empty for #{string.inspect}" unless method_prefix_range.end < string_range.end
+
+        object_name = string[string_range.begin..(method_prefix_range.begin - 1)]
+        method_name = string[(method_prefix_range.end + 1)..string_range.end].to_sym
+        new(object_name, method_prefix, method_name)
+      end
+
+      # Initialize the hook specifier.
+      #
+      # @param [String] object_name object name
+      # @param [String] method_prefix method prefix
+      # @param [Symbol] method_name method name in the object
+      def initialize(object_name, method_prefix, method_name)
+        @object_name   = object_name
+        @method_prefix = normalize_method_prefix(method_prefix)
+        @method_name   = method_name
+      end
+
+      # @attribute [r] object_name
+      # @return [String] object name
+      attr_reader :object_name
+
+      # @attribute [r] method_prefix
+      # @return [String] method prefix
+      attr_reader :method_prefix
+
+      # @attribute [r] method_name
+      # @return [Symbol] method name in the object
+      attr_reader :method_name
+
+      # @attribute [r] method_specifier
+      # @return [String] method specifier in the object
+      def method_specifier
+        @method_prefix + @method_name.to_s
+      end
+
+      def to_s
+        @object_name + method_specifier
+      end
+
+      def inspect
+        "#<#{self.class} #{self}>"
+      end
+
+      def ==(other)
+        self.class     == other.class         &&
+        @object_name   == other.object_name   &&
+        @method_prefix == other.method_prefix &&
+        @method_name   == other.method_name
+      end
+      alias eql? ==
+
+      def hash
+        values = [@object_name, @method_prefix, @method_name]
+        values.inject(self.class.hash) { |hash, value| (hash << 32) + value.hash }
+      end
+
+      private
+
+      def normalize_method_prefix(method_prefix)
+        case method_prefix
+        when *INSTANCE_METHOD_PREFIXES
+          Instance::METHOD_PREFIX
+        when *SINGLETON_METHOD_PREFIXES
+          Singleton::METHOD_PREFIX
+        else
+          init = METHOD_PREFIXES.map(&:inspect)
+          last = init.pop
+          method_prefixes = [init * ', ', last] * ' or '
+          raise ArgumentError, "invalid method prefix, #{method_prefixes} are valid"
+        end
+      end
+
+    end
+  end
+end