regexbuilder 0.0.0

data/lib/regexbuilder.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), 'regexbuilder/**/*.rb')].sort.each { |lib| require lib }

data/lib/regexbuilder/regex_builder.rb

@@ -0,0 +1,114 @@
+module RegexpBuilder
+
+    def pattern(pattern)
+        return /#{pattern}/
+    end
+
+#    Anchors
+    def start_with(pattern)
+        "\\A" + pattern
+    end
+
+    def end_with(pattern)
+        pattern + "\\z"
+    end
+
+    def end_with_if_ignore_last_new_line(pattern)
+        pattern + "\\Z"
+    end
+
+    def line_start_with(pattern)
+        "^" + pattern
+    end
+
+    def line_end_with(pattern)
+        pattern + "$"
+    end
+
+    def word_boundary(pattern)
+        "\\b" + pattern
+    end
+
+    def nonword_boundary(pattern)
+        "\\B" + pattern
+    end
+
+
+#    Character classes
+    def either(pattern)
+        "[" + pattern + "]"
+    end
+
+    def neither(pattern)
+        "[^" + pattern + "]"
+    end
+
+    def digit
+        "\\d"
+    end
+
+    def non_digit
+        "\\D"
+    end
+
+    def space
+        "\\s"
+    end
+
+    def non_space
+        "\\S"
+    end
+
+    def word_char
+        "\\w"
+    end
+
+    def non_word_char
+        "\\W"
+    end
+
+    def any
+        "."
+    end
+
+    def literal(pattern)
+        Regexp.escape(pattern)
+    end
+
+
+#    repeat
+    def repeat_any_times(pattern, mode=:greedy)
+        pattern + (mode == :non_greedy ? "*?" : "*")
+    end
+
+    def repeat(pattern, least, most=-1, mode=:greedy)
+        return pattern + "{" + least.to_s + "}" if most == -1
+        return pattern + "{" + least.to_s + "," + most.to_s + "}" if mode == :greedy
+        return pattern + "{" + least.to_s + "," + most.to_s + "}?"
+    end
+
+    def at_least_once(pattern, mode=:greedy)
+        pattern + (mode == :non_greedy ? "+?" : "+")
+    end
+
+    def at_most_once(pattern)
+        pattern + "?"
+    end
+
+    def at_least(times, pattern)
+        pattern + "{" + times.to_s + ",}"
+    end
+
+
+#    Alternation
+    def one_of(*patterns)
+        "#{patterns.join '|' }"
+    end
+
+
+#    group
+    def group(pattern)
+        "(" + pattern + ")"
+    end
+    
+end

data/lib/regexbuilder/regex_util.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) +  '/regex_builder'
+
+class RegexUtil
+
+    class IP
+        include RegexpBuilder
+
+        def less_than_255
+            _0_to_100 = repeat(digit(), 1, 2)
+            _100_to_200 = "1" + repeat(digit(), 2)
+            _200_to_250 = "2" + either("0-4") + either("0-9")
+            _250_to_255 = "25" + either("0-4")
+            one_of(_0_to_100, _100_to_200, _200_to_250, _250_to_255)
+        end
+
+        def initialize
+            @ip_pattern = repeat(group(group(less_than_255()) + literal(".")), 3) + group(less_than_255())
+        end
+
+        attr_reader :ip_pattern
+
+    end
+
+
+    class Email
+        include RegexpBuilder
+
+        def before_at
+            at_least_once(word_boundary(either("a-z0-9.%+-")))
+        end
+
+        def after_at
+            at_least_once(either("a-z0-9.-")) + literal(".") + repeat(either("a-z"), 2, 4) + word_boundary("")
+        end
+
+        def initialize
+            @email_pattern = before_at() + "@" + after_at()
+        end
+
+        attr_reader :email_pattern
+
+    end
+
+    Email_Pattern = Regexp.new(Email.new.email_pattern, "i")
+    IP_Pattern = Regexp.new(IP.new.ip_pattern)
+
+end

data/tests/regex_builder_test.rb

@@ -0,0 +1,156 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/regexbuilder'
+
+class RegexpBuilderTest < Test::Unit::TestCase
+    include RegexpBuilder
+
+    def initialize(name)
+        super
+        @ruby = "ruby"
+    end
+
+    def test_ruby_start_with_r
+        assert_match(pattern(start_with("r")), @ruby)
+        assert_match(pattern(start_with("ru")), @ruby)
+        assert_match(pattern(start_with("rub")), @ruby)
+        assert_match(pattern(start_with(@ruby)), @ruby)
+        assert_no_match(pattern(start_with("u")), @ruby)
+    end
+
+    def test_ruby_end_with_y
+        assert_match(pattern(end_with("y")), @ruby)
+        assert_match(pattern(end_with("by")), @ruby)
+        assert_match(pattern(end_with("uby")), @ruby)
+        assert_match(pattern(end_with(@ruby)), @ruby)
+        assert_no_match(pattern(end_with("b")), @ruby)
+
+        assert_match(pattern(end_with("\n")), @ruby + "\n")
+        assert_match(pattern(end_with_if_ignore_last_new_line("y")), @ruby + "\n")
+    end
+
+    def test_line_begin
+        adidas = "impossible is\nnothing"
+        assert_match(pattern(line_start_with("impossible")), adidas);
+        assert_no_match(pattern(line_start_with("is")), adidas);
+        assert_match(pattern(line_start_with("nothing")), adidas);
+    end
+
+    def test_line_end
+        adidas = "impossible is\nnothing"
+        assert_no_match(pattern(line_end_with("impossible")), adidas)
+        assert_match(pattern(line_end_with("is")), adidas)
+        assert_match(pattern(line_end_with("nothing")), adidas)
+    end
+
+    def test_word_boundary
+        truth = "ruby is not python"
+        assert_match(pattern(word_boundary("is")), truth)
+        assert_match(pattern(word_boundary("not")), truth)
+        assert_no_match(pattern(word_boundary("by")), truth)
+    end
+
+    def test_nonword_boundary
+        truth = "ruby step by step"
+        assert_match(pattern(word_boundary("by")), truth)
+        assert_match(pattern(nonword_boundary("by")), truth)
+    end
+
+    def test_either
+        assert_match(pattern(either("abc")), "a")
+        assert_match(pattern(either("abc")), "b")
+        assert_match(pattern(either("abc")), "c")
+        assert_no_match(pattern(either("abc")), "A")
+    end
+
+    def test_neither
+        assert_match(pattern(neither("abc")), "1")
+        assert_match(pattern(neither("abc")), "d")
+        assert_match(pattern(neither("abc")), "A")
+        assert_no_match(pattern(neither("abc")), "abc")
+    end
+
+    def test_digit
+        assert_match(pattern(digit()), "2b")
+        assert_match(pattern(digit()), "F4")
+        assert_match(pattern(non_digit()), "PK")
+    end
+
+    def test_space
+        assert_match(pattern(space()), " ")
+        assert_match(pattern(space()), "\n")
+        assert_match(pattern(space()), "\r")
+        assert_match(pattern(space()), "\t")
+        assert_match(pattern(non_space()), "sentence_without_spaces")
+    end
+
+    def test_word_char
+        assert_match(pattern(word_char()), "_")
+        assert_match(pattern(word_char()), "123")
+        assert_match(pattern(word_char()), "haha")
+        assert_match(pattern(non_word_char()), "<>:;")
+    end
+
+    def test_any
+        assert_match(pattern(any()), "!@#%^&*")
+        assert_match(pattern(any()), "1234567890")
+        assert_match(pattern(any()), "abcABC")
+        assert_match(pattern(any()), " \r\t\b")
+        assert_no_match(pattern(any()), "\n")
+    end
+
+    def test_literal_should_escape_special_characters
+        assert_match(pattern(literal(".|()[]{}+\\^$*?")), ".|()[]{}+\\^$*?")
+    end
+
+    def test_repeat_any_times
+        assert_match(pattern(repeat_any_times(digit())), "abc")
+        assert_match(pattern(repeat_any_times(digit())), "1")
+        assert_match(pattern(repeat_any_times(digit())), "12")
+    end
+
+    def test_at_least_once
+        assert_no_match(pattern(at_least_once(digit())), "abc")
+        assert_match(pattern(at_least_once(digit())), "1")
+        assert_match(pattern(at_least_once(digit())), "12")
+    end
+
+    def test_at_most_once
+        assert_match(pattern(at_most_once(digit())), "abc")
+        assert_match(pattern(at_most_once(digit())), "1")
+    end
+
+    def test_repeat
+        assert_match(pattern(repeat(digit(), 3)), "123")
+        assert_no_match(pattern(repeat(digit(), 3)), "12abc")
+
+        assert_match(pattern(repeat(digit(), 3, 5)), "1234")
+        assert_no_match(pattern(repeat(digit(), 4, 5)), "12abc")
+    end
+
+    def test_at_least_m
+        assert_match(pattern(at_least(3, digit())), "123")
+        assert_match(pattern(at_least(3, digit())), "1234")
+        assert_no_match(pattern(at_least(3, digit())), "12abc")
+    end
+
+    def test_non_greedy
+        assert "123" =~ pattern(at_least_once(digit()))
+        assert_equal("123", $&)
+
+        assert "123" =~ pattern(at_least_once(digit(), :non_greedy))
+        assert_equal("1", $&)
+    end
+
+    def test_one_of
+        assert_match(pattern(one_of("ruby", "python")), "the ruby language")
+        assert_match(pattern(one_of("ruby", "python")), "the python language")
+    end
+
+    def test_group
+        assert "banana" =~ pattern(at_least_once("an"))
+        assert_equal("an", $&)
+
+        assert "banana" =~ pattern(at_least_once(group("an")))
+        assert_equal("anan", $&)
+    end
+end

data/tests/regex_util_test.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/regexbuilder'
+
+class RegexUtilTest < Test::Unit::TestCase
+
+    def test_192_168_0_3_is_a_valid_ip_address
+        assert "192.168.0.3".match(RegexUtil::IP_Pattern)
+    end
+
+    def test_500_312_0_3_is_not_a_valid_ip_address
+        assert_nil( "500.312.0.3".match(RegexUtil::IP_Pattern) )
+    end
+
+    def test_chelsea_at_gmail_dot_com_is_a_valid_email_address
+        assert "Chelsea@gmail.com".match(RegexUtil::Email_Pattern)
+    end
+
+    def test_www_dot_google_dot_com_is_not_a_valid_email_address
+        assert_nil( "www.google.com".match(RegexUtil::Email_Pattern) )
+    end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: regexbuilder
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+date: 2007-12-12 00:00:00 +08:00
+summary: An online Diary for families
+require_paths: 
+- lib
+email: chelsea@mail.csdn.net
+homepage: http://regexbuilder.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: regexbuilder
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Guanglei Li
+files: 
+- tests/regex_builder_test.rb
+- tests/regex_util_test.rb
+- lib/regexbuilder
+- lib/regexbuilder/regex_builder.rb
+- lib/regexbuilder/regex_util.rb
+- lib/regexbuilder.rb
+test_files: 
+- tests/regex_builder_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+