ferret 0.10.4 → 0.10.5

data/ext/r_analysis.c

@@ -569,7 +569,7 @@ static TokenStream *
 frt_get_cwrapped_rts(VALUE rts) 
 {
     TokenStream *ts;
-    if (rb_ivar_get(CLASS_OF(rts), id_cclass) == Qtrue) {
+    if (frt_is_cclass(rts) && DATA_PTR(rts)) {
         GET_TS(ts, rts);
         REF(ts);
     }
@@ -972,7 +972,7 @@ frt_stop_filter_init(int argc, VALUE *argv, VALUE self)
  *     StemFilter.new(token_stream) -> token_stream
  *     StemFilter.new(token_stream,
  *                    algorithm="english",
- *                    encoding=locale-specific) -> token_stream
+ *                    encoding="UTF-8") -> token_stream
  *
  *  Create an StemFilter which uses a snowball stemmer (thankyou Martin
  *  Porter) to stem words. You can optionally specify the algorithm (default:
@@ -1034,7 +1034,7 @@ static TokenStream *
 cwa_get_ts(Analyzer *a, char *field, char *text)
 {
     VALUE rts = rb_funcall(CWA(a)->ranalyzer, id_token_stream, 2,
-                           rb_str_new2(field), rb_str_new2(text));
+                           rb_intern(field), rb_str_new2(text));
     return frt_get_cwrapped_rts(rts);
 } 
 
@@ -1042,7 +1042,7 @@ Analyzer *
 frt_get_cwrapped_analyzer(VALUE ranalyzer)
 {
     Analyzer *a = NULL;
-    if (rb_ivar_get(CLASS_OF(ranalyzer), id_cclass) == Qtrue) {
+    if (frt_is_cclass(ranalyzer) && DATA_PTR(ranalyzer)) {
         Data_Get_Struct(ranalyzer, Analyzer, a);
         REF(a);
     }
@@ -1230,7 +1230,7 @@ frt_a_standard_analyzer_init(int argc, VALUE *argv, VALUE self)
     bool lower;
     VALUE rlower, rstop_words;
     Analyzer *a;
-    rb_scan_args(argc, argv, "02", &rlower, &rstop_words);
+    rb_scan_args(argc, argv, "02", &rstop_words, &rlower);
     lower = ((rlower == Qnil) ? true : RTEST(rlower));
     if (rstop_words != Qnil) {
         char **stop_words = get_stopwords(rstop_words);
@@ -1246,7 +1246,7 @@ frt_a_standard_analyzer_init(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *     StandardAnalyzer.new(lower = true, stop_words = ENGLISH_STOP_WORDS)
+ *     StandardAnalyzer.new(stop_words=ENGLISH_STOP_WORDS, lower=true)
  *     -> analyzer
  *
  *  Create a new StandardAnalyzer which downcases tokens by default but can
@@ -1330,7 +1330,7 @@ frt_per_field_analyzer_add_field(VALUE self, VALUE rfield, VALUE ranalyzer)
     Data_Get_Struct(self, Analyzer, pfa);
     a = frt_get_cwrapped_analyzer(ranalyzer);
 
-    pfa_add_field(pfa, StringValuePtr(rfield), a);
+    pfa_add_field(pfa, frt_field(rfield), a);
     return self;
 }
 
@@ -1483,7 +1483,8 @@ static void Init_Token(void)
  */
 static void Init_TokenStream(void)
 {
-    cTokenStream = frt_define_class_under(mAnalysis, "TokenStream", rb_cObject);
+    cTokenStream = rb_define_class_under(mAnalysis, "TokenStream", rb_cObject);
+    frt_mark_cclass(cTokenStream);
     rb_define_method(cTokenStream, "next", frt_ts_next, 0);
     rb_define_method(cTokenStream, "text=", frt_ts_set_text, 1);
     rb_define_method(cTokenStream, "text", frt_ts_get_text, 0);
@@ -1504,7 +1505,8 @@ static void Init_TokenStream(void)
 static void Init_AsciiLetterTokenizer(void)
 {
     cAsciiLetterTokenizer =
-        frt_define_class_under(mAnalysis, "AsciiLetterTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "AsciiLetterTokenizer", cTokenStream);
+    frt_mark_cclass(cAsciiLetterTokenizer);
     rb_define_alloc_func(cAsciiLetterTokenizer, frt_data_alloc);
     rb_define_method(cAsciiLetterTokenizer, "initialize",
                      frt_a_letter_tokenizer_init, 1);
@@ -1526,7 +1528,8 @@ static void Init_AsciiLetterTokenizer(void)
 static void Init_LetterTokenizer(void)
 {
     cLetterTokenizer =
-        frt_define_class_under(mAnalysis, "LetterTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "LetterTokenizer", cTokenStream);
+    frt_mark_cclass(cLetterTokenizer);
     rb_define_alloc_func(cLetterTokenizer, frt_data_alloc);
     rb_define_method(cLetterTokenizer, "initialize",
                      frt_letter_tokenizer_init, -1);
@@ -1546,8 +1549,9 @@ static void Init_LetterTokenizer(void)
 static void Init_AsciiWhiteSpaceTokenizer(void)
 {
     cAsciiWhiteSpaceTokenizer =
-        frt_define_class_under(mAnalysis, "AsciiWhiteSpaceTokenizer",
+        rb_define_class_under(mAnalysis, "AsciiWhiteSpaceTokenizer",
                               cTokenStream);
+    frt_mark_cclass(cAsciiWhiteSpaceTokenizer);
     rb_define_alloc_func(cAsciiWhiteSpaceTokenizer, frt_data_alloc);
     rb_define_method(cAsciiWhiteSpaceTokenizer, "initialize",
                      frt_a_whitespace_tokenizer_init, 1);
@@ -1567,7 +1571,8 @@ static void Init_AsciiWhiteSpaceTokenizer(void)
 static void Init_WhiteSpaceTokenizer(void)
 {
     cWhiteSpaceTokenizer =
-        frt_define_class_under(mAnalysis, "WhiteSpaceTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "WhiteSpaceTokenizer", cTokenStream);
+    frt_mark_cclass(cWhiteSpaceTokenizer);
     rb_define_alloc_func(cWhiteSpaceTokenizer, frt_data_alloc);
     rb_define_method(cWhiteSpaceTokenizer, "initialize",
                      frt_whitespace_tokenizer_init, -1);
@@ -1588,7 +1593,8 @@ static void Init_WhiteSpaceTokenizer(void)
 static void Init_AsciiStandardTokenizer(void)
 {
     cAsciiStandardTokenizer =
-        frt_define_class_under(mAnalysis, "AsciiStandardTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "AsciiStandardTokenizer", cTokenStream);
+    frt_mark_cclass(cAsciiStandardTokenizer);
     rb_define_alloc_func(cAsciiStandardTokenizer, frt_data_alloc);
     rb_define_method(cAsciiStandardTokenizer, "initialize",
                      frt_a_standard_tokenizer_init, 1);
@@ -1609,7 +1615,8 @@ static void Init_AsciiStandardTokenizer(void)
 static void Init_StandardTokenizer(void)
 {
     cStandardTokenizer =
-        frt_define_class_under(mAnalysis, "StandardTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "StandardTokenizer", cTokenStream);
+    frt_mark_cclass(cStandardTokenizer);
     rb_define_alloc_func(cStandardTokenizer, frt_data_alloc);
     rb_define_method(cStandardTokenizer, "initialize",
                      frt_standard_tokenizer_init, 1);
@@ -1636,7 +1643,8 @@ static void Init_StandardTokenizer(void)
 static void Init_RegExpTokenizer(void)
 {
     cRegExpTokenizer =
-        frt_define_class_under(mAnalysis, "RegExpTokenizer", cTokenStream);
+        rb_define_class_under(mAnalysis, "RegExpTokenizer", cTokenStream);
+    frt_mark_cclass(cRegExpTokenizer);
     rtoken_re = rb_reg_new(TOKEN_RE, strlen(TOKEN_RE), 0);
     rb_define_const(cRegExpTokenizer, "REGEXP", rtoken_re);
     rb_define_alloc_func(cRegExpTokenizer, frt_data_alloc);
@@ -1664,7 +1672,8 @@ static void Init_RegExpTokenizer(void)
 static void Init_AsciiLowerCaseFilter(void)
 {
     cAsciiLowerCaseFilter =
-        frt_define_class_under(mAnalysis, "AsciiLowerCaseFilter", cTokenStream);
+        rb_define_class_under(mAnalysis, "AsciiLowerCaseFilter", cTokenStream);
+    frt_mark_cclass(cAsciiLowerCaseFilter);
     rb_define_alloc_func(cAsciiLowerCaseFilter, frt_data_alloc);
     rb_define_method(cAsciiLowerCaseFilter, "initialize",
                      frt_a_lowercase_filter_init, 1);
@@ -1684,7 +1693,8 @@ static void Init_AsciiLowerCaseFilter(void)
 static void Init_LowerCaseFilter(void)
 {
     cLowerCaseFilter =
-        frt_define_class_under(mAnalysis, "LowerCaseFilter", cTokenStream);
+        rb_define_class_under(mAnalysis, "LowerCaseFilter", cTokenStream);
+    frt_mark_cclass(cLowerCaseFilter);
     rb_define_alloc_func(cLowerCaseFilter, frt_data_alloc);
     rb_define_method(cLowerCaseFilter, "initialize",
                      frt_lowercase_filter_init, 1);
@@ -1706,7 +1716,8 @@ static void Init_LowerCaseFilter(void)
 static void Init_HyphenFilter(void)
 {
     cHyphenFilter =
-        frt_define_class_under(mAnalysis, "HyphenFilter", cTokenStream);
+        rb_define_class_under(mAnalysis, "HyphenFilter", cTokenStream);
+    frt_mark_cclass(cHyphenFilter);
     rb_define_alloc_func(cHyphenFilter, frt_data_alloc);
     rb_define_method(cHyphenFilter, "initialize", frt_hyphen_filter_init, 1);
 }
@@ -1725,7 +1736,8 @@ static void Init_HyphenFilter(void)
 static void Init_StopFilter(void)
 {
     cStopFilter =
-        frt_define_class_under(mAnalysis, "StopFilter", cTokenStream);
+        rb_define_class_under(mAnalysis, "StopFilter", cTokenStream);
+    frt_mark_cclass(cStopFilter);
     rb_define_alloc_func(cStopFilter, frt_data_alloc);
     rb_define_method(cStopFilter, "initialize",
                      frt_stop_filter_init, -1);
@@ -1738,14 +1750,10 @@ static void Init_StopFilter(void)
  *
  *  A StemFilter takes a term and transforms the term as per the SnowBall
  *  stemming algorithm.  Note: the input to the stemming filter must already
- *  be in lower case, so you will need to use LowerCaseFilter or
- *  LowerCaseTokenizer further down the Tokenizer chain in order for this to
- *  work properly!
+ *  be in lower case, so you will need to use LowerCaseFilter or lowercasing
+ *  Tokenizer further down the Tokenizer chain in order for this to work
+ *  properly!
  *  
- *  To use this filter with other analyzers, you'll want to write an Analyzer
- *  class that sets up the TokenStream chain as you want it.  To use this with
- *  LowerCaseTokenizer, for example, you'd write an analyzer like this:
- *
  *  === Available algorithms and encodings
  *
  *    Algorithm       Algorithm Pseudonyms       Encoding
@@ -1766,6 +1774,10 @@ static void Init_StopFilter(void)
  *
  *  === Example
  *
+ *  To use this filter with other analyzers, you'll want to write an Analyzer
+ *  class that sets up the TokenStream chain as you want it.  To use this with
+ *  a lowercasing Tokenizer, for example, you'd write an analyzer like this:
+ *
  *    def MyAnalyzer < Analyzer
  *      def token_stream(field, str)
  *        return StemFilter.new(LowerCaseFilter.new(StandardTokenizer.new(str)))
@@ -1784,7 +1796,8 @@ static void Init_StopFilter(void)
 static void Init_StemFilter(void)
 {
     cStemFilter =
-        frt_define_class_under(mAnalysis, "StemFilter", cTokenStream);
+        rb_define_class_under(mAnalysis, "StemFilter", cTokenStream);
+    frt_mark_cclass(cStemFilter);
     rb_define_alloc_func(cStemFilter, frt_data_alloc);
     rb_define_method(cStemFilter, "initialize",
                      frt_stem_filter_init, -1);
@@ -1827,7 +1840,8 @@ static void Init_StemFilter(void)
 static void Init_Analyzer(void)
 {
     cAnalyzer =
-        frt_define_class_under(mAnalysis, "Analyzer", rb_cObject);
+        rb_define_class_under(mAnalysis, "Analyzer", rb_cObject);
+    frt_mark_cclass(cAnalyzer);
     rb_define_alloc_func(cAnalyzer, frt_data_alloc);
     rb_define_method(cAnalyzer, "initialize", frt_letter_analyzer_init, -1);
     rb_define_method(cAnalyzer, "token_stream", frt_analyzer_token_stream, 2);
@@ -1864,7 +1878,8 @@ static void Init_Analyzer(void)
 static void Init_AsciiLetterAnalyzer(void)
 {
     cAsciiLetterAnalyzer =
-        frt_define_class_under(mAnalysis, "AsciiLetterAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "AsciiLetterAnalyzer", cAnalyzer);
+    frt_mark_cclass(cAsciiLetterAnalyzer);
     rb_define_alloc_func(cAsciiLetterAnalyzer, frt_data_alloc);
     rb_define_method(cAsciiLetterAnalyzer, "initialize",
                      frt_a_letter_analyzer_init, -1);
@@ -1894,7 +1909,8 @@ static void Init_AsciiLetterAnalyzer(void)
 static void Init_LetterAnalyzer(void)
 {
     cLetterAnalyzer =
-        frt_define_class_under(mAnalysis, "LetterAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "LetterAnalyzer", cAnalyzer);
+    frt_mark_cclass(cLetterAnalyzer);
     rb_define_alloc_func(cLetterAnalyzer, frt_data_alloc);
     rb_define_method(cLetterAnalyzer, "initialize",
                      frt_letter_analyzer_init, -1);
@@ -1930,7 +1946,8 @@ static void Init_LetterAnalyzer(void)
 static void Init_AsciiWhiteSpaceAnalyzer(void)
 {
     cAsciiWhiteSpaceAnalyzer =
-        frt_define_class_under(mAnalysis, "AsciiWhiteSpaceAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "AsciiWhiteSpaceAnalyzer", cAnalyzer);
+    frt_mark_cclass(cAsciiWhiteSpaceAnalyzer);
     rb_define_alloc_func(cAsciiWhiteSpaceAnalyzer, frt_data_alloc);
     rb_define_method(cAsciiWhiteSpaceAnalyzer, "initialize",
                      frt_a_white_space_analyzer_init, -1);
@@ -1960,7 +1977,8 @@ static void Init_AsciiWhiteSpaceAnalyzer(void)
 static void Init_WhiteSpaceAnalyzer(void)
 {
     cWhiteSpaceAnalyzer =
-        frt_define_class_under(mAnalysis, "WhiteSpaceAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "WhiteSpaceAnalyzer", cAnalyzer);
+    frt_mark_cclass(cWhiteSpaceAnalyzer);
     rb_define_alloc_func(cWhiteSpaceAnalyzer, frt_data_alloc);
     rb_define_method(cWhiteSpaceAnalyzer, "initialize",
                      frt_white_space_analyzer_init, -1);
@@ -1975,18 +1993,16 @@ static void Init_WhiteSpaceAnalyzer(void)
  *  ascii-analyzers. If it were implemented in Ruby it would look like this;
  *
  *    class AsciiStandardAnalyzer
- *      def initialize(lower = true, stop_words = ENGLISH_STOP_WORDS)
+ *      def initialize(stop_words = ENGLISH_STOP_WORDS, lower = true)
  *        @lower = lower
  *        @stop_words = stop_words
  *      end
  *
  *      def token_stream(field, str)
- *        if @lower
- *          return StopFilter.new(AsciiLowerCaseFilter.new(
- *                           AsciiStandardTokenizer.new(str)), @stop_words)
- *        else
- *          return StopFilter.new(AsciiStandardTokenizer.new(str), @stop_words)
- *        end
+ *        ts = AsciiStandardTokenizer.new(str)
+ *        ts = AsciiLowerCaseFilter.new(ts) if @lower
+ *        ts = StopFilter.new(ts, @stop_words)
+ *        ts = HyphenFilter.new(ts)
  *      end
  *    end
  *
@@ -1998,7 +2014,8 @@ static void Init_WhiteSpaceAnalyzer(void)
 static void Init_AsciiStandardAnalyzer(void)
 {
     cAsciiStandardAnalyzer =
-        frt_define_class_under(mAnalysis, "AsciiStandardAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "AsciiStandardAnalyzer", cAnalyzer);
+    frt_mark_cclass(cAsciiStandardAnalyzer);
     rb_define_alloc_func(cAsciiStandardAnalyzer, frt_data_alloc);
     rb_define_method(cAsciiStandardAnalyzer, "initialize",
                      frt_a_standard_analyzer_init, -1);
@@ -2013,13 +2030,16 @@ static void Init_AsciiStandardAnalyzer(void)
  *  it were implemented in Ruby it would look like this;
  *
  *    class StandardAnalyzer
- *      def initialize(lower = true, stop_words = ENGLISH_STOP_WORDS)
+ *      def initialize(stop_words = ENGLISH_STOP_WORDS, lower = true)
  *        @lower = lower
  *        @stop_words = stop_words
  *      end
  *
  *      def token_stream(field, str)
- *        return StopFilter.new(StandardTokenizer.new(str, @lower), @stop_words)
+ *        ts = StandardTokenizer.new(str)
+ *        ts = LowerCaseFilter.new(ts) if @lower
+ *        ts = StopFilter.new(ts, @stop_words)
+ *        ts = HyphenFilter.new(ts)
  *      end
  *    end
  *
@@ -2029,7 +2049,8 @@ static void Init_AsciiStandardAnalyzer(void)
 static void Init_StandardAnalyzer(void)
 {
     cStandardAnalyzer =
-        frt_define_class_under(mAnalysis, "StandardAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "StandardAnalyzer", cAnalyzer);
+    frt_mark_cclass(cStandardAnalyzer);
     rb_define_alloc_func(cStandardAnalyzer, frt_data_alloc);
     rb_define_method(cStandardAnalyzer, "initialize",
                      frt_standard_analyzer_init, -1);
@@ -2058,7 +2079,8 @@ static void Init_StandardAnalyzer(void)
 static void Init_PerFieldAnalyzer(void)
 {
     cPerFieldAnalyzer =
-        frt_define_class_under(mAnalysis, "PerFieldAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "PerFieldAnalyzer", cAnalyzer);
+    frt_mark_cclass(cPerFieldAnalyzer);
     rb_define_alloc_func(cPerFieldAnalyzer, frt_data_alloc);
     rb_define_method(cPerFieldAnalyzer, "initialize",
                      frt_per_field_analyzer_init, 1);
@@ -2098,7 +2120,8 @@ static void Init_PerFieldAnalyzer(void)
 static void Init_RegExpAnalyzer(void)
 {
     cRegExpAnalyzer =
-        frt_define_class_under(mAnalysis, "RegExpAnalyzer", cAnalyzer);
+        rb_define_class_under(mAnalysis, "RegExpAnalyzer", cAnalyzer);
+    frt_mark_cclass(cRegExpAnalyzer);
     rb_define_alloc_func(cRegExpAnalyzer, frt_data_alloc);
     rb_define_method(cRegExpAnalyzer, "initialize",
                      frt_re_analyzer_init, -1);

data/ext/r_index.c

@@ -94,10 +94,12 @@ frt_fi_get_params(VALUE roptions,
     if (Qnil != v) Check_Type(v, T_SYMBOL);
     if (v == sym_no || v == sym_false || v == Qfalse) {
         *store = STORE_NO;
-    } else if (v == sym_yes || v == sym_true || v == Qtrue || v == Qnil) {
+    } else if (v == sym_yes || v == sym_true || v == Qtrue) {
         *store = STORE_YES;
     } else if (v == sym_compress || v == sym_compressed) {
         *store = STORE_COMPRESS;
+    } else if (v == Qnil) {
+        /* leave as default */
     } else {
         rb_raise(rb_eArgError, ":%s isn't a valid argument for :store."
                  " Please choose from [:yes, :no, :compressed]",
@@ -108,7 +110,7 @@ frt_fi_get_params(VALUE roptions,
     if (Qnil != v) Check_Type(v, T_SYMBOL);
     if (v == sym_no || v == sym_false || v == Qfalse) {
         *index = INDEX_NO;
-    } else if (v == sym_yes || v == sym_true || v == Qtrue || v == Qnil) {
+    } else if (v == sym_yes || v == sym_true || v == Qtrue) {
         *index = INDEX_YES;
     } else if (v == sym_untokenized) {
         *index = INDEX_UNTOKENIZED;
@@ -116,6 +118,8 @@ frt_fi_get_params(VALUE roptions,
         *index = INDEX_YES_OMIT_NORMS;
     } else if (v == sym_untokenized_omit_norms) {
         *index = INDEX_UNTOKENIZED_OMIT_NORMS;
+    } else if (v == Qnil) {
+        /* leave as default */
     } else {
         rb_raise(rb_eArgError, ":%s isn't a valid argument for :index."
                  " Please choose from [:no, :yes, :untokenized, "
@@ -133,8 +137,10 @@ frt_fi_get_params(VALUE roptions,
         *term_vector = TERM_VECTOR_WITH_POSITIONS;
     } else if (v == sym_with_offsets) {
         *term_vector = TERM_VECTOR_WITH_OFFSETS;
-    } else if (v == sym_with_positions_offsets || v == Qnil) {
+    } else if (v == sym_with_positions_offsets) {
         *term_vector = TERM_VECTOR_WITH_POSITIONS_OFFSETS;
+    } else if (v == Qnil) {
+        /* leave as default */
     } else {
         rb_raise(rb_eArgError, ":%s isn't a valid argument for "
                  ":term_vector. Please choose from [:no, :yes, "
@@ -507,9 +513,9 @@ frt_fis_add_field(int argc, VALUE *argv, VALUE self)
 {
     FieldInfos *fis = (FieldInfos *)DATA_PTR(self);
     FieldInfo *fi;
-    enum StoreValues store = STORE_YES;
-    enum IndexValues index = INDEX_YES;
-    enum TermVectorValues term_vector = TERM_VECTOR_WITH_POSITIONS_OFFSETS;
+    enum StoreValues store = fis->store;
+    enum IndexValues index = fis->index;
+    enum TermVectorValues term_vector = fis->term_vector;
     float boost = 1.0f;
     VALUE rname, roptions;
 
@@ -2134,6 +2140,21 @@ frt_ir_undelete_all(VALUE self)
     return self;
 }
 
+static VALUE
+frt_get_doc_range(IndexReader *ir, int pos, int len, int max)
+{
+    VALUE ary;
+    int i;
+    max = min2(max, pos+len);
+    len = max - pos;
+    ary = rb_ary_new2(len);
+    for (i = 0; i < len; i++) {
+        RARRAY(ary)->ptr[i] = frt_get_lazy_doc(ir->get_lazy_doc(ir, i + pos));
+    }
+    RARRAY(ary)->len = len;
+    return ary;
+}
+
 /*
  *  call-seq:
  *     index_reader.get_document(doc_id) -> LazyDoc
@@ -2144,10 +2165,43 @@ frt_ir_undelete_all(VALUE self)
  *  which are returned by the Searchers search methods.
  */
 static VALUE
-frt_ir_get_doc(VALUE self, VALUE rdoc_id)
+frt_ir_get_doc(int argc, VALUE *argv, VALUE self)
 {
     IndexReader *ir = (IndexReader *)DATA_PTR(self);
-    return frt_get_lazy_doc(ir->get_lazy_doc(ir, FIX2INT(rdoc_id)));
+    VALUE arg1, arg2;
+    long pos, len;
+    long max = ir->max_doc(ir);
+    rb_scan_args(argc, argv, "11", &arg1, &arg2);
+    if (argc == 1) {
+        if (FIXNUM_P(arg1)) {
+            pos = FIX2INT(arg1);
+            pos = (pos < 0) ? (max + pos) : pos;
+            if (pos < 0 || pos >= max) {
+                rb_raise(rb_eArgError, ":%d is out of range [%d..%d] for "
+                         "IndexWriter#[]", pos, 0, max,
+                         rb_id2name(SYM2ID(argv)));
+            }
+            return frt_get_lazy_doc(ir->get_lazy_doc(ir, pos));
+        }
+
+        /* check if idx is Range */
+        switch (rb_range_beg_len(arg1, &pos, &len, max, 0)) {
+            case Qfalse:
+                rb_raise(rb_eArgError, ":%s isn't a valid argument for "
+                         "IndexReader.get_document(index)",
+                         rb_id2name(SYM2ID(argv)));
+            case Qnil:
+                return Qnil;
+            default:
+                return frt_get_doc_range(ir, pos, len, max);
+        }
+    }
+    else {
+        pos = FIX2LONG(arg1);
+        len = FIX2LONG(arg2);
+        return frt_get_doc_range(ir, pos, len, max);
+    }
+    return Qnil;
 }
 
 /*
@@ -3043,8 +3097,8 @@ Init_IndexReader(void)
     rb_define_method(cIndexReader, "num_docs",      frt_ir_num_docs, 0);
     rb_define_method(cIndexReader, "undelete_all",  frt_ir_undelete_all, 0);
     rb_define_method(cIndexReader, "latest?",       frt_ir_is_latest, 0);
-    rb_define_method(cIndexReader, "get_document",  frt_ir_get_doc, 1);
-    rb_define_method(cIndexReader, "[]",            frt_ir_get_doc, 1);
+    rb_define_method(cIndexReader, "get_document",  frt_ir_get_doc, -1);
+    rb_define_method(cIndexReader, "[]",            frt_ir_get_doc, -1);
     rb_define_method(cIndexReader, "term_vector",   frt_ir_term_vector, 2);
     rb_define_method(cIndexReader, "term_vectors",  frt_ir_term_vectors, 1);
     rb_define_method(cIndexReader, "term_docs",     frt_ir_term_docs, 0);