fast_method_source 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a652f4b019d35eaf42c337bed8e5a556cefaf8bc
-  data.tar.gz: c6dd63e38ed0542570e7bc395a1f798341021c6d
+  metadata.gz: d73c77ef828261b4ad145f88bd1d78682133b215
+  data.tar.gz: 3fa8f4dc7471bd3e2b78f6c479bc795d38972f13
 SHA512:
-  metadata.gz: 4194e5d174e2d5c4ff5699b20bda1ee9676edc224a05b6bd255e3f73dc723329a08468e6e5839283e1136271b1f2c7d68a83cda5979d5aaa0be714dec0e6ec45
-  data.tar.gz: 67b9991bff995852cba78548c5fd8aca9886f353f3ce90fdc34e78387ef25c7564102335a36f4d3263bf00eaca9865ceca0dd8f62a483fdd6df58a0dcaad2bad
+  metadata.gz: 5d3ab1de1d9a55e1c681e684c85cbc92f349e77927cbfb0999ce59419c35a6120d588286133399e0484ff60258fb4313f02145de33a0f71419db504b98f24054
+  data.tar.gz: 4426e0c403f8de0b80bed5264cd91495a06d5468ba73912b5b5a4511ef0a4942915c7d1b19f7a64bb67d2e65d055922a6c1a6d4f298b53fff8ab3ca5f094c871

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 Fast Method Source changelog
 ============================
 
+### v0.3.1 (June 11, 2015)
+
+* Considerable speed improvements
+
 ### v0.3.0 (June 11, 2015)
 
 * _Significantly_ reduced memory consumption (`#comment_and_source` for 19K

data/README.md

@@ -1,7 +1,33 @@
+<a name="Back_to_top">
 # Fast Method Source
 
 * Repository: [https://github.com/kyrylo/fast_method_source/][repo]
 
+Table of Contents
+-----------------
+
+* <a href="#description">Description</a>
+* <a href="#installation">Installation</a>
+* <a href="#synopsis">Synopsis</a>
+    * <a href="#speed-improvements">Speed Improvements</a>
+        * <a href="#source">#source</a>
+        * <a href="#comment">#comment</a>
+        * <a href="#source-and-comment">#source_and_comment</a>
+    * <a href="#correctness-of-output">Correctness Of Output</a>
+    * <a href="#ram-consumption">RAM Consumption</a>
+* <a href="#api">API</a>
+    * <a href="#method-information">Method Information</a>
+        * <a href="#fastmethodsourcesource_formethod">FastMethodSource#source_for(method)</a>
+        * <a href="#fastmethodsourcecomment_formethod">FastMethodSource#comment_for(method)</a>
+        * <a href="#fastmethodsourcecomment_and_source_formethod">FastMethodSource#comment_and_source_for(method)</a>
+* <a href="#limitations">Limitations</a>
+  * <a href="#rubies">Rubies</a>
+  * <a href="#operation-systems">Operation Systems</a>
+* <a href="#roadmap">Roadmap</a>
+  * <a href="#further-speed-improvements">Further Speed Improvements</a>
+  * <a href="#optional-memoization">Optional Memoization</a>
+* <a href="#licence">Licence</a>
+
 Description
 -----------
 
@@ -10,7 +36,7 @@ their source code and comments.
 
 ```ruby
 require 'fast_method_source'
-require 'fast_method_source/core_ext'
+require 'fast_method_source/core_ext' # Adds #source to UnboundMethod
 require 'set'
 
 puts Set.instance_method(:merge).source
@@ -40,73 +66,78 @@ All you need is to install the gem.
 Synopsis
 --------
 
-Fast Method Source provides similar functionality to [method_source][ms], which
-is being used by the Pry REPL, but with a number of major key differences.
-
-### Speed improvements
+Fast Method Source provides functionality similar to [method_source][ms], which
+powers [Pry](https://github.com/pry/pry)'s `show-source`, `show-comment` and
+`find-method` commands, but with a number of key differences that are listed
+below.
 
-The main goal of Fast Method Source is to be as fast as possible. In result, the
-library is much faster than method_source. What's acceptable for Pry, when you
-query only one method, is not acceptable for other use cases such as querying
-all the methods defined in your Ruby process. The benchmark showed that Fast
-Method Source is about 5-10x faster than its competitor.
+### Speed Improvements
 
-I'd be remiss if I didn't mention that there's also room for further speed
-improvements. The benchmarks below represent comparison of both libraries.
+The main goal of Fast Method Source is to retrieve information as fast as
+possible. In result, the library is extremely fast and is capable of quering
+thousands of methods in a couple of seconds. The benchmarks included in this
+repository show that Fast Method Source outpaces method_source in every aspect
+by far. The results from those benchmarks below show the comparison of these
+libraries.
 
-#### #comment_and_source
+#### #source
 ##### ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 
-This is a utility method and method_source doesn't feature it.
+The speed boost of method_source after the rehearsal that can be observed in
+this benchmark comes from the fact that it uses memoization. Fast Method Source
+does not support it at the moment.
 
 ```
 Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19438
-       user     system      total        real
-FastMethodSource#comment_and_source_for 16.240000   1.180000  17.420000 ( 19.439981)
+Sample methods: 18970
+Rehearsal -----------------------------------------------------------
+FastMethodSource#source   6.340000   0.460000   6.800000 (  7.616361)
+MethodSource#source      86.030000   0.500000  86.530000 (104.094356)
+------------------------------------------------- total: 93.330000sec
+
+                              user     system      total        real
+FastMethodSource#source   6.830000   0.590000   7.420000 (  8.258469)
+MethodSource#source      80.470000   0.310000  80.780000 ( 89.864366)
 ```
 
-#### #source
+#### #comment
 ##### ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 
 ```
 Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19438
-Rehearsal -----------------------------------------------------------
-FastMethodSource#source  14.220000   0.880000  15.100000 ( 16.844189)
-MethodSource#source     104.140000   0.420000 104.560000 (126.567209)
------------------------------------------------- total: 119.660000sec
+Sample methods: 19596
+Rehearsal ------------------------------------------------------------
+FastMethodSource#comment   1.820000   0.240000   2.060000 (  2.300117)
+MethodSource#comment      77.020000   0.360000  77.380000 ( 94.672830)
+-------------------------------------------------- total: 79.440000sec
 
-                              user     system      total        real
-FastMethodSource#source  14.920000   0.890000  15.810000 ( 17.658905)
-MethodSource#source      96.860000   0.410000  97.270000 (108.131119)
+                               user     system      total        real
+FastMethodSource#comment   1.570000   0.230000   1.800000 (  1.997811)
+MethodSource#comment      71.410000   0.160000  71.570000 ( 79.657388)
 ```
 
-#### #comment
+#### #comment_and_source
 ##### ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 
+This is a convenience method, and method_source doesn't have it.
+
 ```
+Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19596
-Rehearsal ------------------------------------------------------------
-FastMethodSource#comment   1.790000   0.210000   2.000000 (  2.229802)
-MethodSource#comment      85.020000   0.370000  85.390000 (103.061652)
--------------------------------------------------- total: 87.390000sec
-
-                               user     system      total        real
-FastMethodSource#comment   1.620000   0.250000   1.870000 (  2.072023)
-MethodSource#comment      84.560000   0.320000  84.880000 ( 94.465574)
+Sample methods: 18970
+       user     system      total        real
+FastMethodSource#comment_and_source_for  8.240000   0.750000   8.990000 ( 10.036892)
 ```
 
-### Correctness of output
+### Correctness Of Output
 
 Fast Method Source is capable of displaying source code even for dynamically
-defined methods (there are some crazy methods in stdlib).
+defined methods.
 
 ```ruby
 require 'fast_method_source'
@@ -126,38 +157,39 @@ Output.
             end
 ```
 
-### RAM consumption
+That said, you need to be cautious, because sometimes it's not working as
+expected. Feel free to file issues.
+
+### RAM Consumption
 
 The [`comment_and_source`](/benchmarks/comment_and_source_for.rb) benchmark
-shows that at this moment the library uses about 450 MB of RAM.
+shows that the library uses about 80-140 MB of RES RAM for computing information
+for 19K methods.
 
 API
 ---
 
-### General description
-
 The library provides the following methods: `#comment`, `#source` and
-`#comment_and_source`. There are two ways to use Fast Method Source. One way is
-to monkey-patch relevant core Ruby classes and use the methods directly.
+`#comment_and_source`. There are two ways to use Fast Method Source.
+
+One way is to monkey-patch relevant core Ruby classes and use the methods
+directly.
 
 ```ruby
 require 'fast_method_source'
-require 'fast_method_source/core_ext'
+require 'fast_method_source/core_ext' # <= monkey-patches
 
-# With UnboundMethod
-Set.instance_method(:merge).source
-#=> "  def merge(enum)\n..."
+# Monkey-patch of UnboundMethod
+Set.instance_method(:merge).source #=> "  def merge(enum)\n..."
 
-# With Method
-Set.method(:[]).source
-#=> "  def self.[](*ary)\n..."
+# Monkey-patch of Method
+Set.method(:[]).source #=> "  def self.[](*ary)\n..."
 
-# With Proc (or lambda)
+# Monkey-patch of Proc (or lambda)
 myproc = proc { |arg|
   arg + 1
 }
-myproc.source
-#=> "myproc = proc { |arg|\n..."
+myproc.source #=> "myproc = proc { |arg|\n..."
 ```
 
 The other way is by using these methods defined on the library's class directly.
@@ -166,22 +198,19 @@ The other way is by using these methods defined on the library's class directly.
 require 'fast_method_source'
 
 # With UnboundMethod
-FastMethodSource.source_for(Set.instance_method(:merge))
-#=> "  def merge(enum)\n..."
+FastMethodSource.source_for(Set.instance_method(:merge)) #=> "  def merge(enum)\n..."
 
 # With Method
-FastMethodSource.source_for(Set.method(:[]))
-#=> "  def self.[](*ary)\n..."
+FastMethodSource.source_for(Set.method(:[])) #=> "  def self.[](*ary)\n..."
 
 # With Proc (or lambda)
 myproc = proc { |arg|
   arg + 1
 }
-FastMethodSource.source_for(myproc)
-#=> "myproc = proc { |arg|\n..."
+FastMethodSource.source_for(myproc) #=> "myproc = proc { |arg|\n..."
 ```
 
-### Methods
+### Method Information
 
 #### FastMethodSource#source_for(method)
 
@@ -224,7 +253,7 @@ Limitations
 Rubies below 2.2.2 were not tested, so in theory if it quacks like Ruby 2, it
 may work.
 
-### OS'es
+### Operation Systems
 
 * GNU/Linux
 * Mac OS (hopefully)
@@ -232,19 +261,22 @@ may work.
 Roadmap
 -------
 
-### Further speed improvements
+### Further Speed Improvements
 
 Although Fast Method Source is faster than any of its competitors, it's still
-very slow. On average, a mature Rails 4 application has at least 45K methods. In
-order to query all those methods for their source code, you would need to wait
-for a while and perhaps to drink a cup of tea.
+very slow. On average, a mature Rails 4 application has at least 45K
+methods. The goal of the project is to be able to query 50K methods in less than
+15 seconds.
 
-The goal of the project is to be able to query 50K methods in less than 15
-seconds. Whether it's possible or not is to be determined.
+### Optional Memoization
 
-### Decrease memory consumption
+I'm not sure about this, if it's really needed, but it will speed up further
+queries greatly (at the cost of RAM). At this moment I think if I add it, it
+should be optional and configurable like this:
 
-I'm not happy about the current rates. To be investigated.
+```ruby
+FastMethodSource.memoization = true # or `false`
+```
 
 Licence
 -------

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/ext/fast_method_source/fast_method_source.c

@@ -42,6 +42,7 @@ static VALUE find_method_source(struct method_data *data);
 static NODE *parse_expr(VALUE rb_str);
 static NODE *parse_with_silenced_stderr(VALUE rb_str);
 static void filter_interp(char *line);
+static int contains_skippables(const char *line);
 static int contains_end_kw(const char *line);
 static int is_comment(const char *line, const size_t line_len);
 static int is_static_definition(const char *line);
@@ -121,7 +122,8 @@ read_lines(finder finder, struct method_data *data)
             }
             strncat(expression, current_line, cl_len);
 
-            if (current_line[0] == '\n')
+            if (current_line[0] == '\n' ||
+                is_comment(current_line, cl_len))
                 continue;
 
             if (line_count == data->method_location) {
@@ -130,9 +132,6 @@ read_lines(finder finder, struct method_data *data)
                 }
             }
 
-            if (is_comment(current_line, cl_len))
-                continue;
-
             if (is_dangling_literal_end(current_line)) {
                 dangling_literal = 0;
             } else if (is_dangling_literal_begin(current_line)) {
@@ -149,6 +148,9 @@ read_lines(finder finder, struct method_data *data)
             }
             strncat(parse_expression, current_line, cl_len);
 
+            if (contains_skippables(current_line))
+                continue;
+
             if (should_parse || contains_end_kw(current_line)) {
                 if (parse_expr(rb_str_new2(parse_expression)) != NULL) {
                     found_expression = 1;
@@ -209,7 +211,6 @@ parse_with_silenced_stderr(VALUE rb_str)
 
     volatile VALUE vparser = rb_parser_new();
     NODE *node = rb_parser_compile_string(vparser, "-", rb_str, 1);
-    rb_str_free(rb_str);
     rb_set_errinfo(last_exception);
 
     fflush(stderr);
@@ -255,6 +256,28 @@ filter_interp(char *line)
     }
 }
 
+static int
+contains_skippables(const char *line)
+{
+
+    static unsigned short len = 57;
+    static const char *skippables[57] = {
+        " if ", " else ", " then ", " case ", " for ", " in ", " loop ",
+        " unless ", "||", "||=", "&&", " and ", " or ", " do ", " not ",
+        " while ", " = ", " == ", " === ", " > ", " < ", " >= ", " <= ",
+        " << ", " += ", "\"", "'", ":", ",", ".", " % ", "!", "?",
+        " until ", "(&", "|", "(", ")", "~", " * ", " - ", " + ", " / ",
+        " {", " raise ", " fail ", " begin ", " rescue ", " ensure ",
+        ".new", "@", " lambda", " proc", " ->", "[", "]", "$"};
+
+    for (unsigned short i = 0; i < len; i++) {
+        if (strstr(line, skippables[i]) != NULL)
+            return 1;
+    }
+
+    return 0;
+}
+
 static int
 contains_end_kw(const char *line)
 {
@@ -283,17 +306,7 @@ is_comment(const char *line, const size_t line_len)
     for (size_t i = 0; i < line_len; i++) {
         if (line[i] == ' ')
             continue;
-
-        if (line[i] == '#' && line[i + 1] != '{') {
-            for (size_t j = i - 1; j != 0; j--) {
-                if (line[j] != ' ')
-                    return 0;
-            }
-
-            return 1;
-        } else {
-            return 0;
-        }
+        return line[i] == '#' && line[i + 1] != '{';
     }
 
     return 0;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_method_source
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Kyrylo Silin