srizzo-irber 0.0.3 → 0.0.4

data/lib/irber/papi.rb

@@ -0,0 +1,22 @@
+require 'irber/api'
+
+module Kernel
+  
+private
+  
+  def papi object
+
+    signatures = object.api
+  
+    max_length = signatures.collect {|signature| signature[0].size}.max
+
+    formatted_signatures = signatures.collect do |signature|
+      "#{signature[0].rjust(max_length)}  #{signature[1]}  #{signature[2]}#{signature[3]}"
+    end
+  
+    puts formatted_signatures.join("\n")
+
+  end
+  
+end
+

data/lib/irber/psrc.rb

@@ -0,0 +1,11 @@
+require 'irber/src'
+
+module Kernel
+  
+private
+  
+  def psrc object, method = nil
+    puts object.src method
+  end
+  
+end

data/lib/irber/{printing.rb → self_inspect.rb}

@@ -1,8 +1,9 @@
 require 'pp'
-
+require 'irber/psrc'
+require 'irber/papi'
 
 module Irber
-  module Printing
+  module SelfInspect
     
     module InstanceMethods
       def puts_it
@@ -14,6 +15,15 @@ module Irber
       def pp_it
         pp self
       end
+      
+      def psrc_it *args
+        psrc self, *args
+      end
+
+      def papi_it
+        papi self
+      end
+      
     end
 
     def self.included(receiver)
@@ -25,6 +35,6 @@ end
 
 
 class Object
-  include Irber::Printing
+  include Irber::SelfInspect
 end
 

data/lib/irber/signature.rb

@@ -0,0 +1,45 @@
+require 'irber/src'
+
+module Irber
+  module Signature
+    module InstanceMethods
+      def signature
+         owner, level, method_name  = self.inspect.match(/<(?:Unbound)?Method: ([^.#]*)(\.|#)(.*)>/).captures
+         owner = owner[/^(?:.*\()?([^()]*)\)?$/, 1]
+
+         begin
+           params = "(#{self.owner.src(self.name)[/def [^(]*\(([^)]*)\)\n/, 1]})"
+         rescue Irber::Src::ParseError
+           if self.arity > 0
+             req_args = self.arity
+             params = "(#{(1..req_args).collect {|i| "arg#{i}"}.join(", ")})"
+           elsif self.arity < 0
+             req_args = (-self.arity) -1
+             params = "("
+             params += "#{(1..req_args).collect {|i| "arg#{i}"}.join(", ")}, " if req_args > 0
+             params += "var_args = nil"
+             params += ")"
+           else
+             params = "()"
+           end
+
+         end
+
+         [owner, level, method_name, params]
+      end
+    end
+  
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+    end
+  end
+end
+
+
+class Method
+  include Irber::Signature
+end
+
+class UnboundMethod
+  include Irber::Signature
+end

data/lib/irber/src.rb

@@ -1,12 +1,50 @@
-require 'irber/to_code'
+require 'parse_tree'
+require 'ruby2ruby'
 
+module Irber
+  module Src
+    
+    class ParseError < StandardError; end
+    
+    module InstanceMethods
+      def src method = nil
+    
+        if method
+          
+          if (the_method = self.method(method) rescue nil)
+            receiver = the_method.owner
+          elsif (the_method = self.instance_method(method) if self.respond_to? :instance_method)
+            receiver = the_method.owner
+          else
+            throw NameError.new "couldn't find method `#{method}' for `#{self}'  "
+          end
+        
+          Ruby2Ruby.new.process(ParseTree.translate(receiver, method)) rescue raise ParseError.new("couldn't parse method")
+          
+        else
+          if self.class == Class || self.class == Module
+            receiver = self
+          else
+            receiver = self.class
+          end
 
-module Kernel
-  
-private
-  
-  def src object, method = nil
-    puts object.to_code method
+          Ruby2Ruby.new.process(ParseTree.translate(receiver)) rescue raise ParseError.new("couldn't parse class")
+
+        end
+        
+      end
+    end
+
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+    end
   end
   
 end
+
+
+class Object
+  include Irber::Src
+end
+
+

data/spec/irber/api_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "irber/api"
+
+module Irber
+  module Api
+
+    class A
+      def an_instance_method; end
+      def self.a_class_method; end
+      
+      def a_method_with_args an_arg, another_arg; end
+      
+      private
+      
+      def a_private_method; end
+      def self.a_private_class_method; end
+      
+    end
+
+    describe "#api" do
+      
+      it "should be available on all objects" do
+        Object.new.should respond_to(:api)
+      end
+      
+      describe "on objects" do
+
+        it "should include instance methods" do
+          A.new.api.to_s.should include("an_instance_method")
+        end
+
+        it "should not include private methods" do
+          A.new.api.to_s.should_not include("a_private_class_method()")
+        end
+        
+      end
+
+      describe "on classes" do
+
+        it "should include class methods" do
+          A.api.to_s.should include("a_class_method()")
+        end
+
+        it "should include instance methods" do
+          A.api.to_s.should include("an_instance_method()")
+        end
+
+        it "should not include Module methods" do
+          A.api.to_s.should_not match(/Module/)
+        end
+    
+        it "should not include Class methods" do
+          A.api.to_s.should_not match(/Class/)
+        end
+
+        it "should not include Kernel methods" do
+          A.api.to_s.should_not match(/Kernel/)
+        end
+    
+      end
+      
+    end
+    
+  end
+end

data/spec/irber/papi_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "irber/papi"
+
+module Irber
+  module Papi
+
+    class B
+      def c; end
+      def b; end
+      def self.a; end
+    end
+    
+    
+    module E
+      def e; end;
+    end
+    
+    class Ddd < B
+      include E
+      def d; end
+    end 
+
+    describe "#papi" do
+      
+      describe "formating" do
+      
+        it "should order by method name, showing owner, level (instance, class) and signature, and putting methods on the same column" do
+          stdout{ papi Ddd }.should == "
+              Irber::Papi::B  .  a()
+              Irber::Papi::B  #  b()
+              Irber::Papi::B  #  c()
+            Irber::Papi::Ddd  #  d()
+              Irber::Papi::E  #  e()
+            ".unindented
+        end
+      
+      end
+
+    end
+    
+  end
+end

data/spec/irber/psrc_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "irber/psrc"
+
+
+module Irber
+  module Psrc
+
+    class A
+      def an_instance_method
+        "result"
+      end
+      def self.a_class_method
+        "result"
+      end
+    end
+
+
+    describe "#psrc" do
+  
+      it "should print a class source" do
+        @a = A.new
+        stdout{ psrc @a }.should == stdout{ puts @a.src }
+      end
+
+      it "should print a method source" do
+        @a = A.new
+        stdout{ psrc @a, :an_instance_method }.should == stdout{ puts @a.src :an_instance_method }
+      end
+  
+    end
+  end
+end

data/spec/irber/self_inspect_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "irber/self_inspect"
+
+
+
+module Irber
+  
+  module SelfInspect
+
+    class A
+      def a arg
+        "a"
+      end
+      def to_s
+        "O#to_s"
+      end
+      def inspect
+        "O#inspect"
+      end
+    end
+
+
+    describe Irber::SelfInspect do
+
+      before(:each) do
+        @a = A.new
+      end
+
+      describe "#puts_it" do
+        it "should be available on all objects" do
+          Object.new.should respond_to(:puts_it)
+        end
+
+        it "should puts itself" do
+          stdout{ @a.puts_it }.should == stdout{ puts @a }
+        end
+      end
+
+      describe "#p_it" do
+        it "should be available on all objects" do
+          Object.new.should respond_to(:p_it)
+        end
+
+        it "should puts itself" do
+          stdout{ @a.p_it }.should == stdout{ p @a }
+        end
+      end
+
+      describe "#pp_it" do
+        it "should be available on all objects" do
+          Object.new.should respond_to(:pp_it)
+        end
+
+        it "should puts itself" do
+          stdout{ @a.pp_it }.should == stdout{ pp @a }
+        end
+      end
+
+
+      describe "#psrc_it" do
+        it "should be available on all objects" do
+          Object.new.should respond_to(:psrc_it)
+        end
+
+        it "should psrc itself" do
+          stdout{ @a.psrc_it }.should == stdout{ psrc @a }
+        end
+
+        it "should psrc itself with method arg" do
+          stdout{ @a.psrc_it :a }.should == stdout{ psrc @a, :a }
+        end
+
+      end
+  
+      describe "#papi_it" do
+        it "should be available on all objects" do
+          Object.new.should respond_to(:papi_it)
+        end
+
+        it "should papi itself" do
+          stdout{ @a.papi_it }.should == stdout{ papi @a }
+        end
+      end
+
+
+    end
+    
+  end
+end

data/spec/irber/signature_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'irber/signature'
+
+
+module Irber
+  module Signature
+  
+    class A
+      def a(param); end
+      def self.b; end
+    end
+
+
+    describe Irber::Signature do
+  
+      it "should be available on all unbound methods" do
+        A.instance_method(:a).should respond_to(:signature)
+      end
+  
+  
+      it "should be available on all methods" do
+        A.new.method(:a).should respond_to(:signature)
+      end
+  
+  
+      describe "returned data" do
+      
+        before(:each) do
+          @method = A.instance_method(:a)
+        end
+    
+        it "should include the owner" do
+          @method.signature[0].should == "Irber::Signature::A"
+        end
+    
+        it "should include the level (class/instance)" do
+          @method.signature[1].should == "#"
+        end
+    
+        it "should include the method name" do
+          @method.signature[2].should == "a"
+        end
+    
+        it "should include the params" do
+          @method.signature[3].should == "(param)"
+        end
+      end
+    
+  
+      describe "method signatures creation" do
+      
+        it "should include arg names when possible" do
+          A.instance_method(:a).signature[3].should == "(param)"
+        end
+      
+        it "should create a signature when not possible" do
+          String.instance_method(:between?).signature[3].should == "(arg1, arg2)"
+        end
+      
+      end
+  
+    end
+
+  end
+end