redbooth-ruby 0.0.5 → 0.1.0

data/lib/redbooth-ruby/client.rb

@@ -2,10 +2,11 @@ module RedboothRuby
   class Client
     include RedboothRuby::ClientOperations::Search
     include RedboothRuby::ClientOperations::Metadata
+    include Helpers
 
     RESOURCES = [ :me, :user, :task, :organization, :person, :project,
                   :conversation, :membership, :comment, :note, :subtask,
-                  :file ]
+                  :file, :task_list ]
 
     attr_reader :session, :options
 
@@ -27,7 +28,7 @@ module RedboothRuby
     #
     # @param [String||Symbol] action name of the action to execute over
     # @param [Hash] options for the execution
-    # @returns the execution return or nil
+    # @return the execution return or nil
     #
     # @example
     #   session = RedboothRuby::Session.new(api_key: '_your_api_key_', auth_token: '_aut_token_for_the_user')
@@ -50,43 +51,9 @@ module RedboothRuby
     # @param [String||Symbol] resource_name name of the resource to execute over
     # @param [String||Symbol] action name of the action to execute over
     # @param [Hash] options for the execution
-    # @returns the execution return or nil
+    # @return the execution return or nil
     def perform!(resource_name, action, options = {})
-      fail RedboothRuby::AuthenticationError unless session
-      resource(resource_name).send(action, options_with_session(options))
-    rescue Processing => processing
-      delay = processing.response.data["retry_after"] || 10
-      retry_in(delay, resource_name, action, options)
+      ClientOperations::Perform.new(resource_name, action, session, options).perform!
     end
-
-    # Retryes the request in the given time
-    # either calls the given proc options[:retry]
-    # or executes it in this thread
-    #
-    def retry_in(delay, *args)
-      if options[:retry]
-        options[:retry].call(delay)
-      else
-        sleep(delay)
-        perform!(*args)
-      end
-    end
-
-    # Merge the given options with the session for use the api
-    #
-    # @param [Hash] options options to merge with session
-    # @return [Hash]
-    def options_with_session(options={})
-      options.merge(session: @session)
-    end
-
-    # Gest the api resource model class by his name
-    #
-    # @param [String||Symbol] name name of the resource
-    # @return [Copy::Base] resource to use the api
-    def resource(name)
-      eval('RedboothRuby::' + name.to_s.capitalize) rescue nil
-    end
-
   end
-end
+end

data/lib/redbooth-ruby/client_operations/perform.rb

@@ -0,0 +1,93 @@
+module RedboothRuby
+  module ClientOperations
+    class Perform
+      include RedboothRuby::Helpers
+      attr_accessor :resource_name, :action, :session, :options
+      attr_accessor :tries, :processing_error, :oauth_token_expired_error
+
+      def initialize(resource_name, action, session, options = {})
+        @resource_name = resource_name
+        @action = action
+        @session = session
+        @options = options
+        @tries = 0
+      end
+
+      # Performs the resource action
+      #
+      # @return the execution return or nil
+      def perform!
+        @tries += 1
+        fail RedboothRuby::AuthenticationError unless session
+        resource(resource_name).send(action, options_with_session(options))
+      rescue Processing => processing_error
+        @processing_error = processing_error
+        perform_processing!
+      rescue OauthTokenExpired => oauth_token_expired_error
+        @oauth_token_expired_error = oauth_token_expired_error
+        perform_oauth_token_expired!
+      end
+
+      # Delays the execution of the enqueued processing
+      #
+      # @return the execution return or nil
+      def perform_processing!
+        delay = if processing_error && processing_error.response
+          processing_error.response.data['retry_after'].to_i
+        else
+          10
+        end
+        retry_in(delay)
+      end
+
+      # Perform refresh on the session access token
+      #
+      # @return the execution return or raise OauthTokenExpired
+      def perform_oauth_token_expired!
+        if tries == 1 && refresh_session_access_token!
+          perform!
+        else
+          raise oauth_token_expired_error
+        end
+      end
+
+      private
+
+      # Retries the request in the given time either calls the given
+      # proc options[:retry] or executes it in this thread
+      #
+      def retry_in(delay)
+        if options[:retry]
+          options[:retry].call(delay)
+        else
+          sleep(delay)
+          perform!
+        end
+      end
+
+      # Merge the given options with the session for use the api
+      #
+      # @param [Hash] options options to merge with session
+      # @return [Hash]
+      def options_with_session(options={})
+        options.merge(session: @session)
+      end
+
+      # Get the api resource model class by his name
+      #
+      # @param [String||Symbol] name name of the resource
+      # @return [Copy::Base] resource to use the api
+      def resource(name)
+        Object.const_get("RedboothRuby::#{camelize(name)}") rescue nil
+      end
+
+      # Refresh the session access token if auto_refresh_token is enabled
+      #
+      # @return [Boolean]
+      def refresh_session_access_token!
+        session.auto_refresh_token && session.refresh_access_token!
+      end
+
+    end
+  end
+end

data/lib/redbooth-ruby/file.rb

@@ -24,6 +24,14 @@ module RedboothRuby
                   :created_at,
                   :updated_at
 
+  # Returns a blop with the file data
+  #
+  # @return [String] the object metadata
+  def download(style='original')
+    request = RedboothRuby.request(:download, nil, "files/#{id}/download/#{style}/#{name}", {}, { session: session })
+    request.body
+  end
+
   class << self
       # Create operation overwrite to parse file first
       def create(attrs)

data/lib/redbooth-ruby/helpers.rb

@@ -0,0 +1,32 @@
+module RedboothRuby
+  module Helpers
+
+    # Transform a resource name into a class name.
+    # Transform a Symbol|String:
+    #   capitalize the first letter
+    #   capitalize the first letter after _'s, removing the _'s
+    # Example: camelize(:task_list)   # => TaskList
+    # Example: camelize('task_list')  # => TaskList
+    #
+    # @param  [Symbol|String] name to convert
+    # @return [String] string of the class name
+    def camelize(name)
+      name.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    # Transform a class name into a resource name.
+    # Downcase all the letters, inserting an underscore _ before capitals
+    # Example: underscore('TaskList')   # => task_list
+    #
+    # @param  [String] camel_case_word to convert
+    # @return [String] string of the resource name
+    def underscore(camel_case_word)
+      camel_case_word.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+  end
+end

data/lib/redbooth-ruby/operations/base.rb

@@ -2,6 +2,7 @@ module RedboothRuby
   module Operations
     module Base
       module ClassMethods
+        include RedboothRuby::Helpers
         # Options for request
         # overwrite this in the model to set security
         #
@@ -20,7 +21,7 @@ module RedboothRuby
         #
         def api_member_url(id = nil, method = nil)
           url = api_resource_name(method)
-          url += "/#{id}" if id
+          url += "/#{ id }" if id
           url
         end
 
@@ -35,7 +36,7 @@ module RedboothRuby
         # overwrite this in the model if the api is not well named
         #
         def api_resource_name(method = nil)
-          "#{name.split('::').last.downcase}s"
+          "#{ underscore(name.split('::').last) }s"
         end
       end
 

data/lib/redbooth-ruby/request/collection.rb

@@ -1,6 +1,7 @@
 module RedboothRuby
   module Request
     class Collection
+      include RedboothRuby::Helpers
       attr_reader :response, :params, :method, :session, :resource
 
       def initialize(attributes={})
@@ -99,12 +100,12 @@ module RedboothRuby
         klass.new(hash)
       end
 
-      # Gest the api resource model class by his name
+      # Get the api resource model class by his name
       #
       # @param [String||Symbol] name name of the resource
       # @return [Copy::Base] resource to use the api
       def resource_klass(name)
-        eval('RedboothRuby::' + name.to_s.capitalize) rescue nil
+        eval('RedboothRuby::' + camelize(name)) rescue nil
       end
 
       # Whenever the response is paginated or not

data/lib/redbooth-ruby/request/connection.rb

@@ -14,34 +14,35 @@ module RedboothRuby
 
       def request
         return unless access_token
-        if use_body_file?
-          ::File.open(body_file_attrs[:local_path]) do |file|
-            req = Net::HTTP::Post::Multipart.new(
-                api_url,
-                body_hash.merge(
-                 'asset' => UploadIO.new(file,
-                                         'application/octet-stream',
-                                          body_file_attrs[:name]
-                                        )
-                )
-            )
-            req['Authorization'] = "Bearer #{access_token.token}"
-            # access_token.sign! req
-            if RedboothRuby.configuration[:use_ssl]
-              http = Net::HTTP.new(RedboothRuby.configuration[:api_base] , Net::HTTP.https_default_port)
-              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-              http.use_ssl = RedboothRuby.configuration[:use_ssl]
-            else
-              domain, port = RedboothRuby.configuration[:api_base].split(':')
-              http = Net::HTTP.new(domain, port || Net::HTTP.http_default_port)
-            end
+        case
+        when use_body_file?
+          multipart_request
+        when download_file?
+          download_file_with_redirect
+        else
+          access_token.send(*request_data)
+        end
+      end
+
+      # Downloads the desired file following redirects to
+      # amazon s3 without authentication headers
+      #
+      def download_file_with_redirect
+          max_redirects = access_token.options.fetch(:max_redirects, 20)
+          response = access_token.send(:get, URI.encode(api_url), { redirect_count: max_redirects + 1 })
+          if [302, 301].include? response.status
+            url = response.headers['Location']
+            uri = URI.parse(url)
+            req = Net::HTTP::Get.new(uri)
+            http = Net::HTTP.new(uri.host , Net::HTTP.https_default_port)
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            http.use_ssl = RedboothRuby.configuration[:use_ssl]
             http.start do |inner_http|
               inner_http.request(req)
             end
+          else
+            response
           end
-        else
-          access_token.send(*request_data)
-        end
       end
 
       def set_request_data
@@ -55,6 +56,36 @@ module RedboothRuby
 
       protected
 
+      # Performs a multipart request by containing given files and post data
+      #
+      # @return [Http::Request]
+      def multipart_request
+        ::File.open(body_file_attrs[:local_path]) do |file|
+          req = Net::HTTP::Post::Multipart.new(
+              api_url,
+              body_hash.merge(
+               'asset' => UploadIO.new(file,
+                                       'application/octet-stream',
+                                        body_file_attrs[:name]
+                                      )
+              )
+          )
+          req['Authorization'] = "Bearer #{access_token.token}"
+          # access_token.sign! req
+          if RedboothRuby.configuration[:use_ssl]
+            http = Net::HTTP.new(RedboothRuby.configuration[:api_base] , Net::HTTP.https_default_port)
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            http.use_ssl = RedboothRuby.configuration[:use_ssl]
+          else
+            domain, port = RedboothRuby.configuration[:api_base].split(':')
+            http = Net::HTTP.new(domain, port || Net::HTTP.http_default_port)
+          end
+          http.start do |inner_http|
+            inner_http.request(req)
+          end
+        end
+      end
+
       # Body params hash
       #
       # @return [Hash]
@@ -88,6 +119,11 @@ module RedboothRuby
         body_hash.key?(:asset)
       end
 
+      def download_file?
+        return false unless @info
+        @info.http_method == :download
+      end
+
       def use_url_params?
         return false unless @info
         case @info.http_method
@@ -98,12 +134,12 @@ module RedboothRuby
         end
       end
 
-      # Returns the api url foir this request or default
+      # Returns the api url for this request or default
       def api_url
-        url =  "#{api_url_method}#{api_url_domain}"
-        url += "#{RedboothRuby.configuration[:api_base]}"
-        url += "#{api_url_path}"
-        url += "#{api_url_version}"
+        url =  "#{ api_url_method}#{api_url_domain }"
+        url += "#{ RedboothRuby.configuration[:api_base] }"
+        url += "#{ api_url_path }"
+        url += "#{ api_url_version }"
         if @info
           url += @info.url
           if use_url_params? && !body_hash.empty?
@@ -123,7 +159,7 @@ module RedboothRuby
 
       def api_url_domain
         return '' unless domain
-        "#{domain}."
+        "#{ domain }."
       end
 
       def api_url_path

data/lib/redbooth-ruby/request/helpers.rb

@@ -23,7 +23,7 @@ module RedboothRuby
             result[name.to_s] = normalize_params(value)
           when Array
             value.each_with_index do |item_value, index|
-              result["#{name.to_s}[#{index}]"] = item_value.to_s
+              result["#{ name.to_s }[#{ index }]"] = item_value.to_s
             end
           else
             result[name.to_s] = value.to_s
@@ -33,4 +33,4 @@ module RedboothRuby
       end
     end
   end
-end
+end

data/lib/redbooth-ruby/request/info.rb

@@ -25,7 +25,7 @@ module RedboothRuby
       def path_with_params(path, params)
         unless params.empty?
           encoded_params = URI.encode_www_form(params)
-          [path, encoded_params].join("?")
+          [path, encoded_params].join('?')
         else
           path
         end

data/lib/redbooth-ruby/request/validator.rb

@@ -47,9 +47,9 @@ module RedboothRuby
       def verify_authentication_header
         case raw_response.headers['WWW-Authenticate']
         when /error\=\"invalid_token\".*expired/
-          fail OauhtTokenExpired
+          fail OauthTokenExpired
         when /error\=\"invalid_token\".*revoked/
-          fail OauhtTokenRevoked
+          fail OauthTokenRevoked
         end
       end
 

data/lib/redbooth-ruby/session.rb

@@ -3,18 +3,23 @@ require 'oauth2'
 module RedboothRuby
   class Session
 
-    attr_accessor :token, :refresh_token, :access_token
+    attr_accessor :token, :access_token
+    attr_accessor :refresh_token, :expires_in, :auto_refresh_token, :on_token_refresh
     attr_accessor :consumer_key, :consumer_secret
     attr_accessor :oauth_verifier, :oauth_token
 
     OAUTH_URLS =  {
-        :site => 'https://redbooth.com/api/3',
-        :authorize_url => 'https://redbooth.com/oauth2/authorize',
-        :token_url => 'https://redbooth.com/oauth2/token'
+      site: 'https://redbooth.com/api/3',
+      authorize_url: 'https://redbooth.com/oauth2/authorize',
+      token_url: 'https://redbooth.com/oauth2/token'
     }
 
     def initialize(opts = {})
       @token = opts[:token]
+      @refresh_token = opts[:refresh_token]
+      @expires_in = opts[:expires_in]
+      @auto_refresh_token = opts[:auto_refresh_token] || true
+      @on_token_refresh = opts[:on_token_refresh]
       @consumer_key = opts[:consumer_key] || RedboothRuby.configuration[:consumer_key]
       @consumer_secret = opts[:consumer_secret] || RedboothRuby.configuration[:consumer_secret]
       @oauth_verifier = opts[:oauth_verifier]
@@ -31,16 +36,34 @@ module RedboothRuby
     end
 
     def get_access_token_url
-      url = OAUTH_URLS[:request_token_url]
-      url += "?oauth_verifier=#{oauth_verifier}" if oauth_verifier
-      url += "&oauth_token=#{oauth_token}" if oauth_token
+      uri = URI.parse(OAUTH_URLS[:token_url])
+      params = URI.decode_www_form(uri.query.to_s)
+      params << ['oauth_verifier', oauth_verifier] if oauth_verifier
+      params << ['oauth_token', oauth_token] if oauth_token
+      uri.query = URI.encode_www_form(params) if params.size > 0
+      uri.to_s
     end
 
     def access_token
-      @access_token ||= OAuth2::AccessToken.new(client, token)
+      @access_token ||= OAuth2::AccessToken.new(client, token,
+       refresh_token: refresh_token, expires_in: expires_in)
     end
 
-  end
-end
-
+    def refresh_access_token!
+      new_access_token = access_token.refresh!
+      if new_access_token
+        on_token_refresh.call(access_token, new_access_token) if on_token_refresh.is_a?(Proc)
+        @access_token = new_access_token
+      end
+      new_access_token
+    end
 
+    def on_token_refresh(&block)
+      if block_given?
+        @on_token_refresh = block
+      else
+        @on_token_refresh
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/task_list.rb

@@ -0,0 +1,28 @@
+module RedboothRuby
+  class TaskList < Base
+    include RedboothRuby::Operations::Index
+    include RedboothRuby::Operations::Create
+    include RedboothRuby::Operations::Update
+    include RedboothRuby::Operations::Show
+    include RedboothRuby::Operations::Delete
+    include RedboothRuby::Operations::Meta
+
+    attr_accessor :id,
+                  :name,
+                  :project_id,
+                  :user_id,
+                  :start_on,
+                  :finish_on,
+                  :position,
+                  :archived,
+                  :archived_tasks_count,
+                  :tasks_count,
+                  :last_comment_id,
+                  :updated_by_id,
+                  :metadata,
+                  :deleted,
+                  :completed,
+                  :created_at,
+                  :updated_at
+  end
+end

data/lib/redbooth-ruby/version.rb

@@ -1,3 +1,3 @@
 module RedboothRuby
-  VERSION = '0.0.5'
-end
+  VERSION = '0.1.0'
+end

data/lib/redbooth-ruby.rb

@@ -15,6 +15,7 @@ module RedboothRuby
   autoload :Me,             'redbooth-ruby/me'
   autoload :User,           'redbooth-ruby/user'
   autoload :Task,           'redbooth-ruby/task'
+  autoload :TaskList,       'redbooth-ruby/task_list'
   autoload :Organization,   'redbooth-ruby/organization'
   autoload :Person,         'redbooth-ruby/person'
   autoload :Project,        'redbooth-ruby/project'
@@ -24,6 +25,7 @@ module RedboothRuby
   autoload :Note,           'redbooth-ruby/note'
   autoload :Subtask,        'redbooth-ruby/subtask'
   autoload :File,           'redbooth-ruby/file'
+  autoload :Helpers,        'redbooth-ruby/helpers'
 
 
   module Operations
@@ -47,14 +49,15 @@ module RedboothRuby
   end
 
   module ClientOperations
+    autoload :Perform,    'redbooth-ruby/client_operations/perform'
     autoload :Search,     'redbooth-ruby/client_operations/search'
     autoload :Metadata,   'redbooth-ruby/client_operations/metadata'
   end
 
   class RedboothError < StandardError; end
   class AuthenticationError < RedboothError; end
-  class OauhtTokenExpired < AuthenticationError; end
-  class OauhtTokenRevoked < AuthenticationError; end
+  class OauthTokenExpired < AuthenticationError; end
+  class OauthTokenRevoked < AuthenticationError; end
   class NotFound            < RedboothError; end
   class APIError            < RedboothError; end
   class ObjectNotFound      < APIError; end
@@ -120,4 +123,4 @@ module RedboothRuby
     @@configuration[:api_version] ||= '3'
     @@configuration[:use_ssl] ||= true
   end
-end
+end