sequel_core 1.5.1 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,119 @@
+=== 2.0.0 (2008-06-01)
+
+* Refactor String inflection support, you must use String.inflections instead of Inflector.inflections now (jeremyevans)
+
+* Allow connection to ODBC-MSSQL via a URL (petersumskas) (#230)
+
+* Comprehensive update of all documentation, except for the block filters and adapters (jeremyevans)
+
+* Handle Date and DateTime value literalization correctly in adapters (jeremyevans)
+
+* Literalize DateTime values the same as Time values (jeremyevans)
+
+* MySQL tinyints are now returned as boolean values instead of integers (jeremyevans)
+
+* Set additional MySQL charset options required for creating tables and databases (tmm1)
+
+* Remove methods deprecated in 1.5.0 (jeremyevans)
+
+* Add Module#metaattr_accessor for creating attr_accessors for the metaclass (jeremyevans)
+
+* Add SQL string concatenation support to blockless filters, via Array#sql_string_join (jeremyevans)
+
+* Add Pagination#last_page? and Pagination#first_page? (apeiros)
+
+* Add limited column reflection support, tested on PostgreSQL, MySQL, and SQLite (jeremyevans)
+
+* Allow the use of :schema__table___table_alias syntax for tables, similar to the column support (jeremyevans)
+
+* Merge metaid gem into core_ext.rb and clean it up, so sequel now has no external dependencies (jeremyevans)
+
+* Add Dataset#as, so using a dataset as a column with an alias is not deprecated (jeremyevans)
+
+* Add Dataset#invert, which returns a dataset with inverted HAVING and WHERE clauses (jeremyevans)
+
+* Add blockless filter syntax support (jeremyevans)
+
+* Passing an array to Dataset#order and Dataset#select no longer works, you need to pass multiple arguments (jeremyevans)
+
+* You should use '?' instead of '(?)' when using interpolated strings with array arguments (jeremyevans)
+
+* Dataset.literal now surrounds the literalization of arrays with parentheses (jeremyevans)
+
+* Add echo option (back?) to sequel command line tool, via -E or --echo (jeremyevans)
+
+* Allow databases to have multiple loggers (jeremyevans)
+
+* The sequel command line tool now also accepts a path to a database config YAML file in addition to a URI (mtodd)
+
+* Major update of the postgresql adapter (jdavis, jeremyevans) (#225)
+
+* Make returning inside of a database transaction commit the transaction (ahoward, jeremyevans)
+
+* Dataset#to_table_reference is now protected, and it has a different API (jeremyevans)
+
+* Dataset#join_table and related functions now take an explicit optional table_alias argument, you can no longer include the table alias in the table argument (jeremyevans)
+
+* Aliased and/or qualified columns with embedded spaces can now be specified as symbols (jeremyevans)
+
+* When identifier quoting is enabled, the SQL standard double quote is used by default (jeremyevans)
+
+* When identifier quoting is enabled, quote tables as well as columns (jeremyevans)
+
+* Make identifier quoting optional, enabled by default (jeremyevans)
+
+* Allow Sequel::Database.connect and related methods to take a block that disconnects the database when the block finishes (jeremyevans)
+
+* Add Dataset#unfiltered, for removing filters from dataset (jeremyevans)
+
+* Add add_foreign_key and add_primary_key methods to the AlterTableGenerator (jeremyevans)
+
+* Allow migration files to have more than 3 digits (jeremyevans)
+
+* Add methods directly to Dataset instead of including modules (jeremyevans)
+
+* Make some Dataset instance methods private: invert_order, insert_default_values_sql (jeremyevans)
+
+* Don't add methods that depend on ParseTree unless you can load ParseTree (jeremyevans)
+
+* Don't wipeout the cached columns every time a dataset is cloned, but only on changes to :select, :sql, :from, or :join (jeremyevans)
+
+* Fix Oracle Adapter (yasushi.abe)
+
+* Fixed sqlite uri so that sqlite:// works just like file:// (2 slashes for a relative path, 3 for an absolute) (dlee)
+
+* Raise a Sequel::Error if an invalid limit or offset is used (jeremyevans)
+
+* Refactor and beef up Dataset#first and Dataset#last, with some change in functionality (jeremyevans)
+
+* Add String#to_datetime, for consistency (jeremyevans)
+
+* Fix Range#interval so that it returns 1 less for an exclusive range
+
+* Change SQLite adapter so it doesn't swallow exceptions other than SQLite3::Exception (such as Interrupt) (jeremyevans)
+
+* Change PostgreSQL and MySQL adapters to raise Sequel::Error instead of database specific errors if a database error occurs (jeremyevans)
+
+* Using a memory database with SQLite now defaults to a single connection, so all queries it uses run against the same database (jeremyevans)
+
+* Fix attempting to query MySQL using the same connection being used to concurrently execute another query (jeremyevans)
+
+* Add options to the connection pool to configure reusing connections and converting exceptions (jeremyevans)
+
+* Use the database driver provided string quoting methods for MySQL and SQLite (jeremyevans) (#223)
+
+* Add ColumnAll#==, for checking the equality of two ColumnAlls (jeremyevans)
+
+* Allow an array of arrays instead of a hash when specifying conditions (jeremyevans)
+
+* Add Sequel::DBI::Database#lowercase, for lowercasing column names (jamesearl)
+
+* Remove Dataset#extend_with_destroy, which may break code that uses Dataset#set_model directly and expects the destroy method to be added (jeremyevans)
+
+* Fix some issues when running on Ruby 1.9 (Zverok, jeremyevans)
+
+* Make the DBI adapter work (partially) with PostgreSQL (Seb)
+
 === 1.5.1 (2008-04-30)
 
 * Have Dataset#graph give a nil value instead of a hash with all nil values if no matching rows exist in the graphed table (jeremyevans)

data/COPYING

@@ -1,19 +1,19 @@
-Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008 Jeremy Evans
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-  
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-   
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2007-2008 Sharon Rosner
+Copyright (c) 2008 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -6,7 +6,6 @@ Sequel makes it easy to deal with multiple records without having to break your
 
 == Resources
 
-* {Project page}[http://code.google.com/p/ruby-sequel/]
 * {Source code}[http://github.com/jeremyevans/sequel]
 * {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
 * {Google group}[http://groups.google.com/group/sequel-talk]
@@ -40,11 +39,39 @@ Sequel currently supports:
 
 There are also experimental adapters for DB2, OpenBase and JDBC (on JRuby).
 
+== A Short Example
+
+  require 'rubygems'
+  require 'sequel'
+  
+  DB = Sequel.sqlite # memory database
+  
+  DB.create_table :items do # Create a new table
+    column :name, :text
+    column :price, :float
+  end
+  
+  items = DB[:items] # Create a dataset
+  
+  # Populate the table
+  items << {:name => 'abc', :price => rand * 100}
+  items << {:name => 'def', :price => rand * 100}
+  items << {:name => 'ghi', :price => rand * 100}
+  
+  # Print out the number of records
+  puts "Item count: #{items.count}"
+  
+  # Print out the records in descending order by price
+  items.reverse_order(:price).print
+  
+  # Print out the average price
+  puts "The average price is: #{items.avg(:price)}"
+
 == The Sequel Console
 
 Sequel includes an IRB console for quick'n'dirty access to databases. You can use it like this:
 
-  sequel sqlite:///test.db
+  sequel sqlite://test.db # test.db in current directory
 
 You get an IRB session with the database object stored in DB.
 
@@ -75,8 +102,6 @@ Or getting results as a transposed hash, with one column as key and another as v
 
   middle_east.to_hash(:name, :area) #=> {'Israel' => 20000, 'Greece' => 120000, ...}
 
-Much of Sequel is still undocumented (especially the part relating to model classes). The following section provides examples of common usage. Feel free to explore...
-
 == Getting Started
 
 === Connecting to a database
@@ -84,16 +109,20 @@ Much of Sequel is still undocumented (especially the part relating to model clas
 To connect to a database you simply provide Sequel with a URL:
 
   require 'sequel'
-  DB = Sequel.open 'sqlite:///blog.db'
+  DB = Sequel.connect('sqlite://blog.db')
   
 The connection URL can also include such stuff as the user name and password:
 
-  DB = Sequel.open 'postgres://cico:12345@localhost:5432/mydb'
+  DB = Sequel.connect('postgres://cico:12345@localhost:5432/mydb')
+
+You can also specify optional parameters, such as the connection pool size, or loggers for logging SQL queries:
 
-You can also specify optional parameters, such as the connection pool size, or a logger for logging SQL queries:
+  DB = Sequel.connect("postgres://postgres:postgres@localhost/my_db",
+    :max_connections => 10, :loggers => [Logger.new('log/db.log']))
 
-  DB = Sequel.open("postgres://postgres:postgres@localhost/my_db",
-    :max_connections => 10, :logger => Logger.new('log/db.log'))
+You can specify a block to connect, which will disconnect from the database after it completes:
+
+  Sequel.connect('postgres://cico:12345@localhost:5432/mydb'){|db| db[:posts].delete}
 
 === Arbitrary SQL queries
 
@@ -105,6 +134,18 @@ Or more succinctly:
   DB << "create table t (a text, b text)"
   DB << "insert into t values ('a', 'b')"
 
+You can also create datasets based on raw SQL:
+
+  dataset = DB['select * from items']
+  dataset.count # will return the number of records in the result set
+  dataset.map(:id) # will return an array containing all values of the id column in the result set
+
+You can also fetch records with raw SQL through the dataset:
+
+  DB['select * from items'].each do |row|
+    p row
+  end
+
 === Getting Dataset Instances
 
 Dataset is the primary means through which records are retrieved and manipulated. You can create an blank dataset by using the dataset method:
@@ -115,11 +156,11 @@ Or by using the from methods:
 
   posts = DB.from(:posts)
 
-You can also use the equivalent shorthand:
+The recommended way is the equivalent shorthand:
 
   posts = DB[:posts]
 
-Note: the dataset will only fetch records when you explicitly ask for them, as will be shown below. Datasets can be manipulated to filter through records, change record order and even join tables, as will also be shown below.
+Datasets will only fetch records when you explicitly ask for them. Datasets can be manipulated to filter through records, change record order, join tables, etc..
 
 === Retrieving Records
 
@@ -131,12 +172,12 @@ The all method returns an array of hashes, where each hash corresponds to a reco
 
 You can also iterate through records one at a time:
 
-  posts.each {|row| p row}
+  posts.each{|row| p row}
 
 Or perform more advanced stuff:
 
   posts.map(:id)
-  posts.inject({}) {|h, r| h[r[:id]] = r[:name]}
+  posts.inject({}){|h, r| h[r[:id]] = r[:name]}
   
 You can also retrieve the first record in a dataset:
 
@@ -164,13 +205,9 @@ Or lists of values:
 
   my_posts = posts.filter(:category => ['ruby', 'postgres', 'linux'])
   
-If ParseTree is installed, Sequel also accepts expressions as closures, AKA block filters:
-
-  my_posts = posts.filter {:category == ['ruby', 'postgres', 'linux']}
+Sequel also accepts expressions:
   
-Which also lets you do stuff like:
-
-  my_posts = posts.filter {:stamp > Date.today << 1}
+  my_posts = posts.filter(:stamp > Date.today << 1)
   
 Some adapters (like postgresql) will also let you specify Regexps:
 
@@ -179,19 +216,27 @@ Some adapters (like postgresql) will also let you specify Regexps:
 You can also use an inverse filter:
 
   my_posts = posts.exclude(:category => /ruby/i)
+  my_posts = posts.filter(:category => /ruby/i).invert # same as above
 
-You can then retrieve the records by using any of the retrieval methods:
+You can also specify a custom WHERE clause using a string:
 
-  my_posts.each {|row| p row}
-  
-You can also specify a custom WHERE clause:
+  posts.filter('stamp IS NOT NULL')
+
+You can use parameters in your string, as well (ActiveRecord style):
 
-  posts.filter('(stamp < ?) AND (author <> ?)', Date.today - 3, author_name)
+  posts.filter('(stamp < ?) AND (author != ?)', Date.today - 3, author_name)
+  posts.filter((:stamp < Date.today - 3) & ~(:author => author_name)) # same as above
 
 Datasets can also be used as subqueries:
 
   DB[:items].filter('price > ?', DB[:items].select('AVG(price) + 100'))
 
+After filtering you can retrieve the matching records by using any of the retrieval methods:
+
+  my_posts.each{|row| p row}
+  
+See the doc/dataset_filtering.rdoc file for more details.
+
 === Summarizing Records
 
 Counting records is easy:
@@ -205,26 +250,32 @@ Or calculate a sum:
   
 === Ordering Records
 
-  posts.order(:stamp)
+Ordering datasets is simple:
+
+  posts.order(:stamp) # ORDER BY stamp
+  posts.order(:stamp, :name) # ORDER BY stamp, name
   
 You can also specify descending order
 
-  posts.order(:stamp.desc)
+  posts.order(:stamp.desc) # ORDER BY stamp DESC
 
 === Deleting Records
 
+Deleting records from the table is done with delete:
+
   posts.filter('stamp < ?', Date.today - 3).delete
   
 === Inserting Records
 
-  posts.insert(:category => 'ruby', :author => 'david')
-  
-Or alternatively:
+Inserting records into the table is done with insert:
 
-  posts << {:category => 'ruby', :author => 'david'}
+  posts.insert(:category => 'ruby', :author => 'david')
+  posts << {:category => 'ruby', :author => 'david'} # same as above
   
 === Updating Records
 
+Updating records in the table is done with update:
+
   posts.filter('stamp < ?', Date.today - 7).update(:state => 'archived')
 
 === Joining Tables
@@ -257,7 +308,7 @@ When retrieving records from joined datasets, you get the results in a single ha
   DB[:items].join(:order_items, :item_id => :id).first
   => {:id=>(could be items.id or order_items.id), :item_id=>order_items.order_id}
 
-Using graph, you can split the resulting dataset into separate hashes:
+Using graph, you can split the result hashes into subhashes, one per join:
 
   DB[:items].graph(:order_items, :item_id => :id).first
-  => {:items->{:id=>items.id}, :order_items=>{:id=>order_items.id, :item_id=>order_items.item_id}}
+  => {:items=>{:id=>items.id}, :order_items=>{:id=>order_items.id, :item_id=>order_items.item_id}}

data/Rakefile

@@ -9,19 +9,19 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.5.1"
-CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
-RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source"]
+VERS = "2.0.0"
+CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
+RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
+  'Sequel: The Database Toolkit for Ruby: Core Library and Adapters', \
+  '--main', 'README']
 
 ##############################################################################
 # RDoc
 ##############################################################################
 Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.main = "README"
-  rdoc.title = "Sequel: The Database Toolkit for Ruby: Core Library and Adapters"
-  rdoc.rdoc_files.add ["README", "COPYING", "lib/**/*.rb"]
+  rdoc.rdoc_files.add ["README", "COPYING", "doc/*.rdoc", "lib/**/*.rb"]
 end
 
 ##############################################################################
@@ -36,7 +36,7 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
   s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
   s.summary = "The Database Toolkit for Ruby: Core Library and Adapters"
   s.description = s.summary
@@ -45,18 +45,7 @@ spec = Gem::Specification.new do |s|
   s.homepage = "http://sequel.rubyforge.org"
   s.executables = ["sequel"]
   s.required_ruby_version = ">= 1.8.4"
-
-  s.add_dependency("metaid")
-
-  case RUBY_PLATFORM
-  when /java/
-    s.platform = "jruby"
-  else
-    s.platform = Gem::Platform::RUBY
-  end
-  
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
-
   s.require_path = "lib"
   s.bindir = "bin"
 end
@@ -162,7 +151,7 @@ STATS_DIRECTORIES = [
 
 desc "Report code statistics (KLOCs, etc) from the application"
 task :stats do
-  require "extra/stats"
+  require "../extra/stats"
   verbose = true
   CodeStatistics.new(*STATS_DIRECTORIES).to_s
 end

data/bin/sequel

@@ -2,35 +2,43 @@
 
 require 'rubygems'
 require 'optparse'
-require 'sequel' rescue nil
 require 'sequel_core'
-require 'sequel_model' rescue nil
-require 'logger'
 
-$uri = nil
-$logfile = nil
-$echo = nil
+begin
+  require 'sequel'
+  sequel_loaded = true
+rescue LoadError
+end
+
+db_opts = {}
+echo = nil
+env = nil
+logfile = nil
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
-  opts.define_head "Usage: sequel <uri> [options]"
+  opts.define_head "Usage: sequel <uri|path> [options]"
   opts.separator ""
   opts.separator "Examples:"
   opts.separator "  sequel sqlite:///blog.db"
   opts.separator "  sequel postgres://localhost/my_blog"
-  
+  opts.separator "  sequel config/database.yml"
   opts.separator ""
-  opts.separator "For more information see http://code.google.com/p/ruby-sequel"
+  opts.separator "For more information see http://sequel.rubyforge.org"
   opts.separator ""
   opts.separator "Options:"
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    $logfile = v
+    logfile = v
+  end
+  
+  opts.on("-E", "--echo", "echo SQL statements") do |v|
+    echo = v
   end
   
-  # opts.on("-e", "--echo", "echo SQL statements") do |v|
-  #   $echo = v
-  # end
+  opts.on("-e", "--env ENV", "use environment config for database") do |env|
+    env = env
+  end
   
   opts.on_tail("-?", "--help", "Show this message") do
     puts opts
@@ -39,14 +47,15 @@ opts = OptionParser.new do |opts|
 
   opts.on_tail("-v", "--version", "Show version") do
     class << Gem; attr_accessor :loaded_specs; end
-    specs = Gem.loaded_specs['sequel']
-    puts "sequel #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    begin
     specs = Gem.loaded_specs['sequel_core']
     puts "sequel_core #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
-    begin
-      specs = Gem.loaded_specs['sequel_model']
-      puts "sequel_model #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    if sequel_loaded
+      specs = Gem.loaded_specs['sequel']
+      puts "sequel #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    end
     rescue
+      puts "No gem version found"
     end
     exit
   end
@@ -60,23 +69,27 @@ if db.blank?
   exit
 end
 
-db_opts = {}
-if $logfile
-  db_opts[:logger] = Logger.new($logfile)
-end
-if $echo
-  db_opts[:echo] = true
+if logfile || echo
+  require 'logger'
+  db_opts[:loggers] = []
+  db_opts[:loggers] << Logger.new(logfile) if logfile
+  db_opts[:loggers] << Logger.new($stdout) if echo
 end
 
-begin
-  puts "db_opts = #{db_opts.inspect}"
-  DB = Sequel.connect db, db_opts
-rescue => e
-  puts e.message
-  exit
+if File.exist?(db)
+  require 'yaml'
+  db_config = YAML.load_file(db)[env || "development"]
+  db_config.each {|(k,v)| db_config[k.to_sym] = db_config.delete(k)}
+  db_config.merge!(db_opts)
 end
 
 begin
+  if db_config
+    opts = [db_config]
+  else
+    opts = [db, db_opts]
+  end
+  DB = Sequel.connect(*opts)
   DB.test_connection
 rescue => e
   puts e.message
@@ -87,85 +100,3 @@ end
 require 'irb'
 puts "Your database is stored in DB..."
 IRB.start
-
-__END__
-
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'optparse'
-require 'bulkmail'
-
-$helo = nil
-$from = nil
-$recipients = []
-$content = nil
-$delay = 60..300
-
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: bulkmail <options>"
-  opts.define_head "Simple bulk-mailer."
-  opts.separator ""
-  opts.separator "Options:"
-
-  opts.on("-h", "--helo HOSTNAME", "HELO host name.") do |v|
-    $helo = v
-  end
-  
-  opts.on("-r", "--recipients filename", "Recipients file name") do |v|
-    $recipients = IO.readlines(v).map {|l| l =~ /(.*)(\r\n|\n)$/ ? $1 : l}.compact
-  end
-  
-  opts.on("-c", "--content filename", "Content file name") do |v|
-    $content = IO.read(v)
-  end
-  
-  opts.on("-f", "--from from", "From address") do |v|
-    $from = v
-  end
-  
-  opts.on('-n', "--nodelay", "No delay") do |v|
-    $delay = 0
-  end
-  
-  # No argument, shows at tail.  This will print an options summary.
-  # Try it and see!
-  opts.on_tail("-?", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-
-  # Another typical switch to print the version.
-  opts.on_tail("-v", "--version", "Show version") do
-    class << Gem; attr_accessor :loaded_specs; end
-    specs = Gem.loaded_specs['bulkmail']
-    puts "bulkmail #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
-    exit
-  end
-end
-
-begin
-  opts.parse! ARGV
-rescue => e
-  puts e.message
-  puts e.backtrace.first
-  exit
-end
-
-unless $content
-  puts opts
-  exit
-end
-
-trap('INT') {exit}
-
-puts "Please hold on..."
-
-sender = BulkMail::Sender.new({
-  :list => $recipients,
-  :from => $from,
-  :message => $content,
-  :helo => $helo,
-  :delay => $delay
-})
-sender.start