mmapscanner 0.1a → 0.2

data/README.md

@@ -38,6 +38,8 @@ Usage
         # ファイルの先頭 4096 バイト以降の 1234 バイト分を mmap
         ms = MmapScanner.new(File.open("filename"), 4096, 1234)
 
+* MmapScanner.new は文字列も受け付けます。文字列が途中で変更された時の動作は不定です。
+
 * size, length は mmap(2) したサイズを返します。
 * to_s は mmap(2) した領域を String で返します。Encoding は常に ASCII-8BIT です。
 * slice は mmap(2) した領域の一部を新たな MmapScanner オブジェクトで返します。

data/ext/mmapscanner.c

@@ -6,11 +6,11 @@
 #include <ruby/io.h>
 
 static VALUE cMmapScanner;
+static VALUE cMmap;
 
 typedef struct {
     char *ptr;
     size_t size;
-    size_t pos;
 } mmap_data_t;
 
 static void mmap_free(mmap_data_t *data)
@@ -20,144 +20,148 @@ static void mmap_free(mmap_data_t *data)
     free(data);
 }
 
-static VALUE allocate(VALUE klass)
+static VALUE create_mmap_object(int fd, size_t offset, size_t size)
 {
-    VALUE obj;
     mmap_data_t *data;
-
+    void *ptr;
+    if ((ptr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, offset)) == MAP_FAILED) {
+        rb_exc_raise(rb_funcall(rb_eSystemCallError, rb_intern("new"), 1, INT2FIX(errno)));
+    }
     data = xmalloc(sizeof(mmap_data_t));
-    data->ptr = NULL;
-    data->size = 0;
-    data->pos = 0;
-    obj = Data_Wrap_Struct(klass, 0, mmap_free, data);
-    rb_iv_set(obj, "parent", Qnil);
-    return obj;
+    data->ptr = ptr;
+    data->size = size;
+    return Data_Wrap_Struct(cMmap, 0, mmap_free, data);
 }
 
 static VALUE initialize(int argc, VALUE *argv, VALUE obj)
 {
-    VALUE src, size, pos, p, pp;
-    int fd;
-    void *ptr;
-    mmap_data_t *data, *parent;
-    struct stat st;
-    size_t sz, offset;
-
-    Data_Get_Struct(obj, mmap_data_t, data);
-    if (data->ptr)
-        rb_raise(rb_eRuntimeError, "already initialized");
-    rb_scan_args(argc, argv, "12", &src, &pos, &size);
-    if (pos != Qnil && NUM2LL(pos) < 0)
-        rb_raise(rb_eRangeError, "position out of range: %lld", NUM2LL(pos));
-    if (size != Qnil && NUM2LL(size) < 0)
-        rb_raise(rb_eRangeError, "length out of range: %lld", NUM2LL(size));
-    offset = pos == Qnil ? 0 : NUM2SIZET(pos);
+    VALUE src, voffset, vsize;
+    size_t offset, size;
+    size_t src_offset, src_size;
+    VALUE src_data;
+
+    rb_scan_args(argc, argv, "12", &src, &voffset, &vsize);
+    if (voffset != Qnil && NUM2LL(voffset) < 0)
+        rb_raise(rb_eRangeError, "offset out of range: %lld", NUM2LL(voffset));
+    if (vsize != Qnil && NUM2LL(vsize) < 0)
+        rb_raise(rb_eRangeError, "length out of range: %lld", NUM2LL(vsize));
+    offset = voffset == Qnil ? 0 : NUM2SIZET(voffset);
     if (rb_obj_class(src) == cMmapScanner) {
-        Data_Get_Struct(src, mmap_data_t, parent);
-        if (offset >= parent->size)
-            rb_raise(rb_eRangeError, "length out of range: %zu >= %zu", offset, parent->size);
-        sz = size == Qnil ? parent->size - offset : NUM2SIZET(size);
-        ptr = parent->ptr + offset;
-        if (sz > parent->size - offset)
-            sz = parent->size-offset;
-        data->ptr = ptr;
-        data->size = sz;
-        p = src;
-        while ((pp = rb_iv_get(p, "parent")) != Qnil)
-            p = pp;
-        rb_iv_set(obj, "parent", p);
-        return;
+        src_offset = NUM2SIZET(rb_iv_get(src, "offset"));
+        src_size = NUM2SIZET(rb_iv_get(src, "size"));
+        src_data = rb_iv_get(src, "data");
+    } else if (TYPE(src) == T_FILE) {
+        int fd;
+        struct stat st;
+        fd = RFILE(src)->fptr->fd;
+        fstat(fd, &st);
+        src_offset = 0;
+        src_size = st.st_size;
+        size = vsize == Qnil ? src_size - offset : NUM2SIZET(vsize);
+        if (size > st.st_size - offset)
+            size = st.st_size - offset;
+        src_data = create_mmap_object(fd, offset, size);
+    } else if (TYPE(src) == T_STRING) {
+        src_offset = 0;
+        src_size = RSTRING_LEN(src);
+        src_data = src;
+    } else {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected File/String/MmapScanner)", rb_obj_classname(src));
     }
-    Check_Type(src, T_FILE);
-    fd = RFILE(src)->fptr->fd;
-    fstat(fd, &st);
-    sz = size == Qnil ? st.st_size - offset : NUM2SIZET(size);
-    if (sz > st.st_size - offset)
-        sz = st.st_size - offset;
-    if ((ptr = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, offset)) == MAP_FAILED) {
-        rb_exc_raise(rb_funcall(rb_eSystemCallError, rb_intern("new"), 1, INT2FIX(errno)));
-    }
-    data->ptr = ptr;
-    data->size = sz;
+    if (offset >= src_size)
+        rb_raise(rb_eRangeError, "length out of range: %zu >= %zu", offset, src_size);
+    size = vsize == Qnil ? src_size - offset : NUM2SIZET(vsize);
+    if (size > src_size - offset)
+        size = src_size - offset;
+    rb_iv_set(obj, "offset", SIZET2NUM(src_offset + offset));
+    rb_iv_set(obj, "size", SIZET2NUM(size));
+    rb_iv_set(obj, "data", src_data);
+    rb_iv_set(obj, "pos", INT2NUM(0));
+    return Qnil;
 }
 
 static VALUE size(VALUE obj)
 {
-    mmap_data_t *data;
-
-    Data_Get_Struct(obj, mmap_data_t, data);
-    return ULL2NUM(data->size);
+    return rb_iv_get(obj, "size");
 }
 
 static VALUE to_s(VALUE obj)
 {
-    mmap_data_t *data;
+    size_t offset = NUM2SIZET(rb_iv_get(obj, "offset"));
+    size_t size = NUM2SIZET(rb_iv_get(obj, "size"));
+    VALUE data = rb_iv_get(obj, "data");
+    mmap_data_t *mdata;
 
-    Data_Get_Struct(obj, mmap_data_t, data);
-    return rb_str_new(data->ptr, data->size);
+    if (TYPE(data) == T_STRING)
+        return rb_str_new(RSTRING_PTR(data)+offset, size);
+    Data_Get_Struct(data, mmap_data_t, mdata);
+    return rb_str_new(mdata->ptr+offset, size);
 }
 
 static VALUE slice(VALUE obj, VALUE pos, VALUE len)
 {
-    size_t offset;
-    size_t length;
-    mmap_data_t *data;
-
-    Data_Get_Struct(obj, mmap_data_t, data);
     return rb_funcall(cMmapScanner, rb_intern("new"), 3, obj, pos, len);
 }
 
 static VALUE inspect(VALUE obj)
 {
-    rb_str_new2("#<MmapScanner>");
+    return rb_str_new2("#<MmapScanner>");
 }
 
 static VALUE pos(VALUE obj)
 {
-    mmap_data_t *data;
-
-    Data_Get_Struct(obj, mmap_data_t, data);
-    return ULL2NUM(data->pos);
+    return rb_iv_get(obj, "pos");
 }
 
 static VALUE set_pos(VALUE obj, VALUE pos)
 {
-    mmap_data_t *data;
-    size_t p;
+    size_t p, size;
 
     if (NUM2LL(pos) < 0)
         rb_raise(rb_eRangeError, "out of range: %lld", NUM2LL(pos));
-    Data_Get_Struct(obj, mmap_data_t, data);
     p = NUM2SIZET(pos);
-    if (p > data->size)
-        rb_raise(rb_eRangeError, "out of range: %zu > %zu", p, data->size);
-    data->pos = p;
+    size = NUM2SIZET(rb_iv_get(obj, "size"));
+    if (p > size)
+        rb_raise(rb_eRangeError, "out of range: %zu > %zu", p, size);
+    rb_iv_set(obj, "pos", pos);
     return pos;
 }
 
 static VALUE scan_sub(VALUE obj, VALUE re, int forward)
 {
     regex_t *rb_reg_prepare_re(VALUE re, VALUE str);
-    mmap_data_t *data;
     regex_t *reg;
     int tmpreg;
     int result;
     struct re_registers regs;
     size_t old_pos, matched_len;
+    char *ptr;
+    size_t pos, size;
+    VALUE data;
+    mmap_data_t *mdata;
 
     Check_Type(re, T_REGEXP);
-    Data_Get_Struct(obj, mmap_data_t, data);
-    if (data->pos >= data->size)
+    pos = NUM2SIZET(rb_iv_get(obj, "pos"));
+    size = NUM2SIZET(rb_iv_get(obj, "size"));
+    if (pos >= size)
         return Qnil;
+    data = rb_iv_get(obj, "data");
+    if (TYPE(data) == T_STRING)
+        ptr = RSTRING_PTR(data);
+    else {
+        Data_Get_Struct(data, mmap_data_t, mdata);
+        ptr = mdata->ptr;
+    }
+    ptr += NUM2SIZET(rb_iv_get(obj, "offset"));
 
     reg = rb_reg_prepare_re(re, rb_str_new("", 0));
     tmpreg = reg != RREGEXP(re)->ptr;
     if (!tmpreg) RREGEXP(re)->usecnt++;
 
     onig_region_init(&regs);
-    result = onig_match(reg, (UChar* )(data->ptr+data->pos),
-                        (UChar* )(data->ptr+data->size),
-                        (UChar* )(data->ptr+data->pos),
+    result = onig_match(reg, (UChar* )(ptr+pos),
+                        (UChar* )(ptr+size),
+                        (UChar* )(ptr+pos),
                         &regs, ONIG_OPTION_NONE);
     if (!tmpreg) RREGEXP(re)->usecnt--;
     if (tmpreg) {
@@ -170,10 +174,12 @@ static VALUE scan_sub(VALUE obj, VALUE re, int forward)
     }
     if (result < 0)
         return Qnil;
-    old_pos = data->pos;
+    old_pos = pos;
     matched_len = regs.end[0];
-    if (forward)
-        data->pos += matched_len;
+    if (forward) {
+        pos += matched_len;
+        rb_iv_set(obj, "pos", SIZET2NUM(pos));
+    }
     return rb_funcall(cMmapScanner, rb_intern("new"), 3, obj, ULL2NUM(old_pos), ULL2NUM(matched_len));
 }
 
@@ -189,52 +195,45 @@ static VALUE check(VALUE obj, VALUE re)
 
 static VALUE skip(VALUE obj, VALUE re)
 {
-    mmap_data_t *data;
     VALUE ret = scan_sub(obj, re, 1);
     if (ret == Qnil)
         return ret;
-    Data_Get_Struct(ret, mmap_data_t, data);
-    return ULL2NUM(data->size);
+    return rb_iv_get(ret, "size");
 }
 
 static VALUE match_p(VALUE obj, VALUE re)
 {
-    mmap_data_t *data;
     VALUE ret = scan_sub(obj, re, 0);
     if (ret == Qnil)
         return ret;
-    Data_Get_Struct(ret, mmap_data_t, data);
-    return ULL2NUM(data->size);
+    return rb_iv_get(ret, "size");
 }
 
 static VALUE peek(VALUE obj, VALUE size)
 {
     size_t sz = NUM2SIZET(size);
-    mmap_data_t *data;
-    Data_Get_Struct(obj, mmap_data_t, data);
-    if (sz > data->size - data->pos)
-        sz = data->size - data->pos;
-    return rb_funcall(cMmapScanner, rb_intern("new"), 3, obj, SIZET2NUM(data->pos), SIZET2NUM(sz));
+    size_t data_pos = NUM2SIZET(rb_iv_get(obj, "pos"));
+    size_t data_size = NUM2SIZET(rb_iv_get(obj, "size"));
+    if (sz > data_size - data_pos)
+        sz = data_size - data_pos;
+    return rb_funcall(cMmapScanner, rb_intern("new"), 3, obj, SIZET2NUM(data_pos), SIZET2NUM(sz));
 }
 
 static VALUE eos_p(VALUE obj)
 {
-    mmap_data_t *data;
-    Data_Get_Struct(obj, mmap_data_t, data);
-    return data->pos >= data->size ? Qtrue : Qfalse;
+    size_t data_pos = NUM2SIZET(rb_iv_get(obj, "pos"));
+    size_t data_size = NUM2SIZET(rb_iv_get(obj, "size"));
+    return data_pos >= data_size ? Qtrue : Qfalse;
 }
 
 static VALUE rest(VALUE obj)
 {
-    mmap_data_t *data;
-    Data_Get_Struct(obj, mmap_data_t, data);
-    return rb_funcall(cMmapScanner, rb_intern("new"), 2, obj, SIZET2NUM(data->pos));
+    return rb_funcall(cMmapScanner, rb_intern("new"), 2, obj, rb_iv_get(obj, "pos"));
 }
 
 void Init_mmapscanner(void)
 {
     cMmapScanner = rb_define_class("MmapScanner", rb_cObject);
-    rb_define_alloc_func(cMmapScanner, allocate);
     rb_define_method(cMmapScanner, "initialize", initialize, -1);
     rb_define_method(cMmapScanner, "size", size, 0);
     rb_define_method(cMmapScanner, "length", size, 0);
@@ -251,4 +250,6 @@ void Init_mmapscanner(void)
     rb_define_method(cMmapScanner, "peek", peek, 1);
     rb_define_method(cMmapScanner, "eos?", eos_p, 0);
     rb_define_method(cMmapScanner, "rest", rest, 0);
+
+    cMmap = rb_define_class_under(cMmapScanner, "Mmap", rb_cObject);
 }

data/spec/mmapscanner_spec.rb

@@ -4,138 +4,164 @@ $LOAD_PATH.unshift "#{File.dirname __FILE__}/../ext"
 require 'mmapscanner'
 
 describe MmapScanner do
-  before do
-    tmpf = Tempfile.new 'mmapscanner'
-    tmpf.write '0123456789'*1000
-    @file = File.open(tmpf.path)
-  end
-  subject{MmapScanner.new(@file)}
-  it '#size returns size of file' do
-    subject.size.should == 10000
-  end
-  it '#to_s returns contents of file' do
-    subject.to_s.should == '0123456789'*1000
-  end
-  describe '#slice' do
-    it 'returns MmapScanner' do
-      subject.slice(10, 100).should be_instance_of MmapScanner
-    end
-  end
-  it '#inspect returns "#<MmapScanner>"' do
-    subject.inspect.should == '#<MmapScanner>'
-  end
-  it '#pos returns current position' do
-    subject.pos.should == 0
-    subject.scan(/.../)
-    subject.pos.should == 3
-  end
-  describe '#pos=' do
-    it 'change current position' do
-      subject.pos = 100
-      subject.pos.should == 100
-    end
-    it 'raise error when negative value' do
-      expect{subject.pos = -1}.to raise_error(RangeError, 'out of range: -1')
-    end
-    it 'raise error when over size' do
-      expect{subject.pos = 10001}.to raise_error(RangeError, 'out of range: 10001 > 10000')
-      expect{subject.pos = 20000}.to raise_error(RangeError, 'out of range: 20000 > 10000')
+  shared_examples_for 'MmapScanner' do
+    it '#size returns size of file' do
+      subject.size.should == 10000
     end
-  end
-  describe '#scan' do
-    it 'returns matched data as MmapScanner' do
-      ret = subject.scan(/\d{10}/)
-      ret.class.should == MmapScanner
-      ret.to_s.should == '0123456789'
-    end
-    it 'returns nil if not matched' do
-      subject.scan(/123/).should be_nil
+    it '#to_s returns contents of file' do
+      subject.to_s.should == '0123456789'*1000
     end
-    it 'forward current position' do
-      subject.scan(/\d{10}/)
-      subject.pos.should == 10
+    describe '#slice' do
+      it 'returns MmapScanner' do
+        subject.slice(10, 100).should be_instance_of MmapScanner
+      end
     end
-  end
-  describe '#check' do
-    it 'returns matched data as MmapScanner' do
-      ret = subject.check(/\d{10}/)
-      ret.class.should == MmapScanner
-      ret.to_s.should == '0123456789'
+    it '#inspect returns "#<MmapScanner>"' do
+      subject.inspect.should == '#<MmapScanner>'
     end
-    it 'returns nil if not matched' do
-      subject.check(/123/).should be_nil
-    end
-    it 'do not forward current position' do
-      ret = subject.check(/\d{10}/)
+    it '#pos returns current position' do
       subject.pos.should == 0
+      subject.scan(/.../)
+      subject.pos.should == 3
+    end
+    describe '#pos=' do
+      it 'change current position' do
+        subject.pos = 100
+        subject.pos.should == 100
+      end
+      it 'raise error when negative value' do
+        expect{subject.pos = -1}.to raise_error(RangeError, 'out of range: -1')
+      end
+      it 'raise error when over size' do
+        expect{subject.pos = 10001}.to raise_error(RangeError, 'out of range: 10001 > 10000')
+        expect{subject.pos = 20000}.to raise_error(RangeError, 'out of range: 20000 > 10000')
+      end
+    end
+    describe '#scan' do
+      it 'returns matched data as MmapScanner' do
+        ret = subject.scan(/\d{10}/)
+        ret.class.should == MmapScanner
+        ret.to_s.should == '0123456789'
+      end
+      it 'returns nil if not matched' do
+        subject.scan(/123/).should be_nil
+      end
+      it 'forward current position' do
+        subject.scan(/\d{10}/)
+        subject.pos.should == 10
+      end
+    end
+    describe '#check' do
+      it 'returns matched data as MmapScanner' do
+        ret = subject.check(/\d{10}/)
+        ret.class.should == MmapScanner
+        ret.to_s.should == '0123456789'
+      end
+      it 'returns nil if not matched' do
+        subject.check(/123/).should be_nil
+      end
+      it 'do not forward current position' do
+        ret = subject.check(/\d{10}/)
+        subject.pos.should == 0
+      end
+    end
+    describe '#skip' do
+      it 'returns length of matched data' do
+        subject.skip(/\d{10}/).should == 10
+      end
+      it 'returns nil if not matched' do
+        subject.skip(/123/).should be_nil
+      end
+      it 'forward current position' do
+        subject.skip(/\d{10}/)
+        subject.pos.should == 10
+      end
+    end
+    describe '#match?' do
+      it 'returns length of matched data' do
+        subject.match?(/\d{10}/).should == 10
+      end
+      it 'returns nil if not matched' do
+        subject.match?(/123/).should be_nil
+      end
+      it 'do not forward current position' do
+        subject.match?(/\d{10}/)
+        subject.pos.should == 0
+      end
+    end
+    describe '#peek' do
+      it 'returns MmapScanner' do
+        subject.peek(10).should be_instance_of MmapScanner
+      end
+      it 'do not forward current position' do
+        subject.peek(10)
+        subject.pos.should == 0
+      end
+    end
+    describe '#eos?' do
+      it 'returns true if eos' do
+        subject.pos = 10000
+        subject.eos?.should == true
+      end
+      it 'returns false if not eos' do
+        subject.pos = 9999
+        subject.eos?.should == false
+      end
+    end
+    describe '#rest' do
+      it 'returns rest data as MmapScanner' do
+        subject.pos = 9997
+        ret = subject.rest
+        ret.should be_instance_of MmapScanner
+        ret.to_s.should == '789'
+      end
+    end
+    describe '.new with position' do
+      it '#size is length of rest data' do
+        MmapScanner.new(src, 4096).size.should == src.size-4096
+      end
+    end
+    describe '.new with length' do
+      subject{MmapScanner.new(src, nil, 10)}
+      it '#size is specified size' do
+        subject.size.should == 10
+      end
+      it 'raise error when negative' do
+        expect{MmapScanner.new(src, nil, -1)}.to raise_error(RangeError, 'length out of range: -1')
+      end
     end
   end
-  describe '#skip' do
-    it 'returns length of matched data' do
-      subject.skip(/\d{10}/).should == 10
-    end
-    it 'returns nil if not matched' do
-      subject.skip(/123/).should be_nil
-    end
-    it 'forward current position' do
-      subject.skip(/\d{10}/)
-      subject.pos.should == 10
-    end
-  end
-  describe '#match?' do
-    it 'returns length of matched data' do
-      subject.match?(/\d{10}/).should == 10
-    end
-    it 'returns nil if not matched' do
-      subject.match?(/123/).should be_nil
-    end
-    it 'do not forward current position' do
-      subject.match?(/\d{10}/)
-      subject.pos.should == 0
-    end
-  end
-  describe '#peek' do
-    it 'returns MmapScanner' do
-      subject.peek(10).should be_instance_of MmapScanner
-    end
-    it 'do not forward current position' do
-      subject.peek(10)
-      subject.pos.should == 0
-    end
-  end
-  describe '#eos?' do
-    it 'returns true if eos' do
-      subject.pos = 10000
-      subject.eos?.should == true
-    end
-    it 'returns false if not eos' do
-      subject.pos = 9999
-      subject.eos?.should == false
+
+  context 'with File' do
+    before do
+      tmpf = Tempfile.new 'mmapscanner'
+      tmpf.write '0123456789'*1000
+      @file = File.open(tmpf.path)
     end
-  end
-  describe '#rest' do
-    it 'returns rest data as MmapScanner' do
-      subject.pos = 9997
-      ret = subject.rest
-      ret.should be_instance_of MmapScanner
-      ret.to_s.should == '789'
+    let(:src){@file}
+    subject{MmapScanner.new(src)}
+    it_should_behave_like 'MmapScanner'
+    describe '.new with position' do
+      it 'raise error when invalid position' do
+        expect{MmapScanner.new(@file, 4095)}.to raise_error(Errno::EINVAL)
+      end
     end
   end
-  describe '.new with position' do
-    it '#size is length of rest data' do
-      MmapScanner.new(@file, 4096).size.should == 10000-4096
-    end
-    it 'raise error when invalid position' do
-      expect{MmapScanner.new(@file, 4095)}.to raise_error(Errno::EINVAL)
-    end
+
+  context 'with String' do
+    let(:src){'0123456789'*1020}
+    subject{MmapScanner.new(src, 100, 10000)}
+    it_should_behave_like 'MmapScanner'
   end
-  describe '.new with length' do
-    subject{MmapScanner.new(@file, nil, 10)}
-    it '#size is specified size' do
-      subject.size.should == 10
-    end
-    it 'raise error when negative' do
-      expect{MmapScanner.new(@file, nil, -1)}.to raise_error(RangeError, 'length out of range: -1')
-    end
+
+  context 'with MmapScanner' do
+    before do
+      tmpf = Tempfile.new 'mmapscanner'
+      tmpf.write '0123456789'*1020
+      @file = File.open(tmpf.path)
+    end
+    let(:src){MmapScanner.new(@file)}
+    subject{MmapScanner.new(src, 100, 10000)}
+    it_should_behave_like 'MmapScanner'
   end
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: mmapscanner
 version: !ruby/object:Gem::Version 
-  prerelease: 3
-  version: 0.1a
+  prerelease: 
+  version: "0.2"
 platform: ruby
 authors: 
 - TOMITA Masahiro
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-05 00:00:00 +09:00
+date: 2011-03-02 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -45,9 +45,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.3.1
+      version: "0"
 requirements: []
 
 rubyforge_project: