crowdkit 0.1.0

data/lib/crowdkit/api/request_methods.rb

@@ -0,0 +1,70 @@
+module Crowdkit
+  class API
+    module RequestMethods
+      # Make an HTTP request
+      #
+      # @param url [String] The path, relative to {#api_endpoint}
+      # @param options [Hash] Query and header params for request
+      # @return [Sawyer::Resource]
+      [:get,:post,:put,:patch,:delete,:head].each do |method|
+        define_method("do_#{method}") do |url, data = {}, options = {}|
+          request method, url, data, options
+        end
+      end
+
+      def agent
+        raise Crowdkit::Unauthorized unless config.access_token
+        @agent ||= Sawyer::Agent.new(config.api_endpoint, sawyer_options)
+      end
+
+      private
+
+      def request(method, path, data, options = {})
+        if data.is_a?(Hash)
+          options[:headers] = data.delete(:headers) || {}
+          options[:headers][:accept] = accept if accept = data.delete(:accept)
+          options[:query]   = data.delete(:query) || {}
+          if [:get, :head, :delete].include?(method)
+            data.each do |key, _|
+              options[:query][key] = data.delete(key)
+            end
+          else
+            options[:headers]['Content-Type'] = 'application/json'
+          end
+        end
+
+        begin
+          Crowdkit.last_response = self.last_response = agent.call(method, URI::Parser.new.escape(path.to_s), data, options)
+          @retried = false
+          ResponseWrapper.new(self.last_response, self.client)
+        rescue Crowdkit::ServiceError => e
+          Crowdkit.last_response = self.last_response = Sawyer::Response.new(agent, e.response)
+
+          # The per second limit was exceeded, let's try again in a second
+          if e.response.status == 429 && !@retried
+            sleep(1)
+            @retried = true
+            retry
+          end
+          raise e
+        end
+      end
+
+      # Executes the request, checking if it was successful
+      #
+      # @return [Boolean] True on success, false otherwise
+      def boolean_from_response(method, path, options = {})
+        response = request(method, path, options)
+        response.status == 204
+      rescue Crowdkit::NotFound
+        false
+      end
+
+      def sawyer_options
+        conn_opts = config.connection_options
+        conn_opts[:builder] = config.stack
+        { faraday: Faraday.new(conn_opts) }
+      end
+    end
+  end
+end

data/lib/crowdkit/api/response_wrapper.rb

@@ -0,0 +1,122 @@
+module Crowdkit
+  class API
+    class ResponseWrapper
+      attr_reader :sawyer, :client
+      extend Forwardable
+      include RequestMethods
+
+      def_delegators :data, :empty?, :size, :include?, :length, :first, :last, :flatten, :include?, :keys, :to_s, :to_hash, :rels
+      def_delegators :client, :last_response, :last_response=, :config, :auto_pagination
+      def_delegators :each, :to_a, :to_ary, :to_enum
+
+      def initialize(sawyer, client)
+        @sawyer = sawyer
+        @client = client
+      end
+
+      def data
+        @sawyer.data
+      end
+
+      def headers
+        @sawyer.headers
+      end
+
+      # Lookup an attribute from the body if hash, otherwise behave like array index.
+      # Convert any key to string before calling.
+      #
+      def [](key)
+        if self.data.is_a?(Array)
+          self.data[key]
+        else
+          self.data.send(:"#{key}")
+        end
+      end
+
+      def current_status
+        if self.data["current_status"]
+          do_get(self.data["current_status"].rels["self"].href)
+        else
+          nil
+        end
+      end
+
+      # Iterate over each resource inside the body
+      #
+      def each(to_enum = true, &block)
+        body_parts = self.data.respond_to?(:each) ? self.data : [self.data]
+        if block_given?
+          body_parts.each &block
+          if self.auto_pagination && self.has_next_page?
+            next_page.each &block
+          end
+        else
+          res = self
+          if self.auto_pagination && res.has_next_page?
+            res = next_page
+            body_parts.concat(res.each(false))
+          end
+          result = to_enum ? body_parts.to_enum : body_parts
+        end
+        #Reset auto pagination option
+        client.auto_pagination = nil
+        result
+      end
+
+      [:next, :last, :first, :prev].each do |rel|
+        define_method("#{rel}_page") do
+          @sawyer.rels[rel] && do_get(@sawyer.rels[rel].href)
+        end
+      end
+
+      def has_next_page?
+        @sawyer.rels[:next]
+      end
+
+      # Overwrite methods to hash keys
+      #
+      ['id', 'type'].each do |method_name|
+        define_method(method_name) do
+          self.[](method_name)
+        end
+      end
+
+      def rate_limit_remaining
+        self.headers["X-RateLimit-Remaining"]
+      end
+
+      # Check if body has an attribute
+      #
+      def has_key?(key)
+        res = self.data.is_a?(Array) ? self.data.first : self.data
+        res.key?(key.to_sym)
+      end
+
+      # Coerce any method calls for body attributes
+      #
+      def method_missing(method_name, *args, &block)
+        if self.has_key?(method_name)
+          self.[](method_name, &block)
+        else
+          super
+        end
+      end
+
+      # Check if method is defined on the body
+      #
+      def respond_to?(method_name)
+        if self.has_key?(method_name)
+          true
+        else
+          super
+        end
+      end
+
+      # Print only response body
+      #
+      def inspect
+        "#<#{self.class.name} @data=\"#{self.data}\">"
+      end
+    end
+  end
+end

data/lib/crowdkit/client.rb

@@ -0,0 +1,36 @@
+module Crowdkit
+  #The top level client, all API access starts here.  It's unlike the other
+  #subclasses of API as it overrides the initialize method and sets us up for
+  #chaining.
+  class Client < API
+    attr_accessor :last_response
+
+    #Accepts a hash of configuration overrides or a Config object
+    def initialize(overrides, &block)
+      @config = overrides.is_a?(Config) ? overrides : Config.new(overrides, &block)
+      @client = self
+      @stored_params = {}
+    end
+
+    def root
+      do_get("")
+    end
+
+    namespace :workers
+    namespace :worksets
+    namespace :jobs
+    namespace :units
+    namespace :statuses
+    namespace :judgments
+    namespace :account
+  end
+end
+
+require 'crowdkit/client/workers'
+require 'crowdkit/client/worksets'
+require 'crowdkit/client/jobs'
+require 'crowdkit/client/units'
+require 'crowdkit/client/statuses'
+require 'crowdkit/client/judgments'
+require 'crowdkit/client/poll'
+require 'crowdkit/client/account'

data/lib/crowdkit/client/account.rb

@@ -0,0 +1,7 @@
+module Crowdkit
+  class Client::Account < API
+    def get
+      do_get("account")
+    end
+  end
+end

data/lib/crowdkit/client/jobs.rb

@@ -0,0 +1,56 @@
+module Crowdkit
+  class Client::Jobs < API
+    def create(*args)
+      arguments(args, required: [:title])
+
+      do_post("jobs", {title: title}.merge(arguments.params))
+    end
+
+    def get(*args)
+      arguments(args, required: [:job_id])
+
+      do_get("jobs/#{job_id}")
+    end
+    alias :find :get
+
+    def search(*args)
+      arguments(args)
+      params = arguments.params
+      params[:query] = args.first if args.first.is_a?(String)
+
+      response = do_get("jobs", query: arguments.params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :list :search
+    alias :all :search
+
+    [:statuses, :judgments].each do |method|
+      define_method(method) do |*args|
+        arguments(args, required: [:job_id])
+        do_get("jobs/#{job_id}/#{method}", query: arguments.params)
+      end
+    end
+
+    def copy(*args)
+      arguments(args, required: [:job_id])
+
+      do_post("jobs/#{job_id}/copy", query: arguments.params)
+    end
+
+    def order(*args)
+      arguments(args, required: [:job_id])
+
+      do_post("jobs/#{job_id}/order", query: arguments.params)
+    end
+
+    def upload(*args)
+      arguments(args, required: [:job_id]) do
+        @params = args.last.read if args.last.is_a?(File)
+      end
+      do_put("jobs/#{job_id}/upload", arguments.params, headers: {'Content-Type' => 'text/csv'})
+    end
+
+    namespace :units, class_name: "Client::Units"
+  end
+end

data/lib/crowdkit/client/judgments.rb

@@ -0,0 +1,9 @@
+module Crowdkit
+  class Client::Judgments < API
+    def get(*args)
+      arguments(args, required: [:judgment_id])
+      do_get("judgments/#{judgment_id}")
+    end
+    alias :find :get
+  end
+end

data/lib/crowdkit/client/poll.rb

@@ -0,0 +1,48 @@
+module Crowdkit
+  class Client::Poll < API
+    include Enumerable
+
+    def initialize(options, &block)
+      super(options, &block)
+      arguments([options], required: [:job_id])
+
+      prepare_sawyer
+      get_units
+
+      @units.data.each do |unit|
+        def unit.delete
+          do_delete("units/#{id}/queue")
+        end
+      end unless @units.data.empty?
+    end
+
+    def each(&block)
+      @units.each(&block)
+    end
+
+    def any?
+      last_response.status != 304
+    end
+
+    def method_missing(method_name, *args, &block)
+      @units.send(method_name, *args, &block)
+    end
+
+    def delete(*args)
+      arguments(args, required: [:job_id])
+      do_delete("jobs/#{job_id}/units/queue", {ids: @units.data.map(&:id)}) if any?
+    end
+
+    private
+
+    def get_units
+      @units = do_get("jobs/#{job_id}/units/queue", query: arguments.params)
+    end
+
+    def prepare_sawyer
+      config_link = config
+      Sawyer::Resource.send(:include, RequestMethods)
+      Sawyer::Resource.send(:define_method, :config) { config_link }
+    end
+  end
+end

data/lib/crowdkit/client/statuses.rb

@@ -0,0 +1,14 @@
+module Crowdkit
+  class Client::Statuses < API
+    def id_key
+      :uuid
+    end
+
+    def get(*args)
+      arguments(args, required: [:uuid])
+
+      do_get("statuses/#{uuid}")
+    end
+    alias :find :get
+  end
+end

data/lib/crowdkit/client/units.rb

@@ -0,0 +1,54 @@
+module Crowdkit
+  class Client::Units < API
+    def id_key
+      :unit_id
+    end
+
+    def get(*args)
+      arguments(args, required: [:unit_id])
+
+      do_get("units/#{unit_id}")
+    end
+    alias :find :get
+
+    def list(*args)
+      arguments(args, required: [:job_id])
+
+      do_get("jobs/#{job_id}/units", arguments.params)
+    end
+    alias :all :list
+
+    def create(*args)
+      arguments(args, required: [:job_id]) do
+        @params = args.last if args.last.is_a?(Array)
+      end
+
+      do_post("jobs/#{job_id}/units", arguments.params)
+    end
+
+    def copy(*args)
+      arguments(args, required: [:unit_id, :destination_job_id])
+
+      do_post("units/#{unit_id}/copy", query: {destination_job_id: destination_job_id})
+    end
+
+    def delete(*args)
+      arguments(args, required: [:unit_id])
+      do_delete("units/#{unit_id}")
+    end
+
+    def judgments(*args)
+      arguments(args, required: [:unit_id])
+      do_get("units/#{unit_id}/judgments", query: arguments.params)
+    end
+
+    [:pause, :resume].each do |method|
+      define_method(method) do |*args|
+        arguments(args, required: [:unit_id])
+        do_put("units/#{unit_id}/#{method}")
+      end
+    end
+
+    namespace :poll, class_name: 'Client::Poll'
+  end
+end

data/lib/crowdkit/client/workers.rb

@@ -0,0 +1,13 @@
+module Crowdkit
+  class Client::Workers < API
+    def flag(*args)
+      arguments(args, required: [:worker_id, :reason])
+      do_put("workers/#{worker_id}/flag", {reason: reason}.merge(arguments.params))
+    end
+
+    def deflag(*args)
+      arguments(args, required: [:worker_id])
+      do_put("workers/#{worker_id}/deflag", arguments.params)
+    end
+  end
+end

data/lib/crowdkit/client/worksets.rb

@@ -0,0 +1,27 @@
+module Crowdkit
+  class Client::Worksets < API
+    def get(*args)
+      arguments(args, required: [:workset_id])
+      do_get("worksets/#{workset_id}")
+    end
+    alias :find :get
+
+    def list(*args)
+      arguments(args, required: [:job_id])
+      do_get("jobs/#{job_id}/worksets", arguments.params)
+    end
+    alias :all :list
+
+    def bonus(*args)
+      arguments(args, required: [:workset_id, :amount])
+      do_put("worksets/#{workset_id}/bonus", {amount: amount}.merge(arguments.params))
+    end
+
+    [:flag, :deflag, :reject, :approve].each do |method|
+      define_method(method) do |*args|
+        arguments(args, required: [:workset_id, :reason])
+        do_put("worksets/#{workset_id}/#{method}", {reason: reason}.merge(arguments.params))
+      end
+    end
+  end
+end