taskrabbit 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.idea
+Gemfile.lock
+.rvmrc
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--debug

data/Gemfile

@@ -0,0 +1,22 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in taskrabbit.gemspec
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'yard'
+  gem 'ruby-debug'
+  gem 'pry'
+  gem 'awesome_print'
+end
+
+group :test do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'rb-fsevent'
+  gem 'growl'
+  gem 'vcr'
+  gem 'fakeweb'
+  gem 'rcov', :require => nil
+end

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(/^spec\/(.*)_spec\.rb/)
+  watch(/^lib\/(.*)\.rb/)         { "spec" }
+  watch(/^spec\/spec_helper\.rb/) { "spec" }
+end

data/README.md

@@ -0,0 +1,132 @@
+# TaskRabbit Ruby Gem
+
+Ruby wrapper for TaskRabbit API.
+
+## Installation
+
+I have not published the gem yet so you will either have to vendor it or use a Gemfile:
+
+    gem 'taskrabbit', :git => 'git://github.com/jrichardlai/taskrabbit.git'
+
+
+## Usage Example
+
+### Configuration
+
+In an initializer file.
+
+    Taskrabbit.configure do |config|
+      config.client_secret = 'your-client-secret'
+    end
+
+Available configuration options:
+
+   * client_secret: client secret that has been given to you by TaskRabbit
+   * base_uri: uri of the server (not mandatory, default to www.taskrabbit.com) 
+   * endpoint: endpoint (not mandatory, default to api/v1)
+
+## Task
+
+### use the API client
+
+    tr = Taskrabbit::Api.new
+    
+or with a user token
+
+    tr = Taskrabbit::Api.new(user_token)
+
+### Get the list of all the tasks
+
+    tr = Taskrabbit::Api.new
+    # to get the /tasks
+    tasks = tr.tasks.all
+    # fetch the first task
+    tasks.first
+    
+    tasks.all(:reload => true) # => will redo the query
+
+### Find a task
+
+    tr = Taskrabbit::Api.new
+    t = tr.tasks.find(31231) # This actually wont do the request
+
+To request the API:
+
+    t.fetch # force fetching
+
+or simply access a property:
+
+    t.name # will do the query
+
+### Find the tasks of an user
+
+    tr.users.find(user_id).tasks
+
+### Create a task
+
+    tr = Taskrabbit::Api.new(user_token)
+    task = tr.tasks.create({:named_price => 32, :name => 'Ikea'})
+
+or 
+
+    task = tr.tasks.new({:named_price => 32, :name => 'Ikea'})
+    task.save
+
+### Update a task
+
+    task = tr.tasks.find(32121)
+    task.named_price = 45
+    task.save
+
+### Error for tasks creation or update
+
+    tr = Taskrabbit::Api.new(client_secret)
+    task = tr.tasks.new
+    unless task.save
+      task.error # => "Task title can't be blank, \nAmount you are willing to pay is not a number"
+      task.errors # => { "messages" => ["Task title can't be blank", "Amount you are willing to pay is not a number"],
+                         "fields" => [["name","can't be blank"], ["named_price","is not a number"]] }
+    end
+
+### Redirect
+
+In some case TaskRabbit will return an url which should be used for further operations (i.e: when the user doesn't have a credit card).
+
+    tr = Taskrabbit::Api.new(client_secret)
+    task = tr.tasks.new
+    unless task.save
+      if task.redirect?
+        task.redirect_url #=> 'http://www.taskrabbit.com/somepath'
+      end
+    end
+
+## User account
+
+    tr = Taskrabbit::Api.new(client_secret)
+    tr.account # => Taskrabbit::User object
+
+    tr.account.tasks # => List of tasks
+    tr.account.tasks.create(some_params)
+
+## Cities
+
+### Get list of cities
+
+    tr.cities.each do |city|
+      city.name
+    end
+
+### Find a city using the id
+
+    tr.cities.find(3).name # => "SF Bay Area"
+
+### More informations
+
+More informations: http://taskrabbit.github.com
+
+## TODO
+
+Add:
+
+- Picture and sound upload
+- Pages

data/Rakefile

@@ -0,0 +1,53 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+spec = eval(File.read('taskrabbit.gemspec'))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc 'Cleans out the documentation and cache'
+task :clobber_doc do
+  rm_r '.yardoc' rescue nil
+  rm_r 'doc' rescue nil
+end
+
+
+desc 'Clear out YARD docs and generated packages'
+task :clean => [:clobber_package, :clobber_doc]
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new :doc
+rescue LoadError => e
+  task :doc do
+    warn 'YARD is not available, to generate documentation please install yard.'
+  end
+end
+
+
+begin
+  require 'ci/reporter/rake/rspec'
+rescue LoadError
+end
+
+task :default => :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  desc "Run all specs with rcov"
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.pattern = "./spec/**/*_spec.rb"
+    t.rcov_opts = '--exclude spec/,/gems/,/Library/,/usr/,lib/tasks,.bundle,config,/lib/rspec/,/lib/rspec-'
+  end
+end

data/lib/taskrabbit.rb

@@ -0,0 +1,21 @@
+module Taskrabbit
+  autoload :Client,      "taskrabbit/client"
+  autoload :Association, "taskrabbit/association"
+  autoload :Config,      "taskrabbit/config"
+  autoload :Version,     "taskrabbit/version"
+  autoload :Error,       "taskrabbit/error"
+  autoload :Proxy,       "taskrabbit/proxy"
+  autoload :Transformer, "taskrabbit/transformer"
+  autoload :Smash,       "taskrabbit/smash"
+  autoload :Collection,  "taskrabbit/collection"
+  autoload :Api,         "taskrabbit/api"
+  autoload :Task,        "taskrabbit/task"
+  autoload :Account,     "taskrabbit/account"
+  autoload :User,        "taskrabbit/user"
+  autoload :City,        "taskrabbit/city"
+  autoload :Location,    "taskrabbit/location"
+
+  extend Config
+end
+
+require 'api_smith'

data/lib/taskrabbit/account.rb

@@ -0,0 +1,7 @@
+module Taskrabbit
+  class Account < User
+    def fetch
+      reload('get', "account")
+    end
+  end
+end

data/lib/taskrabbit/api.rb

@@ -0,0 +1,47 @@
+module Taskrabbit
+  class Api
+    include Client
+    include Association
+
+    attr_accessor :user_token
+    attr_accessor *Config::VALID_OPTIONS_KEYS
+
+    has_many :users, User
+    has_many :tasks, Task, :on => 'tasks'
+    has_many :cities, City
+
+    def account
+      @account ||= Account.new({}, self)
+    end
+
+    def initialize(user_token = nil, attrs = {})
+      attrs = Taskrabbit.options.merge(attrs)
+      # set the configuration for the api
+      Config::VALID_OPTIONS_KEYS.each do |key|
+        instance_variable_set("@#{key}".to_sym, attrs[key])
+      end
+      self.user_token = user_token if user_token
+    end
+    
+    def request(method, path, transformer, options = {})
+      send(method, path, request_params(transformer, options))
+    end
+
+    private
+
+    def request_params(transformer, options = {})
+      {
+        :transform => transformer,
+        :extra_body => options,
+        :extra_request => {
+          :headers => {
+            'X-Client-Application' => client_secret.to_s, 
+            'Authorization' => "OAuth #{user_token.to_s}"
+          },
+          :endpoint => endpoint.to_s,
+          :base_uri => base_uri.to_s
+        }
+      }
+    end
+  end
+end

data/lib/taskrabbit/association.rb

@@ -0,0 +1,52 @@
+module Taskrabbit
+  module Association
+    def self.included(base)
+      base.const_set('PATHS', {})
+      base.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+    
+    module ClassMethods
+      # define has many that will proxy the association to the class
+      # if the association has been loaded previously, no proxy will be used
+      def has_many(association, klass, options = {})
+        class_eval <<-"END"
+        def #{association}
+          return self[:#{association}] if property_present?(:#{association})
+          @#{association} ||= Proxy.new(self, #{klass})
+        end
+        END
+        self::PATHS[klass] = options[:on]
+      end
+    end
+    
+    module InstanceMethods
+      
+      # return the association path on the api that correspond to the class
+      def association_path(klass)
+        case paths[klass]
+        when String
+          paths[klass]
+        when Proc
+          paths[klass][self]
+        else
+          raise Error.new("Action not defined for #{self.class} on the #{klass} association")
+        end
+      end
+      
+      private
+
+      # check if the property has been loaded
+      def property_present?(property)
+        respond_to?(:loaded) and loaded and self.class.property?(property) and self[property]
+      end
+      
+      def paths
+        self.class::PATHS
+      end
+      
+    end
+  end
+end

data/lib/taskrabbit/city.rb

@@ -0,0 +1,19 @@
+module Taskrabbit
+  class City < Smash
+    property :id
+    property :name
+    property :lat
+    property :lng
+    property :links
+    
+    def fetch
+      reload('get', "cities/#{id.to_s}")
+    end
+    
+    class << self
+      def all(scope, options = {})
+        scope.request('get', 'cities', Api::collection_transformers[self], options)
+      end
+    end
+  end
+end

data/lib/taskrabbit/client.rb

@@ -0,0 +1,47 @@
+module Taskrabbit
+  module Client
+    def self.included(base)
+      base.class_eval do
+        include APISmith::Client
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def collection_transformers
+        @collection_transformers ||= Hash.new do |h, k|
+          h[k] = Class.new(Collection).tap do |klass|
+            klass.transformer_for :items, k
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      # monkey patch APISmith::Client transform_response to set the api to the object
+      def transform_response(response, options)
+        transformer = options[:transform] || options[:transformer]
+        if transformer
+          obj = transformer.call response
+          obj.api = self if obj.respond_to?(:api=)
+          obj
+        else
+          response
+        end
+      end
+
+      # check if an error has occured
+      def check_response_errors(response)
+        return unless net_http_response = response.response rescue nil
+        return unless [Net::HTTPClientError, Net::HTTPServerError].include?(net_http_response.class.superclass)
+
+        response_hash = response.to_hash
+        error = response_hash.fetch('error') { "#{net_http_response.code} #{net_http_response.message}".strip }
+
+        raise Smash::Error.new(error, response) if response_hash['errors']
+        raise Taskrabbit::Error.new(error, response)
+      end
+    end
+  end
+end

data/lib/taskrabbit/collection.rb

@@ -0,0 +1,17 @@
+module Taskrabbit
+  class Collection < APISmith::Smash
+    property :items
+    property :links
+
+    ARRAY_METHODS = %w{first last count size length each}.freeze
+
+    alias :all :items
+
+    # define array methods for the collection and delegate it to items
+    ARRAY_METHODS.each do |method|
+      define_method(method) do |*args, &block|
+        items.send(method, *args, &block)
+      end
+    end
+  end
+end