asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.4.0.txt

@@ -0,0 +1,325 @@
+New Plugins
+-----------
+
+* A nested_attributes plugin was added allowing you to modify
+  associated objects directly through a model object, similar to
+  ActiveRecord's Nested Attributes.
+  
+    Artist.plugin :nested_attributes
+    Artist.one_to_many :albums
+    Artist.nested_attributes :albums
+    a = Artist.new(:name=>'YJM',
+     :albums_attributes=>[{:name=>'RF'}, {:name=>'MO'}])
+    # No database activity yet
+
+    a.save # Saves artist and both albums
+    a.albums.map{|x| x.name} # ['RF', 'MO']
+  
+  It takes most of the same options as ActiveRecord, as well as a
+  a few additional options:
+  
+  * :destroy - Allow destruction of nested records.
+  * :limit - For *_to_many associations, a limit on the number of
+    records that will be processed, to prevent denial of service
+    attacks.
+  * :remove - Allow disassociation of nested records (can remove the
+    associated object from the parent object, but not destroy the
+    associated object).
+  * :strict - Set to false to not raise an error message if a primary
+    key is provided in a record, but it doesn't match an existing
+    associated object.
+    
+  If a block is provided, it is passed each nested attribute hash.
+  If the hash should be ignored, the block should return anything
+  except false or nil.
+
+* A timestamps plugin was added for automatically adding
+  before_create and before_update hooks for setting values on
+  timestamp columns.  There are a couple of existing external
+  plugins that handle timestamps, but the implementations are
+  suboptimal.  The new built-in plugin supports the following
+  options (with the default in parentheses):
+  
+  * :create - The field to hold the create timestamp (:created_at)
+  * :force - Whether to overwrite an existing create timestamp
+    (false)
+  * :update - The field to hold the update timestamp (:updated_at)
+  * :update_on_create - Whether to set the update timestamp to the
+    create timestamp when creating (false)
+      
+* An instance_hooks plugin was added for adding hooks to specific
+  w
+  model instances:
+  
+    obj = Model.new
+    obj.after_save_hook{do_something}
+    obj.save # calls do_something after the obj has been saved
+
+  All of the standard hooks are supported, except for
+  after_initialize.  Instance level before hooks are executed in
+  reverse order of addition before calling super.  Instance level
+  after hooks are executed in order of addition after calling super.
+  If any of the instance level before hook blocks return false, no
+  more instance level before hooks are called and false is returned.
+
+  Instance level hooks are cleared when the object is saved
+  successfully.
+  
+* A boolean_readers plugin was added for creating attribute? methods
+  for boolean columns.  This can provide a nicer API:
+  
+    obj = Model[1]
+    obj.active  # Sequel default column reader
+    obj.active? # Using the boolean_readers plugin
+    
+  You can provide a block when loading the plugin to change the
+  criteria used to determine if the column is boolean:
+  
+    Sequel::Model.plugin(:boolean_readers) do |c|
+      db_schema[c][:db_type] =~ /\Atinyint/
+    end
+    
+  This may be useful if you are using MySQL and have some tinyint
+  columns that represent booleans and others that represent integers.
+  You can turn the convert_tinyint_to_bool setting off and use the
+  attribute methods for the integer value and the attribute? methods
+  for the boolean value.
+
+Other New Features
+------------------
+
+* Sequel now has support for converting Time/DateTime to local or UTC
+  time upon storage, retrieval, or typecasting.
+  
+  There are three different timezone settings:
+
+  * Sequel.database_timezone - The timezone that timestamps use in
+    the database.  If the database returns a time without an offset,
+    it is assumed to be in this timezone.
+
+  * Sequel.typecast_timezone - Similar to database_timezone, but used
+    for typecasting data from a source other than the database.  This
+    is currently only used by the model typecasting code.
+
+  * Sequel.application_timezone - The timezone that the application
+    wants to deal with.  All Time/DateTime objects are converted into
+    this timezone upon retrieval from the database.
+
+  Unlike most things in Sequel, these are only global settings, you
+  cannot change them per database.  There are only three valid
+  timezone settings:
+
+  * nil (the default) - Don't do any timezone conversion.  This is
+    the historical behavior.
+
+  * :local - Convert to local time/Consider time to be in local time.
+
+  * :utc - Convert to UTC/Consider time to be in UTC.
+
+  So if you want to store times in the database as UTC, but deal with
+  them in local time in the application:
+
+    Sequel.application_timezone = :local
+    Sequel.database_timezone = :utc
+
+  If you want to set all three timezones to the same value:
+
+    Sequel.default_timezone = :utc
+
+  There are three conversion methods that are called:
+
+  * Sequel.database_to_application_timestamp - Called on time objects
+    coming out of the database.  If the object coming out of the
+    database (usually a string) does not have an offset, assume it is
+    already in the database_timezone.  Return a Time/DateTime object
+    (depending on Sequel.datetime_class), in the application_timzone.
+
+  * Sequel.application_to_database_timestamp - Used when literalizing
+    Time/DateTime objects into an SQL string.  Converts the object to
+    the database_timezone before literalizing them.
+
+  * Sequel.typecast_to_application_timestamp - Called when
+    typecasting objects for model datetime columns.  If the object
+    being typecasted does not already have an offset, assume it is
+    already in the typecast_timezone.  Return a Time/DateTime object
+    (depending on Sequel.datetime_class), in the
+    application_timezone.
+
+  Sequel does not yet support named timezones or per thread
+  modification of the timezone (for showing all timestamps in the
+  current user's timezone).  Extensions to support both features are
+  planned for a future version.
+
+* Dataset#truncate was added for truncating tables.  Truncate allows
+  for fast removal of all rows in a table.
+  
+* Sequel now supports typecasting a hash to date, time, and datetime
+  types.  This allows easy usage of Sequel with forms that split
+  the entry of these database types into separate from fields.
+  With this code, you can just have field names like:
+
+    date[year]
+    date[month]
+    date[day]
+
+  Rack will parse that into:
+
+    {'date'=>{'year'=>?, 'month'=>?, 'day'=>?}}
+
+  So then you can do:
+
+    obj.date = params['date']
+    # or
+    obj.set(params)
+  
+* validates_unique now takes a block that can be used to scope the
+  uniqueness constraint. This allows you to easily set up uniqueness
+  validations that are only necessary in a given scope.  For example,
+  a validation on username, but only for active users (as inactive
+  users are soft deleted but remain in the table).  You just pass a
+  block to validates_unique:
+
+    validates_unique(:name){|ds| ds.filter(:active)}
+    
+* The serialization plugin now supports json.
+    
+* Sequel now supports generic concepts of
+  CURRENT_{DATE,TIME,TIMESTAMP}.  Most databases support these SQL
+  concepts, but not all, and some implementations act differently.
+
+  The Sequel::SQL::Constants module holds the three constants,
+  which are instances of SQL::Constant, an SQL::GenericExpression
+  subclass.  This module is included in Sequel, so you can reference
+  the constants more easily (e.g. Sequel::CURRENT_TIMESTAMP).
+  It's separated out into a separate module so that you can just
+  include that module in the top level scope, allowing you to
+  reference the constants directly (e.g. CURRENT_TIMESTAMP).
+  
+    DB[:events].filter{date < ::Sequel::CURRENT_DATE}
+    # or:
+    include Sequel::SQL::Constants
+    DB[:events].filter{date < ::CURRENT_DATE}
+
+* Database#run was added for executing arbitrary SQL on a database.
+  It's an alias for Database#<<, but it allows for a nicer API inside
+  migrations, since you can now do:
+  
+    run 'SQL'
+    
+  instead of:
+  
+    self << 'SQL'
+    
+  You can also provide a :server option to run the SQL on the
+  given server/shard:
+  
+    run 'SQL', :server=>:shard1
+
+* Sequel::Model() can now take a database argument in addition to
+  a symbol or dataset argument.  If a database is given, it'll create
+  an anonymous subclass attached to the given database.  Other changes
+  were made to allow the following code to work:
+  
+    class Item < Sequel::Model(DB2)
+    end
+    
+  That will work correctly assuming a table named items in DB2.
+
+* Dataset#ungrouped was added for removing a grouping from an
+  existing dataset.  Also, Dataset#group when called with no arguments
+  or with a nil argument also removes any existing grouping instead
+  of resulting in invalid SQL.
+
+* Model#modified? was added, letting you know if the model has been
+  modified.  If the model hasn't been modified, calling
+  Model#save_changes will do nothing.
+
+* SQL::OrderedExpression now supports #asc, #desc, and #invert.
+
+Other Improvements
+------------------
+
+* The serialization and lazy_attribute plugins now add accessor
+  methods to a module included in the class, instead of to the
+  model class itself.  This allows the methods to be overridden
+  in the class and work well with super, as well for the plugins
+  to work together on the same column.  Make sure the
+  lazy_attributes accessor is setup before the serialization
+  accessor if you want to have a lazy serialized column.
+  
+* Calling the add_* method for many_to_many association now saves the
+  record if the record is new.  This makes it operate more similarly
+  to one_to_many associations.  Previously, it raised an Error.
+
+* Dataset#import now works correctly when called with a dataset.
+  Previously, it generated incorrect SQL.
+
+* The JDBC adapter now converts byte arrays to/from SQL::Blob.
+
+* The JDBC adapter now attempts to bind unknown types using
+  setObject instead of raising, so it can work with native Java
+  objects.  It also binds boolean parameters correctly.
+
+* Using multiple emulated ALTER TABLE statements (such as
+  drop_column) in a single alter_table block now works correctly
+  on SQLite.
+  
+* Database#indexes now works on JDBC for tables in a non-default
+  schema.  It also now properly detects unique indexes on MSSQL.
+
+* Database#schema on JDBC now accepts a :schema option.  Also,
+  returned schema hashes now include a :column_size entry specifying
+  the maximum length/precision for the column, since the
+  :db_type entry doesn't have contain the information on JDBC.
+
+* Datasets without tables now work correctly on Oracle, so things
+  like DB.get(...) now work.
+  
+* A descriptive error message is given if you attempt to use
+  Sequel with the mysql.rb driver (which Sequel doesn't support).
+  
+* The postgres adapter now works correctly with a modified
+  postgres-pr that raises PGErrors instead of RuntimeErrors
+  (e.g. http://github.com/jeremyevans/postgres-pr).
+  
+* You now get a Sequel::InvalidOperation instead of a NoMethodError
+  if you attempt to update a dataset without a table.
+  
+* The inflection support has been modified to reduce code
+  duplication.
+
+Backwards Compatibility
+-----------------------
+
+* Sequel now includes fractional seconds in timestamps for all
+  adapters except MySQL.  It's possible that this may break
+  timestamp columns for databases that are not regularly tested.
+  
+* Sequel now includes timezone values in timestamps on Microsoft
+  SQL Server, Oracle, PostgreSQL and SQLite.  The modification for
+  SQLite is probably the biggest cause for concern, since SQLite
+  stores times as text.  If you have an SQLite database that uses
+  timestamps and is accessed by something other than Sequel, you
+  should make sure that it works with the timestamp format that
+  Sequel now uses.
+  
+* The default timestamp format used by Sequel now uses a space
+  instead of 'T' between the date and time parts, which could
+  possibly affect some databases that are not regularly tested.
+
+* Attempting to insert into a grouped dataset or a dataset that
+  selects from multiple tables will now raise an Error.  Previously,
+  it would ignore any GROUP or JOIN settings and generate bad SQL if
+  there were multiple FROM tables.
+  
+* Database#<< now always returns nil.  Before, the return value was
+  adapter dependent.
+
+* ODBC::Time and ODBC::DateTime values are now converted to the
+  Sequel.datetime_class.  Before, ODBC::Time used Time and
+  ODBC::DateTime used DateTime regardless of the
+  Sequel.datetime_class setting.
+  
+* The default inflections were modified, fixing some obvious errors
+  and possibly changing some existing inflections.  Further changes
+  to the default inflections are unlikely.

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.40.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* Sequel now has vastly improved support for Microsoft Access.
+
+* Sequel now supports the CUBRID database, with a cubrid adapter
+  that uses the cubrid gem, and a jdbc/cubrid adapter for accessing
+  CUBRID via JDBC on JRuby.
+
+* The association_pks plugin now supports composite keys.
+
+* Database#transaction now accepts a :disconnect=>:retry option,
+  in which case it will automatically retry the block if it
+  detects a disconnection.  This is potentially dangerous, and
+  should only be used if the entire block is idempotent.  There
+  is also no checking against an infinite retry loop.
+
+* SQL::CaseExpression#with_merged_expression has been added, for
+  converting a CaseExpression with an associated expression to
+  one without an associated expression, by merging the expression
+  into each condition.
+
+= Other Improvements
+
+* Sequel now quotes arguments/columns in common table expressions.
+
+* Sequel now handles nil values correctly in the pg_row extension.
+
+* Sequel::Postgres::HStore instances can now be marshalled.
+
+* Sequel now uses clob for String :text=>true types on databases that
+  don't support a text type.
+
+* On PostgreSQL, Sequel now quotes channel identifier names when using
+  LISTEN/NOTIFY.
+
+* On PostgreSQL, Sequel now correctly handles the case where named
+  type conversion procs have been added before the Database object is
+  instantiated.
+
+* On DB2, Sequel now explicitly sets NOT NULL for unique constraint
+  columns instead of foreign key columns.  DB2 does not allow columns
+  in unique constraints to be NULL, but does allow foreign key columns
+  to be NULL.
+
+* In the oracle adapter, clob values are now returned as ruby strings
+  upon retrieval.
+
+* Sequel now detects more types of disconnections in the postgres,
+  mysql, and mysql2 adapters.
+
+* If a database provides a default column value that isn't a ruby
+  string, it is used directly as the ruby default, instead of causing
+  the schema parsing to fail.
+
+= Backwards Compatibility
+
+* Code using Sequel's oracle adapter that expected clob values to be
+  returned as OCI8::CLOB instances needs to be modified to work with
+  ruby strings.
+
+* Because Sequel now quotes column names in common table expressions,
+  those names are now case sensitive, which could break certain poorly
+  coded queries.  Similar issues exist with the quoting of channel
+  identifier names in LISTEN/NOTIFY on PostgreSQL.
+
+* The private Database#requires_return_generated_keys? method
+  has been removed from the jdbc adapter.  Custom jdbc subadapters
+  relying on this method should override the private
+  Database#execute_statement_insert method instead to ensure that
+  RETURN_GENERATED_KEYS is used for insert statements.
+
+* The private Dataset#argument_list and #argument_list_append methods
+  have been removed.

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.41.0.txt

@@ -0,0 +1,155 @@
+= New Features
+
+* A connection_validator extension has been added, which
+  automatically determines if connections checked out from the pool
+  are still valid.  If they are not valid, the connection is
+  disconnected and another connection is used automatically,
+  transparent to user code.
+
+  Checking if connections are valid requires a query, so this
+  extension causes a performance hit.  For that reason, connections
+  are only checked by default if they have been inactive for more than
+  a configured amount of time (1 hour by default).  You can choose to
+  validate connections on every checkout via:
+
+    DB.pool.connection_validation_timeout = -1
+
+  However, this can cause a substantial performance hit unless you are
+  purposely using coarse connection checkouts via manual calls to
+  Database#synchronize (for example, in a Rack middleware).  Using
+  coarse checkouts can greatly reduce the amount of concurrency that
+  Sequel supports (for example, limiting the number of concurrent
+  requests to the number of database connections), so this method is
+  not without its tradeoffs.
+
+* Sequel.delay has been added for a generic form of delayed
+  evaluation.  This method takes a block and delays evaluating it
+  until query literalization.  By default, Sequel evaluates most
+  arguments immediately:
+
+    foo = 1
+    ds = DB[:bar].where(:baz=>foo)
+    # SELECT * FROM bar WHERE (baz = 1)
+    foo = 2
+    ds
+    # SELECT * FROM bar WHERE (baz = 1)
+
+  Using Sequel.delay, you can delay the evaluation:
+
+    foo = 1
+    ds = DB[:bar].where(:baz=>Sequel.delay{foo})
+    # SELECT * FROM bar WHERE (baz = 1)
+    foo = 2
+    ds
+    # SELECT * FROM bar WHERE (baz = 2)
+
+* Sequel now supports the :unlogged option when creating tables on
+  PostgreSQL, to create an UNLOGGED table.
+
+* On SQLite, Database#transaction now supports a :mode option for
+  setting up IMMEDIATE/EXCLUSIVE SQLite transactions.  Sequel also
+  supports a Database#transaction_mode accessor for setting the
+  default transaction mode on SQLite.
+
+* Most pg_* extension objects (e.g. PGArray) now support the #as
+  method for creating an SQL::AliasedExpression object.
+
+* The single_table_inheritance plugin now supports non-bijective
+  mappings.  In lay terms, this means that a one-to-one mapping
+  of column values to classes is no longer required.  You can now
+  have multiple column values that map to a single class in the
+  :model_map option, and specify a :key_chooser option to choose
+  which column value to use for the given model class.
+
+* The touch plugin now handles the touching of many_to_many
+  associations, and other associations that use joined datasets.
+
+* ConnectionPool#pool_type has been added. It returns a symbol
+  representing the type of connection pool in use (similar to
+  Database#database_type).
+
+* Database#valid_connection? has been added for checking if a given
+  connection is still valid.
+
+* Database#disconnect_connection is now part of the public API, and
+  can be used to disconnect a given connection.
+
+= Other Improvements
+
+* Uniqueness validation now correctly handles nil values.
+  Previously, it checked the underlying table for other rows where
+  the column IS NULL, but that is incorrect behavior.  Sequel's new
+  (correct) behavior is to skip the uniqueness check if the column
+  is nil.
+
+* Foreign key parsing is now supported on Microsoft SQL Server.
+
+* Dataset#reverse and #reverse_order now accept virtual row blocks.
+
+* Changing the name of the primary key column, and possibly other
+  schema changes on the primary key column, are now supported on
+  MySQL.
+
+* Primary key columns are now specifically marked as NOT NULL on
+  SQLite, as non-integer primary keys on SQLite are not considered
+  NOT NULL by default.
+
+* Failure to create a native prepared statement is now handled
+  better in the postgres, mysql, and mysql2 adapters.
+
+* Firebird now emulates selecting data without an underlying table
+  (e.g. DB.get(1)).
+
+* Finding the name of the constraint that sets column defaults on
+  Microsoft SQL Server now works correctly on JRuby 1.7.
+
+* An additional type of disconnect error is now recognized in the
+  jdbc/sqlserver adapter.
+
+* Many adapters have been fixed so that they don't raise an exception
+  if trying to disconnect an already disconnected connection.
+
+* Many adapters have been fixed so that
+  Database#log_connection_execute logs and executes the given SQL
+  on the connection.
+
+* Many adapters have been fixed so that
+  Database#database_error_classes returns an array of database
+  exception classes for that adapter.
+
+* Database#log_exception now handles a nil exception message.
+
+* Dataset#limit(nil, nil) now resets offset in addition to limit, but
+  you should still use Dataset#unlimited instead.
+
+* A bin/sequel usage quide has been added to the documentation.
+
+= Backwards Compatibility
+
+* Sequel now treats clob columns as strings instead of blobs
+  (except on DB2 when use_clob_as_blob = true).  This can make it
+  so the values are returned as strings instead of SQL::Blob values.
+  Since SQL::Blob is a String subclass, this generally will
+  not affect user code unless you are passing the values as input
+  to a separate blob column.
+
+* The Database <-> ConnectionPool interface was completely changed.
+  Sequel no longer supports custom connection procs or disconnection
+  procs in the connection pools.  The :disconnection_proc Database
+  option is no longer respected, and blocks passed to Database.new
+  are now ignored.
+
+  This change should not be user-visible, but if you had any code
+  that was monkeying with the connection pool internals, you may
+  need to modify it.
+
+* Code that was using the uniqueness check to also check for presence
+  should add a separate check for presence.  Such code was broken,
+  as it only worked if there was already a NULL column value in the
+  table. If you were relying on this broken behavior, you should
+  clean up the NULL data in the column and then mark the database
+  column as NOT NULL.
+
+* If you have code that specifically abuses the fact that non-integer
+  primary keys on SQLite allow NULL values by default, it will no
+  longer work.