match_skeleton 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ee807aa1f8e0b7050849503c16ac08f4ef6bc3f
+  data.tar.gz: 36b5a97d0a8e12c5d74924373d4d6accf3198987
+SHA512:
+  metadata.gz: 13d436fe8338c8ccd41b6a503b5daa033dab55e6bb66dfab71fb8211a59270acac9cf60b576ed455b36f413e23ad99bd26775ac6b6425b39997668181684c231
+  data.tar.gz: 66d95d123d62cc28348e681f987e94b664761e73c4ae8cacb578c848270fa17e9cc28c8b22876f71faa495d92191e79046ca2c8943e4d305a9eff028aceabb12

data/.gitignore

@@ -0,0 +1,10 @@
+*.[oa]
+*.so
+*~
+*.nogem
+*nogem.*
+*.bak
+*.BAK
+*.backup
+*.org
+*.orig

data/ChangeLog

@@ -0,0 +1,3 @@
+-----
+(Version: 0.1.0) 2016-05-19
+ * First creation.

data/News

@@ -0,0 +1,3 @@
+-----
+(Version: 0.1.0) 2016-05-19
+ * First creation.

data/README.ja.rdoc

@@ -0,0 +1,188 @@
+
+= MatchSkeleton - Equivalent to MatchData with less memory use
+
+This package provides the class {MatchSkeleton}.
+It behaves almost exactly like {MatchData}, except it uses a greatly
+less and practically negligible internal memory.
+
+The built-in {MatchData} class holds a copy of the original
+{String}, from which the matched data are derived, in a "freeze"
+state.  It is useful because no one can by chance destructively modify
+the original string.  However, if is memory-savvy.  Even if
+{MatchData} is the match of the first few characters of a 1-GB string,
+it internally holds the entire 1-GB of the original string.  If a code
+running holds 1000 of them, it needs a memory use of 1TB(!).
+
+This class holds the same information of the matched data as
+{MatchData} but as positional indices, and the original String object only.
+Therefore, as long as the original String is not destructively
+modified by an external process, any method of this class returns the
+equal result as {MatchData}.  Note that while the instance of this
+class is kept, the original string is not garbage-collected by the
+Ruby interpreter.
+
+One additional function this class offers is the instance variable and
+method <tt>pos_begin</tt>.  It can be set by a user and hold the
+information ({Integer}) at which position the {Regexp} match has started to
+generate the matched data.
+
+Note this library, when required, also modifies the operator {MatchData#==}
+so that it can be compared with {MatchSkeleton} objects.
+Now the operator is simply based on duck-typing of
+{#string}, {#regexp}, and {#pre_match}.
+{MatchData#eql?} is not affected, and therefore any comparison between
+{MatchData} and {MatchSkeleton} objects with {MatchData#eql?} or
+{MatchSkeleton#eql?} returns false.
+
+== Install
+
+The standard procedure to install a gem should work:
+  gem install match_skeleton
+Or, get it from
+{https://rubygems.org/gems/match_skeleton}
+
+Then just require as
+  require 'match_skeleton'
+
+Have fun!
+
+
+== Simple Examples
+
+Here are some simple examples.
+
+   require 'match_skeleton'
+
+   str = "Something_Big."
+   pos = 3
+   mtch = str.match(/(.)big/i, pos)
+   mskn = MatchSkeleton.new(mtch, str, pos_begin: pos)
+
+   mtch == mskn     # => true
+   mskn.string      # => "Something_Big."
+   mskn[1]          # => "_"
+   mskn.pos_begin   # => 3
+
+   mskn.post_match  # => "."
+   mtch.post_match  # => "."
+   str[-1,1] = '%'
+   mskn.post_match  # => "%"  # The original string has been destructively modified.  Do not do that...
+   mtch.post_match  # => "."
+   mtch == mskn     # => false
+
+== Known bugs
+
+* None.
+
+This library has been tested in Ruby 2.0 or later only.
+It may work in Ruby 1.8, but has not been tested.
+
+Extensive tests have been performed, as included in the package.
+
+== Acknowledgement
+
+This work is supported by {Wise Babel Ltd}[http://www.wisebabel.com/].  
+{http://www.wisebabel.com/}
+
+== Copyright etc
+
+Author::  Masa Sakano < imagine a_t sakano dot co dot uk >
+License:: MIT.
+Warranty:: No warranty whatsoever.
+Versions:: The versions of this package follow Semantic Versioning (2.0.0) http://semver.org/
+
+
+
+= MatchSkeleton - MatchDataに等価でメモリを節約するクラス
+
+クラス {MatchSkeleton} のGemです。
+{MatchData}とほぼ完全に等価な動作をします。ただし、メモリ使用量は
+比較してはるかに少なくなり、ほぼ無視できます。
+
+組込{MatchData}クラスは、正規表現マッチした元の文字列(String)のコピーを
+"freeze"した状態で保持します。おかげで、外部のプロセスが元文字列を
+破壊的に変更して{MatchData}のオブジェクトも影響を受ける、ということは
+ありません。しかし、それはメモリ使用量が巨大になり得ます。たとえば、
+{MatchData}オブジェクトが1GBの文字列の最初の数文字だけのマッチだったと
+しても、同オブジェクトは、その1GBの文字列を内部的に保持します。
+もし動作中のコードがそんなオブジェクトを1000個保持していたら、
+それだけで 1TB(!)のメモリを消費することになります。
+
+このクラスは、{MatchData}と同じ情報を保持しますが、それは内部的に、
+インデックスと(コピーではない)原文字列そのものだけです。したがって、
+原文字列が外部のプロセスで破壊的に変更されない限り、このクラスの
+メソッドの返り値は、{MatchData}と同じです。念のため、このクラスの
+インスタンスが生きている限り、原文字列がガーベージ・コレクトされる
+ことはありません。
+
+一点、このクラス独自のパラメーターとして、インスタンス変数かつ
+メソッドの<tt>pos_begin</tt>が導入されています。正規表現マッチの
+開始ポジション({Integer})を(ユーザーが設定することで)保持します。
+
+なお、このライブラリを require した時、演算子 {MatchData#==}
+が変更され、{MatchSkeleton} と比較できるようになります。
+結果、同演算子は、ダック・タイピングとして、
+{#string}, {#regexp}, および {#pre_match}に依存するようになります。
+一方、{MatchData#eql?} は影響を受けません。すなわち、
+{MatchData#eql?} あるいは {MatchSkeleton#eql?}によって、
+{MatchData} と {MatchSkeleton} オブジェクトを比較すると常に
+偽(false)を返します。
+
+
+== インストール
+
+gem を使ってインストールできます。
+  gem install match_skeleton
+もしくは以下から入手して下さい。  
+{https://rubygems.org/gems/match_skeleton}
+
+あとは、以下で一発です。
+  require 'match_skeleton'
+
+お楽しみあれ!
+
+
+== 単純な使用例
+
+以下に幾つかの基本的な使用例を列挙します。
+
+   require 'match_skeleton'
+
+   str = "Something_Big."
+   pos = 3
+   mtch = str.match(/(.)big/i, pos)
+   mskn = MatchSkeleton.new(mtch, str, pos_begin: pos)
+
+   mtch == mskn     # => true
+   mskn.string      # => "Something_Big."
+   mskn[1]          # => "_"
+   mskn.pos_begin   # => 3
+
+   mskn.post_match  # => "."
+   mtch.post_match  # => "."
+   str[-1,1] = '%'
+   mskn.post_match  # => "%"  # 元文字列が破壊的に変更された結果。そんなことはしないように……。
+   mtch.post_match  # => "."
+   mtch == mskn     # => false
+
+== 既知のバグ
+
+* なし。
+
+このライブラリは Ruby 2.0 以上でのみ挙動試験されています。
+1.8以前でも動くかもしれませんが、テストされていません。
+
+パッケージに含まれている通り、網羅的なテストが実行されています。
+
+== 謝辞
+
+この開発は、ワイズバベル社({Wise Babel Ltd}[http://www.wisebabel.com/en])に支援されています。  
+http://www.wisebabel.com/ja
+
+== 著作権他情報
+
+著者::  Masa Sakano < imagine a_t sakano dot co dot uk >
+利用許諾条項:: MIT.
+保証:: 一切無し。
+バージョン:: Semantic Versioning (2.0.0) http://semver.org/
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+desc "Run tests"
+task :default => :test
+

data/lib/match_skeleton/match_data.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+# =Class MatchData
+# 
+# Modifies the operator {#==} so it can be compared with {MatchSkeleton}.
+# 
+class MatchData
+
+  # Backup alias for {MatchData#==}
+  alias_method :equal_before_match_skeleton, :== if ! self.method_defined?(:equal_before_match_skeleton)
+
+  # Compares with {MatchSkeleton}, in addition to {MatchData}
+  #
+  # @param [#string, #regexp, #pre_match] All the methods have to be there. Practically, {MatchSkeleton} and {MatchData}
+  # @return [Boolean]
+  def ==(obj)
+    (string    == obj.string) &&
+    (regexp    == obj.regexp) &&
+    (pre_match == obj.pre_match)
+  end
+
+end

data/lib/match_skeleton.rb

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+
+require 'match_skeleton/match_data'
+
+# =Class MatchSkeleton
+# 
+# To represent {MatchData} with much less memory use
+# 
+class MatchSkeleton
+
+  # The same as {MatchData#string} but it is identical to the original string.
+  # If the original string is modified destructively, this too is modified.
+  attr_reader :string
+
+  # The same as {MatchData#regexp}.
+  attr_reader :regexp
+
+  # The position {Regexp} match has started.
+  # For example, both
+  #   /x/.match('0000x', 0)
+  #   /x/.match('0000x', 3)
+  # give the same (equal) {MatchData}.  This instance variable {#pos_begin}
+  # holds the position (0 or 3 in the cases above), if set explicitly.
+  attr_accessor :pos_begin
+
+
+  # @param md [MatchData]
+  # @param string [String] If not specified, it is taken from the first argument (however, that would spoil the whole point of using this class!)
+  # @param pos_begin: [Integer] The position {Regexp} match has started.
+  def initialize(md, string=nil, pos_begin: nil)
+    size_str = md.string.size
+    if string && string.size != size_str
+      raise ArgumentError, 'The first parameter is obligatory.'
+    end
+    @string = (string || md.string)
+    @regexp = md.regexp
+    @pre_match  = (0..(md.pre_match.size-1))	# {Range}
+    @post_match = ((size_str-md.post_match.size)..(size_str-1))	# {Range}
+
+    # @offsets is Hash with the keys of both Integer and possibly Symbol
+    # if names exist.
+    names  = md.names
+    ar_off = (0..(md.size-1)).map do |n|
+      ar = md.offset(n)
+#if names[0]=='foo'
+#print "DEBUG: ar=#{ar.inspect}\n"
+#printf "DEBUG: n=(%d)range=%s\n", n, (ar.first...ar.last).inspect
+#end
+      (ar.first...ar.last)
+    end
+    @offsets = {}
+    ar_off.each_with_index do |ev, ei|
+      @offsets[ei] = ev
+      ej = ei - 1
+      @offsets[names[ej]] = ev if (ej >= 0 && names[ej])
+#print "DEBUG: names=#{names[ei].inspect}\n"
+#p names[ei], ev
+#p md.offset(:foo)
+    end
+#printf "DEBUG: offsets=%s\n", @offsets.inspect if !names.empty?
+    
+
+    @pos_begin = pos_begin
+  end
+
+  # Comparable with {MatchSkeleton} and {MatchData}
+  #
+  # A difference in {#pos_begin} is not taken into account.
+  #
+  # @param [Object] The methods of {#string}, {#regexp}, {#pre_match} have to be defined and return the same to be true. Practically, only {MatchSkeleton} and {MatchData} may return true.
+  # @return [Boolean]
+  # @see #eql?
+  def ==(obj)
+    (string    == obj.string) &&
+    (regexp    == obj.regexp) &&
+    (pre_match == obj.pre_match)
+  end
+
+  # The same as {MatchData#[]}
+  #
+  # @param i [Integer, Range, Symbol, String]
+  # @param j [Integer, NilClass]
+  # @return [String, Array, NilClass]
+  # @raise [IndexError] if an invalid argument(s) is given.
+  def [](i, j=nil)
+    if j
+      to_a[i, j]
+    elsif defined?(i.to_sym)
+      values_at(i)[0]
+    else
+      to_a[i]
+    end
+  end
+
+  # The same as {MatchData#begin}
+  #
+  # @param n [Integer]
+  # @return [Integer]
+  def begin(n)
+    offset(n)[0]
+  end
+
+  # The same as {MatchData#captures}
+  #
+  # @return [Array]
+  def captures
+    to_a[1..-1]
+  end
+
+  # The same as {MatchData#end}
+  #
+  # @param n [Integer]
+  # @return [Integer]
+  def end(n)
+    offset(n)[1]
+  end
+
+  # The same as {#==} but stricter comparison.
+  #
+  # The comparison between {MatchSkeleton} and {MatchData} returns false and
+  # that between {MatchSkeleton} with different {#pos_begin} or
+  # those with strings of different Object-IDs also return false.
+  #
+  # @param [Object]
+  # @return [Boolean]
+  # @see #==
+  def eql?(obj)
+    return false if self != obj
+    return false if !defined?(obj.pos_begin)
+    return false if (string.object_id != obj.string.object_id)
+    return false if pos_begin != obj.pos_begin
+    return true
+  end
+
+  # Similar to {MatchData#inspect}
+  #
+  # @return [String]
+  def inspect
+    core = ''
+    ar = (names.empty? ? captures : names)
+    ar.each_with_index do |ev, ei|
+      core << sprintf(" %d:%s", ei, ev.inspect)
+    end
+    sprintf("#<%s %s%s>", self.class.to_s, self[0].inspect, core)
+  end
+
+  # The same as {MatchData#names} and {Regexp#names}
+  #
+  # @return [Array<String>]
+  def names
+    regexp.names
+  end
+
+  # The same as {MatchData#offset}
+  #
+  # @param n [Integer]
+  # @return [Array<integer>]
+  def offset(n)
+    if defined?(n.to_sym)
+      n = n.to_s 
+      raise IndexError, sprintf("undefined group name reference: %s", n) if !names.include?(n)
+    end
+    [@offsets[n].first, 
+     @offsets[n].last]
+  end
+
+  # The same as {MatchData#pre_match}
+  #
+  # @return [String]
+  def pre_match
+    @string[@pre_match]
+  end
+
+  # The same as {MatchData#post_match}
+  #
+  # @return [String]
+  def post_match
+    @string[@post_match]
+  end
+
+  # The same as {MatchData#size}
+  #
+  # @return [Integer]
+  def size
+    to_a.size
+  end
+  alias_method :length, :size if ! self.method_defined?(:length)
+
+  # The same as {MatchData#to_a}
+  #
+  # @return [Array]
+  def to_a
+#print 'DEBUG: '; p @offsets
+    indices = @offsets.keys.sort
+    indices.delete_if { |i| !defined?(i.divmod) }
+    indices.map { |i| string[@offsets[i]] }
+  end
+
+  # The same as {MatchData#to_s}
+  #
+  # @return [String]
+  def to_s
+    self[0]
+  end
+
+  # The same as {MatchData#values_at}
+  #
+  # @param *rest [Integer, Symbol, String]
+  # @return [Array]
+  def values_at(*rest)
+    rest.map do |i|
+      key = @offsets[i.to_s]
+#    printf "DEBUG(%s): offsets=%s string=%s i=%s key=%s r=%s\n", __method__, @offsets.inspect,string.inspect,i.inspect,key.inspect,(string[key].inspect rescue 'nil') if !names.empty?
+      raise IndexError, sprintf("undefined group name reference: %s", i) if !key
+      string[key]
+    end
+  end
+end

data/test/test_match_skeleton.rb

@@ -0,0 +1,353 @@
+# -*- encoding: utf-8 -*-
+
+$stdout.sync=true
+$stderr.sync=true
+# print '$LOAD_PATH=';p $LOAD_PATH
+
+arlibrelpath = []
+arlibdir  = %w(match_skeleton)
+arlibbase = ['']	# match_skeleton.rb is read.
+
+arlibbase.each do |elibbase|
+arlibdir.each do |elibdir|
+
+  arAllPaths = []
+  er=nil
+  pathnow = nil
+  # (['../lib/', 'lib/', ''].map{|i| i+elibbase+'/'} + ['']).each do |dir|
+  ['../lib', 'lib', ''].each do |dirroot|
+    begin
+      s = [dirroot, elibdir, elibbase].join('/').sub(%r@^/@, '').sub(%r@/$@, '')
+      # eg., %w(../lib/rangeary lib/rangeary rangeary)
+      next if s.empty?
+      arAllPaths.push(s)
+      require s
+      pathnow = s
+      break
+    rescue LoadError => er
+    end
+  end	# (['../lib/', 'lib/', ''].map{|i| i+elibbase+'/'} + '').each do |dir|
+
+  if pathnow.nil?
+    warn "Warning: All the attempts to load the following files have failed.  Abort..."
+    warn arAllPaths.inspect
+    warn " NOTE: It may be because a require statement in that file failed, 
+rather than requiring the file itself.
+ Check with  % ruby -r#{File.basename(elibbase)} -e p
+ or maybe add  env RUBYLIB=$RUBYLIB:`pwd`"
+    # p $LOADED_FEATURES.grep(/#{Regexp.quote(File.basename(elibbase)+'.rb')}$/)
+    raise er
+  else
+    arlibrelpath.push pathnow
+  end
+end	# arlibdir.each do |elibdir|
+end	# arlibbase.each do |elibbase|
+
+print "NOTE: Library relative paths: "; p arlibrelpath
+print "NOTE: Library full paths:\n"
+arlibbase.each do |elibbase|
+  fname = (elibbase.empty? ? arlibdir[0] : elibbase)	# Not complete.
+  p $LOADED_FEATURES.grep(/#{Regexp.quote(File.basename(fname)+'.rb')}$/)
+end
+
+
+#################################################
+# Unit Test
+#################################################
+
+require 'minitest/autorun'
+
+class TestMatchSkeleton < Minitest::Test
+  T = true
+  F = false
+  Inf = Float::INFINITY
+  BS ||= "\u005c"
+  BS_QUOTE ||= Regexp.quote(BS)
+
+  def setup
+    # @ib = 1
+  end
+
+  def teardown	# teardown is not often used.
+    # @foo = nil
+  end
+
+  # # User method
+  # def conjRE(r1, r2)
+  #   Escape_Character.class_eval{ conjunctionRangeExtd(r1, r2) }
+  # end
+
+  def test_readme_example01
+    str = "Something_Big."
+    pos = 3
+    mtch = str.match(/(.)big/i, pos)
+    mskn = MatchSkeleton.new(mtch, str, pos_begin: pos)
+
+    assert_equal true,  (mtch == mskn)
+    assert_equal "Something_Big.", mskn.string
+    assert_equal "_",   mskn[1]
+    assert_equal 3,     mskn.pos_begin
+
+    assert_equal ".",   mskn.post_match
+    assert_equal ".",   mtch.post_match
+    str[-1,1] = '%'
+    assert_equal '%',   mskn.post_match
+    assert_equal ".",   mtch.post_match
+    assert_equal false, (mtch == mskn)
+  end
+
+  def test_string01
+    # string(), regexp()
+    s = 'abcdefghij'
+    id = s.object_id
+    re = /./i
+    md = s.match(re)
+    ms1 = MatchSkeleton.new(md, s)
+
+    assert_equal s,  ms1.string
+    assert_equal id, ms1.string.object_id
+    assert_equal re, ms1.regexp
+  end
+
+  def test_pos_begin01
+    s = 'abcdefghij'
+    re = /g/i
+    pos = 3
+    md = s.match(re, pos)
+    ms1 = MatchSkeleton.new(md, s, pos_begin: pos)
+
+    assert_equal pos,  ms1.pos_begin
+    ms1.pos_begin = 5
+    assert_equal 5,    ms1.pos_begin
+  end
+
+  def test_equal01
+    s = 'abcdefghij'
+    re1 = /g/
+    pos = 3
+
+    md1 = s.match(re1, pos)
+    ms1 = MatchSkeleton.new(md1, s, pos_begin: pos)
+    assert_equal true,  (ms1 == md1)
+    assert_equal true,  (md1 == ms1)
+    assert_equal false, (ms1.eql?(md1))
+
+    # pos_begin does not count.
+    ms1p = ms1.dup
+    assert_equal ms1.string.object_id, ms1p.string.object_id
+    assert_equal true,  (ms1 == ms1p)
+    assert_equal true,  (ms1.eql?(ms1p))
+    ms1p.pos_begin = 6
+    assert_equal true,  (ms1 == ms1p)
+    assert_equal false, (ms1.eql?(ms1p))
+
+    # Different Object-ID
+    s2 = s.dup
+    md2 = s2.match(re1, pos)
+    ms21= MatchSkeleton.new(md2, s, pos_begin: pos)	# Equal but non-identical MatchData, but identical string s (with the identical Object-IDs)
+    assert_equal true,  (ms1 == ms21)
+    assert_equal true,  (ms1 == md2)
+    assert_equal true,  (md2 == ms1)
+    assert_equal true,  (ms21== md2)
+    assert_equal true,  (md2 == ms21)
+    assert_equal true,  (ms21.eql?(ms1))
+
+    ms2 = MatchSkeleton.new(md2, s2, pos_begin: pos)	# Equal MatchData, but non-identical string s (with the different Object-IDs)
+    assert_equal true,  (ms1 == ms2)
+    assert_equal true,  (ms1 == md2)
+    assert_equal true,  (ms2 == md2)
+    assert_equal true,  (md2 == ms2)
+    assert_equal false, (ms2.eql?(ms1))
+
+    # Slightly different Regexp
+    re3 = /g/i
+    md3 = s.match(re3, pos)
+    ms3 = MatchSkeleton.new(md3, s, pos_begin: pos)
+    assert_equal false, (ms3 == ms1)
+
+    # Different pre_match
+    re4 = /./
+    pos4 = 2
+    md4 = s.match(re4, pos4)
+    ms4 = MatchSkeleton.new(md4, s)
+    pos5 = 6
+    md5 = s.match(re4, pos5)
+    ms5 = MatchSkeleton.new(md5, s)
+    assert_equal false, (ms4 == ms5)
+  end
+
+  def test_squarebracket_single
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)	#=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1[0],   ms1[0]
+    assert_equal "HX1138", ms1[0]
+    assert_equal md1[1],   ms1[1]
+    assert_equal "H",      ms1[1]
+    assert_equal md1[3],   ms1[3]
+    assert_equal "113",    ms1[3]
+  end
+
+  def test_squarebracket_double
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)	#=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1[1,2],     ms1[1, 2]
+    assert_equal ["H", "X"],   ms1[1, 2]
+    assert_equal md1[-3, 2],   ms1[-3, 2]
+    assert_equal ["X", "113"], ms1[-3, 2]
+  end
+
+  def test_squarebracket_range
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)	#=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1[1..3],         ms1[1..3]
+    assert_equal ["H", "X", "113"], ms1[1..3]
+  end
+
+  def test_squarebracket_name
+    s = "ccaaab"
+    md1 = /(?<foo>a+)b/.match(s)	#=> #<MatchData "aaab" foo:"aaa">
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1["foo"], ms1["foo"]
+    assert_equal "aaa",      ms1["foo"]
+    assert_equal md1[:foo],  ms1[:foo]
+    assert_equal "aaa",      ms1[:foo]
+    assert_raises(IndexError) { md1.begin(:naiyo) }
+    assert_raises(IndexError) { ms1.begin(:naiyo) }
+  end
+
+  def test_begin_end_int01
+    s ="THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.begin(0), ms1.begin(0)
+    assert_equal md1.begin(2), ms1.begin(2)
+    assert_equal md1.end(0),   ms1.end(0)
+    assert_equal md1.end(2),   ms1.end(2)
+    assert_equal 1, ms1.begin(0)
+    assert_equal 2, ms1.begin(2)
+    assert_equal 7, ms1.end(0)
+    assert_equal 3, ms1.end(2)
+  end
+
+  def test_begin_end_int02
+    s ="hoge"
+    md1 = /(?<foo>.)(.)(?<bar>.)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.begin(:foo), ms1.begin(:foo)
+    assert_equal md1.begin(:bar), ms1.begin(:bar)
+    assert_equal md1.end(:bar),   ms1.end(:bar)
+    assert_equal md1.end(:foo),   ms1.end(:foo)
+    assert_equal 0, ms1.begin(:foo)
+    assert_equal 2, ms1.begin(:bar)
+    assert_equal 1, ms1.end(:foo)
+    assert_equal 3, ms1.end(:bar)
+    assert_raises(IndexError) { ms1.begin(:naiyo) }
+    assert_raises(IndexError) { ms1.end(:naiyo) }
+  end
+
+  def test_captures01
+    s ="THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.captures.size, ms1.captures.size
+    assert_equal md1.captures,      ms1.captures
+    assert_equal md1.captures[0],   ms1.captures[0]
+    assert_equal ms1.captures[3],   ms1.captures[3]
+    assert_equal 4,   ms1.captures.size
+    assert_equal ms1.to_a[1..-1], ms1.captures
+    assert_equal 'H', ms1.captures[0]
+    assert_equal '8', ms1.captures[3]
+  end
+
+  def test_inspect01
+    s ="foo"
+    md1 = /.$/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal '#<MatchSkeleton "o">', ms1.inspect
+  end
+
+  def test_names01
+    s = "hoge"
+    md1 = /(?<foo>.)(?<bar>.)(?<baz>.)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.names, ms1.names
+    assert_equal ["foo", "bar", "baz"], ms1.names
+
+    s = "a"
+    md1 = /(?<x>.)(?<y>.)?/.match(s)	#=> #<MatchData "a" x:"a" y:nil>
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.names,  ms1.names
+    assert_equal ["x", "y"], ms1.names
+  end
+
+  def test_offset_int01
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.offset(0), ms1.offset(0)
+    assert_equal md1.offset(4), ms1.offset(4)
+    assert_equal [1, 7], ms1.offset(0)
+    assert_equal [6, 7], ms1.offset(4)
+  end
+
+  def test_offset_name01
+    s = "hoge"
+    md1 = /(?<foo>.)(.)(?<bar>.)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.offset(:foo), ms1.offset(:foo)
+    assert_equal md1.offset(:bar), ms1.offset(:bar)
+    assert_equal [0, 1], ms1.offset(:foo)
+    assert_equal [2, 3], ms1.offset(:bar)
+    assert_raises(IndexError) { ms1.offset(:naiyo) }
+  end
+
+  def test_post_match01
+    s = "THX1138: The Movie"
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.post_match, ms1.post_match
+    assert_equal ": The Movie", ms1.post_match
+  end
+
+  def test_pre_match01
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.pre_match, ms1.pre_match
+    assert_equal "T", ms1.pre_match
+  end
+
+  def test_size01
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.size,   ms1.size
+    assert_equal md1.length, ms1.length
+    assert_equal 5, ms1.size
+    assert_equal 5, ms1.length
+  end
+
+  def test_to_a01
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.to_a, ms1.to_a
+    assert_equal ["HX1138", "H", "X", "113", "8"], ms1.to_a
+  end
+
+  def test_to_s01
+    s = "THX1138."
+    md1 = /(.)(.)(\d+)(\d)/.match(s)
+    ms1 = MatchSkeleton.new(md1, s)
+    assert_equal md1.to_s, ms1.to_s
+    assert_equal "HX1138", ms1.to_s
+    assert_equal ms1.to_a[0], ms1.to_s
+    assert_equal ms1[0], ms1.to_s
+  end
+
+end	# class TestMatchSkeleton < Minitest::Test
+
+

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: match_skeleton
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Masa Sakano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-19 00:00:00.000000000 Z
+dependencies: []
+description: MatchSkeleton is a class equivalent to MatchData with negligible memory
+  use.  As long as the original string is not destructively modified, it behaves almost
+  icentical to MatchData.
+email: info@wisebabel.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.ja.rdoc
+files:
+- ".gitignore"
+- ChangeLog
+- News
+- README.ja.rdoc
+- Rakefile
+- lib/match_skeleton.rb
+- lib/match_skeleton/match_data.rb
+- test/test_match_skeleton.rb
+homepage: https://www.wisebabel.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: MatchSkeleton - class equivalent to MatchData with negligible memory use
+test_files:
+- test/test_match_skeleton.rb
+has_rdoc: