extra/deprecated.rb @@ -121,10 +121,6 @@ module Sequel # transactions and commits them immediately after. It's wasteful, # but required by DataObject's API. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end th = Thread.current synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(th) lib/sequel/adapters/do.rb @@ -106,10 +106,6 @@ module Sequel end def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) log_info("Transaction.begin") lib/sequel/adapters/firebird.rb @@ -197,10 +197,6 @@ module Sequel # databases. Does not use the JDBC transaction methods, uses # SQL BEGIN/ROLLBACK/COMMIT statements instead. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) stmt = conn.createStatement @@ -476,11 +472,3 @@ module Sequel end end end - -class Java::JavaSQL::Timestamp - # Add a usec method in order to emulate Time values. - def usec - Deprecation.deprecate('Java::JavaSQL::Timestamp#usec', 'Use timestamp.getNanos/1000') - getNanos/1000 - end -end lib/sequel/adapters/jdbc.rb @@ -135,10 +135,6 @@ module Sequel # Support single level transactions on MySQL. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) log_info(begin_transaction_sql) @@ -297,8 +293,8 @@ module Sequel end # Delete rows matching this dataset - def delete(opts = (defarg=true;nil)) - execute_dui(defarg ? delete_sql : delete_sql(opts)){|c| c.affected_rows} + def delete + execute_dui(delete_sql){|c| c.affected_rows} end # Yield all rows matching this dataset @@ -338,8 +334,8 @@ module Sequel end # Update the matching rows. - def update(values={}, opts=(defarg=true;nil)) - execute_dui(defarg ? update_sql(values) : update_sql(values, opts)){|c| c.affected_rows} + def update(values={}) + execute_dui(update_sql(values)){|c| c.affected_rows} end private lib/sequel/adapters/mysql.rb @@ -65,10 +65,6 @@ module Sequel # Support single level transactions on ODBC def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) log_info(begin_transaction_sql) lib/sequel/adapters/odbc.rb @@ -78,10 +78,6 @@ module Sequel alias do execute def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) conn.autocommit = false lib/sequel/adapters/oracle.rb @@ -175,22 +175,10 @@ module Sequel end # MySQL supports ORDER and LIMIT clauses in DELETE statements. - def delete_sql(opts = (defarg=true;nil)) - if defarg - sql = super() - opts = @opts - else - sql = super - opts = opts ? @opts.merge(opts) : @opts - end - - if order = opts[:order] - sql << " ORDER BY #{expression_list(order)}" - end - if limit = opts[:limit] - sql << " LIMIT #{limit}" - end - + def delete_sql + sql = super + sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order] + sql << " LIMIT #{opts[:limit]}" if opts[:limit] sql end @@ -311,11 +299,6 @@ module Sequel else values = values[0] if values.size == 1 - # if hash or array with keys we need to transform the values - if @transform && (values.is_a?(Hash) || (values.is_a?(Array) && values.keys)) - values = transform_save(values) - end - case values when Array if values.empty? @@ -344,22 +327,10 @@ module Sequel end # MySQL supports ORDER and LIMIT clauses in UPDATE statements. - def update_sql(values, opts = (defarg=true;nil)) - if defarg - sql = super(values) - opts = @opts - else - sql = super - opts = opts ? @opts.merge(opts) : @opts - end - - if order = opts[:order] - sql << " ORDER BY #{expression_list(order)}" - end - if limit = opts[:limit] - sql << " LIMIT #{limit}" - end - + def update_sql(values) + sql = super + sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order] + sql << " LIMIT #{opts[:limit]}" if opts[:limit] sql end lib/sequel/adapters/shared/mysql.rb @@ -338,10 +338,6 @@ module Sequel # To use a savepoint instead of reusing the current transaction, # use the :savepoint=>true option. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) and !opts[:savepoint] conn.transaction_depth ||= 0 lib/sequel/adapters/shared/postgres.rb @@ -217,14 +217,8 @@ module Sequel # SQLite performs a TRUNCATE style DELETE if no filter is specified. # Since we want to always return the count of records, add a condition # that is always true and then delete. - def delete(opts = (defarg=true;{})) - # check if no filter is specified - if defarg - @opts[:where] ? super() : filter(1=>1).delete - else - opts = @opts.merge(opts) - super(opts[:where] ? opts : opts.merge(:where=>{1=>1})) - end + def delete + @opts[:where] ? super : filter(1=>1).delete end # Insert the values into the database. lib/sequel/adapters/shared/sqlite.rb @@ -87,10 +87,6 @@ module Sequel # in progress on the connection, always yielding a connection inside a transaction # transaction. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if conn.transaction_active? begin lib/sequel/adapters/sqlite.rb @@ -114,8 +114,10 @@ class Sequel::ConnectionPool ensure release(t, conn, server) unless dde end + rescue StandardError => e + raise e rescue Exception => e - raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e) + raise(@convert_exceptions ? RuntimeError.new(e.message) : e) end end lib/sequel/connection_pool.rb @@ -34,32 +34,13 @@ # # Sequel.datetime_class = DateTime # -# Sequel currently does not use instance_eval for virtual row blocks by default -# (e.g. the block passed to Dataset#filter, #select, #order and other similar -# methods). If you want to use instance_eval for these blocks, don't have any -# block arguments, and set: -# -# Sequel.virtual_row_instance_eval = true -# -# When this is set, you can do: -# -# dataset.filter{|o| o.column > 0} # no instance_eval -# dataset.filter{column > 0} # instance eval -# -# When the virtual_row_instance_eval is false, using a virtual row block without a block -# argument will generate a deprecation message. -# -# The option to not use instance_eval for a block with no arguments will be removed in Sequel 3.0. -# If you have any virtual row blocks that you don't want to use instance_eval for, -# make sure the blocks have block arguments. -# # You can set the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable to have # Sequel not extend the core classes. module Sequel @convert_tinyint_to_bool = true @convert_two_digit_years = true @datetime_class = Time - @virtual_row_instance_eval = false + @virtual_row_instance_eval = true class << self attr_accessor :convert_tinyint_to_bool, :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval @@ -211,7 +192,7 @@ module Sequel private_class_method :adapter_method, :def_adapter_method - require(%w"metaprogramming sql connection_pool exceptions dataset database version deprecated") + require(%w"metaprogramming sql connection_pool exceptions dataset database version") require(%w"schema_generator schema_methods schema_sql", 'database') require(%w"convenience graph prepared_statements sql", 'dataset') require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS') lib/sequel/core.rb @@ -77,10 +77,6 @@ module Sequel @identifier_input_method = nil @identifier_output_method = nil @quote_identifiers = nil - if opts.include?(:upcase_identifiers) - Deprecation.deprecate('The :upcase_identifiers Database option', 'Use the :identifier_input_method => :upcase option instead') - @identifier_input_method = opts[:upcase_identifiers] ? :upcase : "" - end @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block) @pool.connection_proc = proc{|server| connect(server)} unless block @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc] @@ -225,8 +221,7 @@ module Sequel # Executes the supplied SQL statement string. def <<(sql) - Deprecation.deprecate('Passing an array argument to Database#<<', 'Use array.each{|x| database << x}') if Array === sql - execute_ddl((Array === sql) ? sql.to_sql : sql) + execute_ddl(sql) end # Returns a dataset from the database. If the first argument is a string, @@ -409,9 +404,9 @@ module Sequel end # Parse the schema from the database. - # If the table_name is not given, returns the schema for all tables as a hash. - # If the table_name is given, returns the schema for a single table as an - # array with all members being arrays of length 2. Available options are: + # Returns the schema for the given table as an array with all members being arrays of length 2, + # the first member being the column name, and the second member being a hash of column information. + # Available options are: # # * :reload - Get fresh information from the database, instead of using # cached information. If table_name is blank, :reload should be used @@ -420,46 +415,24 @@ module Sequel # that have been requested explicitly. # * :schema - An explicit schema to use. It may also be implicitly provided # via the table name. - def schema(table = nil, opts={}) - Deprecation.deprecate('Calling Database#schema without a table argument', 'Use database.tables.inject({}){|h, m| h[m] = database.schema(m); h}') unless table + def schema(table, opts={}) raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true) - if table - sch, table_name = schema_and_table(table) - quoted_name = quote_schema_table(table) - end + sch, table_name = schema_and_table(table) + quoted_name = quote_schema_table(table) opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema) - if opts[:reload] && @schemas - if table_name - @schemas.delete(quoted_name) - else - @schemas = nil - end - end - - if @schemas - if table_name - return @schemas[quoted_name] if @schemas[quoted_name] - else - return @schemas - end - end - raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true) + @schemas.delete(quoted_name) if opts[:reload] && @schemas + return @schemas[quoted_name] if @schemas && @schemas[quoted_name] @schemas ||= Hash.new do |h,k| quote_name = quote_schema_table(k) h[quote_name] if h.include?(quote_name) end - if table_name - cols = schema_parse_table(table_name, opts) - raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty? - @schemas[quoted_name] = cols - else - tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)} - @schemas - end + cols = schema_parse_table(table_name, opts) + raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty? + @schemas[quoted_name] = cols end # Returns true if the database is using a single-threaded connection pool. @@ -500,10 +473,6 @@ module Sequel # current transaction. Should be overridden for databases that support nested # transactions. def transaction(opts={}) - unless opts.is_a?(Hash) - Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") - opts = {:server=>opts} - end synchronize(opts[:server]) do |conn| return yield(conn) if @transactions.include?(Thread.current) log_info(begin_transaction_sql) @@ -579,6 +548,7 @@ module Sequel # strings with all whitespace, and ones that respond # true to empty? def blank_object?(obj) + return obj.blank? if obj.respond_to?(:blank?) case obj when NilClass, FalseClass true lib/sequel/database.rb @@ -87,7 +87,6 @@ module Sequel @identifier_output_method = db.identifier_output_method if db.respond_to?(:identifier_output_method) @opts = opts || {} @row_proc = nil - @transform = nil end ### Class Methods ### @@ -118,10 +117,9 @@ module Sequel # Returns an array with all records in the dataset. If a block is given, # the array is iterated over after all items have been loaded. - def all(opts = (defarg=true;nil), &block) - Deprecation.deprecate("Calling Dataset#all with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).all.") unless defarg + def all(&block) a = [] - defarg ? each{|r| a << r} : each(opts){|r| a << r} + each{|r| a << r} post_load(a) a.each(&block) if block a @@ -170,24 +168,21 @@ module Sequel # Deletes the records in the dataset. The returned value is generally the # number of records deleted, but that is adapter dependent. - def delete(opts=(defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#delete with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).delete.") unless defarg - execute_dui(defarg ? delete_sql : delete_sql(opts)) + def delete + execute_dui(delete_sql) end # Iterates over the records in the dataset as they are yielded from the # database adapter, and returns self. - def each(opts = (defarg=true;nil), &block) - Deprecation.deprecate("Calling Dataset#each with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).each.") unless defarg - if opts && opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)} - prev_columns = @columns - begin - defarg ? _each(&block) : _each(opts, &block) - ensure - @columns = prev_columns - end + def each(&block) + if @opts[:graph] + graph_each(&block) else - defarg ? _each(&block) : _each(opts, &block) + if row_proc = @row_proc + fetch_rows(select_sql){|r| yield row_proc.call(r)} + else + fetch_rows(select_sql, &block) + end end self end @@ -250,9 +245,8 @@ module Sequel # Updates values for the dataset. The returned value is generally the # number of rows updated, but that is adapter dependent. - def update(values={}, opts=(defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#update with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).update.") unless defarg - execute_dui(defarg ? update_sql(values) : update_sql(value, opts)) + def update(values={}) + execute_dui(update_sql(values)) end # Add the mutation methods via metaprogramming @@ -267,23 +261,6 @@ module Sequel private - # Runs #graph_each if graphing. Otherwise, iterates through the records - # yielded by #fetch_rows, applying any row_proc or transform if necessary, - # and yielding the result. - def _each(opts=(defarg=true;nil), &block) - if @opts[:graph] and !(opts && opts[:graph] == false) - defarg ? graph_each(&block) : graph_each(opts, &block) - else - row_proc = @row_proc unless opts && opts[:naked] - transform = @transform - fetch_rows(defarg ? select_sql : select_sql(opts)) do |r| - r = transform_load(r) if transform - r = row_proc[r] if row_proc - yield r - end - end - end - # Set the server to use to :default unless it is already set in the passed opts def default_server_opts(opts) {:server=>@opts[:server] || :default}.merge(opts) @@ -338,10 +315,6 @@ module Sequel # VirtualRow instance. def virtual_row_block_call(block) return unless block - unless Sequel.virtual_row_instance_eval - Deprecation.deprecate('Using a VirtualRow block without an argument is deprecated, and its meaning will change in Sequel 3.0. Add a block argument to keep the old semantics, or set Sequel.virtual_row_instance_eval = true to use instance_eval for VirtualRow blocks without arguments.') unless block.arity == 1 - return block.call(SQL::VirtualRow.new) - end case block.arity when -1, 0 SQL::VirtualRow.new.instance_eval(&block) lib/sequel/dataset.rb @@ -2,13 +2,16 @@ module Sequel class Dataset COMMA_SEPARATOR = ', '.freeze COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count) + ARRAY_ACCESS_ERROR_MSG = 'You cannot call Dataset#[] with an integer or with no arguments.'.freeze + MAP_ERROR_MSG = 'Using Dataset#map with an argument and a block is not allowed'.freeze + GET_ERROR_MSG = 'must provide argument or block to Dataset#get, not both'.freeze + IMPORT_ERROR_MSG = 'Using Sequel::Dataset#import an empty column array is not allowed'.freeze # Returns the first record matching the conditions. Examples: # # ds[:id=>1] => {:id=1} def [](*conditions) - Deprecation.deprecate('Using an Integer argument to Dataset#[] is deprecated and will raise an error in Sequel 3.0. Use Dataset#first.') if conditions.length == 1 and conditions.is_a?(Integer) - Deprecation.deprecate('Using Dataset#[] without an argument is deprecated and will raise an error in Sequel 3.0. Use Dataset#first.') if conditions.length == 0 + raise(Error, ARRAY_ACCESS_ERROR_MSG) if (conditions.length == 1 and conditions.is_a?(Integer)) or conditions.length == 0 first(*conditions) end @@ -70,8 +73,12 @@ module Sequel # ds.get(:id) # ds.get{|o| o.sum(:id)} def get(column=nil, &block) - raise(Error, 'must provide argument or block to Dataset#get, not both') if column && block - (column ? select(column) : select(&block)).single_value + if column + raise(Error, GET_ERROR_MSG) if block + select(column).single_value + else + select(&block).single_value + end end # Returns a dataset grouped by the given column with count by group, @@ -101,31 +108,18 @@ module Sequel # # # this will commit every 50 records # dataset.import([:x, :y], [[1, 2], [3, 4], ...], :slice => 50) - def import(*args) - if args.empty? - Sequel::Deprecation.deprecate('Calling Sequel::Dataset#import with no arguments', 'Use dataset.multi_insert([])') - return - elsif args[0].is_a?(Array) && args[1].is_a?(Array) - columns, values, opts = *args - elsif args[0].is_a?(Array) && args[1].is_a?(Dataset) - table = @opts[:from].first - columns, dataset = *args - sql = "INSERT INTO #{quote_identifier(table)} (#{identifier_list(columns)}) VALUES #{literal(dataset)}" - return @db.transaction{execute_dui(sql)} - else - Sequel::Deprecation.deprecate('Calling Sequel::Dataset#import with hashes', 'Use Sequel::Dataset#multi_insert') - return multi_insert(*args) - end - # make sure there's work to do - Sequel::Deprecation.deprecate('Calling Sequel::Dataset#import an empty column array is deprecated and will raise an error in Sequel 3.0.') if columns.empty? - return if columns.empty? || values.empty? - - slice_size = opts && (opts[:commit_every] || opts[:slice]) + def import(columns, values, opts={}) + return @db.transaction{execute_dui("INSERT INTO #{quote_schema_table(@opts[:from].first)} (#{identifier_list(columns)}) VALUES #{literal(values)}")} if values.is_a?(Dataset) + + return if values.empty? + raise(Error, IMPORT_ERROR_MSG) if columns.empty? - if slice_size - values.each_slice(slice_size) do |slice| - statements = multi_insert_sql(columns, slice) - @db.transaction(opts){statements.each{|st| execute_dui(st)}} + if slice_size = opts[:commit_every] || opts[:slice] + offset = 0 + loop do + @db.transaction(opts){multi_insert_sql(columns, values[offset, slice_size]).each{|st| execute_dui(st)}} + offset += slice_size + break if offset >= values.length end else statements = multi_insert_sql(columns, values) @@ -155,8 +149,8 @@ module Sequel # ds.map(:id) => [1, 2, 3, ...] # ds.map{|r| r[:id] * 2} => [2, 4, 6, ...] def map(column=nil, &block) - Deprecation.deprecate('Using Dataset#map with an argument and a block is deprecated and will raise an error in Sequel 3.0. Use an argument or a block, not both.') if column && block if column + raise(Error, MAP_ERROR_MSG) if block super(){|r| r[column]} else super(&block) @@ -183,22 +177,10 @@ module Sequel # values. # # You can also use the :slice or :commit_every option that import accepts. - def multi_insert(*args) - if args.empty? - Sequel::Deprecation.deprecate('Calling Sequel::Dataset#multi_insert with no arguments', 'Use dataset.multi_insert([])') - return - elsif args[0].is_a?(Array) && (args[1].is_a?(Array) || args[1].is_a?(Dataset)) - Sequel::Deprecation.deprecate('Calling Sequel::Dataset#multi_insert with an array of columns and an array of arrays of values', 'Use Sequel::Dataset#import') - return import(*args) - else - # we assume that an array of hashes is given - hashes, opts = *args - return if hashes.empty? - columns = hashes.first.keys - # convert the hashes into arrays - values = hashes.map {|h| columns.map {|c| h[c]}} - end - import(columns, values, opts) + def multi_insert(hashes, opts={}) + return if hashes.empty? + columns = hashes.first.keys + import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts) end # Returns a Range object made from the minimum and maximum values for the @@ -210,20 +192,15 @@ module Sequel end # Returns the first record in the dataset. - def single_record(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#single_record with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).single_record.") unless defarg - ds = clone(:limit=>1) - opts = opts.merge(:limit=>1) if opts and opts[:limit] - defarg ? ds.each{|r| return r} : ds.each(opts){|r| return r} + def single_record + clone(:limit=>1).each{|r| return r} nil end # Returns the first value of the first record in the dataset. # Returns nil if dataset is empty. - def single_value(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#single_value with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).single_value.") unless defarg - ds = naked.clone(:graph=>false) - if r = (defarg ? ds.single_record : ds.single_record(opts)) + def single_value + if r = naked.clone(:graph=>false).single_record r.values.first end end lib/sequel/dataset/convenience.rb @@ -17,8 +17,7 @@ module Sequel # the tables are combined in the single return hash. You can get around that by # using .select with correct aliases for all of the columns, but it is simpler to # use graph and have the result set split for you. In addition, graph respects - # any row_proc or transform attributes of the current dataset and the datasets - # you use with graph. + # any row_proc of the current dataset and the datasets you use with graph. # # If you are graphing a table and all columns for that table are nil, this # indicates that no matching rows existed in the table, so graph will return nil @@ -186,7 +185,7 @@ module Sequel # Fetch the rows, split them into component table parts, # tranform and run the row_proc on each part (if applicable), # and yield a hash of the parts. - def graph_each(opts=(defarg=true;nil), &block) + def graph_each # Reject tables with nil datasets, as they are excluded from # the result set datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?} @@ -194,13 +193,11 @@ module Sequel table_aliases = datasets.collect{|ta,ds| ta} # Get an array of arrays, one for each dataset, with # the necessary information about each dataset, for speed - datasets = datasets.collect do |ta, ds| - [ta, ds, ds.instance_variable_get(:@transform), ds.row_proc] - end + datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]} # Use the manually set graph aliases, if any, otherwise # use the ones automatically created by .graph column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases] - fetch_rows(defarg ? select_sql : select_sql(opts)) do |r| + fetch_rows(select_sql) do |r| graph = {} # Create the sub hashes, one per table table_aliases.each{|ta| graph[ta]={}} @@ -211,14 +208,11 @@ module Sequel ta, column = tc graph[ta][column] = r[col_alias] end - # For each dataset, transform and run the row - # row_proc if applicable - datasets.each do |ta,ds,tr,rp| + # For each dataset run the row_proc if applicable + datasets.each do |ta,ds,rp| g = graph[ta] graph[ta] = if g.values.any?{|x| !x.nil?} - g = ds.transform_load(g) if tr - g = rp[g] if rp - g + rp ? rp.call(g) : g else nil end lib/sequel/dataset/graph.rb @@ -87,9 +87,8 @@ module Sequel # # dataset.filter{|o| o.price >= 100}.delete_sql #=> # "DELETE FROM items WHERE (price >= 100)" - def delete_sql(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#delete_sql with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).delete_sql.") unless defarg - opts = opts ? @opts.merge(opts) : @opts + def delete_sql + opts = @opts return static_sql(opts[:sql]) if opts[:sql] @@ -147,9 +146,8 @@ module Sequel # # DB.select(1).where(DB[:items].exists).sql # #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)" - def exists(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#exists with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).exists.") unless defarg - LiteralString.new("EXISTS (#{defarg ? select_sql : select_sql(opts)})") + def exists + LiteralString.new("EXISTS (#{select_sql})") end # Returns a copy of the dataset with the given conditions imposed upon it. @@ -324,7 +322,6 @@ module Sequel when Hash values = @opts[:defaults].merge(values) if @opts[:defaults] values = values.merge(@opts[:overrides]) if @opts[:overrides] - values = transform_save(values) if @transform if values.empty? insert_default_values_sql else @@ -683,19 +680,17 @@ module Sequel # Formats a SELECT statement # # dataset.select_sql # => "SELECT * FROM items" - def select_sql(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#select_sql with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).select_sql.") unless defarg - opts = opts ? @opts.merge(opts) : @opts + def select_sql + opts = @opts return static_sql(opts[:sql]) if opts[:sql] sql = 'SELECT' - select_clause_order.each{|x| send("select_#{x}_sql", sql, opts)} + select_clause_order.each{|x| send(:"select_#{x}_sql", sql, opts)} sql end # Same as select_sql, not aliased directly to make subclassing simpler. - def sql(opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#select_sql with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).select_sql.") unless defarg - defarg ? select_sql : select_sql(opts) + def sql + select_sql end # SQL fragment for specifying subscripts (SQL arrays) @@ -733,9 +728,8 @@ module Sequel # # Raises an error if the dataset is grouped or includes more # than one table. - def update_sql(values = {}, opts = (defarg=true;nil)) - Deprecation.deprecate("Calling Dataset#update_sql with an argument is deprecated and will raise an error in Sequel 3.0. Use dataset.clone(opts).update_sql.") unless defarg - opts = opts ? @opts.merge(opts) : @opts + def update_sql(values = {}) + opts = @opts return static_sql(opts[:sql]) if opts[:sql] @@ -750,7 +744,6 @@ module Sequel values = opts[:defaults].merge(values) if opts[:defaults] values = values.merge(opts[:overrides]) if opts[:overrides] # get values from hash - values = transform_save(values) if @transform values.map do |k, v| "#{[String, Symbol].any?{|c| k.is_a?(c)} ? quote_identifier(k) : literal(k)} = #{literal(v)}" end.join(COMMA_SEPARATOR) @@ -775,7 +768,7 @@ module Sequel end # Returns a copy of the dataset with the static SQL used. This is useful if you want - # to keep the same row_proc/transform/graph, but change the SQL used to custom SQL. + # to keep the same row_proc/graph, but change the SQL used to custom SQL. # # dataset.with_sql('SELECT * FROM foo') # SELECT * FROM foo def with_sql(sql, *args) @@ -802,7 +795,6 @@ module Sequel # Internal filter method so it works on either the having or where clauses. def _filter(clause, *cond, &block) cond = cond.first if cond.size == 1 - cond = transform_save(cond) if @transform if cond.is_a?(Hash) cond = filter_expr(cond, &block) cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause] clone(clause => cond) lib/sequel/dataset/sql.rb @@ -32,7 +32,6 @@ class String # clear :all # clear :plurals def self.clear(scope = :all) - Sequel::Inflections.clear(scope) case scope when :all @plurals, @singulars, @uncountables = [], [], [] @@ -48,7 +47,6 @@ class String # irregular 'octopus', 'octopi' # irregular 'person', 'people' def self.irregular(singular, plural) - Sequel::Inflections.irregular(singular, plural) plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1]) singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1]) end @@ -59,7 +57,6 @@ class String # Example: # plural(/(x|ch|ss|sh)$/i, '\1es') def self.plural(rule, replacement) - Sequel::Inflections.plural(rule, replacement) @plurals.insert(0, [rule, replacement]) end @@ -69,7 +66,6 @@ class String # Example: # singular(/([^aeiouy]|qu)ies$/i, '\1y') def self.singular(rule, replacement) - Sequel::Inflections.singular(rule, replacement) @singulars.insert(0, [rule, replacement]) end @@ -80,7 +76,6 @@ class String # uncountable "money", "information" # uncountable %w( money information rice ) def self.uncountable(*words) - Sequel::Inflections.uncountable(*words) (@uncountables << words).flatten! end lib/sequel/extensions/inflector.rb @@ -45,7 +45,7 @@ module Sequel last left_outer_join limit map multi_insert naked order order_by order_more paginate print query range reverse_order right_outer_join select select_all select_more server set set_graph_aliases - single_value to_csv to_hash transform union unfiltered unordered + single_value to_csv to_hash union unfiltered unordered update where with_sql'.map{|x| x.to_sym} # Class instance variables to set to nil when a subclass is created, for -w compliance @@ -106,5 +106,4 @@ module Sequel require 'associations', 'model' Model.plugin Model::Associations end - require 'deprecated', 'model' end lib/sequel/model.rb @@ -285,7 +285,6 @@ module Sequel raise(Error, "Model.set_dataset takes a Symbol or a Sequel::Dataset") end @dataset.row_proc = Proc.new{|r| load(r)} - @dataset.transform(@transform) if @transform if inherited @simple_table = superclass.simple_table @columns = @dataset.columns rescue nil @@ -438,8 +437,6 @@ module Sequel def set_columns(new_columns) @columns = new_columns def_column_accessor(*new_columns) if new_columns - # Deprecation.deprecated - @str_columns = nil @columns end @@ -837,16 +834,12 @@ module Sequel # Set the columns, filtered by the only and except arrays. def set_restricted(hash, only, except) - columns_not_set = [nil, false, "", [], {}].include?(model.instance_variable_get(:@columns)) meths = setter_methods(only, except) strict = strict_param_setting hash.each do |k,v| m = "#{k}=" if meths.include?(m) send(m, v) - elsif columns_not_set && (Symbol === k) - Deprecation.deprecate('Calling Model#set_restricted for a column without a setter method when the model class does not have any columns', 'Use Model#[] for these columns') - self[k] = v elsif strict raise Error, "method #{m} doesn't exist or access is restricted to it" end @@ -887,8 +880,7 @@ module Sequel # typecast_value method, so database adapters can override/augment the handling # for database specific column types. def typecast_value(column, value) - # Deprecation.deprecate : Remove model.serialized call - return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column]) && !model.serialized?(column) + return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column]) value = nil if value == '' and typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type]) raise(InvalidValue, "nil/NULL is not allowed for the #{column} column") if raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false) begin lib/sequel/model/base.rb @@ -97,8 +97,6 @@ module Sequel end # Setup the default inflections - # Commented out until the deprecated inflector is removed -=begin plural(/$/, 's') plural(/s$/i, 's') plural(/(ax|test)is$/i, '\1es') @@ -149,14 +147,13 @@ module Sequel irregular('move', 'moves') uncountable(%w(equipment information rice money species series fish sheep)) -=end private # Convert the given string to CamelCase. Will also convert '/' to '::' which is useful for converting paths to namespaces. def camelize(s) s = s.to_s - # return s.camelize if s.respond_to?(:camelize) + return s.camelize if s.respond_to?(:camelize) s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase} s end @@ -166,7 +163,7 @@ module Sequel # or is not initialized. def constantize(s) s = s.to_s - # return s.constantize if s.respond_to?(:constantize) + return s.constantize if s.respond_to?(:constantize) raise(NameError, "#{inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s.to_s) Object.module_eval("::#{m[1]}", __FILE__, __LINE__) end @@ -174,14 +171,14 @@ module Sequel # Removes the module part from the expression in the string def demodulize(s) s = s.to_s - # return s.demodulize if s.respond_to?(:demodulize) + return s.demodulize if s.respond_to?(:demodulize) s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING) end # Returns the plural form of the word in the string. def pluralize(s) s = s.to_s - # return s.pluralize if s.respond_to?(:pluralize) + return s.pluralize if s.respond_to?(:pluralize) result = s.dup Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase) result @@ -190,7 +187,7 @@ module Sequel # The reverse of pluralize, returns the singular form of a word in a string. def singularize(s) s = s.to_s - # return s.singularize if s.respond_to?(:singularize) + return s.singularize if s.respond_to?(:singularize) result = s.dup Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase) result @@ -200,7 +197,7 @@ module Sequel # Also changes '::' to '/' to convert namespaces to paths. def underscore(s) s = s.to_s - # return s.underscore if s.respond_to?(:underscore) + return s.underscore if s.respond_to?(:underscore) s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE). gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase end lib/sequel/model/inflections.rb @@ -107,7 +107,7 @@ module Sequel end module InstanceMethods - Model::HOOKS.each{|h| class_eval("def #{h}; run_hooks(:#{h}); end", __FILE__, __LINE__)} + Model::HOOKS.each{|h| class_eval("def #{h}; return false if super == false; run_hooks(:#{h}); end", __FILE__, __LINE__)} private lib/sequel/plugins/hook_class_methods.rb @@ -63,50 +63,6 @@ context "Array#sql_array" do end end -context "Array#to_sql" do - deprec_specify "should concatenate multiple lines into a single string" do - "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \ - should == 'SELECT * FROM items WHERE a = 1' - end - - deprec_specify "should remove superfluous white space and line breaks" do - "\tSELECT * \n FROM items ".split.to_sql. \ - should == 'SELECT * FROM items' - end - - deprec_specify "should remove ANSI SQL comments" do - "SELECT * --comment\r\n FROM items\r\n --comment".split.to_sql. \ - should == 'SELECT * FROM items' - end - - deprec_specify "should remove C-style comments" do - "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \ - should == 'SELECT * FROM items' - end -end - -context "String#to_sql" do - deprec_specify "should concatenate multiple lines into a single string" do - "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \ - should == 'SELECT * FROM items WHERE a = 1' - end - - deprec_specify "should remove superfluous white space and line breaks" do - "\tSELECT * \r\n FROM items ".to_sql. \ - should == 'SELECT * FROM items' - end - - deprec_specify "should remove ANSI SQL comments" do - "SELECT * --comment \r\n FROM items\r\n --comment".to_sql. \ - should == 'SELECT * FROM items' - end - - deprec_specify "should remove C-style comments" do - "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \ - should == 'SELECT * FROM items' - end -end - context "String#lit" do specify "should return an LiteralString object" do 'xyz'.lit.should be_a_kind_of(Sequel::LiteralString) @@ -118,13 +74,6 @@ context "String#lit" do "UPDATE t SET stamp = NOW()" end - deprec_specify "should be aliased as expr" do - 'xyz'.expr.should be_a_kind_of(Sequel::LiteralString) - 'xyz'.expr.to_s.should == 'xyz' - Sequel::Database.new[:t].update_sql(:stamp => "NOW()".expr).should == \ - "UPDATE t SET stamp = NOW()" - end - specify "should return a PlaceholderLiteralString object if args are given" do a = 'DISTINCT ?'.lit(:a) a.should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString) @@ -146,18 +95,6 @@ context "String#to_sequel_blob" do end end -context "String#split_sql" do - deprec_specify "should split a string containing multiple statements" do - "DROP TABLE a; DROP TABLE c".split_sql.should == \ - ['DROP TABLE a', 'DROP TABLE c'] - end - - deprec_specify "should remove comments from the string" do - "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \ - ['DROP TABLE a', 'DROP TABLE d'] - end -end - context "#desc" do before do @ds = Sequel::Dataset.new(nil) @@ -365,10 +302,6 @@ context "Symbol" do :abc.cast(:integer).to_s(@ds).should == "CAST(abc AS integer)" end - deprec_specify "should support cast_as method" do - :abc.cast_as(:integer).to_s(@ds).should == "CAST(abc AS integer)" - end - specify "should support cast_numeric and cast_string" do x = :abc.cast_numeric x.should be_a_kind_of(Sequel::SQL::NumericExpression) @@ -406,110 +339,11 @@ context "Symbol" do :abc.cast_numeric(String).to_s(@ds2).should == "CAST(abc AS bar)" end - deprec_specify "should support subscript access using | operator" do - (:abc|1).to_s(@ds).should == 'abc[1]' - (:abc|[1]).to_s(@ds).should == 'abc[1]' - (:abc|[1, 2]).to_s(@ds).should == 'abc[1, 2]' - (:abc|1|2).to_s(@ds).should == 'abc[1, 2]' - end - specify "should support SQL EXTRACT function via #extract " do :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)" end end -context "String#to_time" do - deprec_specify "should convert the string into a Time object" do - "2007-07-11".to_time.should == Time.parse("2007-07-11") - "06:30".to_time.should == Time.parse("06:30") - end - - deprec_specify "should raise InvalidValue for an invalid time" do - proc {'0000-00-00'.to_time}.should raise_error(Sequel::InvalidValue) - end -end - -context "String#to_date" do - after do - Sequel.convert_two_digit_years = true - end - - deprec_specify "should convert the string into a Date object" do - "2007-07-11".to_date.should == Date.parse("2007-07-11") - end - - deprec_specify "should convert 2 digit years by default" do - "July 11, 07".to_date.should == Date.parse("2007-07-11") - end - - deprec_specify "should not convert 2 digit years if set not to" do - Sequel.convert_two_digit_years = false - "July 11, 07".to_date.should == Date.parse("0007-07-11") - end - - deprec_specify "should raise InvalidValue for an invalid date" do - proc {'0000-00-00'.to_date}.should raise_error(Sequel::InvalidValue) - end -end - -context "String#to_datetime" do - after do - Sequel.convert_two_digit_years = true - end - - deprec_specify "should convert the string into a DateTime object" do - "2007-07-11 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a") - end - - deprec_specify "should convert 2 digit years by default" do - "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a") - end - - deprec_specify "should not convert 2 digit years if set not to" do - Sequel.convert_two_digit_years = false - "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("0007-07-11 10:11:12a") - end - - deprec_specify "should raise InvalidValue for an invalid date" do - proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::InvalidValue) - end -end - -context "String#to_sequel_time" do - after do - Sequel.datetime_class = Time - Sequel.convert_two_digit_years = true - end - - deprec_specify "should convert the string into a Time object by default" do - "2007-07-11 10:11:12a".to_sequel_time.class.should == Time - "2007-07-11 10:11:12a".to_sequel_time.should == Time.parse("2007-07-11 10:11:12a") - end - - deprec_specify "should convert the string into a DateTime object if that is set" do - Sequel.datetime_class = DateTime - "2007-07-11 10:11:12a".to_sequel_time.class.should == DateTime - "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a") - end - - deprec_specify "should convert 2 digit years by default if using DateTime class" do - Sequel.datetime_class = DateTime - "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a") - end - - deprec_specify "should not convert 2 digit years if set not to when using DateTime class" do - Sequel.datetime_class = DateTime - Sequel.convert_two_digit_years = false - "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("0007-07-11 10:11:12a") - end - - deprec_specify "should raise InvalidValue for an invalid time" do - proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue) - Sequel.datetime_class = DateTime - proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue) - end -end - context "Sequel::SQL::Function#==" do specify "should be true for functions with the same name and arguments, false otherwise" do a = :date.sql_function(:t) spec/core/core_sql_spec.rb @@ -56,27 +56,6 @@ context "A new Database" do db.send(:identifier_output_method_default).should == :downcase end - deprec_specify "should respect the :upcase_identifiers option" do - Sequel.upcase_identifiers = false - db = Sequel::Database.new(:upcase_identifiers=>false) - db.upcase_identifiers?.should == false - db.upcase_identifiers = true - db.upcase_identifiers?.should == true - db = Sequel::Database.new(:upcase_identifiers=>true) - db.upcase_identifiers?.should == true - db.upcase_identifiers = false - db.upcase_identifiers?.should == false - Sequel.upcase_identifiers = true - db = Sequel::Database.new(:upcase_identifiers=>false) - db.upcase_identifiers?.should == false - db.upcase_identifiers = true - db.upcase_identifiers?.should == true - db = Sequel::Database.new(:upcase_identifiers=>true) - db.upcase_identifiers?.should == true - db.upcase_identifiers = false - db.upcase_identifiers?.should == false - end - specify "should respect the :identifier_input_method option" do Sequel.identifier_input_method = nil Sequel::Database.identifier_input_method.should == "" @@ -134,17 +113,6 @@ context "A new Database" do Sequel::Database.new({}).quote_identifiers?.should == false end - deprec_specify "should use the default Sequel.upcase_identifiers value" do - Sequel.upcase_identifiers = true - Sequel::Database.new({}).upcase_identifiers?.should == true - Sequel.upcase_identifiers = false - Sequel::Database.new({}).upcase_identifiers?.should == false - Sequel::Database.upcase_identifiers = true - Sequel::Database.new({}).upcase_identifiers?.should == true - Sequel::Database.upcase_identifiers = false - Sequel::Database.new({}).upcase_identifiers?.should == false - end - specify "should use the default Sequel.identifier_input_method value" do Sequel.identifier_input_method = :downcase Sequel::Database.new({}).identifier_input_method.should == :downcase @@ -316,28 +284,6 @@ context "Database#<<" do (@db << "DELETE FROM items").should == "DELETE FROM items" end - deprec_specify "should accept an array and convert it to SQL" do - a = %[ - -- - CREATE TABLE items (a integer, /*b integer*/ - b text, c integer); - DROP TABLE old_items; - ].split($/) - (@db << a).should == - "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;" - end - - deprec_specify "should remove comments and whitespace from arrays" do - s = %[ - -- - CREATE TABLE items (a integer, /*b integer*/ - b text, c integer); \r\n - DROP TABLE old_items; - ].split($/) - (@db << s).should == - "CREATE TABLE items (a integer, b text, c integer); DROP TABLE old_items;" - end - specify "should not remove comments and whitespace from strings" do s = "INSERT INTO items VALUES ('---abc')" (@db << s).should == s @@ -733,13 +679,6 @@ context "A Database adapter with a scheme" do CCC::DISCONNECTS.should == [z, y, x] end - deprec_specify "should be accessible through Sequel.open" do - c = Sequel.open 'ccc://localhost/db' - c.should be_a_kind_of(CCC) - c.opts[:host].should == 'localhost' - c.opts[:database].should == 'db' - end - specify "should be accessible through Sequel.<adapter>" do Sequel.send(:def_adapter_method, :ccc) @@ -863,25 +802,6 @@ context "A database" do Sequel::Database.single_threaded = false end - deprec_specify "should have a multi_threaded? method" do - db = Sequel::Database.new(:single_threaded => true) - db.should_not be_multi_threaded - - db = Sequel::Database.new(:max_options => 1) - db.should be_multi_threaded - - db = Sequel::Database.new - db.should be_multi_threaded - - Sequel::Database.single_threaded = true - - db = Sequel::Database.new - db.should_not be_multi_threaded - - db = Sequel::Database.new(:max_options => 4) - db.should_not be_multi_threaded - end - specify "should have single_threaded? respond to true if in single threaded mode" do db = Sequel::Database.new(:single_threaded => true) db.should be_single_threaded @@ -901,20 +821,6 @@ context "A database" do db.should be_single_threaded end - deprec_specify "should have a logger method" do - db = Sequel::Database.new - s = "I'm a logger" - db.logger = s - db.logger.should == s - db.logger = nil - db.logger.should == nil - db.loggers = [] - db.logger.should == nil - t = "I'm also a logger" - db.loggers = [s, t] - db.logger.should == s - end - specify "should be able to set loggers via the logger= and loggers= methods" do db = Sequel::Database.new s = "I'm a logger" @@ -934,18 +840,6 @@ context "A database" do end end -context "Database#dataset" do - before do - @db = Sequel::Database.new - end - - deprec_specify "should delegate to Dataset#query if block is provided" do - @d = @db.query {select :x; from :y} - @d.should be_a_kind_of(Sequel::Dataset) - @d.sql.should == "SELECT x FROM y" - end -end - context "Database#fetch" do before do @db = Sequel::Database.new @@ -1084,32 +978,6 @@ context "Database#alter_table_sql" do end end -context "Database.connect" do - EEE_YAML = "development:\r\n adapter: eee\r\n username: mau\r\n password: tau\r\n host: alfonso\r\n database: mydb\r\n" - - before do - class EEE < Sequel::Database - set_adapter_scheme :eee - end - - @fn = File.join(File.dirname(__FILE__), 'eee.yaml') - File.open(@fn, 'wb') {|f| f << EEE_YAML} - end - - after do - File.delete(@fn) - end - - specify "should accept hashes loaded from YAML files" do - db = Sequel.connect(YAML.load_file(@fn)['development']) - db.class.should == EEE - db.opts[:database].should == 'mydb' - db.opts[:user].should == 'mau' - db.opts[:password].should == 'tau' - db.opts[:host].should == 'alfonso' - end -end - context "Database#inspect" do before do @db = DummyDatabase.new spec/core/database_spec.rb @@ -74,20 +74,6 @@ context "Dataset" do @dataset.literal(:a).should == 'a' end - deprec_specify "should have upcase_identifiers= method which changes literalization of identifiers" do - @dataset.upcase_identifiers = true - @dataset.literal(:a).should == 'A' - @dataset.upcase_identifiers = false - @dataset.literal(:a).should == 'a' - end - - deprec_specify "should have upcase_identifiers? method which returns whether identifiers are currently upcased" do - @dataset.upcase_identifiers = true - @dataset.upcase_identifiers?.should == true - @dataset.upcase_identifiers = false - @dataset.upcase_identifiers?.should == false - end - specify "should have identifier_input_method= method which changes literalization of identifiers" do @dataset.identifier_input_method = :upcase @dataset.literal(:a).should == 'A' @@ -1252,10 +1238,6 @@ context "Dataset#distinct" do @dataset.distinct.sql.should == 'SELECT DISTINCT name FROM test' end - deprec_specify "should be aliased by Dataset#uniq" do - @dataset.uniq.sql.should == 'SELECT DISTINCT name FROM test' - end - specify "should accept an expression list" do @dataset.distinct(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test' @dataset.distinct(:stamp.cast(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test' @@ -1288,10 +1270,6 @@ context "Dataset#count" do @c.sql.should == 'SELECT COUNT(*) FROM test LIMIT 1' end - deprec_specify "should be aliased by #size" do - @dataset.size.should == 1 - end - specify "should include the where clause if it's there" do @dataset.filter(:abc.sql_number < 30).count.should == 1 @c.sql.should == 'SELECT COUNT(*) FROM test WHERE (abc < 30) LIMIT 1' @@ -1357,11 +1335,6 @@ context "Dataset#group_and_count" do @ds.group_and_count(:a, :b).sql.should == "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count" end - - deprec_specify "should work within query block" do - @ds.query{group_and_count(:a, :b)}.sql.should == - "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count" - end end context "Dataset#empty?" do @@ -1961,14 +1934,6 @@ context "Dataset#single_record" do @d.single_record.should == 'SELECT * FROM test LIMIT 1' end - deprec_specify "should pass opts to each" do - @d.single_record(:order => [:name]).should == 'SELECT * FROM test ORDER BY name LIMIT 1' - end - - deprec_specify "should override the limit if passed as an option" do - @d.single_record(:limit => 3).should == 'SELECT * FROM test LIMIT 1' - end - specify "should return nil if no record is present" do @e.single_record.should be_nil end @@ -1993,10 +1958,6 @@ context "Dataset#single_value" do @d.single_value.should == 'SELECT * FROM test LIMIT 1' end - deprec_specify "should pass opts to each" do - @d.single_value(:from => [:blah]).should == 'SELECT * FROM blah LIMIT 1' - end - specify "should return nil if no records" do @e.single_value.should be_nil end @@ -2071,251 +2032,6 @@ context "Dataset#set_row_proc" do end end -context "Dataset#set_model" do - before do - @c = Class.new(Sequel::Dataset) do - def fetch_rows(sql, &block) - # yield a hash with kind as the 1 bit of a number - (1..10).each {|i| block.call({:kind => i[0]})} - end - end - @dataset = @c.new(nil).from(:items) - @m = Class.new do - attr_accessor :c, :args - def initialize(c, *args); @c = c; @args = args; end - def ==(o); (@c == o.c) && (@args = o.args); end - end - end - - deprec_specify "should clear the models hash and restore the stock #each if nil is specified" do - @dataset.set_model(@m) - @dataset.set_model(nil) - @dataset.first.should == {:kind => 1} - @dataset.model_classes.should be_nil - end - - deprec_specify "should clear the models hash and restore the stock #each if nothing is specified" do - @dataset.set_model(@m) - @dataset.set_model(nil) - @dataset.first.should == {:kind => 1} - @dataset.model_classes.should be_nil - end - - deprec_specify "should alter #each to provide model instances" do - @dataset.first.should == {:kind => 1} - @dataset.set_model(@m) - @dataset.first.should == @m.new({:kind => 1}) - end - - deprec_specify "should set opts[:naked] to nil" do - @dataset.opts[:naked] = true - @dataset.set_model(@m) - @dataset.opts[:naked].should be_nil - end - - deprec_specify "should send additional arguments to the models' initialize method" do - @dataset.set_model(@m, 7, 6, 5) - @dataset.first.should == @m.new({:kind => 1}, 7, 6, 5) - end - - deprec_specify "should provide support for polymorphic model instantiation" do - @m1 = Class.new(@m) - @m2 = Class.new(@m) - @dataset.set_model(:kind, 0 => @m1, 1 => @m2) - @dataset.opts[:polymorphic_key].should == :kind - all = @dataset.all - all[0].class.should == @m2 - all[1].class.should == @m1 - all[2].class.should == @m2 - all[3].class.should == @m1 - #... - - # denude model - @dataset.set_model(nil) - @dataset.first.should == {:kind => 1} - end - - deprec_specify "should send additional arguments for polymorphic models as well" do - @m1 = Class.new(@m) - @m2 = Class.new(@m) - @dataset.set_model(:kind, {0 => @m1, 1 => @m2}, :hey => :wow) - all = @dataset.all - all[0].class.should == @m2; all[0].args.should == [{:hey => :wow}] - all[1].class.should == @m1; all[1].args.should == [{:hey => :wow}] - all[2].class.should == @m2; all[2].args.should == [{:hey => :wow}] - all[3].class.should == @m1; all[3].args.should == [{:hey => :wow}] - end - - deprec_specify "should raise for invalid parameters" do - proc {@dataset.set_model('kind')}.should raise_error(ArgumentError) - proc {@dataset.set_model(0)}.should raise_error(ArgumentError) - proc {@dataset.set_model(:kind)}.should raise_error(ArgumentError) # no hash given - end -end - -context "Dataset#model_classes" do - before do - @c = Class.new(Sequel::Dataset) do - # # We don't need that for now - # def fetch_rows(sql, &block) - # (1..10).each(&block) - # end - end - @dataset = @c.new(nil).from(:items) - @m = Class.new do - attr_accessor :c - def initialize(c); @c = c; end - def ==(o); @c == o.c; end - end - end - - deprec_specify "should return nil for a naked dataset" do - @dataset.model_classes.should == nil - end - - deprec_specify "should return a {nil => model_class} hash for a model dataset" do - @dataset.set_model(@m) - @dataset.model_classes.should == {nil => @m} - end - - deprec_specify "should return the polymorphic hash for a polymorphic model dataset" do - @m1 = Class.new(@m) - @m2 = Class.new(@m) - @dataset.set_model(:key, 0 => @m1, 1 => @m2) - @dataset.model_classes.should == {0 => @m1, 1 => @m2} - end -end - -context "Dataset#polymorphic_key" do - before do - @c = Class.new(Sequel::Dataset) do - # # We don't need this for now - # def fetch_rows(sql, &block) - # (1..10).each(&block) - # end - end - @dataset = @c.new(nil).from(:items) - @m = Class.new do - attr_accessor :c - def initialize(c); @c = c; end - def ==(o); @c == o.c; end - end - end - - deprec_specify "should return nil for a naked dataset" do - @dataset.polymorphic_key.should be_nil - end - - deprec_specify "should return the polymorphic key" do - @dataset.set_model(:id, nil => @m) - @dataset.polymorphic_key.should == :id - end -end - -context "A model dataset" do - before do - @c = Class.new(Sequel::Dataset) do - def fetch_rows(sql, &block) - (1..10).each(&block) - end - end - @dataset = @c.new(nil).from(:items) - @m = Class.new do - attr_accessor :c - def initialize(c); @c = c; end - def ==(o); @c == o.c; end - end - @dataset.row_proc = Proc.new{|r| @m.new(r)} - end - - deprec_specify "should supply naked records if the naked option is specified" do - @dataset.each {|r| r.class.should == @m} - @dataset.naked.each(:naked => true) {|r| r.class.should == Fixnum} - end -end - -context "A polymorphic model dataset" do - before do - @c = Class.new(Sequel::Dataset) do - def fetch_rows(sql, &block) - (1..10).each {|i| block.call(:bit => i[0])} - end - end - @dataset = @c.new(nil).from(:items) - @m = Class.new do - attr_accessor :c - def initialize(c); @c = c; end - def ==(o); @c == o.c; end - end - end - - deprec_specify "should use a nil key in the polymorphic hash to specify the default model class" do - @m2 = Class.new(@m) - @dataset.set_model(:bit, nil => @m, 1 => @m2) - all = @dataset.all - all[0].class.should == @m2 - all[1].class.should == @m - all[2].class.should == @m2 - all[3].class.should == @m - #... - end - - deprec_specify "should raise Sequel::Error if no suitable class is found in the polymorphic hash" do - @m2 = Class.new(@m) - @dataset.set_model(:bit, 1 => @m2) - proc {@dataset.all}.should raise_error(Sequel::Error) - end - - deprec_specify "should supply naked records if the naked option is specified" do - @dataset.set_model(:bit, nil => @m) - @dataset.each(:naked => true) {|r| r.class.should == Hash} - end -end - -context "A dataset with associated model class(es)" do - before do - @c = Class.new(Sequel::Dataset) do - def fetch_rows(sql, &block) - block.call({:x => 1, :y => 2}) - end - end - @dataset = @c.new(nil).from(:items) - @m1 = Class.new do - attr_accessor :v - def initialize(v); @v = v; end - end - @m2 = Class.new do - attr_accessor :v, :vv - def initialize(v = nil); @v = v; end - def self.load(v); o = new(nil); o.vv = v; o; end - end - @m3 = Class.new(@m2) - end - - deprec_specify "should instantiate an instance by passing the record hash as argument" do - @dataset.set_model(@m1) - o = @dataset.first - o.class.should == @m1 - o.v.should == {:x => 1, :y => 2} - end - - deprec_specify "should use the .load constructor if available" do - @dataset.set_model(@m2) - o = @dataset.first - o.class.should == @m2 - o.v.should == nil - o.vv.should == {:x => 1, :y => 2} - end - - deprec_specify "should use the .load constructor also for polymorphic datasets" do - @dataset.set_model(:y, 1 => @m2, 2 => @m3) - o = @dataset.first - o.class.should == @m3 - o.v.should == nil - o.vv.should == {:x => 1, :y => 2} - end -end - context "Dataset#<<" do before do @d = Sequel::Dataset.new(nil) @@ -2329,104 +2045,6 @@ context "Dataset#<<" do end end -context "A paginated dataset" do - before do - @d = Sequel::Dataset.new(nil) - @d.meta_def(:count) {153} - - deprec{@paginated = @d.paginate(1, 20)} - end - - deprec_specify "should raise an error if the dataset already has a limit" do - proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error) - proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error) - end - - deprec_specify "should set the limit and offset options correctly" do - @paginated.opts[:limit].should == 20 - @paginated.opts[:offset].should == 0 - end - - deprec_specify "should set the page count correctly" do - @paginated.page_count.should == 8 - @d.paginate(1, 50).page_count.should == 4 - end - - deprec_specify "should set the current page number correctly" do - @paginated.current_page.should == 1 - @d.paginate(3, 50).current_page.should == 3 - end - - deprec_specify "should return the next page number or nil if we're on the last" do - @paginated.next_page.should == 2 - @d.paginate(4, 50).next_page.should be_nil - end - - deprec_specify "should return the previous page number or nil if we're on the last" do - @paginated.prev_page.should be_nil - @d.paginate(4, 50).prev_page.should == 3 - end - - deprec_specify "should return the page range" do - @paginated.page_range.should == (1..8) - @d.paginate(4, 50).page_range.should == (1..4) - end - - deprec_specify "should return the record range for the current page" do - @paginated.current_page_record_range.should == (1..20) - @d.paginate(4, 50).current_page_record_range.should == (151..153) - @d.paginate(5, 50).current_page_record_range.should == (0..0) - end - - deprec_specify "should return the record count for the current page" do - @paginated.current_page_record_count.should == 20 - @d.paginate(3, 50).current_page_record_count.should == 50 - @d.paginate(4, 50).current_page_record_count.should == 3 - @d.paginate(5, 50).current_page_record_count.should == 0 - end - - deprec_specify "should know if current page is last page" do - @paginated.last_page?.should be_false - @d.paginate(2, 20).last_page?.should be_false - @d.paginate(5, 30).last_page?.should be_false - @d.paginate(6, 30).last_page?.should be_true - end - - deprec_specify "should know if current page is first page" do - @paginated.first_page?.should be_true - @d.paginate(1, 20).first_page?.should be_true - @d.paginate(2, 20).first_page?.should be_false - end - - deprec_specify "should work with fixed sql" do - ds = @d.clone(:sql => 'select * from blah') - ds.meta_def(:count) {150} - ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50' - end -end - -context "Dataset#each_page" do - before do - @d = Sequel::Dataset.new(nil).from(:items) - @d.meta_def(:count) {153} - end - - deprec_specify "should raise an error if the dataset already has a limit" do - proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error) - end - - deprec_specify "should iterate over each page in the resultset as a paginated dataset" do - a = [] - @d.each_page(50) {|p| a << p} - a.map {|p| p.sql}.should == [ - 'SELECT * FROM items LIMIT 50 OFFSET 0', - 'SELECT * FROM items LIMIT 50 OFFSET 50', - 'SELECT * FROM items LIMIT 50 OFFSET 100', - 'SELECT * FROM items LIMIT 50 OFFSET 150', - ] - end -end - context "Dataset#columns" do before do @dataset = DummyDataset.new(nil).from(:items) @@ -2469,39 +2087,9 @@ context "Dataset#columns!" do end end -require 'stringio' - -context "Dataset#print" do - before do - @output = StringIO.new - @orig_stdout = $stdout - $stdout = @output - @dataset = DummyDataset.new(nil).from(:items) - end - - after do - $stdout = @orig_stdout - end - - deprec_specify "should print out a table with the values" do - @dataset.print(:a, :b) - @output.rewind - @output.read.should == \ - "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n" - end - - deprec_specify "should default to the dataset's columns" do - @dataset.meta_def(:columns) {[:a, :b]} - @dataset.print - @output.rewind - @output.read.should == \ - "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n" - end -end - context "Dataset#import" do before do - @dbc = Class.new do + @dbc = Class.new(Sequel::Database) do attr_reader :sqls def execute(sql, opts={}) @@ -2524,76 +2112,6 @@ context "Dataset#import" do @list = [{:name => 'abc'}, {:name => 'def'}, {:name => 'ghi'}] end - deprec_specify "should issue multiple inserts inside a transaction" do - @ds.import(@list) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (name) VALUES ('abc')", - "INSERT INTO items (name) VALUES ('def')", - "INSERT INTO items (name) VALUES ('ghi')", - 'COMMIT' - ] - end - - deprec_specify "should handle different formats for tables" do - @ds = @ds.from(:sch__tab) - @ds.import(@list) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO sch.tab (name) VALUES ('abc')", - "INSERT INTO sch.tab (name) VALUES ('def')", - "INSERT INTO sch.tab (name) VALUES ('ghi')", - 'COMMIT' - ] - @db.sqls.clear - - @ds = @ds.from(:tab.qualify(:sch)) - @ds.import(@list) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO sch.tab (name) VALUES ('abc')", - "INSERT INTO sch.tab (name) VALUES ('def')", - "INSERT INTO sch.tab (name) VALUES ('ghi')", - 'COMMIT' - ] - @db.sqls.clear - @ds = @ds.from(:sch__tab.identifier) - @ds.import(@list) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO sch__tab (name) VALUES ('abc')", - "INSERT INTO sch__tab (name) VALUES ('def')", - "INSERT INTO sch__tab (name) VALUES ('ghi')", - 'COMMIT' - ] - end - - deprec_specify "should accept the :commit_every option for committing every x records" do - @ds.import(@list, :commit_every => 2) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (name) VALUES ('abc')", - "INSERT INTO items (name) VALUES ('def')", - 'COMMIT', - 'BEGIN', - "INSERT INTO items (name) VALUES ('ghi')", - 'COMMIT' - ] - end - - deprec_specify "should accept the :slice option for committing every x records" do - @ds.import(@list, :slice => 2) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (name) VALUES ('abc')", - "INSERT INTO items (name) VALUES ('def')", - 'COMMIT', - 'BEGIN', - "INSERT INTO items (name) VALUES ('ghi')", - 'COMMIT' - ] - end - specify "should accept string keys as column names" do @ds.import(['x', 'y'], [[1, 2], [3, 4]]) @db.sqls.should == [ @@ -2625,6 +2143,16 @@ context "Dataset#import" do ] end + specify "should accept a columns array and a values array with :commit_every option" do + @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :commit_every => 3) + @db.sqls.should == [ + 'BEGIN', + "INSERT INTO items (x, y) VALUES (1, 2)", + "INSERT INTO items (x, y) VALUES (3, 4)", + "INSERT INTO items (x, y) VALUES (5, 6)", + 'COMMIT', + ] + end specify "should accept a columns array and a values array with slice option" do @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2) @db.sqls.should == [ @@ -2637,23 +2165,6 @@ context "Dataset#import" do 'COMMIT' ] end - - deprec_specify "should not do anything if no columns or values are given" do - @ds.import - @db.sqls.should be_nil - - @ds.import([]) - @db.sqls.should be_nil - - @ds.import([], []) - @db.sqls.should be_nil - - @ds.import([{}, {}]) - @db.sqls.should be_nil - - @ds.import([:a, :b], []) - @db.sqls.should be_nil - end end context "Dataset#multi_insert" do @@ -2726,10 +2237,12 @@ context "Dataset#multi_insert" do end specify "should accept the :commit_every option for committing every x records" do - @ds.multi_insert(@list, :commit_every => 2) + @ds.multi_insert(@list, :commit_every => 1) @db.sqls.should == [ 'BEGIN', "INSERT INTO items (name) VALUES ('abc')", + 'COMMIT', + 'BEGIN', "INSERT INTO items (name) VALUES ('def')", 'COMMIT', 'BEGIN', @@ -2761,118 +2274,12 @@ context "Dataset#multi_insert" do ] end - deprec_specify "should accept a columns array and a values array" do - @ds.multi_insert([:x, :y], [[1, 2], [3, 4]]) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (x, y) VALUES (1, 2)", - "INSERT INTO items (x, y) VALUES (3, 4)", - 'COMMIT' - ] - end - - deprec_specify "should accept a columns array and a dataset" do - @ds2 = Sequel::Dataset.new(@db).from(:cats).filter(:purr => true).select(:a, :b) - - @ds.multi_insert([:x, :y], @ds2) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (x, y) VALUES (SELECT a, b FROM cats WHERE (purr IS TRUE))", - 'COMMIT' - ] - end - - deprec_specify "should accept a columns array and a values array with slice option" do - @ds.multi_insert([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2) - @db.sqls.should == [ - 'BEGIN', - "INSERT INTO items (x, y) VALUES (1, 2)", - "INSERT INTO items (x, y) VALUES (3, 4)", - 'COMMIT', - 'BEGIN', - "INSERT INTO items (x, y) VALUES (5, 6)", - 'COMMIT' - ] - end - - deprec_specify "should not do anything if no hashes are provided" do - @ds.multi_insert + specify "should not do anything if no hashes are provided" do + @ds.multi_insert([]) @db.sqls.should be_nil end end -context "Dataset#query" do - before do - @d = Sequel::Dataset.new(nil) - end - - deprec_specify "should support #from" do - q = @d.query {from :xxx} - q.class.should == @d.class - q.sql.should == "SELECT * FROM xxx" - end - - deprec_specify "should support #select" do - q = @d.query do - select :a, :b___mongo - from :yyy - end - q.class.should == @d.class - q.sql.should == "SELECT a, b AS mongo FROM yyy" - end - - deprec_specify "should support #where" do - q = @d.query do - from :zzz - where(:x + 2 > :y + 3) - end - q.class.should == @d.class - q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))" - - q = @d.from(:zzz).query do - where((:x.sql_number > 1) & (:y.sql_number > 2)) - end - q.class.should == @d.class - q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))" - - q = @d.from(:zzz).query do - where :x => 33 - end - q.class.should == @d.class - q.sql.should == "SELECT * FROM zzz WHERE (x = 33)" - end - - deprec_specify "should support #group_by and #having" do - q = @d.query do - from :abc - group_by :id - having(:x.sql_number >= 2) - end - q.class.should == @d.class - q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)" - end - - deprec_specify "should support #order, #order_by" do - q = @d.query do - from :xyz - order_by :stamp - end - q.class.should == @d.class - q.sql.should == "SELECT * FROM xyz ORDER BY stamp" - end - - deprec_specify "should raise on non-chainable method calls" do - proc {@d.query {first_source}}.should raise_error(Sequel::Error) - end - - deprec_specify "should raise on each, insert, update, delete" do - proc {@d.query {each}}.should raise_error(Sequel::Error) - proc {@d.query {insert(:x => 1)}}.should raise_error(Sequel::Error) - proc {@d.query {update(:x => 1)}}.should raise_error(Sequel::Error) - proc {@d.query {delete}}.should raise_error(Sequel::Error) - end -end - context "Dataset" do before do @d = Sequel::Dataset.new(nil).from(:x) @@ -2920,191 +2327,6 @@ context "Dataset" do end end -context "Dataset#transform" do - before do - @c = Class.new(Sequel::Dataset) do - attr_accessor :raw - attr_accessor :sql - - def fetch_rows(sql, &block) - block[@raw] - end - - def insert(v) - @sql = insert_sql(v) - end - - def update(v) - @sql = update_sql(v) - end - end - - @ds = @c.new(nil).from(:items) - deprec do - @ds.transform(:x => [ - proc {|v| Marshal.load(v)}, - proc {|v| Marshal.dump(v)} - ]) - end - end - - deprec_specify "should change the dataset to transform values loaded from the database" do - @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'} - @ds.first.should == {:x => [1, 2, 3], :y => 'hello'} - @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'} - @ds.all.should == [{:x => [1, 2, 3], :y => 'hello'}] - end - - deprec_specify "should change the dataset to transform values saved to the database" do - @ds.insert(:x => :toast) - @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')" - - @ds.insert(:y => 'butter') - @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')" - - @ds.update(:x => ['dream']) - @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'" - end - - deprec_specify "should be transferred to cloned datasets" do - @ds2 = @ds.filter(:a => 1) - - @ds2.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'} - @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'} - - @ds2.insert(:x => :toast) - @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}')" - end - - deprec_specify "should work correctly together with set_row_proc" do - @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r} - @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'} - @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"} - - f = nil - @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'} - @ds.naked.each{|r| f = r} - f.should == {:x => "wow", :y => 'hello'} - end - - deprec_specify "should leave the supplied values intact" do - h = {:x => :toast} - @ds.insert(h) - h.should == {:x => :toast} - end -end - -context "Dataset#transform" do - before do - @c = Class.new(Sequel::Dataset) do - attr_accessor :raw - attr_accessor :sql - - def fetch_rows(sql, &block) - block[@raw] - end - - def insert(v) - @sql = insert_sql(v) - end - - def update(v) - @sql = update_sql(v) - end - end - - @ds = @c.new(nil).from(:items) - end - - deprec_specify "should raise Sequel::Error for invalid transformations" do - proc {@ds.transform(:x => 'mau')}.should raise_error(Sequel::Error::InvalidTransform) - proc {@ds.transform(:x => :mau)}.should raise_error(Sequel::Error::InvalidTransform) - proc {@ds.transform(:x => [])}.should raise_error(Sequel::Error::InvalidTransform) - proc {@ds.transform(:x => ['mau'])}.should raise_error(Sequel::Error::InvalidTransform) - proc {@ds.transform(:x => [proc {|v|}, proc {|v|}])}.should_not raise_error(Sequel::Error::InvalidTransform) - end - - deprec_specify "should support stock YAML transformation" do - @ds.transform(:x => :yaml) - - @ds.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'} - @ds.first.should == {:x => [1, 2, 3], :y => 'hello'} - - @ds.insert(:x => :toast) - @ds.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}')" - @ds.insert(:y => 'butter') - @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')" - @ds.update(:x => ['dream']) - @ds.sql.should == "UPDATE items SET x = '#{['dream'].to_yaml}'" - - @ds2 = @ds.filter(:a => 1) - @ds2.raw = {:x => [1, 2, 3].to_yaml, :y => 'hello'} - @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'} - @ds2.insert(:x => :toast) - @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{:toast.to_yaml}')" - - @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r} - @ds.raw = {:x => "wow".to_yaml, :y => 'hello'} - @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"} - f = nil - @ds.raw = {:x => "wow".to_yaml, :y => 'hello'} - @ds.naked.each{|r| f = r} - f.should == {:x => "wow", :y => 'hello'} - end - - deprec_specify "should support stock Marshal transformation with Base64 encoding" do - @ds.transform(:x => :marshal) - - @ds.raw = {:x => [Marshal.dump([1, 2, 3])].pack('m'), :y => 'hello'} - @ds.first.should == {:x => [1, 2, 3], :y => 'hello'} - - @ds.insert(:x => :toast) - @ds.sql.should == "INSERT INTO items (x) VALUES ('#{[Marshal.dump(:toast)].pack('m')}')" - @ds.insert(:y => 'butter') - @ds.sql.should == "INSERT INTO items (y) VALUES ('butter')" - @ds.update(:x => ['dream']) - @ds.sql.should == "UPDATE items SET x = '#{[Marshal.dump(['dream'])].pack('m')}'" - - @ds2 = @ds.filter(:a => 1) - @ds2.raw = {:x => [Marshal.dump([1, 2, 3])].pack('m'), :y => 'hello'} - @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'} - @ds2.insert(:x => :toast) - @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{[Marshal.dump(:toast)].pack('m')}')" - - @ds.row_proc = proc{|r| r[:z] = r[:x] * 2; r} - @ds.raw = {:x => [Marshal.dump("wow")].pack('m'), :y => 'hello'} - @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"} - f = nil - @ds.raw = {:x => [Marshal.dump("wow")].pack('m'), :y => 'hello'} - @ds.naked.each{|r| f = r} - f.should == {:x => "wow", :y => 'hello'} - end - - deprec_specify "should support loading of Marshalled values without Base64 encoding" do - @ds.transform(:x => :marshal) - - @ds.raw = {:x => Marshal.dump([1,2,3]), :y => nil} - @ds.first.should == {:x => [1,2,3], :y => nil} - end - - deprec_specify "should return self" do - @ds.transform(:x => :marshal).should be(@ds) - end -end - -context "A dataset with a transform" do - before do - @ds = Sequel::Dataset.new(nil).from(:items) - deprec{@ds.transform(:x => :marshal)} - end - - deprec_specify "should automatically transform hash filters" do - @ds.filter(:y => 2).sql.should == 'SELECT * FROM items WHERE (y = 2)' - - @ds.filter(:x => 2).sql.should == "SELECT * FROM items WHERE (x = '#{[Marshal.dump(2)].pack('m')}')" - end -end - context "Dataset#to_csv" do before do @c = Class.new(Sequel::Dataset) do @@ -3137,48 +2359,6 @@ context "Dataset#to_csv" do end end -context "Dataset#create_view" do - before do - @dbc = Class.new(Sequel::Database) do - attr_reader :sqls - - def execute(sql, opts={}) - @sqls ||= [] - @sqls << sql - end - end - @db = @dbc.new - - @ds = @db[:items].order(:abc).filter(:category => 'ruby') - end - - deprec_specify "should create a view with the dataset's sql" do - @ds.create_view(:xyz) - @db.sqls.should == ["CREATE VIEW xyz AS #{@ds.sql}"] - end -end - -context "Dataset#create_or_replace_view" do - before do - @dbc = Class.new(Sequel::Database) do - attr_reader :sqls - - def execute(sql, opts={}) - @sqls ||= [] - @sqls << sql - end - end - @db = @dbc.new - - @ds = @db[:items].order(:abc).filter(:category => 'ruby') - end - - deprec_specify "should create a view with the dataset's sql" do - @ds.create_or_replace_view(:xyz) - @db.sqls.should == ["CREATE OR REPLACE VIEW xyz AS #{@ds.sql}"] - end -end - context "Dataset#update_sql" do before do @ds = Sequel::Dataset.new(nil).from(:items) @@ -3296,14 +2476,6 @@ context "Dataset#all" do ] end - deprec_specify "should accept options and pass them to #each" do - @dataset.all(:limit => 33).should == [ - {:x => 1, :y => 2}, - {:x => 3, :y => 4}, - "SELECT * FROM items LIMIT 33" - ] - end - specify "should iterate over the array if a block is given" do a = [] @@ -3354,30 +2526,6 @@ context "Dataset#grep" do end end -context "Sequel.use_parse_tree" do - deprec_specify "be false" do - Sequel.use_parse_tree.should == false - end -end - -context "Sequel.use_parse_tree=" do - deprec_specify "raise an error if true" do - proc{Sequel.use_parse_tree = true}.should raise_error(Sequel::Error) - end - - deprec_specify "do nothing if false" do - proc{Sequel.use_parse_tree = false}.should_not raise_error - end -end - -context "Dataset.dataset_classes" do - deprec_specify "should be an array of dataset subclasses" do - ds_class = Class.new(Sequel::Dataset) - Sequel::Dataset.dataset_classes.should be_a_kind_of(Array) - Sequel::Dataset.dataset_classes.should include(ds_class) - end -end - context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" do before do @db = Sequel::Database.new @@ -3591,43 +2739,3 @@ context "Sequel::Dataset #set_overrides" do @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1" end end - -context "Sequel::Dataset#each" do - before do - @ds = Sequel::Dataset.new(nil).from(:items) - def @ds.fetch_rows(sql) - @columns = /count/i.match(sql) ? [:count] : [:a] - yield({@columns.first=>sql}) - end - end - - deprec_specify "should not set the columns if passing an option that modifies them" do - @ds.each(:select=>[:count]){} - @ds.columns.should == [:a] - @ds.each(:from=>[:count]){} - @ds.columns.should == [:a] - @ds.each(:join=>[Sequel::SQL::JoinClause.new(:natural, :count)]){} - @ds.columns.should == [:a] - @ds.each(:sql=>'SELECT COUNT'){} - @ds.columns.should == [:a] - end - - deprec_specify "should have the correct columns inside the block regardless" do - @ds.each(:select=>[:count]) do |x| - x[:count].should == 'SELECT count FROM items' - @ds.columns.should == [:count] - end - @ds.each(:from=>[:count]) do |x| - x[:count].should == 'SELECT * FROM count' - @ds.columns.should == [:count] - end - @ds.each(:join=>[Sequel::SQL::JoinClause.new(:natural, :count)]) do |x| - x[:count].should == 'SELECT * FROM items NATURAL JOIN count' - @ds.columns.should == [:count] - end - @ds.each(:sql=>'SELECT COUNT') do |x| - x[:count].should == 'SELECT COUNT' - @ds.columns.should == [:count] - end - end -end spec/core/dataset_spec.rb @@ -710,22 +710,6 @@ context "Schema Parser" do @sqls.should == ['x', 'x'] end - deprec_specify "should parse the schema correctly for all tables" do - sqls = @sqls - proc{@db.schema}.should raise_error(Sequel::Error) - @db.meta_def(:tables){[:x]} - @db.meta_def(:schema_parse_table) do |t, opts| - sqls << t - [[:x, {:db_type=>t.to_s}]] - end - @db.schema.should == {'x'=>[[:x, {:db_type=>"x"}]]} - @sqls.should == ['x'] - @db.schema.should == {'x'=>[[:x, {:db_type=>"x"}]]} - @sqls.should == ['x'] - @db.schema(nil, :reload=>true).should == {'x'=>[[:x, {:db_type=>"x"}]]} - @sqls.should == ['x', 'x'] - end - specify "should convert various types of table name arguments" do @db.meta_def(:schema_parse_table) do |t, opts| [[t, {:db_type=>t}]] spec/core/schema_spec.rb @@ -6,31 +6,6 @@ end Sequel.virtual_row_instance_eval = true -module Spec::Example::ExampleMethods - def deprec - output = Sequel::Deprecation.output = nil - begin - yield - ensure - Sequel::Deprecation.output = output - end - end -end - -module Spec::Example::ExampleGroupMethods - def deprec_specify(*args, &block) - specify(*args) do - output = Sequel::Deprecation.output - Sequel::Deprecation.output = nil - begin - instance_eval(&block) - ensure - Sequel::Deprecation.output = output - end - end - end -end - class MockDataset < Sequel::Dataset def insert(*args) @db.execute insert_sql(*args) spec/core/spec_helper.rb @@ -1,5 +1,7 @@ require File.join(File.dirname(__FILE__), "spec_helper") +require 'yaml' + describe "Serialization plugin" do before do @c = Class.new(Sequel::Model(:items)) do spec/extensions/serialization_spec.rb @@ -70,12 +70,10 @@ end class << Sequel::Model alias orig_columns columns - alias orig_str_columns str_columns def columns(*cols) return if cols.empty? define_method(:columns){cols} @dataset.instance_variable_set(:@columns, cols) if @dataset - define_method(:str_columns){cols.map{|x|x.to_s.freeze}} def_column_accessor(*cols) @columns = cols @db_schema = {} spec/extensions/spec_helper.rb @@ -24,13 +24,6 @@ describe "Database schema parser" do INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number end - deprec_specify "should be a hash with table_names as symbols" do - INTEGRATION_DB.create_table!(:items){integer :number} - schema = INTEGRATION_DB.schema(nil, :reload=>true) - schema.should be_a_kind_of(Hash) - schema[:items].should_not == nil - end - specify "should not issue an sql query if the schema has been loaded unless :reload is true" do INTEGRATION_DB.create_table!(:items){integer :number} INTEGRATION_DB.schema(:items, :reload=>true) @@ -42,11 +35,6 @@ describe "Database schema parser" do sqls_should_be "PRAGMA table_info('items')" end - deprec_specify "should give the same result for a single table regardless of whether schema was called for a single table" do - INTEGRATION_DB.create_table!(:items){integer :number} - INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items] - end - specify "should raise an error when the table doesn't exist" do proc{INTEGRATION_DB.schema(:no_table)}.should raise_error(Sequel::Error) end spec/integration/schema_test.rb @@ -11,20 +11,6 @@ end Sequel.virtual_row_instance_eval = true Sequel::Model.use_transactions = false -module Spec::Example::ExampleGroupMethods - def deprec_specify(*args, &block) - specify(*args) do - output = Sequel::Deprecation.output - Sequel::Deprecation.output = nil - begin - instance_eval(&block) - ensure - Sequel::Deprecation.output = output - end - end - end -end - $sqls = [] def clear_sqls $sqls.clear spec/integration/spec_helper.rb @@ -392,20 +392,6 @@ describe Sequel::Model, "many_to_one" do proc{c.parent = p}.should raise_error(Sequel::Error) end - deprec_specify "should have belongs_to alias" do - @c2.belongs_to :parent, :class => @c2 - - d = @c2.load(:id => 1) - MODEL_DB.reset - d.parent_id = 234 - d.associations[:parent].should == nil - ds = @c2.dataset - def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end - e = d.parent - MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"] - d.associations[:parent].should == e - end - it "should make the change to the foreign_key value inside a _association= method" do @c2.many_to_one :parent, :class => @c2 @c2.private_instance_methods.collect{|x| x.to_s}.sort.should(include("_parent=")) @@ -866,19 +852,6 @@ describe Sequel::Model, "one_to_many" do im2.should_not(include('remove_all_attributes')) end - deprec_specify "should have has_many alias" do - @c2.has_many :attributes, :class => @c1 - - n = @c2.new(:id => 1234) - atts = n.attributes - atts.should be_a_kind_of(Array) - atts.size.should == 1 - atts.first.should be_a_kind_of(@c1) - atts.first.values.should == {} - - MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)'] - end - it "should populate the reciprocal many_to_one instance variable when loading the one_to_many association" do @c2.one_to_many :attributes, :class => @c1, :key => :node_id @c1.many_to_one :node, :class => @c2, :key => :node_id @@ -1532,15 +1505,6 @@ describe Sequel::Model, "many_to_many" do im2.should_not(include('remove_all_attributes')) end - deprec_specify "should have has_and_belongs_to_many alias" do - @c2.has_and_belongs_to_many :attributes, :class => @c1 - - n = @c2.new(:id => 1234) - a = n.attributes_dataset - a.should be_a_kind_of(Sequel::Dataset) - a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))' - end - it "should have an remove_all_ method that removes all associations" do @c2.many_to_many :attributes, :class => @c1 @c2.new(:id => 1234).remove_all_attributes spec/model/associations_spec.rb @@ -31,112 +31,6 @@ describe "Model attribute setters" do end -describe "Model#serialize" do - - before(:each) do - MODEL_DB.reset - end - - deprec_specify "should translate values to YAML when creating records" do - @c = Class.new(Sequel::Model(:items)) do - no_primary_key - serialize :abc - columns :abc - end - - @c.create(:abc => 1) - @c.create(:abc => "hello") - - MODEL_DB.sqls.should == [ \ - "INSERT INTO items (abc) VALUES ('--- 1\n')", \ - "INSERT INTO items (abc) VALUES ('--- hello\n')", \ - ] - end - - deprec_specify "should support calling after the class is defined" do - @c = Class.new(Sequel::Model(:items)) do - no_primary_key - columns :def - end - - @c.serialize :def - - @c.create(:def => 1) - @c.create(:def => "hello") - - MODEL_DB.sqls.should == [ \ - "INSERT INTO items (def) VALUES ('--- 1\n')", \ - "INSERT INTO items (def) VALUES ('--- hello\n')", \ - ] - end - - deprec_specify "should support using the Marshal format" do - @c = Class.new(Sequel::Model(:items)) do - no_primary_key - serialize :abc, :format => :marshal - columns :abc - end - - @c.create(:abc => 1) - @c.create(:abc => "hello") - x = [Marshal.dump("hello")].pack('m') - - MODEL_DB.sqls.should == [ \ - "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \ - "INSERT INTO items (abc) VALUES ('#{x}')", \ - ] - end - - deprec_specify "should translate values to and from YAML using accessor methods" do - @c = Class.new(Sequel::Model(:items)) do - serialize :abc, :def - columns :abc, :def - end - - ds = @c.dataset - ds.extend(Module.new { - attr_accessor :raw - - def fetch_rows(sql, &block) - block.call(@raw) - end - - @@sqls = nil - - def insert(*args) - @@sqls = insert_sql(*args) - end - - def update(*args) - @@sqls = update_sql(*args) - end - - def sqls - @@sqls - end - - def columns - [:id, :abc, :def] - end - } - ) - - ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"} - o = @c.first - o.id.should == 1 - o.abc.should == 1 - o.def.should == "hello" - - o.update(:abc => 23) - ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)" - - ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"} - o = @c.create(:abc => [1, 2, 3]) - ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')" - end - -end - describe Sequel::Model, "dataset" do before do @a = Class.new(Sequel::Model(:items)) spec/model/base_spec.rb @@ -1,173 +1,5 @@ require File.join(File.dirname(__FILE__), "spec_helper") -describe "Model hooks" do - before do - MODEL_DB.reset - end - - deprec_specify "should be definable using a block" do - $adds = [] - c = Class.new(Sequel::Model) - c.class_eval do - before_save {$adds << 'hi'} - end - - c.new.before_save - $adds.should == ['hi'] - end - - deprec_specify "should be definable using a method name" do - $adds = [] - c = Class.new(Sequel::Model) - c.class_eval do - def bye; $adds << 'bye'; end - before_save :bye - end - - c.new.before_save - $adds.should == ['bye'] - end - - deprec_specify "should be additive" do - $adds = [] - c = Class.new(Sequel::Model) - c.class_eval do - after_save {$adds << 'hyiyie'} - after_save {$adds << 'byiyie'} - end - - c.new.after_save - $adds.should == ['hyiyie', 'byiyie'] - end - - deprec_specify "before hooks should run in reverse order" do - $adds = [] - c = Class.new(Sequel::Model) - c.class_eval do - before_save {$adds << 'hyiyie'} - before_save {$adds << 'byiyie'} - end - - c.new.before_save - $adds.should == ['byiyie', 'hyiyie'] - end - - deprec_specify "should not be additive if the method or tag already exists" do - $adds = [] - c = Class.new(Sequel::Model) - c.class_eval do - def bye; $adds << 'bye'; end - before_save :bye - before_save :bye - end - - c.new.before_save - $adds.should == ['bye'] - - $adds = [] - d = Class.new(Sequel::Model) - d.class_eval do - before_save(:bye){$adds << 'hyiyie'} - before_save(:bye){$adds << 'byiyie'} - end - - d.new.before_save - $adds.should == ['byiyie'] - - $adds = [] - e = Class.new(Sequel::Model) - e.class_eval do - def bye; $adds << 'bye'; end - before_save :bye - before_save(:bye){$adds << 'byiyie'} - end - - e.new.before_save - $adds.should == ['byiyie'] - - $adds = [] - e = Class.new(Sequel::Model) - e.class_eval do - def bye; $adds << 'bye'; end - before_save(:bye){$adds << 'byiyie'} - before_save :bye - end - - e.new.before_save - $adds.should == ['bye'] - end - - deprec_specify "should be inheritable" do - $adds = [] - a = Class.new(Sequel::Model) - a.class_eval do - after_save {$adds << '123'} - end - - b = Class.new(a) - b.class_eval do - after_save {$adds << '456'} - after_save {$adds << '789'} - end - - b.new.after_save - $adds.should == ['123', '456', '789'] - end - - deprec_specify "should be overridable in descendant classes" do - $adds = [] - a = Class.new(Sequel::Model) - a.class_eval do - before_save {$adds << '123'} - end - - b = Class.new(a) - b.class_eval do - def before_save; $adds << '456'; end - end - - a.new.before_save - $adds.should == ['123'] - $adds = [] - b.new.before_save - $adds.should == ['456'] - end - - deprec_specify "should stop processing if a hook returns false" do - $flag = true - $adds = [] - - a = Class.new(Sequel::Model) - a.class_eval do - after_save {$adds << 'blah'; $flag} - after_save {$adds << 'cruel'} - end - - a.new.after_save - $adds.should == ['blah', 'cruel'] - - # chain should not break on nil - $adds = [] - $flag = nil - a.new.after_save - $adds.should == ['blah', 'cruel'] - - $adds = [] - $flag = false - a.new.after_save - $adds.should == ['blah'] - - b = Class.new(a) - b.class_eval do - after_save {$adds << 'mau'} - end - - $adds = [] - b.new.after_save - $adds.should == ['blah'] - end -end - describe "Model#after_initialize" do specify "should be called after initialization" do $values1 = nil @@ -359,8 +191,8 @@ describe "Model#before_validation && Model#after_validation" do @c.class_eval do def after_validation; MODEL_DB << "BLAH after" end - def self.validate(o) - o.errors[:id] << 'not valid' unless o[:id] == 2233 + def validate + errors.add(:id, 'not valid') unless id == 2233 end columns :id end @@ -405,68 +237,3 @@ describe "Model#before_validation && Model#after_validation" do MODEL_DB.sqls.should == [] end end - -describe "Model.has_hooks?" do - before do - @c = Class.new(Sequel::Model(:items)) - end - - deprec_specify "should return false if no hooks are defined" do - @c.has_hooks?(:before_save).should be_false - end - - deprec_specify "should return true if hooks are defined" do - @c.before_save {'blah'} - @c.has_hooks?(:before_save).should be_true - end - - deprec_specify "should return true if hooks are inherited" do - @d = Class.new(@c) - @d.has_hooks?(:before_save).should be_false - end -end - -describe "Model#add_hook_type" do - before do - deprec do - class Foo < Sequel::Model(:items) - add_hook_type :before_bar, :after_bar - - def bar - return :b if before_bar == false - return :a if after_bar == false - true - end - end - end - @f = Class.new(Foo) - end - - deprec_specify "should have before_bar and after_bar class methods" do - @f.should respond_to(:before_bar) - @f.should respond_to(:before_bar) - end - - deprec_specify "should have before_bar and after_bar instance methods" do - @f.new.should respond_to(:before_bar) - @f.new.should respond_to(:before_bar) - end - - deprec_specify "it should return true for bar when before_bar and after_bar hooks are returing true" do - a = 1 - @f.before_bar { a += 1} - @f.new.bar.should be_true - a.should == 2 - @f.after_bar { a *= 2} - @f.new.bar.should be_true - a.should == 6 - end - - deprec_specify "it should return nil for bar when before_bar and after_bar hooks are returing false" do - @f.new.bar.should be_true - @f.after_bar { false } - @f.new.bar.should == :a - @f.before_bar { false } - @f.new.bar.should == :b - end -end spec/model/hooks_spec.rb @@ -64,22 +64,6 @@ describe Sequel::Model, "dataset & schema" do ds.should respond_to(:destroy) end - deprec_specify "sets schema with implicit table name" do - @model.set_schema do - primary_key :ssn, :string - end - @model.primary_key.should == :ssn - @model.table_name.should == :items - end - - deprec_specify "sets schema with explicit table name" do - @model.set_schema :foo do - primary_key :id - end - @model.primary_key.should == :id - @model.table_name.should == :foo - end - it "doesn't raise an error on set_dataset if there is an error raised getting the schema" do @model.meta_def(:get_db_schema){raise Sequel::Error} proc{@model.set_dataset(MODEL_DB[:foo])}.should_not raise_error @@ -91,60 +75,6 @@ describe Sequel::Model, "dataset & schema" do end end -describe Sequel::Model, "#sti_key" do - before do - deprec do - class ::StiTest < Sequel::Model - def kind=(x); self[:kind] = x; end - def refresh; end - set_sti_key :kind - end - end - class ::StiTestSub1 < StiTest - end - class ::StiTestSub2 < StiTest - end - @ds = StiTest.dataset - MODEL_DB.reset - end - - deprec_specify "should return rows with the correct class based on the polymorphic_key value" do - def @ds.fetch_rows(sql) - yield({:kind=>'StiTest'}) - yield({:kind=>'StiTestSub1'}) - yield({:kind=>'StiTestSub2'}) - end - StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2] - end - - deprec_specify "should fallback to the main class if polymophic_key value is NULL" do - def @ds.fetch_rows(sql) - yield({:kind=>nil}) - end - StiTest.all.collect{|x| x.class}.should == [StiTest] - end - - deprec_specify "should fallback to the main class if the given class does not exist" do - def @ds.fetch_rows(sql) - yield({:kind=>'StiTestSub3'}) - end - StiTest.all.collect{|x| x.class}.should == [StiTest] - end - - deprec_specify "should add a before_create hook that sets the model class name for the key" do - StiTest.new.save - StiTestSub1.new.save - StiTestSub2.new.save - MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"] - end - - deprec_specify "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do - StiTest.dataset.sql.should == "SELECT * FROM sti_tests" - StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')" - StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub2')" - end -end - describe Sequel::Model, "constructor" do before(:each) do @@ -327,47 +257,6 @@ describe Sequel::Model, ".find_or_create" do end end -describe Sequel::Model, ".delete_all" do - - before(:each) do - MODEL_DB.reset - @c = Class.new(Sequel::Model(:items)) do - no_primary_key - end - - @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql} - end - - deprec_specify "should delete all records in the dataset" do - @c.delete_all - MODEL_DB.sqls.should == ["DELETE FROM items"] - end - -end - -describe Sequel::Model, ".destroy_all" do - - before(:each) do - MODEL_DB.reset - @c = Class.new(Sequel::Model(:items)) do - no_primary_key - end - - @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql} - end - - deprec_specify "should delete all records in the dataset" do - @c.dataset.meta_def(:destroy) {MODEL_DB << "DESTROY this stuff"} - @c.destroy_all - MODEL_DB.sqls.should == ["DESTROY this stuff"] - end - - deprec_specify "should call dataset.destroy" do - @c.dataset.should_receive(:destroy).and_return(true) - @c.destroy_all - end -end - describe Sequel::Model, ".all" do before(:each) do @@ -582,12 +471,3 @@ context "Model.db_schema" do @c.db_schema.should == {:x=>{}} end end - -context "Model.str_columns" do - deprec_specify "should return the columns as frozen strings" do - c = Class.new(Sequel::Model) - c.meta_def(:columns){[:a, :b]} - c.orig_str_columns.should == %w'a b' - proc{c.orig_str_columns.first << 'a'}.should raise_error - end -end spec/model/model_spec.rb @@ -69,74 +69,4 @@ describe Sequel::Model, "using a plugin" do c.should respond_to(:ghi) c.ghi.should == {:a => 1, :b => 2} end - - deprec_specify "should have an .is alias" do - c = nil - proc do - c = Class.new(Sequel::Model) - c.class_eval do - set_dataset MODEL_DB[:items] - is :timestamped, :a => 1, :b => 2 - end - end.should_not raise_error(LoadError) - - c.should respond_to(:stamp_opts) - c.stamp_opts.should == {:a => 1, :b => 2} - - # instance methods - m = c.new - m.should respond_to(:get_stamp) - m.should respond_to(:abc) - m.abc.should == {:a => 1, :b => 2} - t = Time.now - m[:stamp] = t - m.get_stamp.should == t - - # class methods - c.should respond_to(:deff) - c.deff.should == {:a => 1, :b => 2} - - # dataset methods - c.dataset.should respond_to(:ghi) - c.dataset.ghi.should == {:a => 1, :b => 2} - - # dataset methods called on the class - c.should respond_to(:ghi) - c.ghi.should == {:a => 1, :b => 2} - end - - deprec_specify "should have an .is_a alias" do - c = nil - proc do - c = Class.new(Sequel::Model) - c.class_eval do - set_dataset MODEL_DB[:items] - is_a :timestamped, :a => 1, :b => 2 - end - end.should_not raise_error(LoadError) - - c.should respond_to(:stamp_opts) - c.stamp_opts.should == {:a => 1, :b => 2} - - # instance methods - m = c.new - m.should respond_to(:get_stamp) - m.should respond_to(:abc) - m.abc.should == {:a => 1, :b => 2} - t = Time.now - m[:stamp] = t - m.get_stamp.should == t - - # class methods - c.should respond_to(:deff) - c.deff.should == {:a => 1, :b => 2} - - # dataset methods - c.dataset.should respond_to(:ghi) - c.dataset.ghi.should == {:a => 1, :b => 2} - - # dataset methods called on the class - c.should respond_to(:ghi) - c.ghi.should == {:a => 1, :b => 2} - end end spec/model/plugins_spec.rb @@ -228,73 +228,6 @@ describe "Model#save_changes" do end end -describe "Model#update_values" do - before(:each) do - MODEL_DB.reset - - @c = Class.new(Sequel::Model(:items)) do - unrestrict_primary_key - columns :id, :x, :y - end - end - - deprec_specify "should generate an update statement" do - o = @c.new(:id => 1) - o.update_values(:x => 1) - MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)" - end - - deprec_specify "should update attribute values" do - o = @c.new(:id => 1) - o.x.should be_nil - o.update_values(:x => 1) - o.x.should == 1 - end - - deprec_specify "should support string keys" do - o = @c.new(:id => 1) - o.x.should be_nil - o.update_values('x' => 1) - o.x.should == 1 - MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)" - end -end - -describe "Model#set_values" do - before(:each) do - MODEL_DB.reset - - @c = Class.new(Sequel::Model(:items)) do - unrestrict_primary_key - columns :id, :x, :y - end - end - - deprec_specify "should not touch the database" do - o = @c.new(:id => 1) - o.set_values(:x => 1) - MODEL_DB.sqls.should == [] - end - - deprec_specify "should update attribute values" do - o = @c.new(:id => 1) - o.x.should be_nil - o.set_values(:x => 1) - o.x.should == 1 - end - - deprec_specify "should support string keys" do - o = @c.new(:id => 1) - o.x.should be_nil - o.set_values('x' => 1) - o.x.should == 1 - end - - deprec_specify "should raise an error if used with a non-String, non-Symbol key" do - proc{@c.new.set_values(1=>2)}.should raise_error(Sequel::Error) - end -end - describe "Model#new?" do before(:each) do @@ -506,23 +439,11 @@ describe Sequel::Model, "#set" do MODEL_DB.sqls.should == [] end - deprec_specify "should be aliased as set_with_params" do - @o1.set_with_params(:x => 1, :z => 2) - @o1.values.should == {:x => 1} - MODEL_DB.sqls.should == [] - end - it "should return self" do returned_value = @o1.set(:x => 1, :z => 2) returned_value.should == @o1 MODEL_DB.sqls.should == [] end - - deprec_specify "should assume it is a column if no column information is present and the key is a symbol" do - @c.instance_variable_set(:@columns, nil) - o = @c.new.set(:x123=>1) - o[:x123].should == 1 - end end describe Sequel::Model, "#update" do @@ -562,11 +483,6 @@ describe Sequel::Model, "#update" do @o2.values.should == {:y => 1, :id=> 5} MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)" end - - deprec_specify "should be aliased as update_with_params" do - @o1.update_with_params(:x => 1, :z => 2) - MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)" - end end describe Sequel::Model, "#(set|update)_(all|except|only)" do @@ -950,14 +866,6 @@ describe Sequel::Model, "typecasting" do m.x.should == '1' end - deprec_specify "should not convert if serializing the field" do - @c.serialize :x - @c.instance_variable_set(:@db_schema, {:x=>{:type=>:string}}) - m = @c.new - m.x =[1, 2] - m.x.should == [1, 2] - end - specify "should convert to integer for an integer field" do @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}}) m = @c.new @@ -1065,7 +973,7 @@ describe Sequel::Model, "typecasting" do specify "should convert to BigDecimal for a decimal field" do @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}}) m = @c.new - bd = '1.0'.to_d + bd = BigDecimal.new('1.0') m.x = '1.0' m.x.should == bd m.x = 1.0 spec/model/record_spec.rb @@ -10,31 +10,6 @@ end Sequel.virtual_row_instance_eval = true -module Spec::Example::ExampleMethods - def deprec - output = Sequel::Deprecation.output = nil - begin - yield - ensure - Sequel::Deprecation.output = output - end - end -end - -module Spec::Example::ExampleGroupMethods - def deprec_specify(*args, &block) - specify(*args) do - output = Sequel::Deprecation.output - Sequel::Deprecation.output = nil - begin - instance_eval(&block) - ensure - Sequel::Deprecation.output = output - end - end - end -end - class MockDataset < Sequel::Dataset def insert(*args) @db.execute insert_sql(*args) @@ -104,12 +79,10 @@ end class << Sequel::Model alias orig_columns columns - alias orig_str_columns str_columns def columns(*cols) return if cols.empty? define_method(:columns){cols} @dataset.instance_variable_set(:@columns, cols) if @dataset - define_method(:str_columns){cols.map{|x|x.to_s.freeze}} def_column_accessor(*cols) @columns = cols @db_schema = {} spec/model/spec_helper.rb @@ -77,122 +77,6 @@ end describe Sequel::Model do before do - deprec do - @c = Class.new(Sequel::Model) do - def self.validates_coolness_of(attr) - validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool} - end - end - end - end - - deprec_specify "should respond to validates, validations, has_validations?" do - @c.should respond_to(:validations) - @c.should respond_to(:has_validations?) - end - - deprec_specify "should acccept validation definitions using validates_each" do - @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50} - o = @c.new - o.should_receive(:xx).once.and_return(40) - o.should_receive(:yy).once.and_return(60) - o.valid?.should == false - o.errors.full_messages.should == ['xx too low'] - end - - deprec_specify "should return true/false for has_validations?" do - @c.has_validations?.should == false - @c.validates_each(:xx) {1} - @c.has_validations?.should == true - end - - deprec_specify "should validate multiple attributes at once" do - o = @c.new - def o.xx - 1 - end - def o.yy - 2 - end - vals = nil - atts = nil - @c.validates_each([:xx, :yy]){|obj,a,v| atts=a; vals=v} - o.valid? - vals.should == [1,2] - atts.should == [:xx, :yy] - end - - deprec_specify "should respect allow_missing option when using multiple attributes" do - o = @c.new - def o.xx - self[:xx] - end - def o.yy - self[:yy] - end - vals = nil - atts = nil - @c.validates_each([:xx, :yy], :allow_missing=>true){|obj,a,v| atts=a; vals=v} - - o.values[:xx] = 1 - o.valid? - vals.should == [1,nil] - atts.should == [:xx, :yy] - - vals = nil - atts = nil - o.values.clear - o.values[:yy] = 2 - o.valid? - vals.should == [nil, 2] - atts.should == [:xx, :yy] - - vals = nil - atts = nil - o.values.clear - o.valid?.should == true - vals.should == nil - atts.should == nil - end - - deprec_specify "should overwrite existing validation with the same tag and attribute" do - @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors[a] << 'too low' if v < 50} - @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors[a] << 'too low' if v < 50} - @c.validates_presence_of(:zz, :zz) - @c.validates_length_of(:aa, :aa, :tag=>:blah) - o = @c.new - def o.zz - @a ||= 0 - @a += 1 - end - def o.aa - @b ||= 0 - @b += 1 - end - o.should_receive(:xx).once.and_return(40) - o.should_receive(:yy).once.and_return(60) - o.should_receive(:xxx).once - o.should_receive(:yyy).twice - o.valid?.should == false - o.zz.should == 2 - o.aa.should == 2 - o.errors.full_messages.should == ['xx too low'] - end - - deprec_specify "should provide a validates method that takes block with validation definitions" do - @c.validates do - coolness_of :blah - end - @c.validations[:blah].should_not be_empty - o = @c.new - o.should_receive(:blah).once.and_return(nil) - o.valid?.should == false - o.errors.full_messages.should == ['blah is not cool'] - end -end - -describe Sequel::Model do - before do @c = Class.new(Sequel::Model) do columns :score def validate @@ -222,821 +106,6 @@ describe Sequel::Model do end end -describe 'Sequel::Model::Validation::Generator' do - before do - $testit = nil - - @c = Class.new(Sequel::Model) do - def self.validates_blah - $testit = 1324 - end - end - end - - deprec_specify "should instance_eval the block, sending everything to its receiver" do - @c.class_eval do - validates do - blah - end - end - $testit.should == 1324 - end -end - -describe Sequel::Model do - before do - @c = Class.new(Sequel::Model) do - columns :value - - def self.filter(*args) - o = Object.new - def o.count; 2; end - o - end - - def skip; false; end - def dont_skip; true; end - end - @m = @c.new - end - - deprec_specify "should validate acceptance_of" do - @c.validates_acceptance_of :value - @m.should be_valid - @m.value = '1' - @m.should be_valid - end - - deprec_specify "should validate acceptance_of with accept" do - @c.validates_acceptance_of :value, :accept => 'true' - @m.value = '1' - @m.should_not be_valid - @m.value = 'true' - @m.should be_valid - end - - deprec_specify "should validate acceptance_of with allow_nil => false" do - @c.validates_acceptance_of :value, :allow_nil => false - @m.should_not be_valid - end - - deprec_specify "should validate acceptance_of with allow_missing => true" do - @c.validates_acceptance_of :value, :allow_missing => true - @m.should be_valid - end - - deprec_specify "should validate acceptance_of with allow_missing => true and allow_nil => false" do - @c.validates_acceptance_of :value, :allow_missing => true, :allow_nil => false - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should validate acceptance_of with if => true" do - @c.validates_acceptance_of :value, :if => :dont_skip - @m.value = '0' - @m.should_not be_valid - end - - deprec_specify "should validate acceptance_of with if => false" do - @c.validates_acceptance_of :value, :if => :skip - @m.value = '0' - @m.should be_valid - end - - deprec_specify "should validate acceptance_of with if proc that evaluates to true" do - @c.validates_acceptance_of :value, :if => proc{true} - @m.value = '0' - @m.should_not be_valid - end - - deprec_specify "should validate acceptance_of with if proc that evaluates to false" do - @c.validates_acceptance_of :value, :if => proc{false} - @m.value = '0' - @m.should be_valid - end - - deprec_specify "should raise an error if :if option is not a Symbol, Proc, or nil" do - @c.validates_acceptance_of :value, :if => 1 - @m.value = '0' - proc{@m.valid?}.should raise_error(Sequel::Error) - end - - deprec_specify "should validate confirmation_of" do - @c.send(:attr_accessor, :value_confirmation) - @c.validates_confirmation_of :value - - @m.value = 'blah' - @m.should_not be_valid - - @m.value_confirmation = 'blah' - @m.should be_valid - end - - deprec_specify "should validate confirmation_of with if => true" do - @c.send(:attr_accessor, :value_confirmation) - @c.validates_confirmation_of :value, :if => :dont_skip - - @m.value = 'blah' - @m.should_not be_valid - end - - deprec_specify "should validate confirmation_of with if => false" do - @c.send(:attr_accessor, :value_confirmation) - @c.validates_confirmation_of :value, :if => :skip - - @m.value = 'blah' - @m.should be_valid - end - - deprec_specify "should validate confirmation_of with allow_missing => true" do - @c.send(:attr_accessor, :value_confirmation) - @c.validates_acceptance_of :value, :allow_missing => true - @m.should be_valid - @m.value_confirmation = 'blah' - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should validate format_of" do - @c.validates_format_of :value, :with => /.+_.+/ - @m.value = 'abc_' - @m.should_not be_valid - @m.value = 'abc_def' - @m.should be_valid - end - - deprec_specify "should raise for validate_format_of without regexp" do - proc {@c.validates_format_of :value}.should raise_error(ArgumentError) - proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError) - end - - deprec_specify "should validate format_of with if => true" do - @c.validates_format_of :value, :with => /_/, :if => :dont_skip - - @m.value = 'a' - @m.should_not be_valid - end - - deprec_specify "should validate format_of with if => false" do - @c.validates_format_of :value, :with => /_/, :if => :skip - - @m.value = 'a' - @m.should be_valid - end - - deprec_specify "should validate format_of with allow_missing => true" do - @c.validates_format_of :value, :allow_missing => true, :with=>/./ - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should validate length_of with maximum" do - @c.validates_length_of :value, :maximum => 5 - @m.should_not be_valid - @m.value = '12345' - @m.should be_valid - @m.value = '123456' - @m.should_not be_valid - end - - deprec_specify "should validate length_of with minimum" do - @c.validates_length_of :value, :minimum => 5 - @m.should_not be_valid - @m.value = '12345' - @m.should be_valid - @m.value = '1234' - @m.should_not be_valid - end - - deprec_specify "should validate length_of with within" do - @c.validates_length_of :value, :within => 2..5 - @m.should_not be_valid - @m.value = '12345' - @m.should be_valid - @m.value = '1' - @m.should_not be_valid - @m.value = '123456' - @m.should_not be_valid - end - - deprec_specify "should validate length_of with is" do - @c.validates_length_of :value, :is => 3 - @m.should_not be_valid - @m.value = '123' - @m.should be_valid - @m.value = '12' - @m.should_not be_valid - @m.value = '1234' - @m.should_not be_valid - end - - deprec_specify "should validate length_of with allow_nil" do - @c.validates_length_of :value, :is => 3, :allow_nil => true - @m.should be_valid - end - - deprec_specify "should validate length_of with if => true" do - @c.validates_length_of :value, :is => 3, :if => :dont_skip - - @m.value = 'a' - @m.should_not be_valid - end - - deprec_specify "should validate length_of with if => false" do - @c.validates_length_of :value, :is => 3, :if => :skip - - @m.value = 'a' - @m.should be_valid - end - - deprec_specify "should validate length_of with allow_missing => true" do - @c.validates_length_of :value, :allow_missing => true, :minimum => 5 - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should allow multiple calls to validates_length_of with different options without overwriting" do - @c.validates_length_of :value, :maximum => 5 - @c.validates_length_of :value, :minimum => 5 - @m.should_not be_valid - @m.value = '12345' - @m.should be_valid - @m.value = '123456' - @m.should_not be_valid - @m.value = '12345' - @m.should be_valid - @m.value = '1234' - @m.should_not be_valid - end - - deprec_specify "should validate numericality_of" do - @c.validates_numericality_of :value - @m.value = 'blah' - @m.should_not be_valid - @m.value = '123' - @m.should be_valid - @m.value = '123.1231' - @m.should be_valid - @m.value = '+1' - @m.should be_valid - @m.value = '-1' - @m.should be_valid - @m.value = '+1.123' - @m.should be_valid - @m.value = '-0.123' - @m.should be_valid - @m.value = '-0.123E10' - @m.should be_valid - @m.value = '32.123e10' - @m.should be_valid - @m.value = '+32.123E10' - @m.should be_valid - @m.should be_valid - @m.value = '.0123' - end - - deprec_specify "should validate numericality_of with only_integer" do - @c.validates_numericality_of :value, :only_integer => true - @m.value = 'blah' - @m.should_not be_valid - @m.value = '123' - @m.should be_valid - @m.value = '123.1231' - @m.should_not be_valid - end - - deprec_specify "should validate numericality_of with if => true" do - @c.validates_numericality_of :value, :if => :dont_skip - - @m.value = 'a' - @m.should_not be_valid - end - - deprec_specify "should validate numericality_of with if => false" do - @c.validates_numericality_of :value, :if => :skip - - @m.value = 'a' - @m.should be_valid - end - - deprec_specify "should validate numericality_of with allow_missing => true" do - @c.validates_numericality_of :value, :allow_missing => true - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should validate presence_of" do - @c.validates_presence_of :value - @m.should_not be_valid - @m.value = '' - @m.should_not be_valid - @m.value = 1234 - @m.should be_valid - @m.value = nil - @m.should_not be_valid - @m.value = true - @m.should be_valid - @m.value = false - @m.should be_valid - end - - deprec_specify "should validate inclusion_of with an array" do - @c.validates_inclusion_of :value, :in => [1,2] - @m.should_not be_valid - @m.value = 1 - @m.should be_valid - @m.value = 1.5 - @m.should_not be_valid - @m.value = 2 - @m.should be_valid - @m.value = 3 - @m.should_not be_valid - end - - deprec_specify "should validate inclusion_of with a range" do - @c.validates_inclusion_of :value, :in => 1..4 - @m.should_not be_valid - @m.value = 1 - @m.should be_valid - @m.value = 1.5 - @m.should be_valid - @m.value = 0 - @m.should_not be_valid - @m.value = 5 - @m.should_not be_valid - end - - deprec_specify "should raise an error if inclusion_of doesn't receive a valid :in option" do - lambda { - @c.validates_inclusion_of :value - }.should raise_error(ArgumentError) - - lambda { - @c.validates_inclusion_of :value, :in => 1 - }.should raise_error(ArgumentError) - end - - deprec_specify "should raise an error if inclusion_of handles :allow_nil too" do - @c.validates_inclusion_of :value, :in => 1..4, :allow_nil => true - @m.value = nil - @m.should be_valid - @m.value = 0 - @m.should_not be_valid - end - - deprec_specify "should validate presence_of with if => true" do - @c.validates_presence_of :value, :if => :dont_skip - @m.should_not be_valid - end - - deprec_specify "should validate presence_of with if => false" do - @c.validates_presence_of :value, :if => :skip - @m.should be_valid - end - - deprec_specify "should validate presence_of with allow_missing => true" do - @c.validates_presence_of :value, :allow_missing => true - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end - - deprec_specify "should validate uniqueness_of with if => true" do - @c.validates_uniqueness_of :value, :if => :dont_skip - - @m.value = 'a' - @m.should_not be_valid - end - - deprec_specify "should validate uniqueness_of with if => false" do - @c.validates_uniqueness_of :value, :if => :skip - - @m.value = 'a' - @m.should be_valid - end - - deprec_specify "should validate uniqueness_of with allow_missing => true" do - @c.validates_uniqueness_of :value, :allow_missing => true - @m.should be_valid - @m.value = nil - @m.should_not be_valid - end -end - -context "Superclass validations" do - before do - deprec do - @c1 = Class.new(Sequel::Model) do - columns :value - validates_length_of :value, :minimum => 5 - end - - @c2 = Class.new(@c1) do - columns :value - validates_format_of :value, :with => /^[a-z]+$/ - end - end - end - - deprec_specify "should be checked when validating" do - o = @c2.new - o.value = 'ab' - o.valid?.should == false - o.errors.full_messages.should == [ - 'value is too short' - ] - - o.value = '12' - o.valid?.should == false - o.errors.full_messages.should == [ - 'value is too short', - 'value is invalid' - ] - - o.value = 'abcde' - o.valid?.should be_true - end - - deprec_specify "should be skipped if skip_superclass_validations is called" do - @c2.skip_superclass_validations - - o = @c2.new - o.value = 'ab' - o.valid?.should be_true - - o.value = '12' - o.valid?.should == false - o.errors.full_messages.should == [ - 'value is invalid' - ] - - o.value = 'abcde' - o.valid?.should be_true - end -end - -context ".validates with block" do - deprec_specify "should support calling .each" do - @c = Class.new(Sequel::Model) do - columns :vvv - validates do - each :vvv do |o, a, v| - o.errors[a] << "is less than zero" if v.to_i < 0 - end - end - end - - o = @c.new - o.vvv = 1 - o.should be_valid - o.vvv = -1 - o.should_not be_valid - end -end - -describe Sequel::Model, "Validations" do - - before(:all) do - class ::Person < Sequel::Model - columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms - end - - class ::Smurf < Person - end - - class ::Cow < Sequel::Model - columns :id, :name, :got_milk - end - - class ::User < Sequel::Model - columns :id, :username, :password - end - - class ::Address < Sequel::Model - columns :id, :zip_code - end - end - - deprec_specify "should validate the acceptance of a column" do - class ::Cow < Sequel::Model - validations.clear - validates_acceptance_of :got_milk, :accept => 'blah', :allow_nil => false - end - - @cow = Cow.new - @cow.should_not be_valid - @cow.errors.full_messages.should == ["got_milk is not accepted"] - - @cow.got_milk = "blah" - @cow.should be_valid - end - - deprec_specify "should validate the confirmation of a column" do - class ::User < Sequel::Model - def password_confirmation - "test" - end - - validations.clear - validates_confirmation_of :password - end - - @user = User.new - @user.should_not be_valid - @user.errors.full_messages.should == ["password is not confirmed"] - - @user.password = "test" - @user.should be_valid - end - - deprec_specify "should validate format of column" do - class ::Person < Sequel::Model - validates_format_of :first_name, :with => /^[a-zA-Z]+$/ - end - - @person = Person.new :first_name => "Lancelot99" - @person.valid?.should be_false - @person = Person.new :first_name => "Anita" - @person.valid?.should be_true - end - - deprec_specify "should validate length of column" do - class ::Person < Sequel::Model - validations.clear - validates_length_of :first_name, :maximum => 30 - validates_length_of :last_name, :minimum => 30 - validates_length_of :middle_name, :within => 1..5 - validates_length_of :initials, :is => 2 - end - - @person = Person.new( - :first_name => "Anamethatiswaytofreakinglongandwayoverthirtycharacters", - :last_name => "Alastnameunderthirtychars", - :initials => "LGC", - :middle_name => "danger" - ) - - @person.should_not be_valid - @person.errors.full_messages.size.should == 4 - @person.errors.full_messages.should include( - 'first_name is too long', - 'last_name is too short', - 'middle_name is the wrong length', - 'initials is the wrong length' - ) - - @person.first_name = "Lancelot" - @person.last_name = "1234567890123456789012345678901" - @person.initials = "LC" - @person.middle_name = "Will" - @person.should be_valid - end - - deprec_specify "should validate that a column doesn't have a string value" do - p = Class.new(Sequel::Model) - p.class_eval do - columns :age, :price, :confirmed - self.raise_on_typecast_failure = false - validates_not_string :age - validates_not_string :confirmed - validates_not_string :price, :message=>'is not valid' - @db_schema = {:age=>{:type=>:integer}} - end - - @person = p.new - @person.should be_valid - - @person.confirmed = 't' - @person.should_not be_valid - @person.errors.full_messages.should == ['confirmed is a string'] - @person.confirmed = true - @person.should be_valid - - @person.age = 'a' - @person.should_not be_valid - @person.errors.full_messages.should == ['age is not a valid integer'] - @person.db_schema[:age][:type] = :datetime - @person.should_not be_valid - @person.errors.full_messages.should == ['age is not a valid datetime'] - @person.age = 20 - @person.should be_valid - - @person.price = 'a' - @person.should_not be_valid - @person.errors.full_messages.should == ['price is not valid'] - @person.price = 20 - @person.should be_valid - end - - deprec_specify "should validate numericality of column" do - class ::Person < Sequel::Model - validations.clear - validates_numericality_of :age - end - - @person = Person.new :age => "Twenty" - @person.should_not be_valid - @person.errors.full_messages.should == ['age is not a number'] - - @person.age = 20 - @person.should be_valid - end - - deprec_specify "should validate the presence of a column" do - class ::Cow < Sequel::Model - validations.clear - validates_presence_of :name - end - - @cow = Cow.new - @cow.should_not be_valid - @cow.errors.full_messages.should == ['name is not present'] - - @cow.name = "Betsy" - @cow.should be_valid - end - - deprec_specify "should validate the uniqueness of a column" do - class ::User < Sequel::Model - validations.clear - validates do - uniqueness_of :username - end - end - User.dataset.extend(Module.new { - def fetch_rows(sql) - @db << sql - - case sql - when /COUNT.*username = '0records'/ - yield({:v => 0}) - when /COUNT.*username = '2records'/ - yield({:v => 2}) - when /COUNT.*username = '1record'/ - yield({:v => 1}) - when /username = '1record'/ - yield({:id => 3, :username => "1record", :password => "test"}) - end - end - }) - - @user = User.new(:username => "2records", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username is already taken'] - - @user = User.new(:username => "1record", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username is already taken'] - - @user = User.load(:id=>4, :username => "1record", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username is already taken'] - - @user = User.load(:id=>3, :username => "1record", :password => "anothertest") - @user.should be_valid - @user.errors.full_messages.should == [] - - @user = User.new(:username => "0records", :password => "anothertest") - @user.should be_valid - @user.errors.full_messages.should == [] - end - - deprec_specify "should validate the uniqueness of multiple columns" do - class ::User < Sequel::Model - validations.clear - validates do - uniqueness_of [:username, :password] - end - end - User.dataset.extend(Module.new { - def fetch_rows(sql) - @db << sql - - case sql - when /COUNT.*username = '0records'/ - yield({:v => 0}) - when /COUNT.*username = '2records'/ - yield({:v => 2}) - when /COUNT.*username = '1record'/ - yield({:v => 1}) - when /username = '1record'/ - if sql =~ /password = 'anothertest'/ - yield({:id => 3, :username => "1record", :password => "anothertest"}) - else - yield({:id => 4, :username => "1record", :password => "test"}) - end - end - end - }) - - @user = User.new(:username => "2records", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username and password is already taken'] - - @user = User.new(:username => "1record", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username and password is already taken'] - - @user = User.load(:id=>4, :username => "1record", :password => "anothertest") - @user.should_not be_valid - @user.errors.full_messages.should == ['username and password is already taken'] - - @user = User.load(:id=>3, :username => "1record", :password => "test") - @user.should_not be_valid - @user.errors.full_messages.should == ['username and password is already taken'] - - @user = User.load(:id=>3, :username => "1record", :password => "anothertest") - @user.should be_valid - @user.errors.full_messages.should == [] - - @user = User.new(:username => "0records", :password => "anothertest") - @user.should be_valid - @user.errors.full_messages.should == [] - end - - deprec_specify "should have a validates block that contains multiple validations" do - class ::Person < Sequel::Model - validations.clear - validates do - format_of :first_name, :with => /^[a-zA-Z]+$/ - length_of :first_name, :maximum => 30 - end - end - - Person.validations[:first_name].size.should == 2 - - @person = Person.new :first_name => "Lancelot99" - @person.valid?.should be_false - - @person2 = Person.new :first_name => "Wayne" - @person2.valid?.should be_true - end - - deprec_specify "should allow 'longhand' validations direcly within the model." do - lambda { - class ::Person < Sequel::Model - validations.clear - validates_length_of :first_name, :maximum => 30 - end - }.should_not raise_error - Person.validations.length.should eql(1) - end - - deprec_specify "should define a has_validations? method which returns true if the model has validations, false otherwise" do - class ::Person < Sequel::Model - validations.clear - validates do - format_of :first_name, :with => /\w+/ - length_of :first_name, :maximum => 30 - end - end - - class ::Smurf < Person - validations.clear - end - - Person.should have_validations - Smurf.should_not have_validations - end - - deprec_specify "should validate correctly instances initialized with string keys" do - class ::Can < Sequel::Model - columns :id, :name - - validates_length_of :name, :minimum => 4 - end - - Can.new('name' => 'ab').should_not be_valid - Can.new('name' => 'abcd').should be_valid - end - -end - -describe "Model#save!" do - before do - @c = Class.new(Sequel::Model(:people)) do - def columns; [:id]; end - - validates_each :id do |o, a, v| - o.errors[a] << 'blah' unless v == 5 - end - end - @m = @c.load(:id => 4) - MODEL_DB.reset - end - - deprec_specify "should save regardless of validations" do - @m.should_not be_valid - @m.save! - MODEL_DB.sqls.should == ['UPDATE people SET id = 4 WHERE (id = 4)'] - end -end - describe "Model#save" do before do @c = Class.new(Sequel::Model(:people)) do spec/model/validations_spec.rb lib/sequel/deprecated.rb lib/sequel/deprecated_migration.rb lib/sequel/model/deprecated.rb lib/sequel/model/deprecated_hooks.rb lib/sequel/model/deprecated_inflector.rb lib/sequel/model/deprecated_validations.rb spec/core/core_ext_spec.rb spec/core/migration_spec.rb spec/core/pretty_table_spec.rb spec/model/caching_spec.rb spec/model/inflector_spec.rb spec/model/schema_spec.rb 38a57ceb3207ee64038bcd7b0851e4d5bb992bb3 Jeremy Evans code@jeremyevans.net http://github.com/foca/sequel/commit/ac1976a8c9079728666337a802f469ebe854d4f1 ac1976a8c9079728666337a802f469ebe854d4f1 2009-04-09T14:59:56-07:00 2009-04-09T13:50:09-07:00 Remove all methods and features deprecated in 2.12 This huge commit removes the deprecated code and deprecated specs (over 300!). It also makes some other minor changes. Sequel.virtual_row_instance_eval is now true, but setting it to false does nothing. Using instance_eval for virtual row blocks that don't accept arguments is now standard Sequel behavior. Some error messages in convenience.rb were turned into constants to reduce garbaged produced. More work on this will probably be done in the future. Dataset#import was using each_slice, which was probably provided by enumerator. Change to using a loop and slicing manually. The built in inflector now calls the string inflection methods if the string responds to the method. The inflector extension no longer updates the built in inflector, since it no longer needs to. Database#blank_object? calls blank? on the object if the object responds to it. The connection pool had a slight code refactoring to make things easier to read. The hook_class_methods plugin instance methods call super, so using the plugin doesn't ignore previous instance level hooks. Among other things, this allows you to use the hook_class_methods plugin after the caching plugin, which fixes #264. Make the serialization plugin test require yaml, since it uses yaml. This only seems necessary on ruby 1.9. Sequel::Deprecation is being moved to the extra directory. I'm moving it out of lib so it won't show up in the RDoc. I'm not removing it completely because I expect it may be used again sometime in the future. One thing that I realize that I should have officially deprecated was the 4th argument to join_table being a table_alias instead of a hash of options. So Sequel will continue to support that. 0d478fbfbcc75f823270fd2e9a7bf7eaec96d181 Jeremy Evans code@jeremyevans.net