namey 0.0.2 → 0.0.5

data/lib/namey.rb

@@ -1,17 +1,24 @@
-require 'sqlite3'
-
 module Namey
   def self.db_path
-    @@db_path
+    @@db_path ||= "sqlite://#{File.join(self.libdir, "..", "data", "names.db")}"  
   end
   def self.db_path=(x)
     @@db_path = x
   end
+
+
+  require 'namey/version'
   
+  # Return a directory with the project libraries.
+  def self.libdir
+    t = ["#{File.expand_path(File.dirname(__FILE__))}", "#{Gem.dir}/gems/#{Namey::NAME}-#{Namey::VERSION}"]
+
+    t.each {|i| return i if File.readable?(i) }
+    raise "both paths are invalid: #{t}"
+  end
 
-  # Your code goes here...
-  @@db_path = File.join(File.dirname(__FILE__), "..", "data", "names.db")
 
+  
   require 'namey/generator'
 end
 

data/lib/namey/generator.rb

@@ -1,39 +1,80 @@
+require 'sequel'
+
 module Namey
+
+  #
+  # Main class for namey, handles generating a name.
+  #
   class Generator
 
-    def initialize(dbname = Namey.db_path)     
-      @db = SQLite3::Database.open dbname
+    #
+    # initialize the name generator
+    # * +dbname+ - Sequel style db URI ex: 'sqlite://foo.db'
+    def initialize(dbname = nil)
+      dbname = Namey.db_path if dbname.nil?
+      @db = Sequel.connect(dbname)
     end
 
+    #
+    # generate a name
+    #
+    # * +frequency+ - :common, :rare, :all
+    # * +surname+ - true if you want a full name, false if you just want a first name
     def name(frequency = :common, surname = true)
-      method = rand > 0.5 ? :male : :female
-      send(method, frequency, surname)
+      generate(:frequency => frequency, :with_surname =>surname)
     end
     
+    #
+    # generate a male name
+    #
+    # * +frequency+ - :common, :rare, :all
+    # * +surname+ - true if you want a full name, false if you just want a first name
     def male(frequency = :common, surname = true)
       generate(:type => :male, :frequency => frequency, :with_surname => surname)
     end
 
+    #
+    # generate a female name
+    #
+    # * +frequency+ - :common, :rare, :all
+    # * +surname+ - true if you want a full name, false if you just want a first name
     def female(frequency = :common, surname = true)
       generate(:type => :female, :frequency => frequency, :with_surname => surname)      
     end
 
+    #
+    # generate a surname
+    #
+    # * +frequency+ - :common, :rare, :all
     def surname(frequency = :common)
       generate(:type => :surname, :frequency => frequency)
     end
     
+    #
+    # generate a name using the supplied parameter hash
+    #
+    # * +params+ - A hash of parameters
+    #
+    # ==== Params
+    # * +:type+ - :male, :female, :surname
+    # * +:frequency+ -  :common, :rare, :all
+    # * +:min_freq+ - raw frequency values to specify a precise range
+    # * +:max_freq+ - raw frequency values to specify a precise range
     def generate(params = {})
       params = {
-        :type => :female,
+        :type => random_gender,
         :frequency => :common,
         :with_surname => true
       }.merge(params)
 
+      
       if ! ( params[:min_freq] || params[:max_freq] )
         params[:min_freq], params[:max_freq] = frequency_values(params[:frequency])
       end
       
       name = get_name(params[:type], params[:min_freq], params[:max_freq])
+
+      # add surname if needed
       if params[:type] != :surname && params[:with_surname] == true
         name = "#{name} #{get_name(:surname, params[:min_freq], params[:max_freq])}"
       end
@@ -41,6 +82,13 @@ module Namey
     end
     
 
+    protected
+
+    #
+    # generate a set of min/max frequency values for the specified
+    # frequency symbol
+    #
+    # * +f+ -  desired frequency range -- :common, :rare, :all
     def frequency_values(f)
       low = case f
             when :common then 0
@@ -59,13 +107,34 @@ module Namey
       [ low, high ]
     end
     
-    protected
-    def get_name(src, min_freq = 0, max_freq = 100)
-      @db.get_first_row("SELECT name FROM #{src.to_s} WHERE freq > ? AND freq < ? ORDER BY RANDOM() LIMIT 1;",
-                         min_freq, max_freq).first
+
+
+    #
+    # pick a gender at random
+    #
+    def random_gender
+      rand > 0.5 ? :male : :female
     end
     
+    #
+    # randomly sort a result set according to the data adapter class
+    #
+    def random_sort(set)
 
-    
+      # this is a bit of a hack obviously, but it checks the sort of data engine being used
+      # to figure out how to randomly sort
+      if @db.class.name == "Sequel::SQLite::Database"
+        set.order{RANDOM{}}
+      else
+        set.order{RAND{}}
+      end
+    end
+
+    #
+    # query the db for a name
+    #
+    def get_name(src, min_freq = 0, max_freq = 100)     
+      random_sort(@db[src.to_sym].filter{(freq >= min_freq) & (freq <= max_freq)}).first[:name]
+    end
   end
 end

data/lib/namey/parser.rb

@@ -1,52 +1,115 @@
+require 'sequel'
+
 module Namey
+
+  #
+  # parse the census bureau data files and load into our datasource
+  #
   class Parser
 
     attr_accessor :db
 
-    def initialize(dbname)
-      # Open a database
-      @db = SQLite3::Database.new dbname
+    #
+    # initialize the parser
+    # dbname - Sequel style db URI ex: 'sqlite://foo.db'
+    #   
+    def initialize(dbname = Namey.db_path)     
+      @db = Sequel.connect(dbname)
     end
 
+    #
+    # load in the male name list
+    #
     def load_male_names(src)
       parse_file(src, "male")
     end
 
+    #
+    # load in the female name list
+    #
     def load_female_names(src)
       parse_file(src, "female")
     end
 
+    #
+    # load in the surname list
+    #   
     def load_surnames(src)
       parse_file(src, "surname")
     end
 
     protected
+
+    #
+    # parse a census file.  it will have the format:
+    #    name           freq   cumulative rank
+    #    MARY           2.629  2.629      1
+    #    PATRICIA       1.073  3.702      2
+    #    LINDA          1.035  4.736      3
+    #
+    # we only need the name and the frequency, parse those out and
+    # insert into specified table
+    #
+    # src - which file to parse
+    # dest - which table to load into
     def parse_file(src, dest)
       create_table(dest)
 
-      file = File.new(src, "r")
-      while (line = file.gets)
+      puts "***** Importing #{dest}"
+
+      count = 0
+      names = File.foreach(src).collect do |line|
+        count += 1
+        if count % 2000 == 0
+          puts count
+        end
+
         data = line.split
 
         name = data.first.capitalize
         freq = data[2].to_f
 
-        if dest == "surname"
-          name = cleanup_surname(name)
-        end
-        
-        puts "#{name} #{freq}"
-        @db.execute "insert into #{dest} (name, freq) values ( ?, ? )", name, freq
+        name = if dest == "surname"
+                 cleanup_surname(name)
+               else
+                 cleanup_firstname(name)
+               end
+
+        {:name => name, :freq => freq}
       end
-      file.close     
+
+      puts "loading into db"
+
+      # remove any existing records
+      @db[dest.to_sym].truncate
+
+      # insert!
+      @db[dest.to_sym].multi_insert(names)
     end
 
+    #
+    # create a name table
+    #
     def create_table(name)   
-      # Create a database
-      @db.execute "drop table IF EXISTS #{name};"
-      @db.execute "create table #{name} (name varchar(20), freq REAL);"
+      if ! db.tables.include?(name)
+        db.create_table name do
+          String :name, :size => 15
+          Float :freq
+          index :freq
+        end
+      end
+    end
+
+    #
+    # apply some simple regexps to clean up first names
+    #
+    def cleanup_firstname(name)
+      name.gsub(/^Dean(\w+)/) { |s| "DeAn#{$1}" }
     end
 
+    #
+    # apply some simple regexps to clean up surnames
+    #
     def cleanup_surname(name)
       if name.length > 4
         name.gsub!(/^Mc(\w+)/) { |s| "Mc#{$1.capitalize}" }
@@ -55,7 +118,7 @@ module Namey
         name.gsub!(/^Osh(\w+)/) { |s| "O'sh#{$1}" }
         name.gsub!(/^Van(\w+)/) { |s| "Van#{$1.capitalize}" }
         name.gsub!(/^Von(\w+)/) { |s| "Von#{$1.capitalize}" }        
-        name.gsub!(/^De(\w+)/) { |s| "De#{$1.capitalize}" }        
+#        name.gsub!(/^Dev(\w+)/) { |s| "DeV#{$1}" }        
       end
       name
     end

data/lib/namey/version.rb

@@ -1,3 +1,4 @@
 module Namey
-  VERSION = "0.0.2"
+  NAME = "namey"
+  VERSION = "0.0.5"
 end

data/namey.gemspec

@@ -23,15 +23,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sequel>, [">= 0"])
       s.add_runtime_dependency(%q<sqlite3>, [">= 0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])      
     else
-      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<sequel>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])      
       s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<sequel>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])    
     s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
   end
 end
 

data/spec/generator_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Namey::Generator" do
+  before(:each) do
+    @uri = "sqlite:/"
+    @gen = Namey::Generator.new(@uri)
+  end
+
+  describe "name" do
+    it "should pass params to generate" do
+      @gen.should_receive(:generate).with(:frequency => :common, :with_surname => true)
+      @gen.name
+    end
+  end
+
+  describe "male" do
+    it "should pass params to generate" do
+      @gen.should_receive(:generate).with(:type => :male, :frequency => :common, :with_surname => true)
+      @gen.male
+    end
+  end
+
+  describe "female" do
+    it "should pass params to generate" do
+      @gen.should_receive(:generate).with(:type => :female, :frequency => :common, :with_surname => true)
+      @gen.female
+    end
+  end
+
+  describe "surname" do
+    it "should pass params to generate" do
+      @gen.should_receive(:generate).with(:type => :surname, :frequency => :common)
+      @gen.surname
+    end
+  end
+
+  describe "generate" do
+    it "should pass to get_name once for surnames" do
+      @gen.should_receive(:get_name).with(:surname, 0, 20).and_return("Chuck")
+      @gen.generate(:type => :surname).should == "Chuck"
+    end
+
+    it "should pass to get_name once when with_surname is false" do
+      @gen.should_receive(:get_name).with(:male, 0, 20).and_return("Chuck")
+      @gen.generate(:type => :male, :with_surname => false).should == "Chuck"
+    end
+
+    it "should pass to get_name twice for full names" do
+      @gen.should_receive(:get_name).with(:male, 0, 20).and_return("Chuck")      
+      @gen.should_receive(:get_name).with(:surname, 0, 20).and_return("Smith")
+      @gen.generate(:type => :male).should == "Chuck Smith"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start
+#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+#$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'bundler/setup'
+Bundler.require
+
+#require 'rspec'
+#require 'chatterbot'
+
+require 'tempfile'
+require 'sqlite3'
+
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namey
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-13 00:00:00.000000000Z
+date: 2011-11-09 00:00:00.000000000Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &17389620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *17389620
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &13358580 !ruby/object:Gem::Requirement
+  requirement: &17389120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +32,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13358580
+  version_requirements: *17389120
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &13358080 !ruby/object:Gem::Requirement
+  requirement: &17388640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *17388640
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &17388160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,22 +54,83 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13358080
+  version_requirements: *17388160
 description: Simple name generator, which can generate male/female names based on
   US Census Data
 email:
 - colin@muffinlabs.com
 executables:
-- load-data
+- namey-load-data
 - random-name
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- README.markdown
 - Rakefile
-- bin/load-data
+- api/Gemfile
+- api/config.ru
+- api/namey_app.rb
+- api/public/LICENSE
+- api/public/Makefile
+- api/public/README.md
+- api/public/api.js
+- api/public/bootstrap.css
+- api/public/bootstrap.min.css
+- api/public/docs/assets/css/docs.css
+- api/public/docs/assets/ico/bootstrap-apple-114x114.png
+- api/public/docs/assets/ico/bootstrap-apple-57x57.png
+- api/public/docs/assets/ico/bootstrap-apple-72x72.png
+- api/public/docs/assets/ico/favicon.ico
+- api/public/docs/assets/img/bird.png
+- api/public/docs/assets/img/browsers.png
+- api/public/docs/assets/img/example-diagram-01.png
+- api/public/docs/assets/img/example-diagram-02.png
+- api/public/docs/assets/img/example-diagram-03.png
+- api/public/docs/assets/img/grid-18px.png
+- api/public/docs/assets/img/twitter-logo-no-bird.png
+- api/public/docs/assets/js/application.js
+- api/public/docs/assets/js/google-code-prettify/prettify.css
+- api/public/docs/assets/js/google-code-prettify/prettify.js
+- api/public/docs/index.html
+- api/public/docs/javascript.html
+- api/public/examples/container-app.html
+- api/public/examples/fluid.html
+- api/public/examples/hero.html
+- api/public/js/bootstrap-alerts.js
+- api/public/js/bootstrap-buttons.js
+- api/public/js/bootstrap-dropdown.js
+- api/public/js/bootstrap-modal.js
+- api/public/js/bootstrap-popover.js
+- api/public/js/bootstrap-scrollspy.js
+- api/public/js/bootstrap-tabs.js
+- api/public/js/bootstrap-twipsy.js
+- api/public/js/tests/index.html
+- api/public/js/tests/unit/bootstrap-alerts.js
+- api/public/js/tests/unit/bootstrap-buttons.js
+- api/public/js/tests/unit/bootstrap-dropdown.js
+- api/public/js/tests/unit/bootstrap-modal.js
+- api/public/js/tests/unit/bootstrap-popover.js
+- api/public/js/tests/unit/bootstrap-scrollspy.js
+- api/public/js/tests/unit/bootstrap-tabs.js
+- api/public/js/tests/unit/bootstrap-twipsy.js
+- api/public/js/tests/vendor/qunit.css
+- api/public/js/tests/vendor/qunit.js
+- api/public/lib/bootstrap.less
+- api/public/lib/forms.less
+- api/public/lib/mixins.less
+- api/public/lib/patterns.less
+- api/public/lib/reset.less
+- api/public/lib/scaffolding.less
+- api/public/lib/tables.less
+- api/public/lib/type.less
+- api/public/lib/variables.less
+- api/public/ui.js
+- api/views/index.erb
+- bin/namey-load-data
 - bin/random-name
+- data/dist.all.last
 - data/dist.female.first
 - data/dist.male.first
 - data/names.db
@@ -56,6 +139,8 @@ files:
 - lib/namey/parser.rb
 - lib/namey/version.rb
 - namey.gemspec
+- spec/generator_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/muffinista/namey
 licenses: []
 post_install_message: 
@@ -76,8 +161,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: namey
-rubygems_version: 1.8.3
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Simple name generator based on US Census Data
 test_files: []
+has_rdoc: