fast_method_source 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d73c77ef828261b4ad145f88bd1d78682133b215
-  data.tar.gz: 3fa8f4dc7471bd3e2b78f6c479bc795d38972f13
+  metadata.gz: c0cd70578b6aaaef59d7671494865a18c5e86de0
+  data.tar.gz: 247ab14fe91beb917dd9d136682707594c3d3e47
 SHA512:
-  metadata.gz: 5d3ab1de1d9a55e1c681e684c85cbc92f349e77927cbfb0999ce59419c35a6120d588286133399e0484ff60258fb4313f02145de33a0f71419db504b98f24054
-  data.tar.gz: 4426e0c403f8de0b80bed5264cd91495a06d5468ba73912b5b5a4511ef0a4942915c7d1b19f7a64bb67d2e65d055922a6c1a6d4f298b53fff8ab3ca5f094c871
+  metadata.gz: b799a52825b9e85e26a8084138240e37f5cf75db475d72935b6f0eb63464293685a89bf2e783f549a87666568bf086a9ea2a3afc536c218c9dddd6afedf62ab8
+  data.tar.gz: 385239928c2a382550889de7dfdcb3547f44b5e8b11c0c63cafc061887bd6b6a64d095a96af2e817d84f56716b18db5f0146143b0437989b183f405e483cfd49

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 Fast Method Source changelog
 ============================
 
+### v0.4.0 (June 18, 2015)
+
+* _Significantly_ improve speed of both `#soruce` and `#comment`. The trade-off
+is that you must indent methods properly.
+* Decrease memeory consumption
+
 ### v0.3.1 (June 11, 2015)
 
 * Considerable speed improvements

data/README.md

@@ -1,6 +1,8 @@
 <a name="Back_to_top">
 # Fast Method Source
 
+[![Build Status](https://travis-ci.org/kyrylo/fast_method_source.svg?branch=master)](https://travis-ci.org/kyrylo/fast_method_source)
+
 * Repository: [https://github.com/kyrylo/fast_method_source/][repo]
 
 Table of Contents
@@ -24,7 +26,6 @@ Table of Contents
   * <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>
 
@@ -91,15 +92,15 @@ 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: 18970
+Sample methods: 19280
 Rehearsal -----------------------------------------------------------
-FastMethodSource#source   6.340000   0.460000   6.800000 (  7.616361)
-MethodSource#source      86.030000   0.500000  86.530000 (104.094356)
-------------------------------------------------- total: 93.330000sec
+FastMethodSource#source   0.760000   0.240000   1.000000 (  1.104455)
+MethodSource#source      53.240000   0.250000  53.490000 ( 59.304424)
+------------------------------------------------- total: 54.490000sec
 
                               user     system      total        real
-FastMethodSource#source   6.830000   0.590000   7.420000 (  8.258469)
-MethodSource#source      80.470000   0.310000  80.780000 ( 89.864366)
+FastMethodSource#source   0.610000   0.190000   0.800000 (  0.890971)
+MethodSource#source      51.770000   0.230000  52.000000 ( 57.640986)
 ```
 
 #### #comment
@@ -109,15 +110,15 @@ MethodSource#source      80.470000   0.310000  80.780000 ( 89.864366)
 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
+Sample methods: 19437
 Rehearsal ------------------------------------------------------------
-FastMethodSource#comment   1.820000   0.240000   2.060000 (  2.300117)
-MethodSource#comment      77.020000   0.360000  77.380000 ( 94.672830)
--------------------------------------------------- total: 79.440000sec
+FastMethodSource#comment   0.180000   0.170000   0.350000 (  0.395569)
+MethodSource#comment      19.860000   0.230000  20.090000 ( 36.373289)
+-------------------------------------------------- total: 20.440000sec
 
                                user     system      total        real
-FastMethodSource#comment   1.570000   0.230000   1.800000 (  1.997811)
-MethodSource#comment      71.410000   0.160000  71.570000 ( 79.657388)
+FastMethodSource#comment   0.270000   0.190000   0.460000 (  0.520414)
+MethodSource#comment      19.360000   0.020000  19.380000 ( 21.726528)
 ```
 
 #### #comment_and_source
@@ -129,9 +130,9 @@ 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: 18970
+Sample methods: 19435
        user     system      total        real
-FastMethodSource#comment_and_source_for  8.240000   0.750000   8.990000 ( 10.036892)
+FastMethodSource#comment_and_source_for  0.810000   0.420000   1.230000 (  1.374435)
 ```
 
 ### Correctness Of Output
@@ -163,8 +164,9 @@ expected. Feel free to file issues.
 ### RAM Consumption
 
 The [`comment_and_source`](/benchmarks/comment_and_source_for.rb) benchmark
-shows that the library uses about 80-140 MB of RES RAM for computing information
-for 19K methods.
+shows that the library uses about 10 MB of RES RAM for computing information for
+19K methods. I measure with `htop`, manually. If you know a better way to
+measure RAM, please drop a letter here: `silin@kyrylo.org`.
 
 API
 ---
@@ -247,7 +249,8 @@ Limitations
 
 ### Rubies
 
-* CRuby 2.2.2
+* CRuby 2.1.x
+* CRuby 2.2.x
 * CRuby 2.3.0dev and higher
 
 Rubies below 2.2.2 were not tested, so in theory if it quacks like Ruby 2, it
@@ -261,13 +264,6 @@ may work.
 Roadmap
 -------
 
-### 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. The goal of the project is to be able to query 50K methods in less than
-15 seconds.
-
 ### Optional Memoization
 
 I'm not sure about this, if it's really needed, but it will speed up further
@@ -278,6 +274,8 @@ should be optional and configurable like this:
 FastMethodSource.memoization = true # or `false`
 ```
 
+So far I'm happy about the speed of the library.
+
 Licence
 -------
 

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/ext/fast_method_source/extconf.rb

@@ -1,5 +1,7 @@
 require 'mkmf'
 
-$CFLAGS << ' -std=c99 -Wno-declaration-after-statement -O3'
+$CFLAGS << ' -std=c99 -Wno-declaration-after-statement'
+
+have_func('rb_sym2str', 'ruby.h')
 
 create_makefile('fast_method_source/fast_method_source')

data/ext/fast_method_source/fast_method_source.c

@@ -3,6 +3,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #include <ruby.h>
 
 #include "node.h"
@@ -19,9 +22,28 @@ static const char *null_filename = "/dev/null";
 #define DUP2(fd, newfd) dup2(fd, newfd)
 #endif
 
-#define EXPRESSION_SIZE 80 * 50
+#ifndef HAVE_RB_SYM2STR
+# define rb_sym2str(obj) rb_id2str(SYM2ID(obj))
+#endif
 
-#define SAFE_CHAR 'z'
+#ifdef __APPLE__
+void *
+memrchr(const void *s, int c, size_t n)
+{
+    const unsigned char *cp;
+
+    if (n != 0) {
+        cp = (unsigned char *)s + n;
+        do {
+            if (*(--cp) == (unsigned char)c)
+                return((void *)cp);
+        } while (--n != 0);
+    }
+    return NULL;
+}
+#else
+void *memrchr(const void *s, int c, size_t n);
+#endif
 
 typedef struct {
     int source  : 1;
@@ -39,18 +61,19 @@ static VALUE read_lines_before(struct method_data *data);
 static VALUE read_lines_after(struct method_data *data);
 static VALUE find_method_comment(struct method_data *data);
 static VALUE find_method_source(struct method_data *data);
+static VALUE find_comment_expression(struct method_data *data);
+static VALUE find_source_expression(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 void restore_ch(char *line, char ch, int last_ch_idx);
+static void close_map(int fd, char *map, size_t map_size, const char *filename);
+static void nulify_ch(char *line, char *ch, int last_ch_idx);
 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);
-static int is_accessor(const char *line);
-static int is_dangling_literal_end(const char *line);
-static int is_dangling_literal_begin(const char *line);
+static int is_definition_end(const char *line);
+static int is_static_definition_start(const char *line);
+static size_t count_prefix_spaces(const char *line);
 static void raise_if_nil(VALUE val, VALUE method_name);
-static void realloc_expression(char **expression, size_t len);
 static void method_data_init(VALUE self, struct method_data *data);
 static VALUE mMethodExtensions_source(VALUE self);
 
@@ -83,118 +106,192 @@ read_lines_before(struct method_data *data)
 }
 
 static VALUE
-read_lines(finder finder, struct method_data *data)
+find_comment_expression(struct method_data *data)
 {
-    FILE *fp;
+    struct stat filestat;
+    int fd;
+    char *map;
+
+    VALUE comment = Qnil;
 
-    if ((fp = fopen(data->filename, "r")) == NULL) {
-        rb_raise(rb_eIOError, "No such file or directory - %s", data->filename);
+    if ((fd = open(data->filename, O_RDONLY)) == -1) {
+        rb_raise(rb_eIOError, "failed to read - %s", data->filename);
     }
 
-    ssize_t cl_len;
-    VALUE rb_expr;
+    if (fstat(fd, &filestat) == -1) {
+        rb_raise(rb_eIOError, "filestat failed for %s", data->filename);
+    }
+
+    map = mmap(NULL, filestat.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+    if (map == MAP_FAILED) {
+        rb_raise(rb_eIOError, "mmap failed for %s", data->filename);
+    }
 
-    size_t bufsize, parse_bufsize, future_bufsize, future_parse_bufsize,
-        current_linebuf_size, line_count;
+    char *rest = map;
+    unsigned line_count = 0;
 
-    bufsize = parse_bufsize = EXPRESSION_SIZE;
-    line_count = current_linebuf_size = 0;
+    while (line_count++ != data->method_location - 1) {
+        rest = (char *) memchr(rest, '\n', filestat.st_size) + 1;
+    }
 
-    int should_parse, dangling_literal, found_expression;
-    should_parse = dangling_literal = found_expression = 0;
+    size_t end = filestat.st_size - strlen(rest);
+    map[end] = '\0';
 
-    char *expression = ALLOC_N(char, bufsize);
-    expression[0] = '\0';
+    size_t offset = end;
+    char *prev = NULL;
 
-    char *parse_expression = ALLOC_N(char, bufsize);
-    parse_expression[0] = '\0';
+    while (line_count-- != 0) {
+        rest = memrchr(map, '\n', offset - 2);
 
-    char *current_line = NULL;
+        if (rest == NULL) {
+            rest = memrchr(map, '\n', offset);
+        } else {
+            rest++;
+        }
 
-    while ((cl_len = getline(&current_line, &current_linebuf_size, fp)) != -1) {
-        line_count++;
+        offset = end - strlen(rest);
 
-        if (finder.source && line_count >= data->method_location) {
-            future_bufsize = strlen(expression) + cl_len;
-            if (future_bufsize >= bufsize) {
-                bufsize = future_bufsize + EXPRESSION_SIZE + 1;
-                realloc_expression(&expression, bufsize);
+        if (is_comment(rest, offset)) {
+            prev = rest;
+        } else {
+            if (prev == NULL) {
+                comment = rb_str_new("", 0);
+            } else {
+                comment = rb_str_new2(prev);
             }
-            strncat(expression, current_line, cl_len);
 
-            if (current_line[0] == '\n' ||
-                is_comment(current_line, cl_len))
-                continue;
+            break;
+        }
+    }
+
+    if (munmap (map, filestat.st_size) == -1) {
+        rb_raise(rb_eIOError, "munmap failed for %s", data->filename);
+    }
+    close(fd);
+
+    return comment;
+}
+
+static VALUE
+find_source_expression(struct method_data *data)
+{
+    struct stat filestat;
+    int fd;
+    char *map;
+
+    VALUE source = Qnil;
+
+    if ((fd = open(data->filename, O_RDONLY)) == -1) {
+        rb_raise(rb_eIOError, "failed to read - %s", data->filename);
+    }
+
+    if (fstat(fd, &filestat) == -1) {
+        rb_raise(rb_eIOError, "filestat failed for %s", data->filename);
+    }
+
+    map = mmap(NULL, filestat.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+    if (map == MAP_FAILED) {
+        rb_raise(rb_eIOError, "mmap failed for %s", data->filename);
+    }
+
+    char *expr_start = map;
+    char *expr_end, *next_expr, *line;
+    unsigned line_count = 0;
+
+    while (line_count++ != data->method_location - 1) {
+        expr_start = (char *) memchr(expr_start, '\n', filestat.st_size) + 1;
+    }
+
+    size_t last_ch_idx;
+    char ch, next_ch;
+    next_expr = expr_end = expr_start;
+    size_t leftover_size = filestat.st_size - strlen(expr_end);
+    size_t offset = filestat.st_size - leftover_size;
+    size_t next_offset;
+    size_t prefix_len = 0;
+    int inside_static_def = 0;
+    int should_parse = 0;
+    VALUE rb_expr;
+
+    while (offset != 0) {
+        next_expr = (char *) memchr(expr_end, '\n', offset) + 1;
+        next_offset = strlen(next_expr);
+        line = expr_end;
+
+        last_ch_idx = offset - next_offset - 1;
+
+        nulify_ch(line, &ch, last_ch_idx);
+
+        expr_end = next_expr;
+        offset = next_offset;
+
+        if (is_static_definition_start(line) && !inside_static_def) {
+            inside_static_def = 1;
+            prefix_len = count_prefix_spaces(line);
 
-            if (line_count == data->method_location) {
-                if (is_static_definition(current_line) || is_accessor(current_line)) {
-                    should_parse = 1;
+            if (contains_end_kw(line)) {
+                if (parse_expr(rb_str_new2(line)) != NULL) {
+                    restore_ch(line, ch, last_ch_idx);
+                    rb_expr = rb_str_new2(expr_start);
+
+                    close_map(fd, map, filestat.st_size, data->filename);
+                    return rb_expr;
                 }
             }
+        }
 
-            if (is_dangling_literal_end(current_line)) {
-                dangling_literal = 0;
-            } else if (is_dangling_literal_begin(current_line)) {
-                dangling_literal = 1;
-            } else if (dangling_literal) {
-                continue;
-            }
+        if (line[0] == '\n' || is_comment(line, strlen(line))) {
+            line[last_ch_idx] = ch;
+            continue;
+        }
 
-            filter_interp(current_line);
-            future_parse_bufsize = strlen(parse_expression) + cl_len;
-            if (future_parse_bufsize >= parse_bufsize) {
-                parse_bufsize = future_parse_bufsize + EXPRESSION_SIZE + 1;
-                realloc_expression(&parse_expression, parse_bufsize);
+        if (inside_static_def) {
+            if (is_definition_end(line) &&
+                count_prefix_spaces(line) == prefix_len)
+            {
+                restore_ch(line, ch, last_ch_idx);
+                rb_expr = rb_str_new2(expr_start);
+
+                close_map(fd, map, filestat.st_size, data->filename);
+                return rb_expr;
+            } else {
+                line[last_ch_idx] = ch;
+                continue;
             }
-            strncat(parse_expression, current_line, cl_len);
+        } else {
+            should_parse = 1;
+        }
 
-            if (contains_skippables(current_line))
-                continue;
+        if (should_parse) {
+            line[last_ch_idx] = ch;
+            nulify_ch(line, &next_ch, last_ch_idx + 1);
 
-            if (should_parse || contains_end_kw(current_line)) {
-                if (parse_expr(rb_str_new2(parse_expression)) != NULL) {
-                    found_expression = 1;
-                    break;
-                }
-            }
-        } else if (finder.comment) {
-            if (line_count < data->method_location) {
-                if (is_comment(current_line, cl_len)) {
-                    future_bufsize = strlen(expression) + cl_len;
-                    if (future_bufsize >= bufsize) {
-                        bufsize = future_bufsize + EXPRESSION_SIZE + 1;
-                        realloc_expression(&expression, bufsize);
-                    }
-                    strncat(expression, current_line, cl_len);
-                } else {
-                    expression[0] = '\0';
-                    bufsize = EXPRESSION_SIZE;
-                }
-            } else if (line_count == data->method_location) {
-                found_expression = 1;
-                break;
+            if (parse_expr(rb_str_new2(expr_start)) != NULL) {
+                rb_expr = rb_str_new2(expr_start);
+                close_map(fd, map, filestat.st_size, data->filename);
+                return rb_expr;
+            } else {
+                line[last_ch_idx+1] = next_ch;
             }
         }
-    }
 
-    if (found_expression) {
-        rb_expr = rb_str_new2(expression);
-    } else {
-        rb_expr = Qnil;
+        line[last_ch_idx] = ch;
     }
+    close_map(fd, map, filestat.st_size, data->filename);
 
-    xfree(parse_expression);
-    xfree(expression);
-    free(current_line);
-    fclose(fp);
-    return (rb_expr);
+    return source;
 }
 
-static void
-realloc_expression(char **expression, size_t len)
+static VALUE
+read_lines(finder finder, struct method_data *data)
 {
-    char *tmp_comment = REALLOC_N(*expression, char, len);
-    *expression = tmp_comment;
+    if (finder.comment) {
+        return find_comment_expression(data);
+    } else if (finder.source) {
+        return find_source_expression(data);
+    }
+
+    return Qnil;
 }
 
 static NODE *
@@ -228,52 +325,59 @@ parse_expr(VALUE rb_str) {
 }
 
 static void
-filter_interp(char *line)
+restore_ch(char *line, char ch, int last_ch_idx)
 {
-    int brackets = 0;
+    line[last_ch_idx] = ch;
+    line[last_ch_idx + 1] = '\0';
+}
 
-    for (int i = 0; line[i] != '\0'; i++) {
-        if (line[i] == '#') {
-            if (line[i + 1] == '{') {
-                brackets++;
+static void
+close_map(int fd, char *map, size_t map_size, const char *filename)
+{
+    close(fd);
+    if (munmap(map, map_size) == -1) {
+        rb_raise(rb_eIOError, "munmap failed for %s", filename);
+    }
+}
 
-                line[i] = SAFE_CHAR;
+static void
+nulify_ch(char *line, char *ch, int last_ch_idx)
+{
+    *ch = line[last_ch_idx];
+    line[last_ch_idx] = '\0';
+}
 
-                if (line[i - 1] == '\\')
-                    line[i - 1] = SAFE_CHAR;
-            }
+static size_t
+count_prefix_spaces(const char *line)
+{
+    int i = 0;
+    size_t spaces = 0;
+
+    do {
+        if (line[i] == ' ') {
+            spaces++;
+        } else {
+            break;
         }
+    } while (line[i++] != '\n');
 
-        if (line[i] == '}') {
-            brackets--;
-
-            if (brackets == 0) {
-                line[i] = SAFE_CHAR;
-            }
-        } else if (brackets > 0) {
-            line[i] = SAFE_CHAR;
-        }
-    }
+    return spaces;
 }
 
 static int
-contains_skippables(const char *line)
+is_definition_end(const char *line)
 {
+    int i = 0;
 
-    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)
+    do {
+        if (line[i] == ' ') {
+            continue;
+        } else if (strncmp((line + i), "end", 3) == 0) {
             return 1;
-    }
+        } else {
+            return 0;
+        }
+    } while (line[i++] != '\0');
 
     return 0;
 }
@@ -292,20 +396,13 @@ contains_end_kw(const char *line)
     }
 }
 
-static int
-is_accessor(const char *line)
-{
-    return strstr(line, "attr_reader") != NULL ||
-        strstr(line, "attr_writer") != NULL ||
-        strstr(line, "attr_accessor") != NULL;
-}
-
 static int
 is_comment(const char *line, const size_t line_len)
 {
     for (size_t i = 0; i < line_len; i++) {
         if (line[i] == ' ')
             continue;
+
         return line[i] == '#' && line[i + 1] != '{';
     }
 
@@ -313,29 +410,36 @@ is_comment(const char *line, const size_t line_len)
 }
 
 static int
-is_static_definition(const char *line)
+is_static_definition_start(const char *line)
 {
-    return strstr(line, " def ") != NULL || strncmp(line, "def ", 4);
-}
+    int i = 0;
 
-static int
-is_dangling_literal_end(const char *line)
-{
-    return strstr(line, "}") != NULL && strstr(line, "{") == NULL;
-}
+    do {
+        if (line[i] == ' ') {
+            continue;
+        } else if (strncmp((line + i), "def ", 4) == 0) {
+            return 1;
+        } else if (strncmp((line + i), "class ", 6) == 0) {
+            return 1;
+        } else {
+            return 0;
+        }
+    } while (line[i++] != '\0');
 
-static int
-is_dangling_literal_begin(const char *line)
-{
-    return strstr(line, "%{") != NULL && strstr(line, "}") == NULL;
+    return 0;
 }
 
 static void
 raise_if_nil(VALUE val, VALUE method_name)
 {
     if (NIL_P(val)) {
-        rb_raise(rb_eSourceNotFoundError, "could not locate source for %s",
-                 RSTRING_PTR(rb_sym2str(method_name)));
+        if (SYMBOL_P(method_name)) {
+            rb_raise(rb_eSourceNotFoundError, "could not locate source for %s",
+                     RSTRING_PTR(rb_sym2str(method_name)));
+        } else {
+            rb_raise(rb_eSourceNotFoundError, "could not locate source for %s",
+                     RSTRING_PTR(method_name));
+        }
     }
 }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_method_source
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Kyrylo Silin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement