randomexp 0.1.7

data/spec/regression/regexp_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "#{'*' * 80}\nRegression Specs:" do
+  it "/abcd/                          => 'abcd'" do
+    100.times do
+      /abcd/.gen.should == 'abcd'
+    end
+  end
+
+  it "/(abcd)|(defg)/                 => ['abcd', 'defg']" do
+    100.times do
+      ['abcd', 'defg'].should include(/(abcd)|(defg)/.gen)
+    end
+  end
+
+  it "/(abcd)|(defg)|(hijk)/          => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/(abcd)|(defg)|(hijk)/.gen)
+    end
+  end
+
+  it "/((abcd)|(defg))|(hijk)/        => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/((abcd)|(defg))|(hijk)/.gen)
+    end
+  end
+
+  it "/(abcd)|((defg)|(hijk))/        => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/(abcd)|((defg)|(hijk))/.gen)
+    end
+  end
+
+  it "/(abc)def(ghi)/                 => 'abcdefghi'" do
+    100.times do
+      /(abc)def(ghi)/.gen.should == 'abcdefghi'
+    end
+  end
+
+  it "/(((abc)))/                     => 'abc'" do
+    100.times do
+      /(((abc)))/.gen.should == 'abc'
+    end
+  end
+
+  it "/ab(c(def))/                    => 'abcdef'" do
+    100.times do
+      /ab(c(def))/.gen.should == 'abcdef'
+    end
+  end
+
+  it "/(\\w+)/                         => /\\w+/" do
+    100.times do
+      /(\w+)/.gen.should =~ /\w+/
+    end
+  end
+
+  it "/\\w+ \\w+/                       => /\\w+\\s\\w+/" do
+    100.times do
+      /\w+ \w+/.gen.should =~ /\w+\s\w+/
+    end
+  end
+
+  it "/\\w*/                           => /(\\w+)|/" do
+    100.times do
+      /\w*/.gen.should =~ /(\w+)|/
+    end
+  end
+
+  it "/\\w{2,5}/                       => /\\w{2,5}/" do
+    100.times do
+      /\w{2,5}/.gen.should =~ /\w{2,5}/
+    end
+  end
+
+  it "/\\w{1}/                         => /\\w/" do
+    100.times do
+      /\w{1}/.gen.should =~ /\w/
+    end
+  end
+
+  it "/\\w{4}/                         => /\\w{4}/" do
+    100.times do
+      /\w{4}/.gen.should =~ /\w{4}/
+    end
+  end
+
+  it "/[:word:]/                      => /\\w+/" do
+    100.times do
+      /[:word:]/.gen.should =~ /\w+/
+    end
+  end
+
+  it "/[:bool:]/                      => /true|false/" do
+    /[:bool:]/.gen.should =~ /true|false/
+  end
+
+  it "/[:sentence:]/                  => /(\w+ )*/" do
+    100.times do
+      /[:sentence:]/.gen.should =~ /(\w+ )*/
+    end
+  end
+
+  it "/[:paragraph:]/                 => /(  (\w+ )*\.)*/" do
+    100.times do
+      /[:paragraph:]/.gen.should =~ /(\w+ )*/
+    end
+  end
+
+  it "/(abc|def){1,2}/                => ['abc', 'def', 'abcabc', 'abcdef', 'defabc', 'defdef']" do
+    100.times do
+      ['abc', 'def', 'abcabc', 'abcdef', 'defabc', 'defdef'].should include(/(abc|def){1,2}/.gen)
+    end
+  end
+
+  it "/abc(def)?hij/                  => /abc(def)?hij/" do
+    100.times do
+      /abc(def)?hij/.gen.should =~ /abc(def)?hij/
+    end
+  end
+
+  it "/ab(c(def))?h/                  => /ab(c(def))?h/" do
+    100.times do
+      /ab(c(def))?h/.gen.should =~ /ab(c(def))?h/
+    end
+  end
+
+  it "/abc?/                          => ['ab', 'abc']" do
+    100.times do
+      ['ab', 'abc'].should include(/abc?/.gen)
+    end
+  end
+
+  it "/(\\d{3}-)?\\d{3}-\\d{4}/          => /(\\d{3}-)?\\d{3}-\\d{4}/" do
+    100.times do
+      /(\d{3}-)?\d{3}-\d{4}/.gen.should =~ /(\d{3}-)?\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]/              => /(\\d{3}-)?\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]/.gen.should =~ /(\d{3}-)?\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]{7}/           => /\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]{7}/.gen.should =~ /\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]{10}/          => /\\d{3}-\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]{10}/.gen.should =~ /\d{3}-\d{3}-\d{4}/
+    end
+  end
+
+  it "/\\w+@\\w+\\.(com|org|net)/        => /\\w+@\\w+\\.(com|org|net)/.gen" do
+    100.times do
+      /\w+@\w+\.(com|org|net)/.gen.should =~ /\w+@\w+\.(com|org|net)/
+    end
+  end
+
+  it "/\\$\\d{2,3}\\.\\d{2}/              => /\\$\\d{2,3}\\.\\d{2}/" do
+    100.times do
+      /\$\d{2,3}\.\d{2}/.gen.should =~ /\$\d{2,3}\.\d{2}/
+    end
+  end
+
+  it "/[:first_name:]/                => /\\w+/" do
+    100.times do
+      /[:first_name:]/.gen.should =~ /\w+/
+    end
+  end
+
+  it "/[:last_name:]/                 => /\\w+/" do
+    /[:last_name:]/.gen.should =~ /\w+/
+  end
+
+  it "/[:name:]/                      => /\\w+ \\w+/" do
+    /[:name:]/.gen.should =~ /\w+ \w+/
+  end
+
+  it "/[:last_name:]{5,10}/           => /\\w{5,10}/" do
+    /[:last_name:]{5,10}/.gen.should =~ /\w{5,10}/
+  end
+
+  it "/[:first_name:]{5,10}/          => /\\w{5,10}/" do
+    /[:first_name:]{5,10}/.gen.should =~ /\w{5,10}/
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rspec'
+require 'randomexp'
+
+Randomexp::Dictionary.register(File.join(File.dirname(__FILE__), 'fixtures', 'osx_dictionary'))
+
+RSpec::Runner.configure do |config|
+end

data/spec/unit/core_ext/regexp_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Regexp do
+  describe "#gen" do
+    it "should always return a string" do
+      /abcd/.gen.class.should == String
+    end
+  end
+end

data/spec/unit/randgen_spec.rb

@@ -0,0 +1,244 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Randgen do
+  describe ".bool" do
+    it "should return 'true' or 'false'" do
+      100.times do
+        ['true', 'false'].should include(Randgen.bool)
+      end
+    end
+  end
+
+  describe ".lchar" do
+    it "should return 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', or 'z'" do
+      100.times do
+        ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'].should include(Randgen.lchar)
+      end
+    end
+  end
+
+  describe ".uchar" do
+    it "should return 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z'" do
+      100.times do
+        ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'].should include(Randgen.uchar)
+      end
+    end
+  end
+
+  describe ".char" do
+    it "should return 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', or 'z'" do
+      100.times do
+        ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z'].should include(Randgen.char)
+      end
+    end
+  end
+
+  describe ".whitespace" do
+    it "should return '\\t', '\\n', '\\r', or '\\f'" do
+      100.times do
+        ["\t", "\n", "\r", "\f"].should include(Randgen.whitespace)
+      end
+    end
+  end
+
+  describe ".digit" do
+    it "should return '0', '1', '2', '3', '4', '5', '6', '7', '8', or '9'" do
+      100.times do
+        ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].should include(Randgen.digit)
+      end
+    end
+  end
+
+  describe ".alpha_numeric" do
+    it "should return 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', or '9'" do
+      100.times do
+        ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].should include(Randgen.alpha_numeric)
+      end
+    end
+  end
+
+  describe ".word" do
+    it "should handle generating long strings" do
+      Randgen.word(:length => 64).length.should == 64
+    end
+    it "should pick_rand_value an entry from Dictionary" do
+      10.times do
+        Randomexp::Dictionary.words.should include(Randgen.word)
+      end
+    end
+
+    it "should pick_rand_value a word with a length if the length option is supplied" do
+      10.times do
+        length = (3..10).pick_rand_value
+        Randgen.word(:length => length).length.should == length
+      end
+    end
+
+    it "should not return a string that is not a word" do
+      strings = %w[foo's bars]
+      Randomexp::Dictionary.should_receive(:words).at_least(1).and_return strings
+
+      100.times do
+        Randgen.word.should_not == "foo's"
+      end
+    end
+  end
+
+  describe ".first_name" do
+    it "should pick_rand_value a word from the female names list if the gender option is female" do
+      100.times do
+        female_name = Randgen.first_name(:gender => :female)
+        RealName.female_first_names.should include(female_name)
+      end
+    end
+
+    it "should pick_rand_value a word from the male names list if the gender option is male" do
+      100.times do
+        male_name = Randgen.first_name(:gender => :male)
+        RealName.male_first_names.should include(male_name)
+      end
+    end
+
+    it "should pick_rand_value a word from the male names list with the same length in the options" do
+      100.times do
+        length = (3..10).pick_rand_value
+        male_name = Randgen.first_name(:length => length)
+        (RealName.female_first_names + RealName.male_first_names).should include(male_name)
+      end
+    end
+
+    it "returns nil if there is no name that matches the length option" do
+      Randgen.first_name(:length => 100).should be_nil
+    end
+  end
+
+  describe ".last_name" do
+    it "should pick_rand_value a word from the last names list with the same length in the options" do
+      100.times do
+        length = (3..10).pick_rand_value
+        last_name = Randgen.last_name(:length => length)
+        RealName.surnames.should include(last_name)
+      end
+    end
+
+    it "returns nil if there is no name that matches the length option" do
+      Randgen.last_name(:length => 100).should be_nil
+    end
+  end
+
+  describe ".name" do
+    it "should be two words long" do
+      100.times do
+        Randgen.name.should =~ /\w+ \w+/
+      end
+    end
+  end
+
+  describe ".email" do
+    it "should pick_rand_value a local-part from the dictionnary" do
+      100.times do
+        Randomexp::Dictionary.words.should include(Randgen.email[/^(\w+)@/, 1])
+      end
+    end
+
+    it "should use the domain option paramter" do
+      100.times do
+        Randgen.email(:domain => 'foobar.com')[/@((?:\w|\.)+)$/, 1].should == 'foobar.com'
+      end
+    end
+
+    it "should pick_rand_value a subdomain of example.org by default" do
+      100.times do
+        Randomexp::Dictionary.words.should include(Randgen.email[/@(\w+)\.example\.org$/, 1])
+      end
+    end
+  end
+
+  describe ".sentence" do
+    it "should be capitalized" do
+      10.times do
+        Randgen.sentence.should =~ /^[A-Z]/
+      end
+    end
+  end
+
+  describe ".paragraph" do
+    it "should end in a period" do
+      10.times do
+        Randgen.paragraph.should =~ /\.$/
+      end
+    end
+  end
+
+  describe ".phone_number" do
+    it "should match /(\\d{3}-)?\\d{3}-\\d{4}/ when no length is given" do
+      100.times do
+        Randgen.phone_number =~ /(\d{3}-)?\d{3}-\d{4}/
+      end
+    end
+
+    it "should match /\\d{3}-\\d{4}/ when the length is 7" do
+      100.times do
+        Randgen.phone_number(:length => 7) =~ /\d{3}-\d{4}/
+      end
+    end
+
+    it "should match /\\d{3}-\\d{3}-\\d{4}/ when the length is 10" do
+      100.times do
+        Randgen.phone_number(:length => 10) =~ /\d{3}-\d{3}-\d{4}/
+      end
+    end
+  end
+
+  it "should generate a first name" do
+    100.times do
+      Randgen.first_name.should =~ /\w/
+    end
+  end
+
+  it "should generate a male first name" do
+    male_list = RealName.male_first_names
+    100.times do
+      Randgen.first_name(:gender => :male).should =~ /\w/
+      male_list.include?(Randgen.first_name(:gender => :male)).should be_true
+    end
+  end
+
+  it "should generate a female first name" do
+    female_list = RealName.female_first_names
+    100.times do
+      Randgen.first_name(:gender => :female).should =~ /\w/
+      female_list.include?(Randgen.first_name(:gender => :female)).should be_true
+    end
+  end
+
+  it "should generate a last name" do
+    100.times do
+      Randgen.last_name.should =~ /\w/
+    end
+  end
+
+  it "should generate a real name" do
+    100.times do
+      Randgen.name.should =~ /\w{2}/
+    end
+  end
+
+  it "should generate a real male name" do
+    male_list = RealName.male_first_names
+    100.times do
+      name = Randgen.name(:gender => :male)
+      name.should =~ /\w{2}/
+      male_list.include?(name.split(' ').first).should be_true
+    end
+  end
+
+  it "should generate a real female name" do
+    female_list = RealName.female_first_names
+    100.times do
+      name = Randgen.name(:gender => :female)
+      name.should =~ /\w{2}/
+      female_list.include?(name.split(' ').first).should be_true
+    end
+  end
+end

data/spec/unit/randomexp/parser_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Randomexp::Parser do
+  describe ".parse" do
+    it "should return a sexp for a non-empty string" do
+      Randomexp::Parser.parse("abc").should be_instance_of(Array)
+    end
+
+    it "should return nil for an empty string" do
+      Randomexp::Parser.parse("").should be_nil
+    end
+
+    it "should alias :[] to :parse" do
+      Randomexp::Parser[""].should be_nil
+    end
+  end
+
+  describe ".quantify" do
+    it "should return a :quantify sexp" do
+      Randomexp::Parser.quantify([:literal, 'a'], :*)[0].should == :quantify
+    end
+
+    it "should push the quantify symbol on the end of the sexp" do
+      Randomexp::Parser.quantify([:literal, 'a'], :*).last.should == :*
+    end
+
+    it "should push the argument sexp to the first entry of the :quantify sexp" do
+      Randomexp::Parser.quantify([:literal, 'a'], :*)[1].should == [:literal, 'a']
+    end
+  end
+
+  describe ".union" do
+    it "should return the union of the right-hand side if the left-hand side is nil" do
+      Randomexp::Parser.union(nil, [:literal, 'a']).should == Randomexp::Parser.union([:literal, 'a'])
+    end
+
+    it "should return the left-hand side if the right hand side is not present" do
+      Randomexp::Parser.union([:literal, 'a']).should == [:literal, 'a']
+    end
+
+    it "should append the right-hand side(s) to the left-hand side if the left-hand side is a union sexp" do
+      Randomexp::Parser.union([:union, [:literal, 'a'], [:literal, 'b']], [:literal, 'c']).should == [:union, [:literal, 'a'], [:literal, 'b'], [:literal, 'c']]
+    end
+
+    it "should return a :union sexp between the left-hand and right-hand sexp's" do
+      Randomexp::Parser.union([:literal, 'a'], [:literal, 'b']).should == [:union, [:literal, 'a'], [:literal, 'b']]
+    end
+  end
+
+  describe ".intersection" do
+    it "should prepend the left-hand side onto the right-hand side :intersection sexp if the right-hand side is an :intersection sexp" do
+      Randomexp::Parser.intersection([:literal, 'a'], [:intersection, [:literal, 'b'], [:literal, 'c']]).should == [:intersection, [:literal, 'a'], [:literal, 'b'], [:literal, 'c']]
+    end
+
+    it "should create an :intersection sexp between the left-hand and right-hand sexp's" do
+      Randomexp::Parser.intersection([:literal, 'a'], [:literal, 'b']).should == [:intersection, [:literal, 'a'], [:literal, 'b']]
+    end
+  end
+
+  describe ".random" do
+    it "should return a :random sexp" do
+      Randomexp::Parser.random('w').should be_instance_of(Array)
+      Randomexp::Parser.random('w').first.should == :random
+    end
+
+    it "should convert the char parameter to a symbol" do
+      Randomexp::Parser.random('w').last.should == :w
+    end
+  end
+
+  describe ".literal" do
+    it "should return a literal sexp" do
+      Randomexp::Parser.literal('a').should be_instance_of(Array)
+      Randomexp::Parser.literal('a').first.should == :literal
+    end
+  end
+end