asana2flowdock 1.0.0

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

@@ -0,0 +1,105 @@
+= New Features
+
+* Database#schema now includes :max_length entries for string
+  columns, specifying the size of the string field.  The
+  auto_validations plugin now uses this information to
+  automatically set up max_length validations on those fields.
+
+* The Dataset join methods now support a :reset_implicit_qualifier
+  option.  If set to false, this makes the join not reset the
+  implicit qualifier, so that the next join will not consider this
+  table as the last table joined.  Example:
+
+    DB[:a].join(:b, :c=>:d).
+      join(:e, :f=>:g)
+    # SELECT * FROM a
+    # INNER JOIN b ON (b.c = a.d)
+    # INNER JOIN e ON (e.f = b.g)
+
+    DB[:a].join(:b, {:c=>:d}, :reset_implicit_qualifier=>false).
+      join(:e, :f=>:g)
+    # SELECT * FROM a
+    # INNER JOIN b ON (b.c = a.d)
+    # INNER JOIN e ON (e.f = a.g)
+
+* The Dataset cross and natural join methods now accept an options
+  hash. Example:
+
+    DB[:a].cross_join(:b, :table_alias=>:c)
+    # SELECT * FROM a CROSS JOIN b AS c
+
+* Model#set_nested_attributes has been added to the nested_attributes
+  plugin, which allows you to to set the nested_attributes options to
+  use per-call.  This is very helpful if you have multiple forms that
+  handle associated objects, but with different input fields used
+  for the associated objects depending on the form.  Example:
+
+    album.set_nested_attributes(:tracks,
+      params[:track_attributes],
+      :fields=>[:a, :b, :c])
+
+* Database#values has been added on PostgreSQL, which creates a
+  dataset that uses VALUES instead of SELECT.  Just as PostgreSQL
+  allows, you can also use orders, limits, and offsets with this
+  dataset.
+
+* A :notice_receiver option is now supported in the postgres adapter
+  if the pg driver is used.  This should be a proc, which will be
+  passed to the pg connection's set_notice_receiver method.
+
+* A Database :readonly option is now supported in the sqlite adapter,
+  which opens the database in a read-only mode, causing an error
+  if a query is issued that would modify the database.
+
+* A :before_thread_exit option has been added to
+  Database#listen_for_static_cache_updates in the
+  pg_static_cache_updater extension, allowing you to run code before
+  the created thread exits.
+
+= Other Improvements
+
+* Eager loading limited associations using a UNION now works
+  correctly when an association block is used.  This fixes a
+  regression that first occurred in 4.10.0, when the union
+  eager loader became the default eager loader.
+
+* When creating a new associated object in the nested_attributes
+  plugin, where the reciprocal association is a many_to_one
+  association, set the cached reciprocal object in the new
+  associated object before saving it.
+
+  This fixes issues when validations in the associated object
+  require access to the current object, which may not yet be
+  saved in the database.
+
+* The prepared_statements and prepared_statements_associations
+  plugins now automatically use explicit column references when
+  preparing statements.  This fixes issues on PostgreSQL when a
+  column is added to a table while a prepared statement exists
+  that selects * from the table.  Previously, all further attempts
+  to use the prepared statement will fail.
+
+  This allows you to run migrations that add columns to tables
+  while concurrently running an application that uses the
+  prepared statements plugins.  Note that many other schema
+  modifications can cause issues when running migrations
+  while concurrently running an application, but most of those
+  are not specific to usage of prepared statements.
+
+* Dataset#insert_select on PostgreSQL now respects an existing
+  RETURNING clause, and won't override it to use RETURNING *.
+
+  A similar fix was applied to the generalized prepared statements
+  support as well.
+
+* The interval parser in the pg_interval extension now supports
+  intervals with 2-10 digits for hours.  Previously, it only
+  supported using 2 digits for hours.
+
+= Backwards Compatibility
+
+* The methods and classes deprecated in 4.11.0 have been removed.
+
+* The nested_attributes internal API has changed significantly. If
+  you were calling any private nested_attributes methods, you'll
+  probably need to update your code.

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

@@ -0,0 +1,169 @@
+= New Features
+
+* A modification_detection plugin has been added, for automatic
+  detection of in-place column value modifications.  This makes
+  it so you don't have to call Model#modified! manually when
+  changing a value in place.
+
+* A column_select plugin has been added, for automatically
+  selecting explicitly qualified columns in model datasets.
+  Example:
+
+    Sequel::Model.plugin :column_select
+    class Album < Sequel::Model
+    end
+    Album.dataset.sql
+    # SELECT albums.id, albums.name, albums.artist_id
+    # FROM albums
+
+* An insert_returning_select plugin has been added, for automatically
+  setting up RETURNING clauses for models that select explicit
+  columns.  This is useful when using the column_select or
+  lazy_attributes plugins.
+
+* A pg_enum extension has been added, for easier dealing with
+  PostgreSQL enum types.  The possible values for the type
+  are then returned in the schema hashes under the :enum_values
+  key.  It also adds create_enum, drop_enum, and add_enum_value
+  Database methods for migration support.
+
+* A round_timestamps extension has been added, for automatically
+  rounding timestamps to database supported precision when
+  literalizing.
+
+* A dataset_source_alias extension has been added, for automatically
+  aliasing datasets to their first source, instead of using t1, t2.
+  Example:
+
+    DB.from(:a, DB[:b]).sql
+    # SELECT * FROM a, (SELECT * FROM b) AS t1
+
+    DB.extension(:dataset_source_alias)
+    DB.from(:a, DB[:b]).sql
+    # SELECT * FROM a, (SELECT * FROM b) AS b
+
+* On Microsoft SQL Server, Sequel now emulates RETURNING support
+  using the OUTPUT clause, as long as only simple column references
+  are used.
+
+= Other Improvements
+
+* A regression has been fixed in the timestamps and table
+  inheritance plugins, where column values would not be
+  saved when skipping validations.  This was first broken in
+  4.11.0.
+
+* A regression has been fixed on JRuby and Rubinius when using
+  Sequel::Model(dataset) if the dataset needs to literalize a
+  symbol (and most do).  This was first broken in 4.10.0.
+
+* Primary keys are now automatically setup for models even if
+  the models select specific columns.
+
+* The lazy_attributes plugin now uses qualified columns in its
+  selection, instead of unqualified columns.
+
+* When looking up model instances by primary key, Sequel now uses a
+  qualified primary key if the model uses a joined dataset.
+
+* For associations that require joins, Sequel will now use the
+  associated model's selection directly (instead of
+  associated_table.*) if the associated model's selection consists
+  solely of qualified columns.
+
+  Among other things, this means that a many_to_many association to 
+  a model that uses lazy attributes will not eagerly load the lazy
+  attributes by default.
+
+* Model#save now uses insert_select if there is an existing
+  RETURNING clause used by the underlying dataset, even if the model
+  selects specific columns.
+
+* In Dataset#insert, aliased tables are now automatically unaliased.
+  This allows you to use a dataset with an aliased table and have
+  full SELECT/INSERT/UPDATE/DELETE support, assuming the database
+  supports aliased tables in UPDATE and DELETE.
+
+* Dataset#graph now qualifies columns correctly if the current
+  dataset is a joined dataset and it moves the current dataset to
+  a subselect.
+
+* Dataset#joined_dataset? is now a public method, and can be used to
+  determine whether the dataset uses a join, either explicitly via
+  JOIN or implicitly via multiple FROM tables.
+
+* The Dataset#unqualified_column_for helper method has been added,
+  returning the unqualified version of a possibly qualified column.
+
+* The composition and serialization plugins now support validations
+  on the underlying columns.  Previously, they didn't update the
+  underlying columns until after validations were performed.  This
+  works better when using the auto_validations plugin.
+
+* The class_table_inheritance plugin now uses JOIN ON instead of
+  JOIN USING, which makes it work on all databases that Sequel
+  supports.  Additionally, the plugin now explicitly selects
+  qualified columns from all of the tables.
+
+* The list plugin now adds an after_destroy hook that will renumber
+  rows after the current row, similar to how moving existing values
+  in the list works.
+
+* The pg_json extension is now faster when json column value is a
+  plain string, number, true, false, or nil, if the underlying json
+  library handles such values natively.
+
+* External jdbc, odbc, and do subadapters can now be loaded
+  automatically without requiring them first, assuming proper
+  support in the external subadapter.
+
+* When using create_table on MySQL, correctly handle the :key
+  option to when calling foreign_key with a column reference.
+
+* On Oracle, use all_tab_cols instead of user_tab_cols for getting
+  default values when parsing the schema.  This makes it work if the
+  user does not own the table.
+
+* On Oracle, use all_tables and all_views for Database#tables and
+  Database#views.  This works better for users with limited rights.
+
+* Additional disconnect errors are now recognized in the postgres and
+  jdbc/mysql adapters.
+
+* Sequel::Model now uses copy constructors (e.g. initialize_copy)
+  instead of overriding #dup and #clone.
+
+* The rake default task now runs plugin specs in addition to
+  core and model specs.
+
+= bin/sequel Improvements
+
+* Add the sequel lib directory to the front of the load path
+  instead of the end, fixing cases where you end up requiring an
+  old version of the sequel gem (e.g. by using sequel_pg).
+
+* Add the sequel lib directory as an absolute path, fixing cases
+  where you later change the current directory.
+
+* Require sequel later in the code, so that bin/sequel -h doesn't
+  need to require sequel, and full backtrace is not printed if
+  requiring sequel raises an error (unless -t is used).
+
+* If an exception is raised, put a newline between the exception
+  message and backtrace.
+
+* Don't allow usage of -C with any of -cdDmS.
+
+* If sequel -v is given along with a database or code string to
+  execute, print the Sequel version but also continue, similar
+  to how ruby -v works.
+
+= Backwards Compatibility
+
+* The switch from JOIN ON to JOIN USING in the
+  class_table_inheritance can break certain usage, such as querying
+  using unqualified primary key.  Users should switch to using a
+  qualified primary key instead.
+
+* Calling Dataset#returning when the underlying database does not
+  support it now raises an Error.

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

@@ -0,0 +1,68 @@
+= New Features
+
+* Delayed evaluation blocks can now accept the dataset literalizing
+  the delayed evaluation as an argument.  This makes it so the
+  delayed evaluation result can depend on the dataset doing the
+  literalization:
+
+    ds = DB[:a].where(Sequel.delay do |ds|
+      {Sequel.qualify(ds.first_source, :col)=>1}
+    end)
+    ds.sql          # SELECT * FROM a WHERE (a.col = 1)
+    ds.from(:b).sql # SELECT * FROM b WHERE (b.col = 1)
+
+* Database#create_trigger on PostgreSQL now supports a :when option
+  to create a filter for the trigger, so that it is only triggered
+  when the filter condition is true.
+
+* You can now override the cache key prefix in the caching plugin
+  by overriding the cache_key_prefix class method.  This can be
+  useful when using a table inheritance plugin.
+
+= Other Improvements
+
+* You can now pass arbitrary types to Dataset#where and related
+  methods.  Previously, if a type was not explicitly handled, an
+  exception would be raised.  Now you can pass any object that can
+  be literalized.  The only exception is that you can't pass
+  Numeric objects, since #where and similar methods should
+  only deal with boolean expressions.
+
+* association_join and related methods now work correctly if the
+  dataset already has an explicit selection.
+
+* A regression has been fixed in the class_table_inheritance plugin
+  when using a hierarchy of more than 2 levels, when using the
+  superclass to load a subclass instance more than 2 levels below,
+  and later attempting to load a column contained in one of the
+  middle tables.
+ 
+* When using _delete or _remove keys in the nested_attributes plugin
+  to remove existing associated objects, the associated objects are
+  now deleted from the cached association array at time of call.
+  This is for consistency when adding new associated objects, where
+  the new associated objects are added to the cached association
+  array at time of call.
+
+* The nested_attributes plugin now handles composite primary keys
+  correctly when working around validation issues for one_to_one
+  and one_to_many associations.
+
+* If exception A is raised during a transaction, and exception B
+  is raised while attempting to rollback the transaction, the
+  transaction code will now raise exception A instead of exception B.
+
+* An additional serialization failure is now detected on PostgreSQL.
+
+* An additional disconnect error is now recognized in the jdbc/jtds
+  adapter.
+
+* The code examples in the RDoc are now syntax highlighted, and
+  many minor fixes to the code examples in the RDoc were made.
+  Additionally, many other improvements were made to the RDoc.
+
+= Backwards Compatibility
+
+* Dataset#delayed_evaluation_sql_append now accepts the delayed
+  evaluation as an argument, instead of the callable contained by the
+  delayed evaluation.

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

@@ -0,0 +1,56 @@
+= New Features
+
+* fdbsql and jdbc/fdbsql adapters have been added, for connecting to
+  FoundationDB SQL Layer.
+
+* A split_values plugin has been added, for moving non-column entries
+  from the values hash into a separate hash.  This allows you to
+  select additional columns (e.g. computed columns) when retrieving
+  model instances, and be able to save those instances without
+  removing the additional columns.
+
+* A Sequel::Model.cache_associations accessor has been added, which
+  can be set to false to not cache any association metadata.  This
+  can fix issues in a development environment that uses code
+  reloading.
+
+* The active_model plugin now supports activemodel 4.2.0beta1.
+
+* More PostgreSQL array types are handled automatically by the
+  pg_array extension, such as xml[] and uuid[].
+
+* Creating foreign tables is now supported on PostgreSQL via the
+  :foreign and :options create_table options.
+
+* The :nolog Database option is now supported in the informix
+  adapter, where it disables the use of transactions.
+
+* PlaceholderLiteralizer#with_dataset has been added, allowing you
+  to create another PlaceholderLiteralizer with a modified dataset,
+  useful if you want to change the row_proc or any non-SQL dataset
+  options.
+
+= Other Improvements
+
+* The tactical_eager_loading plugin once again works correctly with
+  limited associations.
+
+* A bug in older versions of MySQL is now worked around when schema
+  dumping a table with multiple timestamp columns.
+
+* On PostgreSQL, create_view(:view_name, dataset, :materialized=>true)
+  is now reversible.
+
+* Postgres::{JSON,JSONB}Op#to_record and #to_recordset no longer take
+  an optional argument.  This was supported in PostgreSQL 9.4beta1,
+  but removed before PostgreSQL 9.4beta2.
+
+* Dataset#insert now returns the last inserted id in the informix
+  adapter.
+
+* Sequel no longer raises an exception in
+  AssociationReflection#reciprocal if the associated class has an
+  association that does not have a valid associated class.
+
+* Sequel now raises an exception if a primary key is necessary to use
+  an association, but the model does not have a primary key.

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

@@ -0,0 +1,129 @@
+= New Features
+
+* LATERAL subqueries are now supported on PostgreSQL 9.3+, HSQLDB,
+  and DB2 via Dataset#lateral:
+
+    DB.from(:a, DB[:b].where(:c=>:a__d).lateral)
+    # SELECT * FROM a,
+    # LATERAL (SELECT * FROM b WHERE (c = a.d)) AS t1
+
+  You can use a similar syntax when joining tables:
+
+    DB[:a].cross_join(DB[:b].where(:c=>:a__d).lateral)
+    # SELECT * FROM a
+    # CROSS JOIN LATERAL (SELECT * FROM b WHERE (c = a.d)) AS t1
+
+  If you are using Microsoft SQL Server, you can use the new
+  mssql_emulate_lateral_with_apply extension to emulate LATERAL
+  subqueries via CROSS/OUTER APPLY.
+
+* The static_cache plugin now supports a :frozen=>false option.  When
+  this option is used, instead of returning the frozen cached values,
+  the model now returns new, unfrozen objects that can be modified.
+  Note that if you make any database modifications, you are
+  responsible for updating the cache manually.
+
+* A pg_static_cache_updater extension has been added.  This extension
+  can automatically update the caches used by the static_cache plugin,
+  whenever the underlying database table is updated, using PostgreSQL's
+  notification channels.
+
+  This works by defining triggers on the underlying model tables that
+  use NOTIFY, and spinning up a thread in your application processes
+  that uses LISTEN, and refreshes the cache for the related model
+  whenever it receives a notification that the underlying table has
+  been modified.
+
+  This extension should make it possible to use the static_cache plugin
+  with the :frozen=>false option for any table that is small and not
+  frequently updated.
+
+* A from_block extension has been added that makes Database#from operate
+  like Dataset#from in regards to a passed block, allowing you to write
+  code like:
+
+    DB.from{table_returning_function(arg1, arg2)}
+
+* Database#supports_partial_indexes? has been added for checking for
+  partial index support.  Partial indexes are now supported on SQLite
+  3.8.0+.
+
+* A pg_loose_count extension has been added for fast approximate counts
+  of PostgreSQL tables.  This uses the system tables and should be
+  fairly accurate if the table statistics are up to date:
+
+    DB.loose_count(:table)
+
+* The Dataset#use_cursor method in the postgres adapter now supports
+  a :cursor_name option.  You can set this option if you want to
+  use nested cursors.
+
+* The mysql2 adapter now supports a :flags Database option allowing to
+  set custom mysql2 flags (e.g. ::Mysql2::Client::MULTI_STATEMENTS).
+
+= Other Improvements
+
+* Dataset#freeze has been implemented.  Previously, it was not
+  implemented, so Object#freeze was used, which resulted in a dataset
+  that wasn't cloneable.  Dataset#freeze now works as expected,
+  resulting in a cloneable dataset, but it doesn't allow methods to
+  be called that mutate the receiver.
+
+* Dataset#dup has been implemented.  Previously, it was not
+  implemented, so Object#dup was used, which resulted in a dataset
+  that shared an options hash with the receiver, so modifying the
+  dup's opts could also change the original dataset. Now dup works
+  similarly to clone, except that the returned object will not be
+  frozen.
+
+* Model#dup has been implemented.  Previously, it was not implemented,
+  so Object#dup was used, which resulted in a model instance that
+  shared the values hash with the receiver, so modifying the dup's
+  values also changed the original's values.  Now, dup does a shallow
+  copy of some of the internal data structures as well, so the copy
+  is more independent.
+
+  Note that you still need to be careful if you mutate objects:
+
+    m = Model.new(:a=>'a')
+    m2 = m.dup
+    m.a.gsub!('a', 'b') # also changes m2
+
+* Model#clone has been implemented.  Previously, it had the same
+  issues as dup.  Now, it calls the new Model#dup, but also
+  freezes the returned object if the receiver is frozen.
+
+* Placeholder literal strings with an empty parameter hash are now
+  handled correctly.
+
+= Backwards Compatibility
+
+* The static_cache plugin now disallows saving/destroying instances
+  unless the :frozen=>false option is used.  As the cached objects
+  returned by the model were frozen anyway, this affects creating
+  new instances or saving/destroying instances returned from the
+  underlying dataset.
+
+* Model#set_values has been removed (it was deprecated starting in
+  Sequel 4.0).
+
+* The following Model class methods are no longer defined:
+  insert_multiple, set, to_csv, paginate, query, set_overrides,
+  set_defaults.  By default, these methods used call the
+  dataset method of the same name, but as those methods are no
+  longer defined on datasets by default, they also resulted in a
+  NoMethodError.
+
+* Dataset#query!, #set_defaults!, and #set_overrides! are no longer
+  defined on all datasets.  They are now only defined on datasets
+  that use the query or set_overrides extensions.
+
+* Partial indexes are no longer returned by Database#indexes on MSSQL,
+  for consistency with PostgreSQL.  Note that the same change was
+  desired for SQLite, but SQLite currently does not offer reflection
+  support for determining which indexes are partial.
+
+* Database#foreign_key_list on MSSQL now will return a
+  SQL::QualifiedIdentifier instead of a symbol for the :table entry if
+  the schema of the referenced table does not match the schema of the
+  referencing table.