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

@@ -1,144 +0,0 @@
-= bin/sequel
-bin/sequel is the name used to refer to the "sequel" command line tool that ships with the sequel gem.  By default, bin/sequel provides an IRB shell with the +DB+ constant set to a Sequel::Database object created using the database connection string provided on the command line.  For example, to connect to a new in-memory SQLite database using the sqlite adapter, you can use the following:
-  sequel sqlite:/
-This is very useful for quick testing of ideas, and does not affect the environment, since the in-memory SQLite database is destroyed when the program exits.
-== Running from a git checkout
-If you've installed the sequel gem, then just running "sequel" should load the program, since rubygems should place the sequel binary in your load path.  However, if you want to run bin/sequel from the root of a repository checkout, you should probably do:
-  ruby -I lib bin/sequel
-The -I lib makes sure that you are using the repository checkout's code.
-== Choosing the Database to Connect to
-=== Connection String
-In general, you probably want to provide a connection string argument to bin/sequel, indicating the adapter and database connection information you want to use.  For example:
-  sequel sqlite:/
-  sequel postgres://user:pass@host/database_name
-  sequel mysql2://user:pass@host/database_name
-See the {Connecting to a database guide}[rdoc-ref:doc/opening_databases.rdoc] for more details about and examples of connection strings.
-=== YAML Connection File
-Instead of specifying the database connection using a connection string, you can provide the path to a YAML configuration file containing the connection information.  This YAML file can contain a single options hash, or it can contain a nested hash, where the top-level hash uses environment keys with hash values for
-each environment.  Using the -e option with a yaml connection file, you can choose which environment to use if using a nested hash.
-  sequel -e production config/database.yml
-Note that bin/sequel does not directly support ActiveRecord YAML configuration files, as they use different names for some options.
-=== Mock Connection
-If you don't provide a connection string or YAML connection file, Sequel will start with a mock database.  The mock database allows you to play around with Sequel without any database at all, and can be useful if you just want to test things out and generate SQL without actually getting results from a database.
-  sequel
-Sequel also has the ability to use the mock adapter with database-specific syntax, allowing you to pretend you are connecting to a specific type of database without actually connecting to one.  To do that, you need to use a connection string:
-  sequel mock://postgres
-== Not Just an IRB shell
-bin/sequel is not just an IRB shell, it can also do far more.
-=== Execute Code
-bin/sequel can also be used to execute other ruby files with +DB+ preset to the database given on the command line:
-  sequel postgres://host/database_name path/to/some_file.rb
-On modern versions of Linux, this means that you can use bin/sequel in a shebang line:
-  #!/path/to/bin/sequel postgres://host/database_name
-If you want to quickly execute a small piece of ruby code, you can use the -c option:
-  sequel -c "p DB.tables" postgres://host/database_name
-Similarly, if data is piped into bin/sequel, it will be executed:
-  echo "p DB.tables" | sequel postgres://host/database_name
-=== Migrate Databases
-With -m option, Sequel will migrate the database given using the migration directory provided by -m:
-  sequel -m /path/to/migrations/dir postgres://host/database
-You can use the -M attribute to set the version to migrate to:
-  sequel -m /path/to/migrations/dir -M 3 postgres://host/database
-See the {migration guide}[rdoc-ref:doc/migration.rdoc] for more details about migrations.
-=== Dump Schemas
-Using the -d or -D options, Sequel will dump the database's schema in Sequel migration format to the standard output:
-  sequel -d postgres://host/database
-To save this information to a file, use a standard shell redirection:
-  sequel -d postgres://host/database > /path/to/migrations/dir/001_base_schema.rb
-The -d option dumps the migration in database-independent format, the -D option dumps it in database-specific format.
-The -S option dumps the schema cache for all tables in the database, which can speed up the usage of Sequel with models when using the schema_caching extension.  You should provide this option with the path to which to dump the schema:
-  sequel -S /path/to/schema_cache.db postgres://host/database
-=== Copy Databases
-Using the -C option, Sequel can copy the contents of one database to another, even between different database types.  Using this option, you provide two connection strings on the command line:
-  sequel -C mysql://host1/database postgres://host2/database2
-This copies the table structure, table data, indexes, and foreign keys from the MySQL database to the PostgreSQL database.
-== Other Options
-Other options not mentioned above are explained briefly here.
-=== -E
--E logs all SQL queries to the standard output, so you can see all SQL that Sequel is sending the database.
-=== -I include_directory
--I is similar to ruby -I, and specifies an additional $LOAD_PATH directory.
-=== -l log_file
--l is similar to -E, but logs all SQL queries to the given file.
-=== -L load_directory
--L loads all *.rb files under the given directory.  This is usually used to load Sequel::Model classes into bin/sequel.
-=== -N
--N skips testing the connection when creating the Database object.  This is rarely needed.
-=== -r require_lib
--r is similar to ruby -r, requiring the given library.
-=== -t
--t tells bin/sequel to output full backtraces in the case of an error, which can aid in debugging.
-=== -h
--h prints the usage information for bin/sequel.
-=== -v
--v prints the Sequel version in use.

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/cheat_sheet.rdoc DELETED Viewed

@@ -1,220 +0,0 @@
-= Cheat Sheet
-== Open a database
-  require 'sequel'
-  DB = Sequel.sqlite('my_blog.db')
-  DB = Sequel.connect('postgres://user:password@localhost/my_db')
-  DB = Sequel.postgres('my_db', :user => 'user', :password => 'password', :host => 'localhost')
-  DB = Sequel.ado('mydb')
-== Open an SQLite memory database
-Without a filename argument, the sqlite adapter will setup a new sqlite database in memory.
-  DB = Sequel.sqlite
-== Logging SQL statements
-  require 'logger'
-  DB = Sequel.sqlite '', :loggers => [Logger.new($stdout)]
-  # or
-  DB.loggers << Logger.new($stdout)
-== Using raw SQL
-  DB.run "CREATE TABLE users (name VARCHAR(255) NOT NULL, age INT(3) NOT NULL)"
-  dataset = DB["SELECT age FROM users WHERE name = ?", name]
-  dataset.map(:age)
-  DB.fetch("SELECT name FROM users") do |row|
-    p row[:name]
-  end
-== Create a dataset
-  dataset = DB[:items]
-  dataset = DB.from(:items)
-== Most dataset methods are chainable
-  dataset = DB[:managers].where(:salary => 5000..10000).order(:name, :department)
-== Insert rows
-  dataset.insert(:name => 'Sharon', :grade => 50)
-== Retrieve rows
-  dataset.each{|r| p r}
-  dataset.all # => [{...}, {...}, ...]
-  dataset.first # => {...}
-== Update/Delete rows
-  dataset.exclude(:active).delete
-  dataset.where('price < ?', 100).update(:active => true)
-== Datasets are Enumerable
-  dataset.map{|r| r[:name]}
-  dataset.map(:name) # same as above
-  dataset.inject(0){|sum, r| sum + r[:value]}
-  dataset.sum(:value) # better
-== Filtering (see also {Dataset Filtering}[rdoc-ref:doc/dataset_filtering.rdoc])
-=== Equality
-  dataset.where(:name => 'abc')
-  dataset.where('name = ?', 'abc')
-=== Inequality
-  dataset.where{value > 100}
-  dataset.exclude{value <= 100}
-=== Inclusion
-  dataset.where(:value => 50..100)
-  dataset.where{(value >= 50) & (value <= 100)}
-  dataset.where('value IN ?', [50,75,100])
-  dataset.where(:value=>[50,75,100])
-  dataset.where(:id=>other_dataset.select(:other_id))
-=== Subselects as scalar values
-  dataset.where('price > (SELECT avg(price) + 100 FROM table)')
-  dataset.where{price > dataset.select(avg(price) + 100)}
-=== LIKE/Regexp
-  DB[:items].where(Sequel.like(:name, 'AL%'))
-  DB[:items].where(:name => /^AL/)
-=== AND/OR/NOT
-  DB[:items].where{(x > 5) & (y > 10)}.sql
-  # SELECT * FROM items WHERE ((x > 5) AND (y > 10))
-  DB[:items].where(Sequel.or(:x => 1, :y => 2) & Sequel.~(:z => 3)).sql
-  # SELECT * FROM items WHERE (((x = 1) OR (y = 2)) AND (z != 3))
-=== Mathematical operators
-  DB[:items].where{x + y > z}.sql
-  # SELECT * FROM items WHERE ((x + y) > z)
-  DB[:items].where{price - 100 < avg(price)}.sql
-  # SELECT * FROM items WHERE ((price - 100) < avg(price))
-== Ordering
-  dataset.order(:kind)
-  dataset.reverse_order(:kind)
-  dataset.order(Sequel.desc(:kind), :name)
-== Limit/Offset
-  dataset.limit(30) # LIMIT 30
-  dataset.limit(30, 10) # LIMIT 30 OFFSET 10
-  dataset.limit(30).offset(10) # LIMIT 30 OFFSET 10
-== Joins
-  DB[:items].left_outer_join(:categories, :id => :category_id).sql
-  # SELECT * FROM items
-  # LEFT OUTER JOIN categories ON categories.id = items.category_id
-  DB[:items].join(:categories, :id => :category_id).join(:groups, :id => :items__group_id)
-  # SELECT * FROM items
-  # INNER JOIN categories ON categories.id = items.category_id
-  # INNER JOIN groups ON groups.id = items.group_id
-== Aggregate functions methods
-  dataset.count #=> record count
-  dataset.max(:price)
-  dataset.min(:price)
-  dataset.avg(:price)
-  dataset.sum(:stock)
-  dataset.group_and_count(:category)
-  dataset.select_group(:category).select_append{avg(:price)}
-== SQL Functions / Literals
-  dataset.update(:updated_at => Sequel.function(:NOW))
-  dataset.update(:updated_at => Sequel.lit('NOW()'))
-  dataset.update(:updated_at => Sequel.lit("DateValue('1/1/2001')"))
-  dataset.update(:updated_at => Sequel.function(:DateValue, '1/1/2001'))
-== Schema Manipulation
-  DB.create_table :items do
-    primary_key :id
-    String :name, :unique => true, :null => false
-    TrueClass :active, :default => true
-    foreign_key :category_id, :categories
-    DateTime :created_at
-    index :created_at
-  end
-  DB.drop_table :items
-== Aliasing
-  DB[:items].select(Sequel.as(:name, :item_name))
-  DB[:items].select(:name___item_name)
-  DB[:items___items_table].select(:items_table__name___item_name)
-  # SELECT items_table.name AS item_name FROM items AS items_table
-== Transactions
-  DB.transaction do
-    dataset.insert(:first_name => 'Inigo', :last_name => 'Montoya')
-    dataset.insert(:first_name => 'Farm', :last_name => 'Boy')
-  end # Either both are inserted or neither are inserted
-Database#transaction is re-entrant:
-  DB.transaction do # BEGIN issued only here
-    DB.transaction do
-      dataset << {:first_name => 'Inigo', :last_name => 'Montoya'}
-    end
-  end # COMMIT issued only here
-Transactions are aborted if an error is raised:
-  DB.transaction do
-    raise "some error occurred"
-  end # ROLLBACK issued and the error is re-raised
-Transactions can also be aborted by raising Sequel::Rollback:
-  DB.transaction do
-    raise(Sequel::Rollback) if something_bad_happened
-  end # ROLLBACK issued and no error raised
-Savepoints can be used if the database supports it:
-  DB.transaction do
-    dataset << {:first_name => 'Farm', :last_name => 'Boy'} # Inserted
-    DB.transaction(:savepoint=>true) do # This savepoint is rolled back
-      dataset << {:first_name => 'Inigo', :last_name => 'Montoya'} # Not inserted
-      raise(Sequel::Rollback) if something_bad_happened
-    end
-    dataset << {:first_name => 'Prince', :last_name => 'Humperdink'} # Inserted
-  end
-== Miscellaneous:
-  dataset.sql # "SELECT * FROM items"
-  dataset.delete_sql # "DELETE FROM items"
-  dataset.columns # => array of columns in the result set, does a SELECT
-  DB.schema(:items) # => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/code_order.rdoc DELETED Viewed

@@ -1,96 +0,0 @@
-= Code Order
-In Sequel, the order in which code is executed is important.  This
-guide provides the recommended way to order your Sequel code.  Some
-of these guidelines are not strictly necessary, but others are, and
-this guide will be specific about which are strictly necessary.
-== Require Sequel
-This is sort of a no brainer, but you need to require the library
-first.  This is a strict requirement, none of the other code can
-be executed unless the library has been required first. Example:
-  require 'sequel'
-== Add Global Extensions
-Global extensions are loaded with Sequel.extension, and affect
-other parts of Sequel or the general ruby environment.  It's not
-necessary to load them first, but it is a recommended practice.
-The exception to this is global extensions that integrate with
-Database-specific extensions, where the Database-specific
-extension should be loaded first (such as some of the pg_*
-extensions).  In those cases, the global extensions should be
-loaded after the Database-specific extensions.
-Example:
-  Sequel.extension :blank
-== Add Extensions Applied to All Databases/Datasets
-If you want database or datasets extensions applied to all databases
-and datasets, you must use Sequel::Database.extension to load the
-extension before connecting to a database.  If you connect to a
-database before using Sequel::Database.extension, it will not have
-that extension loaded. Example:
-  Sequel::Database.extension :columns_introspection
-== Connect to Databases
-Connecting to a database is required before running any queries against
-that database, or creating any datasets or models.  You cannot create
-model classes without having a database object created first.  The
-convention for an application with a single Database instance is to
-store that instance in a constant named DB.  Example:
-  DB = Sequel.connect('postgres://user:pass@host/database')
-== Add Extensions Specific to a Database or All Datasets in that Database
-If you want specific databases to use specific extensions, or have all
-datasets in that database use a specific extension, you need to load that
-extension into the database after creating it using
-Sequel::Database#extension.  Example:
-  DB.extension :pg_array
-== Configure Global Model Behavior
-If you want to change the configuration for all model classes, you must do
-so before loading your model classes, as configuration is copied into the
-subclass when model subclasses are created.  Example:
-  Sequel::Model.raise_on_save_failure = false
-== Add Global Model Plugins
-If you want to load a plugin into all models classes, you must do so
-before loading your model classes, as plugin specific data may need to be
-copied into the subclass when model subclasses are created.  Example:
-  Sequel::Model.plugin :prepared_statements
-== Load Model Classes
-After you have established a database connection, and configured your
-global model configration and global plugins, you can load your model
-classes.  It's recommended to have a separate file for each model class,
-unless the model classes are very simple.  Example:
-  Dir['./models/*.rb'].each{|f| require f}
-== Disconnect If Using Forking Webserver with Code Preloading
-If you are using a forking webserver such as unicorn or passenger, with
-a feature that loads your Sequel code before forking connections (code
-preloading), then you must disconnect your database connections before
-forking.  If you don't do this, you can end up with child processes
-sharing database connections and all sorts of weird behavior.  Sequel
-will automatically reconnect on an as needed basis in the child
-processes, so you only need to do the following in the parent process:
-  DB.disconnect