stringglob 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in stringglob.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new
+

data/lib/stringglob/version.rb

@@ -0,0 +1,3 @@
+module StringGlob
+  VERSION = "0.0.1"
+end

data/lib/stringglob.rb

@@ -0,0 +1,95 @@
+## Ruby StringGlob: Generate a Regexp object from a glob(3) pattern
+##       (Port Text::Glob 0.08 from Perl to Ruby)
+## Copyright (c) 2002, 2003, 2006, 2007 Richard Clamp.  All Rights Reserved.
+## Copyright (c) 2009-2011 SATOH Fumiyasu @ OSS Technology Inc.
+##               <http://www.osstech.co.jp/>
+##
+## License: This module is free software; you can redistribute it and/or
+##          modify it under the same terms as Ruby itself
+## Date: 2011-06-21, since 2009-07-15
+
+require "stringglob/version"
+
+module StringGlob
+  IGNORE_CASE =			1 << 0
+  NO_STRICT_LEADING_DOT = 	1 << 1
+  NO_STRICT_WILDCARD_SLASH =	1 << 2
+
+  def regexp(glob, opt = 0, code = nil)
+    re = regexp_string(glob, opt)
+    return Regexp.new("\\A#{re}\\z", nil, code)
+  end
+  module_function :regexp
+
+  def regexp_string(glob, opt = 0)
+    re_str = ''
+    in_curlies = 0
+    escaping = false
+    first_byte = true
+    asterisk = false
+    strict_leading_dot = (opt & NO_STRICT_LEADING_DOT == 0)
+    strict_wildcard_slash = (opt & NO_STRICT_WILDCARD_SLASH == 0)
+    glob.scan(/./m) do |glob_c|
+      if first_byte
+	if strict_leading_dot
+	  re_str += '(?=[^\.])' unless glob_c == '.'
+	end
+	first_byte = false
+      end
+      if asterisk && glob_c != '*'
+	re_str += strict_wildcard_slash ? '[^/]*' : '.*'
+	asterisk = false
+      end
+      if glob_c == '/'
+	first_byte = true
+      end
+      if (glob_c == '.' || glob_c == '(' || glob_c == ')' || glob_c == '|' ||
+	  glob_c == '+' || glob_c == '^' || glob_c == '$' || glob_c == '@' || glob_c == '%' )
+	re_str += '\\' + glob_c
+      elsif glob_c == '*'
+	if escaping
+	  re_str += '\\*'
+	elsif asterisk
+	  re_str += '.*'
+	  asterisk = false
+	else
+	  asterisk = true
+	end
+      elsif glob_c == '?'
+	re_str += escaping ? '\\?' :
+	  strict_wildcard_slash ? '[^/]' : '.'
+      elsif glob_c == '{'
+	re_str += escaping ? '\\{' : '('
+	in_curlies += 1 unless escaping
+      elsif glob_c == '}' && in_curlies > 0
+	re_str += escaping ? '}' : ')'
+	in_curlies -= 1 unless escaping
+      elsif glob_c == ',' && in_curlies > 0
+	re_str += escaping ? ',' : '|'
+      elsif glob_c == '\\'
+	if escaping
+	  re_str += '\\\\'
+	  escaping = false
+	else
+	  escaping = true
+	end
+	next
+      else
+	## Suppress warning: re_str has `}' without escape
+	re_str += '\\' if glob_c == '}'
+	re_str += glob_c
+	escaping = false
+      end
+      escaping = false
+    end
+    if asterisk
+      re_str += strict_wildcard_slash ? '[^/]*' : '.*'
+    end
+
+    re_str = "(?i:#{re_str})" if (opt & IGNORE_CASE != 0)
+
+    return re_str
+  end
+  module_function :regexp_string
+end
+

data/stringglob.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "stringglob/version"
+
+Gem::Specification.new do |s|
+  s.name        = "stringglob"
+  s.version     = StringGlob::VERSION
+  s.authors     = ["SATOH Fumiyasu"]
+  s.email       = ["fumiyas@osstech.co.jp"]
+  s.homepage    = ""
+  s.summary     = %q{Generate a Regexp object from a glob(3) pattern}
+  s.description = %q{Generate a Regexp object from a glob(3) pattern}
+
+  s.rubyforge_project = "stringglob"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/test_stringglob.rb

@@ -0,0 +1,114 @@
+require 'stringglob'
+require 'test/unit'
+
+SG = StringGlob
+
+class StringGlobTest < Test::Unit::TestCase
+  def test_all
+    regexp = SG.regexp('foo')
+    assert_not_nil regexp.match('foo')
+    assert_nil regexp.match('foobar')
+
+    ## absolute string
+    assert_not_nil	SG.regexp('foo').match('foo')
+    assert_nil		SG.regexp('foo').match('foobar')
+
+    ## * wildcard
+    assert_not_nil	SG.regexp('foo.*').match('foo.')
+    assert_not_nil	SG.regexp('foo.*').match('foo.bar')
+    assert_nil		SG.regexp('foo.*').match('gfoo.bar')
+
+    ## ? wildcard
+    assert_not_nil	SG.regexp('foo.?p').match('foo.cp')
+    assert_nil		SG.regexp('foo.?p').match('foo.cd')
+
+    ## .{alternation,or,something}
+    assert_not_nil	SG.regexp('foo.{c,h}').match('foo.h')
+    assert_not_nil	SG.regexp('foo.{c,h}').match('foo.c')
+    assert_nil		SG.regexp('foo.{c,h}').match('foo.o')
+
+    ## \escaping
+    assert_not_nil	SG.regexp('foo.\\{c,h}\\*').match('foo.{c,h}*')
+    assert_nil		SG.regexp('foo.\\{c,h}\\*').match('foo.\\c')
+
+    ## escape ()
+    assert_not_nil	SG.regexp('foo.(bar)').match('foo.(bar)')
+
+    ## strict . rule fail
+    assert_nil		SG.regexp('*.foo').match('.file.foo')
+    ## strict . rule match
+    assert_not_nil	SG.regexp('.*.foo').match('.file.foo')
+    ## relaxed . rule
+    assert_not_nil	SG.regexp('*.foo', SG::NO_STRICT_LEADING_DOT).match('.file.foo')
+
+    ## strict wildcard / fail
+    assert_nil		SG.regexp('*.fo?').match('foo/file.fob')
+    ## strict wildcard / match
+    assert_not_nil	SG.regexp('*/*.fo?').match('foo/file.fob')
+    ## relaxed wildcard /
+    assert_not_nil	SG.regexp('*.fo?', SG::NO_STRICT_WILDCARD_SLASH).match('foo/file.fob')
+
+    ## more strict wildcard / fail
+    assert_nil		SG.regexp('foo/*.foo').match('foo/.foo')
+    ## more strict wildcard / match
+    assert_not_nil	SG.regexp('foo/.f*').match('foo/.foo')
+    ## relaxed wildcard /
+    assert_not_nil	SG.regexp('*.foo', SG::NO_STRICT_WILDCARD_SLASH).match('foo/.foo')
+
+    ## properly escape +
+    assert_not_nil	SG.regexp('f+.foo').match('f+.foo')
+    assert_nil		SG.regexp('f+.foo').match('ffff.foo')
+
+    ## handle embedded \\n
+    assert_not_nil	SG.regexp("foo\nbar").match("foo\nbar")
+    assert_nil		SG.regexp("foo\nbar").match("foobar")
+
+    ## [abc]
+    assert_not_nil	SG.regexp('test[abc]').match('testa')
+    assert_not_nil	SG.regexp('test[abc]').match('testb')
+    assert_not_nil	SG.regexp('test[abc]').match('testc')
+    assert_nil		SG.regexp('test[abc]').match('testd')
+
+    ## escaping \$
+    assert_not_nil	SG.regexp('foo$bar.*').match('foo$bar.c')
+
+    ## escaping ^
+    assert_not_nil	SG.regexp('foo^bar.*').match('foo^bar.c')
+
+    ## escaping |
+    assert_not_nil	SG.regexp('foo|bar.*').match('foo|bar.c')
+
+
+    ## {foo,{bar,baz}}
+    assert_not_nil	SG.regexp('{foo,{bar,baz}}').match('foo')
+    assert_not_nil	SG.regexp('{foo,{bar,baz}}').match('bar')
+    assert_not_nil	SG.regexp('{foo,{bar,baz}}').match('baz')
+    assert_nil		SG.regexp('{foo,{bar,baz}}').match('foz')
+
+    ## @ character
+    assert_not_nil	SG.regexp('foo@bar').match('foo@bar')
+    ## $ character
+    assert_not_nil	SG.regexp('foo$bar').match('foo$bar')
+    ## % character
+    assert_not_nil	SG.regexp('foo%bar').match('foo%bar')
+
+    ## ** wildcard and path components
+    assert_not_nil	SG.regexp('foo/*/baz').match('foo/bar/baz')
+    assert_nil		SG.regexp('foo/*/baz').match('foo/bar/bar/baz')
+    assert_nil		SG.regexp('foo/**/baz').match('foo/baz')
+    assert_not_nil	SG.regexp('foo/**/baz').match('foo/bar/baz')
+    assert_not_nil	SG.regexp('foo/**/baz').match('foo/bar/bar/baz')
+    assert_nil		SG.regexp('foo/**').match('foo')
+    assert_not_nil	SG.regexp('foo/**').match('foo/bar')
+    assert_not_nil	SG.regexp('foo/**').match('foo/bar/baz')
+    assert_nil		SG.regexp('**/foo').match('foo')
+    assert_not_nil	SG.regexp('**/foo').match('bar/foo')
+    assert_not_nil	SG.regexp('**/foo').match('baz/bar/foo')
+    ## escaping ** wildcard
+    assert_nil		SG.regexp('foo/\\**/baz').match('foo/bar/baz')
+    assert_not_nil	SG.regexp('foo/\\**/baz').match('foo/*bar/baz')
+    assert_nil		SG.regexp('foo/*\\*/baz').match('foo/bar/baz')
+    assert_not_nil	SG.regexp('foo/*\\*/baz').match('foo/bar*/baz')
+  end
+end
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: stringglob
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- SATOH Fumiyasu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-26 00:00:00 Z
+dependencies: []
+
+description: Generate a Regexp object from a glob(3) pattern
+email: 
+- fumiyas@osstech.co.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/stringglob.rb
+- lib/stringglob/version.rb
+- stringglob.gemspec
+- test/test_stringglob.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: stringglob
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Generate a Regexp object from a glob(3) pattern
+test_files: 
+- test/test_stringglob.rb