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/reflection.rdoc DELETED Viewed

@@ -1,121 +0,0 @@
-= Reflection
-Sequel supports reflection information in multiple ways.
-== Adapter in Use
-You can get the adapter in use using Database#adapter_scheme:
-  DB.adapter_scheme # e.g. :postgres, :jdbc, :odbc
-== Database Connected To
-In some cases, the adapter scheme will be the same as the database to which you are connecting.  However, many adapters support multiple databases.  You can use the Database#database_type method to get the type of database to which you are connecting:
-  DB.database_type # :postgres, :h2, :mssql
-== Tables in the Database
-Database#tables gives an array of table name symbols:
-  DB.tables # [:table1, :table2, :table3, ...]
-== Views in the Database
-Database#views and gives an array of view name symbols:
-  DB.views # [:view1, :view2, :view3, ...]
-== Indexes on a table
-Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
-  DB.indexes(:table1) # {:index1=>{:columns=>[:column1], :unique=>false}, :index2=>{:columns=>[:column2, :column3], :unique=>true}}
-Index information generally does not include partial indexes, functional indexes, or indexes on the primary key of the table.
-== Foreign Key Information for a Table
-Database#foreign_key_list takes a table name and gives an array of hashes of foreign key information:
-  DB.foreign_key_list(:table1) # [{:columns=>[:column1], :table=>:referenced_table, :key=>[:referenced_column1]}]
-At least the following entries will be present in the hash:
-:columns :: An array of columns in the given table
-:table :: The table referenced by the columns
-:key :: An array of columns referenced (in the table specified by :table), but can be nil on certain adapters
-        if the primary key is referenced.
-The hash may also contain entries for:
-:deferrable :: Whether the constraint is deferrable
-:name :: The name of the constraint
-:on_delete :: The action to take ON DELETE
-:on_update :: The action to take ON UPDATE
-== Column Information for a Table
-Database#schema takes a table symbol and returns column information in an array with each element being an array with two elements.  The first elements of the subarray is a column symbol, and the second element is a hash of information about that column.  The hash should include the following keys:
-:allow_null :: Whether NULL/nil is an allowed value for this column. Used by the Sequel::Model typecasting code.
-:db_type :: The type of column the database provided, as a string.  Used by the schema_dumper plugin for a more specific type translation.
-:default :: The default value of the column, as either a string or nil.  Uses a database specific format. Used by the schema_dumper plugin for converting to a ruby value.
-:primary_key :: Whether this column is one of the primary key columns for the table.  Used by the Sequel::Model code to determine primary key columns.
-:ruby_default :: The default value of the column as a ruby object, or nil if there is no default or the default could not be successfully parsed into a ruby object.
-:type :: The type of column, as a symbol (e.g. :string).  Used by the Sequel::Model typecasting code.
-Example:
-  DB.schema(:table) # [[:column1, {:allow_null=>true, :db_type=>'varchar(255)', :default=>'blah', :primary_key=>false, :type=>:string}], ...]
-== Column Information for a Model
-Model#db_schema returns pretty much the same information, except it returns it as a hash with column keys instead of an array of two element arrays.
-  Model.db_schema # {:column1=>{:allow_null=>true, :db_type=>'varchar(255)', :default=>'blah', :primary_key=>false, :type=>:string}, ...}
-== Columns used by a dataset/model
-Dataset#columns returns the columns of the current dataset as an array of symbols:
-  DB[:table].columns # [:column1, :column2, :column3, ...]
-Dataset#columns! does the same thing, except it ignores any cached value.  In general, the cached value should never be incorrect, unless the database schema is changed after the dataset is created.
-  DB[:table].columns! # [:column1, :column2, :column3, ...]
-Model.columns does the same thing as Dataset#columns, using the model's dataset:
-  Model.columns # [:column1, :column2, :column3, ...]
-== Associations Defined
-Sequel::Model offers complete introspection capability for all associations.
-You can get an array of association symbols with Model.associations:
-  Model.associations # [:association1, :association2, ...]
-You can get the association reflection for a single association via the Model.association_reflection.  Association reflections are subclasses of hash, for ease of use and introspection (and backwards compatibility):
-  Model.association_reflection(:association1) # {:name=>:association1, :type=>:many_to_one, :model=>Model, ...}
-You can get an array of all association reflections via Model.all_association_reflections:
-  Model.all_association_reflections # [{:name=>:association1, :type=>:many_to_one, :model=>Model, ...}, ...]
-Finally, you can get a hash of association reflections via Model.association_reflections:
-  Model.association_reflections # {:association1=>{:name=>:association1, :type=>:many_to_one, :model=>Model, ...}, ...}
-== Validations Defined
-When using the validation_class_methods plugin, you can use the validation_reflections class method to get a hash with validation reflection information.  This returns a hash keyed on the column name symbol:
-  Model.validation_reflections[:column] # => [[:presence, {}], [:length, {:maximum=>255, :message=>'is just too long'}]]
-Similarly, when using the constraint_validations plugin, you can use the constraint_validation_reflections class method:
-  Model.constraint_validation_reflections[:column] # => [[:presence, {}], [:max_length, {:argument=>255, :message=>'is just too long'}]]

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

@@ -1,38 +0,0 @@
-=== New code organization
-Sequel is now divided into two parts: sequel_core and sequel_model.
-These two parts are distributed as two separate gems. The sequel gem
-bundles sequel_core and sequel_model together. If you don't use
-Sequel::Model in your code, you can just install and use sequel_core.
-=== New model hooks implementation
-The hooks implementation have been rewritten from scratch, is much
-more robust and offers a few new features:
-* More ways to define hooks: hooks can now be defined by supplying a
-block or a method name, or by overriding the hook instance method.
-* Inheritable hooks: Hooks can now be inherited, which means that you
-can define general hooks in a model superclass, and use them in
-subclasses. You can also define global hooks on Sequel::Model that
-will be invoked for all model classes.
-* Hook chains can be broken by returning false from within the hook.
-* New after_initialize hook, invoked after instance initialization.
-* The hook invocation order can no longer be changed. Hooks are
-invoked in order of definition, from the top of the class hierarchy
-(that is, from Sequel::Model) down to the specific class.
-=== Miscellanea
-* Removed deprecated adapter stubs, and all other deprecations in both
-sequel_core and sequel_model.
-* Fixed String#to_time to raise error correctly for invalid time
-stamps.
-* Fixed error behavior when parse_tree or ruby2ruby are not available.

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

@@ -1,143 +0,0 @@
-=== DRY Sequel models
-With the new Sequel release you no longer need to explicitly specify
-the table
-name for each model class, assuming your model name is the singular of
-the
-table name (just like in ActiveRecord or DataMapper):
-  class UglyBug < Sequel::Model
-  end
-  UglyBug.table_name #=> :ugly_bugs
-=== New model validations and support for virtual attributes
-Sequel model now include validation functionality which largly follows
-the
-validations offered in ActiveRecord. Validations can be checked
-anytime by
-calling Model#valid?, with validation errors accessible through
-Model#errors:
-  class Item < Sequel::Model
-    validates_presence_of :name
-  end
-  my_item = Item.new
-  my_item.valid? #=> false
-  my_item.errors.full_messages #=> ["name is not present"]
-The Model#save method has been changed to check for validity before
-saving. If
-the model instance is not valid, the #save method returns false
-without saving
-the instance. You can also bypass the validity test by calling
-Model#save!
-instead.
-Model classes also now support virtual attributes, letting you assign
-values to
-any attribute (virtual or persistent) at initialization time:
-  class User < Sequel::Model
-    attr_accessor :password
-  end
-  u = User.new(:password => 'blah', ...)
-  u.password #=> 'blah'
-Also, virtual attributes can be validated just like persistent
-attributes.
-=== Other changes (long list!)
-* Added Model#reload as alias to Model#refresh.
-* Changed Model.create to accept a block (#126).
-* Fixed Model#initialize to accept nil values (#115).
-* Added Model#update_with_params method with support for virtual
-attributes and auto-filtering of unrelated parameters, and changed
-Model.create_with_params to support virtual attributes (#128).
-* Fixed Model.dataset to correctly set the dataset if using implicit
-naming or inheriting the superclass dataset (thanks celldee).
-* Finalized support for virtual attributes.
-* Fixed Model#set to work with string keys (#143).
-* Fixed Model.create to correctly initialize instances marked as new
-(#135).
-* Fixed Model#initialize to convert string keys into symbol keys. This
-also fixes problem with validating objects initialized with string
-keys (#136).
-* Added Dataset#table_exists? convenience method.
-* Changed Dataset#group_and_count to accept multiple columns (#134).
-* Added Dataset#select_all method.
-* Added Dataset#select_more, Dataset#order_more methods (#129).
-* Fixed Dataset#count to work correctly for grouped datasets (#144).
-* Fixed joining datasets using aliased tables (#140).
-* Added support for UNSIGNED constraint, used in MySQL? (#127).
-* Implemented constraint definitions inside Database#create_table.
-* Enhanced Database.connect to accept options with string keys, so it
-can now accept options loaded from YAML files. Database.connect also
-automatically converts :username option into :user for compatibility
-with existing YAML configuration files for AR and DataMapper.
-* Changed ODBC::Database to support connection using driver and
-database name, also added support for untitled columns in
-ODBC::Dataset (thanks Leonid Borisenko).
-* Changed MySQL adapter to support specifying socket option.
-* Fixed MySQL adapter to correctly format foreign key definitions
-(#123).
-* Changed MySQL::Dataset to allow HAVING clause on ungrouped datasets,
-and put HAVING clause before ORDER BY clause (#133).
-* Changed mysql adapter to default to localhost if :host option is not
-specified (#114).
-* Added String#to_date. Updated mysql adapter to use String#to_date
-for mysql date types (thanks drfreeze).
-* Fixed postgres adapter to define PGconn#async_exec as alias to #exec
-if not defined (for pure-ruby postgres driver).
-* Changed postgres adapter to quote column references using double
-quotes.
-* Applied patch for oracle adapter: fix behavior of limit and offset,
-transactions, #table_exists?, #tables and additional specs (thanks
-Liming Lian #122).
-* Added support additional field types in postgresql adapter (#146).
-* Added support for date field types in postgresql adapter (#145).
-* Added support for limiting and paginating datasets with fixed SQL,
-e.g. using Database#fetch.
-* Added new Dataset#from_self method that returns a dataset selecting
-from the original dataset.
-* Allow for additional filters on a grouped dataset (#119 and #120)
-* Refactored Sequelizer to use Proc#to_sexp (method provided by r2r).
-* Fixed bin/sequel to require sequel_model if available.

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

@@ -1,101 +0,0 @@
-=== Better model associations
-The latest release of sequel_model includes a new associations
-functionality written by Jeremy Evans which replaces the old relations
-code in previous versions. Please note that this version is not
-completely backward-compatible and you should therefore upgrade with
-caution.
-The new implementation supports three kinds of relations: one_to_many,
-many_to_one and many_to_many, which correspond to has_many, belongs_to
-and has_and_belongs_to_many relations in ActiveRecord. In fact, the
-new implementation includes aliases for ActiveRecord assocation macros
-and is basically compatible with ActiveRecord conventions. It also
-supports DRY implicit class name references. Here's a simple example:
-  class Author < Sequel::Model
-    has_many :books # equivalent to one_to_many
-  end
-  class Book < Sequel::Model
-    belongs_to :author # equivalent to many_to_one
-    has_and_belongs_to_many :categories # equivalent to many_to_many
-  end
-  class Category < Sequel::Model
-    has_and_belongs_to_many :books
-  end
-These macros will create the following methods:
-* Author#books, Author#add_book, Author#remove_book
-* Book#author, Book#categories, Book#add_category,
-Book#remove_category
-* Category#books, Category#add_book, Category#remove_book
-Unlike ActiveRecord, one_to_many and many_to_many association methods
-return a dataset:
-  a = Author[1234]
-  a.books.sql #=> 'SELECT * FROM books WHERE (author_id = 1234)'
-You can also tell Sequel to cache the association result set and
-return it as an array:
-  class Author < Sequel::Model
-    has_many :books, :cache => true
-  end
-  Author[1234].books.class #=> Array
-You can of course bypass the defaults and specify class names and key
-names:
-  class Node < Sequel::Model
-    belongs_to :parent, :class => Node
-    belongs_to :session, :key => :producer_id
-  end
-Another useful option is :order, which sets the order for the
-association dataset:
-  class Author < Sequel::Model
-    has_many :books, :order => :title
-  end
-  Author[1234].books.sql #=> 'SELECT * FROM books WHERE (author_id =
-1234) ORDER BY title'
-More information about associations can be found in the Sequel
-documentation.
-=== Other changes
-* Added configuration file for running specs (#186).
-* Changed Database#drop_index to accept fixed arity (#173).
-* Changed column definition sql to put UNSIGNED constraint before
-unique in order to satisfy MySQL (#171).
-* Enhanced MySQL adapter to support load data local infile_, added
-compress option for mysql connection by default (#172).
-* Fixed bug when inserting hashes in array tuples mode.
-* Changed SQLite adapter to catch RuntimeError raised when executing a
-statement and raise Error::InvalidStatement with the offending SQL and
-error message (#188).
-* Fixed Dataset#reverse to not raise for unordered dataset (#189).
-* Added Dataset#unordered method and changed #order to remove order if
-nil is specified (#190).
-* Fixed reversing order of ASC expression (#164).
-* Added support for :null => true option when defining table columns
-(#192).
-* Fixed Symbol#method_missing to accept variable arity (#185).

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

@@ -1,53 +0,0 @@
-Eager loading for all types of associations:
-  Artist.eager(:albums).all
-  Album.eager(:artist, :genre, :tracks).all
-  Album.eager(:artist).eager(:genre).eager(:tracks).all
-  Album.filter(:year=>2008).eager(:artist).all
-Eager loading supports cascading to an unlimited depth, and doesn't have
-any aliasing issues:
-  Artist.eager(:albums=>:tracks).all
-  Artist.eager(:albums=>{:tracks=>:genre}).all
-Unfortunately, eager loading comes at the expense of a small amount of
-backward compatibility.  If you were using uncached associations (the
-default in sequel_model 0.5), they no longer work the same way.  Now,
-all associations act as if :cache=>true (which is now set for all
-associations, so if you wrote a tool that worked with both cached and
-uncached associations, it should still work).
-One to many associations now populate the corresponding many to one
-instance variable (even when eagerly loaded):
-  # Assuming: Album.one_to_many :tracks
-  album = Album.first
-  # This following code is only one query,
-  # not a query for the album and one for each track
-  album.tracks.each{|t| puts t.album.name}
-ActiveRecord style has_many :through associations are now supported via
-many_to_many.  many_to_many will no longer select the entire result set,
-just the columns of the associated table (and not the join table), so it
-works for both has_and_belongs_to_many (simple join table) and has_many
-:through (join table model) scenarios.  If you want to include all or
-part of the join table attributes, see the :select option for
-many_to_many associations.
-We reduced the number of gems from three (sequel, sequel_core,
-sequel_model) to two (sequel, sequel_core).  Basically, sequel_model is
-now just sequel, and the old sequel gem metapackage is no longer.  There
-isn't a reason to have a gem metapackage for two gems when one
-(sequel_model) depends on the other (sequel_core).  This required a
-version bump for the model part of sequel from 0.5.0.2 to 1.4.0 (since
-the previous sequel gem version was 1.3).
-Sequel 1.4.0 has fixes for 11 trackers issues, including fixes to the
-MySQL and PostgreSQL adapters.
-We have switched the source control repository for Sequel from Google
-Code (which uses subversion) to github (which uses git).  If you would
-like to contribute to Sequel, please fork the github repository, make
-your changes, and send a pull request.  As before, posting patches on
-the Google Code issue tracker is fine as well.