openc-asana 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e8b344a69d1e1f4e4179036f6ea1f8fbd0683e9
+  data.tar.gz: c563fc621a50385012b203543ad8e4abd37f4069
+SHA512:
+  metadata.gz: 13d6487fa1e320009acb725ee360e917ca9f27ac95c3d37dab7076a81ac711aa696d9ad3f9827b826cbd139c486e8465bd18466a3ef2fb10705cce55c47fb897
+  data.tar.gz: 3d734aa235a08302f979644bec4d0230784346449ec165b6f98ad4035cad459cd8ca3e7b653b88a420aff9e90a59a194bc5e7ab046d68b2d1d92db44a9d2040f

data/.codeclimate.yml

@@ -0,0 +1,4 @@
+languages:
+  Ruby: true
+exclude_paths:
+- "lib/asana/resources/*"

data/.gitignore

@@ -0,0 +1,13 @@
+.idea
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/
+test.rb
+/node_modules/

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--require spec_helper
+--require asana
+--order random

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  Include:
+    - '**/Rakefile'
+  Exclude:
+    - 'bin/**/*'
+    - 'examples/**/*'
+    - 'lib/asana/resources/*'
+    - 'spec/templates/unicorn.rb'
+    - 'spec/templates/world.rb'
+    - 'test.rb'
+require: rubocop-rspec

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+- 2.2.2
+- 2.0.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: ZFzExKt6auBOcQyg8955GwlZW2OaS64Q+XHGSay2MzjALw1iiy5uuMdwkueCKrGWSv6/eBe9jjsmYBe3OfkUIpIBbUacnbEYeaC70AyucNjvFrrl0YVYHb7neojarJUmKz9bz9Pkju/jdxksaYaj58xfq5YPQDfjFtdmylvuNEYpujT6goPEbxG4U4PpIhhQOZRDRXXAPS+f7jHejTSK06kvJjiJw0d51VJtBbp+0TKNKL6BDKdOKjKeHuebuUmSw8crDyaYdnwYwmNg1cJrGOv2t76M08zoKkkIO2lwPMHisi1/+cbVcZfxM4SfdHJeU6cQuRdb0uCUbbj6GsGwT8vWP2mGUrLe4UV/GfZDmvK3MKeKIlkgig31a3Qny9yjn8EjSnKHYuHBbJvPQDPPpFUfgEneUxn2t4P6m+epkd1gldWqTWf8mhMR/6xAFT4s+BaxnMMJsTC3Ea+dZZ30EqCw/kx5B2Z1KVLgsxHeMN/Q+AeOcbOvlGDsFL0Mjk/PqDTW1AWKLs/D1ohcxjSmlNJGWR6JHa/Ei0GqjDE2+/ZGsKsRfcDD4kU5qnKdqdzDlbL3cL4tChzuWVcguYdrg1yZzqPrCPzmy+2D7Hphyaj9CPKEh7qwT+IQU5o/V2peOJUjKrMlJS4gFq6MvTDh5U59J88Kkg72DXhcEUcySkU=
+  gem: asana
+  on:
+    tags: true
+    repo: Asana/ruby-asana

data/.yardopts

@@ -0,0 +1,5 @@
+--title "Asana API Ruby Client"
+--readme README.md
+--plugin tomdoc
+lib
+- LICENSE.txt

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in asana.gemspec
+gemspec
+
+group :tools do
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-rubocop'
+  gem 'guard-yard'
+
+  gem 'yard'
+  gem 'yard-tomdoc'
+
+  gem 'byebug'
+
+  gem 'simplecov', require: false
+end

data/Guardfile

@@ -0,0 +1,86 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end
+
+guard :rubocop do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+  watch(%r{ext/.+\.c})
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Asana, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,355 @@
+# Asana
+
+[![Gem Version](https://badge.fury.io/rb/asana.svg)](http://badge.fury.io/rb/asana)
+[![Build Status](https://travis-ci.org/Asana/ruby-asana.svg?branch=master)](https://travis-ci.org/Asana/ruby-asana)
+[![Code Climate](https://codeclimate.com/github/Asana/ruby-asana/badges/gpa.svg)](https://codeclimate.com/github/Asana/ruby-asana)
+[![Dependency Status](https://gemnasium.com/Asana/ruby-asana.svg)](https://gemnasium.com/Asana/ruby-asana)
+
+
+A Ruby client for the 1.0 version of the Asana API.
+
+Supported rubies:
+
+* MRI 2.0.0 up to 2.2.x stable
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'asana'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install asana
+
+## Usage
+
+To do anything, you'll need always an instance of `Asana::Client` configured
+with your preferred authentication method (see the Authentication section below
+for more complex scenarios) and other options.
+
+The most minimal example would be as follows:
+
+```ruby
+require 'asana'
+
+client = Asana::Client.new do |c|
+  c.authentication :api_token, 'my_api_token'
+end
+
+client.workspaces.find_all.first
+```
+
+A full-blown customized client using OAuth2 wih a previously obtained refresh
+token, Typhoeus as a Faraday adapter, a custom user agent and custom Faraday
+middleware:
+
+```ruby
+require 'asana'
+
+client = Asana::Client.new do |c|
+  c.authentication :oauth2,
+                   refresh_token: 'abc',
+                   client_id: 'bcd',
+                   client_secret: 'cde',
+                   redirect_uri: 'http://example.org/auth'
+  c.faraday_adapter :typhoeus
+  c.configure_faraday { |conn| conn.use SomeFaradayMiddleware }
+end
+
+workspace = client.workspaces.find_by_id(12)
+workspace.users
+# => #<Asana::Collection<User> ...>
+client.tags.create_in_workspace(workspace: workspace.id, name: 'foo')
+# => #<Asana::Tag id: ..., name: "foo">
+```
+
+All resources are exposed as methods on the `Asana::Client` instance. Check out
+the [documentation for each of them][docs].
+
+### Authentication
+
+This gem supports authenticating against the Asana API with either an API token or through OAuth2.
+
+#### API Token
+
+```ruby
+Asana::Client.new do |c|
+  c.authentication :api_token, 'my_api_token'
+end
+```
+
+#### OAuth2
+
+Authenticating through OAuth2 is preferred. There are many ways you can do this.
+
+##### With a plain bearer token (doesn't support auto-refresh)
+
+If you have a plain bearer token obtained somewhere else and you don't mind not
+having your token auto-refresh, you can authenticate with it as follows:
+
+```ruby
+Asana::Client.new do |c|
+  c.authentication :oauth2, bearer_token: 'my_bearer_token'
+end
+```
+
+##### With a refresh token and client credentials
+
+If you obtained a refresh token, you can use it together with your client
+credentials to authenticate:
+
+```ruby
+Asana::Client.new do |c|
+  c.authentication :oauth2,
+                   refresh_token: 'abc',
+                   client_id: 'bcd',
+                   client_secret: 'cde',
+                   redirect_uri: 'http://example.org/auth'
+end
+```
+
+##### With an ::OAuth2::AccessToken object (from `omniauth-asana` for example)
+
+If you use `omniauth-asana` or a browser-based OAuth2 authentication strategy in
+general, possibly because your application is a web application, you can reuse
+those credentials to authenticate with this API client. Here's how to do it from
+the callback method:
+
+```ruby
+# assuming we're using Sinatra and omniauth-asana
+get '/auth/:name/callback' do
+  creds = request.env["omniauth.auth"]["credentials"].tap { |h| h.delete('expires') }
+  strategy = request.env["omniauth.strategy"]
+
+  # We need to refresh the omniauth OAuth2 token
+  access_token = OAuth2::AccessToken.from_hash(strategy.client, creds).refresh!
+
+  $client = Asana::Client.new do |c|
+    c.authentication :oauth2, access_token
+  end
+ 
+  redirect '/'
+end
+```
+
+See `examples/omniauth_integration.rb` for a working example of this.
+
+##### Using an OAuth2 offline authentication flow (for CLI applications)
+
+If your application can't receive HTTP requests and thus you can't use
+`omniauth-asana`, for example if it's a CLI application, you can authenticate as
+follows:
+
+```ruby
+access_token = Asana::Authentication::OAuth2.offline_flow(client_id: ...,
+                                                          client_secret: ...)
+client = Asana::Client.new do |c|
+  c.authentication :oauth2, access_token
+end
+
+client.tasks.find_by_id(12)
+```
+
+This will print an authorization URL on STDOUT, and block until you paste in the
+authorization code, which you can get by visiting that URL and granting the
+necessary permissions.
+
+### Pagination
+
+Whenever you ask for a collection of resources, you can provide a number of
+results per page to fetch, between 1 and 100. If you don't provide any, it
+defaults to 20.
+
+```ruby
+my_tasks = client.tasks.find_by_tag(tag: tag_id, per_page: 5)
+# => #<Asana::Collection<Task> ...>
+```
+
+An `Asana::Collection` is a paginated collection -- it holds the first
+`per_page` results, and a reference to the next page if any.
+
+When you iterate an `Asana::Collection`, it'll transparently keep fetching all
+the pages, and caching them along the way:
+
+```ruby
+my_tasks.size # => 23, not 5
+my_tasks.take(14)
+# => [#<Asana::Task ...>, #<Asana::Task ...>, ... until 14]
+```
+
+#### Manual pagination
+
+If you only want to deal with one page at a time and manually paginate, you can
+get the elements of the current page with `#elements` and ask for the next page
+with `#next_page`, which will return an `Asana::Collection` with the next page
+of elements:
+
+```ruby
+my_tasks.elements # => [#<Asana::Task ...>, #<Asana::Task ...>, ... until 5]
+my_tasks.next_page # => #<Asana::Collection ...>
+```
+
+#### Lazy pagination
+
+Because an `Asana::Collection` represents the entire collection, it is often
+handy to just take what you need from it, rather than let it fetch all its
+contents from the network. You can accomplish this by turning it into a lazy
+collection with `#lazy`:
+
+```ruby
+# let my_tasks be an Asana::Collection of 10 pages of 100 elements each
+my_tasks.lazy.drop(120).take(15).to_a
+# Fetches only 2 pages, enough to get elements 120 to 135
+# => [#<Asana::Task ...>, #<Asana::Task ...>, ...]
+```
+
+### Error handling
+
+In any request against the Asana API, there a number of errors that could
+arise. Those are well documented in the [Asana API Documentation][apidocs], and
+are represented as exceptions under the namespace `Asana::Errors`.
+
+All errors are subclasses of `Asana::Errors::APIError`, so make sure to rescue
+instances of this class if you want to handle them yourself.
+
+### I/O options
+
+All requests (except `DELETE`) accept extra I/O options
+[as documented in the API docs][io]. Just pass an extra `options` hash to any
+request:
+
+```ruby
+client.tasks.find_by_id(12, options: { expand: ['workspace'] })
+```
+
+### Attachment uploading
+
+To attach a file to a task or a project, you just need its absolute path on your
+filesystem and its MIME type, and the file will be uploaded for you:
+
+```ruby
+task = client.tasks.find_by_id(12)
+attachment = task.attach(filename: '/absolute/path/to/my/file.png',
+                         mime: 'image/png')
+attachment.name # => 'file.png'
+```
+
+### Event streams
+
+To subscribe to an event stream of a task or a project, just call `#events` on
+it:
+
+```ruby
+task = client.tasks.find_by_id(12)
+task.events # => #<Asana::Events ...>
+
+# You can do the same with only the task id:
+events = client.events.for(task.id)
+```
+
+An `Asana::Events` object is an infinite collection of `Asana::Event`
+instances. Be warned that if you call `#each` on it, it will block forever!
+
+Note that, by default, an event stream will wait at least 1 second between
+polls, but that's configurable with the `wait` parameter:
+
+```ruby
+# wait at least 3 and a half seconds between each poll to the API
+task.events(wait: 3.5) # => #<Asana::Events ...>
+```
+
+There are some interesting things you can do with an event stream, as it is a
+normal Ruby Enumerable. Read below to get some ideas.
+
+#### Subscribe to the event stream with a callback, polling every 2 seconds
+
+```ruby
+# Run this in another thread so that we don't block forever
+events = client.tasks.find_by_id(12).events(wait: 2)
+Thread.new do
+  events.each do |event|
+    notify_someone "New event arrived! #{event}"
+  end
+end
+```
+
+#### Make the stream lazy and filter it by a specific pattern
+
+To do that we need to call `#lazy` on the `Events` instance, just like with any
+other `Enumerable`.
+
+```ruby
+events = client.tasks.find_by_id(12).events
+only_change_events = events.lazy.select { |event| event.action == 'changed' }
+Thread.new do
+  only_change_events.each do |event|
+    notify_someone "New change event arrived! #{event}"
+  end
+end
+```
+
+## Development
+
+You'll need Ruby 2.1+ and Node v0.10.26+ / NPM 1.4.3+ installed.
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`bin/console` for an interactive prompt that will allow you to experiment.
+
+Run the build with `rake`. This is equivalent to:
+
+    $ rake spec && rake rubocop && rake yard
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Releasing a new version
+
+To release a new version, run either of these commands:
+
+    rake bump:patch
+    rake bump:minor
+    rake bump:major
+
+This will: update `lib/asana/version.rb`, commit and tag the commit. Then you
+just need to `push --tags` to let Travis build and release the new version to
+Rubygems:
+
+    git push --tags
+
+### Code generation
+
+The specific Asana resource classes (`Tag`, `Workspace`, `Task`, etc) are
+generated code, hence they shouldn't be modified by hand. The code that
+generates it lives in `lib/templates/resource.ejs`, and is tested by generating
+`spec/templates/unicorn.rb` and running `spec/templates/unicorn_spec.rb` as part
+of the build.
+
+If you wish to make changes on the code generation script:
+
+1. Add/modify a spec on `spec/templates/unicorn_spec.rb`
+2. Add your new feature or change to `lib/templates/resource.ejs`
+3. Run `rake` or, more granularly, `rake codegen && rspec
+   spec/templates/unicorn_spec.rb`
+
+Once you're sure your code works, submit a pull request and ask the maintainer
+to make a release, as they'll need to run a release script from the
+[asana-api-meta][meta] repository.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/asana/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+[apidocs]: https://asana.com/developers
+[io]: https://asana.com/developers/documentation/getting-started/input-output-options
+[docs]: https://asana.github.com/ruby-asana
+[meta]: https://github.com/asana/asana-api-meta