RubyGems - asana2flowdock - Versions diffs - 1.0.0 → 1.1.0 - Mend

asana2flowdock 1.0.0 → 1.1.0

Files changed (1595) hide show

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

@@ -1,325 +0,0 @@
-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 DELETED Viewed

@@ -1,73 +0,0 @@
-= 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 DELETED Viewed

@@ -1,155 +0,0 @@
-= 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.