todoist-ruby 0.1.3 → 0.2.5

data/lib/todoist/sync/labels.rb

@@ -1,27 +1,27 @@
 module Todoist
   module Sync
-    class Labels
+    class Labels < Todoist::Service
         include Todoist::Util  
 
         # Return a Hash of labels where key is the id of a label and value is a label
         def collection
-          return ApiHelper.collection("labels")
+          return @client.api_helper.collection("labels")
         end
 
         # Add a label with a given hash of attributes and returns the label id
         def add(args)
-          return ApiHelper.add(args, "label_add")
+          return @client.api_helper.add(args, "label_add")
         end
 
         # Update label given a hash of attributes
         def update(args)
-          return ApiHelper.command(args, "label_update")
+          return @client.api_helper.command(args, "label_update")
         end
 
         # Delete a label given a label
         def delete(label)
           args = {id: label.id}
-          return ApiHelper.command(args, "label_delete")
+          return @client.api_helper.command(args, "label_delete")
         end
 
         # Update orders for an array of labels
@@ -31,7 +31,7 @@ module Todoist
             args[label.id] = label.item_order
           end
           args = {id_order_mapping: args.to_json}
-          return ApiHelper.command(args, "label_update_orders")
+          return @client.api_helper.command(args, "label_update_orders")
         end
 
     end

data/lib/todoist/sync/notes.rb

@@ -1,29 +1,29 @@
 module Todoist
   module Sync
-    class Notes
+    class Notes < Todoist::Service
         include Todoist::Util  
 
         # Return a Hash of notes where key is the id of a note and value is a note
         def collection
-          return ApiHelper.collection("notes")
+          return @client.api_helper.collection("notes")
         end
 
         # Add a note with a given hash of attributes and returns the note id.  
         # Please note that item_id or project_id key is required.  In addition, 
         # content is also a required key in the hash.
         def add(args)
-          return ApiHelper.add(args, "note_add")
+          return @client.api_helper.add(args, "note_add")
         end
 
         # Update a note given a hash of attributes
         def update(args)
-          return ApiHelper.command(args, "note_update")
+          return @client.api_helper.command(args, "note_update")
         end
 
         # Delete notes given an a note
         def delete(note)
           args = {id: note.id}
-          return ApiHelper.command(args, "note_delete")
+          return @client.api_helper.command(args, "note_delete")
         end
 
       

data/lib/todoist/sync/projects.rb

@@ -2,43 +2,43 @@ module Todoist
   module Sync
     
 
-    class Projects
+    class Projects < Todoist::Service
       include Todoist::Util  
 
       # Return a Hash of projects where key is the id of a project and value is a project
       def collection
-        return ApiHelper.collection("projects")
+        return @client.api_helper.collection("projects")
       end
 
       # Add a project with a given hash of attributes and returns the project id
       def add(args)
-        return ApiHelper.add(args, "project_add")
+        return @client.api_helper.add(args, "project_add")
       end
 
       # Delete projects given an array of projects
       def delete(projects)
         project_ids = projects.collect { |project| project.id }   
         args = {ids: project_ids.to_json}
-        return ApiHelper.command(args, "project_delete")
+        return @client.api_helper.command(args, "project_delete")
       end
 
       # Archive projects given an array of projects
       def archive(projects)
         project_ids = projects.collect { |project| project.id }   
         args = {ids: project_ids.to_json}
-        return ApiHelper.command(args, "project_archive")
+        return @client.api_helper.command(args, "project_archive")
       end
 
       # Unarchive projects given an array of projects
       def unarchive(projects)
         project_ids = projects.collect { |project| project.id }   
         args = {ids: project_ids.to_json}
-        return ApiHelper.command(args, "project_unarchive")
+        return @client.api_helper.command(args, "project_unarchive")
       end
 
       # Update project given a hash of attributes
       def update(args)
-        return ApiHelper.command(args, "project_update")
+        return @client.api_helper.command(args, "project_update")
       end
 
       # Update orders and indents for an array of projects
@@ -48,7 +48,7 @@ module Todoist
           tuples[project.id] = [project.item_order, project.indent]
         end
         args = {ids_to_orders_indents: tuples.to_json}
-        return ApiHelper.command(args, "project_update_orders_indents")
+        return @client.api_helper.command(args, "project_update_orders_indents")
       end
 
     end

data/lib/todoist/sync/reminders.rb

@@ -1,35 +1,35 @@
 module Todoist
   module Sync
-    class Reminders
+    class Reminders < Todoist::Service
         include Todoist::Util  
 
         # Return a Hash of reminders where key is the id of a reminder and value is a reminder
         def collection
-          return ApiHelper.collection("reminders")
+          return @client.api_helper.collection("reminders")
         end
 
         # Add a reminder with a given hash of attributes and returns the reminder id.  
         # Please note that item_id is required as is a date as specific in the
         # documentation.  This method can be tricky to all.
         def add(args)
-          return ApiHelper.add(args, "reminder_add")
+          return @client.api_helper.add(args, "reminder_add")
         end
 
         # Update a reminder given a hash of attributes
         def update(args)
-          return ApiHelper.command(args, "reminder_update")
+          return @client.api_helper.command(args, "reminder_update")
         end
 
         # Delete reminder given an array of reminders
         def delete(reminder)
           args = {id: reminder.id}
-          return ApiHelper.command(args, "reminder_delete")
+          return @client.api_helper.command(args, "reminder_delete")
         end
 
         # Clear locations which is used for location reminders
         def clear_locations
           args = {}
-          return ApiHelper.command(args, "clear_locations")
+          return @client.api_helper.command(args, "clear_locations")
         end
     end
   end

data/lib/todoist/util/api_helper.rb

@@ -1,10 +1,9 @@
 require "net/http"
 require "json"
-require "todoist/util/config"
+require "todoist/config"
 require "todoist/util/network_helper"
 require "todoist/util/parse_helper"
 require "todoist/util/uuid"
-require "todoist/util/command_synchronizer"
 require "ostruct"
 require 'concurrent'
 
@@ -15,18 +14,21 @@ module Todoist
   module Util
 
     class ApiHelper
-      
-      @@object_cache = {"projects" => Concurrent::Hash.new({}), "labels" => Concurrent::Hash.new({}), 
+      def initialize(client)
+        @client = client
+        @object_cache = {"projects" => Concurrent::Hash.new({}), "labels" => Concurrent::Hash.new({}), 
         "items" => Concurrent::Hash.new({}), "notes" => Concurrent::Hash.new({}),
         "reminders" => Concurrent::Hash.new({}), "filters" => Concurrent::Hash.new({})
-      }
-      @@sync_token_cache = Concurrent::Hash.new({"projects" => "*", "labels" => "*", 
-        "items" => "*", "notes" => "*", "reminders" => "*", "filters" => "*"})
-
-      def self.collection(type)
-        CommandSynchronizer.sync
+        }
+        @sync_token_cache = Concurrent::Hash.new({"projects" => "*", "labels" => "*", 
+          "items" => "*", "notes" => "*", "reminders" => "*", "filters" => "*"})
+        @network_helper = NetworkHelper.new(client)
+      end
+      
+      def collection(type)
+        @network_helper.sync
         
-        response = getSyncResponse({sync_token: sync_token(type), resource_types: "[\"#{type}\"]"})
+        response = @network_helper.get_sync_response({sync_token: sync_token(type), resource_types: "[\"#{type}\"]"})
         response[type].each do |object_data|
            object = OpenStruct.new(object_data)
            objects(type)[object.id] = object
@@ -35,23 +37,24 @@ module Todoist
         return objects(type)
       end
       
-      def self.exec(args, command, temporary_resource_id)
+      def exec(args, command, temporary_resource_id)
         command_uuid = Uuid.command_uuid
         commands = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
-        response = getSyncResponse({commands: "[#{commands.to_json}]"})
+        response = @network_helper.get_sync_response({commands: "[#{commands.to_json}]"})
         raise RuntimeError, "Response returned is not ok" unless response["sync_status"][command_uuid] == "ok"
         return response
       end
       
-      def self.command(args, command)
+      def command(args, command)
         temporary_resource_id = Uuid.temporary_resource_id
         command_uuid = Uuid.command_uuid
         command = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
-        CommandSynchronizer.queue(command)
+        
+        @network_helper.queue(command)
         return true
       end
 
-      def self.add(args, command)
+      def add(args, command)
         temporary_resource_id = Uuid.temporary_resource_id
         command_uuid = Uuid.command_uuid
         command = {type: command, temp_id: temporary_resource_id, uuid: command_uuid, args: args}
@@ -60,28 +63,38 @@ module Todoist
             object.id = temp_id_mappings[temporary_resource_id] if temp_id_mappings[temporary_resource_id]
         end
         
-        CommandSynchronizer.queue(command, temp_id_callback)
+        @network_helper.queue(command, temp_id_callback)
         return object
       end
 
-      def self.getSyncResponse(params)
-        NetworkHelper.getResponse(Config::TODOIST_SYNC_COMMAND, params)
+      def get_response(command, params = {}, token = true)
+        @network_helper.get_response(command, params, token)
       end
 
-      protected
+      def get_multipart_response(command, params)
+        @network_helper.get_multipart_response(command, params)
+      end
 
+      def multipart_file(file) 
+        @network_helper.multipart_file(file)
+      end
 
+      def sync
+        @network_helper.sync  
+      end
+
+      protected
       
-      def self.objects(type)
-        @@object_cache[type]
+      def objects(type)
+        @object_cache[type]
       end
 
-      def self.sync_token(type)
-        @@sync_token_cache[type]
+      def sync_token(type)
+        @sync_token_cache[type]
       end
 
-      def self.set_sync_token(type, value)
-        @@sync_token_cache[type] = value
+      def set_sync_token(type, value)
+        @sync_token_cache[type] = value
       end
 
     end

data/lib/todoist/util/network_helper.rb

@@ -1,23 +1,33 @@
 require "net/http"
 require "json"
-require "todoist/util/config"
+require "todoist/config"
 require 'net/http/post/multipart'
 require 'mimemagic'
+require 'openssl'
 
 module Todoist
   module Util
     class NetworkHelper
 
-      @@last_request_time = 0.0
       
-      def self.configureHTTP(command)
+
+      def initialize(client)
+        @client = client
+        @command_cache = Concurrent::Array.new([])
+        @command_mutex = Mutex.new
+        @temp_id_callback_cache = Concurrent::Array.new([])
+        @last_request_time = 0.0
+        
+      end
+      
+      def configure_http(command)
         http = Net::HTTP.new(Config.getURI()[command].host, Config.getURI()[command].port)
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         return http
       end
 
-      def self.configureRequest(command, params)
+      def configure_request(command, params)
         request = Net::HTTP::Post.new(Config.getURI()[command].request_uri)
         request.set_form_data(params)
         return request
@@ -25,9 +35,9 @@ module Todoist
       
       # Files need to be of class UploadIO
       
-      def self.getMultipartResponse(command, params={})
-        token = {token: Todoist::Util::Config.token}
-        http = configureHTTP(command)
+      def get_multipart_response(command, params={})
+        token = {token: @client.token}
+        http = configure_http(command)
         url = Config.getURI()[command]
         http.start do
           req = Net::HTTP::Post::Multipart.new(url, token.merge(params))
@@ -40,11 +50,11 @@ module Todoist
         end
       end
     
-      def self.getResponse(command, params ={}, token = true)
-        token = token ? {token: Todoist::Util::Config.token} : {}
-        http = configureHTTP(command)
-        request = configureRequest(command, token.merge(params))
-        retry_after_secs = Todoist::Util::Config.retry_time
+      def get_response(command, params ={}, token = true)
+        token = token ? {token: @client.token} : {}
+        http = configure_http(command)
+        request = configure_request(command, token.merge(params))
+        retry_after_secs = Todoist::Config.retry_time
         # Hack to fix encoding issues with Net:HTTP for login case
         request.body = request.body.gsub '%40', '@' unless token
         while true
@@ -67,7 +77,7 @@ module Todoist
           when 429
             puts("Encountered 429 - retry after #{retry_after_secs}")
             sleep(retry_after_secs)
-            retry_after_secs *= Todoist::Util::Config.retry_time
+            retry_after_secs *= Todoist::Config.retry_time
           when 500
             raise StandardError, "HTTP 500 Error - The request failed due to a server error."
           when 503
@@ -77,24 +87,50 @@ module Todoist
         
       end
       
-      def self.throttle_request(http, request)
-        time_since_last_request = Time.now.to_f - @@last_request_time
+      def throttle_request(http, request)
+        time_since_last_request = Time.now.to_f - @last_request_time
         
-        if (time_since_last_request < Todoist::Util::Config.delay_between_requests)
-          wait = Todoist::Util::Config.delay_between_requests - time_since_last_request
+        if (time_since_last_request < Todoist::Config.delay_between_requests)
+          wait = Todoist::Config.delay_between_requests - time_since_last_request
           puts("Throttling request by: #{wait}")
           sleep(wait)
         end
-        @@last_request_time = Time.now.to_f
+        @last_request_time = Time.now.to_f
         http.request(request)
       end
       
       # Prepares a file for multipart upload
-      def self.multipart_file(file)
+      def multipart_file(file)
           filename = File.basename(file)
           mime_type = MimeMagic.by_path(filename).type
           return UploadIO.new(file, mime_type, filename)
       end
+        
+      def queue(command, callback = nil) 
+        @command_mutex.synchronize do
+          @command_cache.push(command)
+          @temp_id_callback_cache.push(callback) if callback
+        end
+        
+      end
+      
+      def sync
+        @command_mutex.synchronize do    
+          response = get_sync_response({commands: @command_cache.to_json})
+          @command_cache.clear
+          # Process callbacks here
+          temp_id_mappings = response["temp_id_mapping"]
+          @temp_id_callback_cache.each do |callback| 
+              callback.(temp_id_mappings)
+          end
+          @temp_id_callback_cache.clear
+        end
+      end
+
+      def get_sync_response(params)
+        get_response(Config::TODOIST_SYNC_COMMAND, params)
+      end
+
     end
   end
 end

data/lib/todoist/util/parse_helper.rb

@@ -4,11 +4,11 @@ module Todoist
   module Util
     class ParseHelper
 
-      def self.utcOffsetHours
+      def self.utc_offset_hours
         return Time.now.utc_offset/60/60
       end
 
-      def self.parseTodoistDate(item, key)
+      def self.parse_todoist_date(item, key)
         if item[key]
           time = Time.parse(item[key])
           return time.to_datetime
@@ -18,17 +18,17 @@ module Todoist
       end
 
 
-      def self.filterToday(item, key)
+      def self.filter_today(item, key)
 
         now = DateTime.now
-        if parseTodoistDate(item, key) && parseTodoistDate(item, key) <= DateTime.new(now.year, now.month, now.day, -utcOffsetHours) + 1
+        if parse_todoist_date(item, key) && parse_todoist_date(item, key) <= DateTime.new(now.year, now.month, now.day, -utc_offset_hours) + 1
           return true
         else 
           return false
         end
       end
       
-      def self.formatTime(datetime)
+      def self.format_time(datetime)
         datetime.strftime("%Y-%m-%dT%H:%M")
       end