toolhound-ruby 1.0.4

data/lib/toolhound-ruby/client/notifications.rb

@@ -0,0 +1,31 @@
+module Nearmiss
+  class Client
+
+    # Methods for the Notifications API
+    #
+    module Notifications
+
+      # List notifications for the current user
+      #
+      # If user is not supplied, repositories for the current
+      #   authenticated user are returned.
+      #
+      # @note If the user provided is a GitHub organization, only the
+      #   organization's public repositories will be listed. For retrieving
+      #   organization repositories the {Organizations#organization_repositories}
+      #   method should be used instead.
+      # @see https://developer.github.com/v3/repos/#list-your-repositories
+      # @see https://developer.github.com/v3/repos/#list-user-repositories
+      # @param user [Integer, String] Optional GitHub user login or id for which
+      #   to list repos.
+      # @return [Array<Sawyer::Resource>] List of projects
+      def notifications(options = {})
+        paginate "notifications", options
+      end
+      alias :list_notifications :notifications
+
+
+
+    end
+  end
+end

data/lib/toolhound-ruby/client/projects.rb

@@ -0,0 +1,40 @@
+module Toolhound
+  class Client
+
+    # Methods for the Projects API
+    #
+    module Projects
+
+      # List projects
+      #
+      # @note Shows a list of projects for the users organization aka account
+      #
+      # @return [Array<Sawyer::Resource>] List of projects
+      def projects(options = {})
+        # paginate "projects", options
+        
+      end
+      # alias :list_projects :projects
+
+      # Get a single project
+      #
+      # @param project [String] UUID of project to fetch
+      # @return [Sawyer::Resource] Project information
+      #
+      def project(project, options = {})
+        # get "#{project_path(project)}", options
+      end
+
+      private
+
+      # def project_path(id)
+      #   if uuid?(id)
+      #     "projects/#{id}"
+      #   else
+      #     "project/#{id}"
+      #   end
+      # end
+
+    end
+  end
+end

data/lib/toolhound-ruby/client/users.rb

@@ -0,0 +1,81 @@
+module Toolhound
+  class Client
+
+    # Methods for the Users API
+    #
+    module Users
+
+      # List users
+      #
+      # @note Logged in user must be an admin to see all users
+      #
+      # @return [Array<Sawyer::Resource>] List of projects
+      def users(options = {})
+        paginate "users", options
+      end
+      alias :list_users :users
+
+      # Get a single user
+      #
+      # @param user [String] Nearmiss user email or id.
+      # @return [Sawyer::Resource]
+      # @example
+      #   Nearmiss.user("31817811-dce4-48c4-aa5f-f49603c5abee") or Nearmiss.user("m4rkuskk+a@gmail.com")
+      def user(user=nil, options = {})
+        if user.nil?
+          get "me", options
+        else
+          get "users/#{user}", options
+        end
+        # get User.path(user), options
+      end
+
+      # Edit a user
+      #
+      # @param options [Hash] User information.
+      # @option options [String] :email Email of user
+      # @option options [String] :name Name of user
+      # @option options [String] :nickname Nickname of user
+      # @option options [Integer] :role Set to admin or not
+      # @option options [String] :phone_number Phone number of user
+      # @option options [String] :image URL of image of user
+      # @option options [String] :language Code "en", "de", "es"
+      # @return
+      #   [Sawyer::Resource] Edited user info
+      # @example Update a user
+      #   @client.edit_user('some_id', {
+      #     email: "mklooth@webcor.com",
+      #     name: "Markus Klooth"
+      #   })
+      #
+      def edit_user(user, options = {})
+        patch "update_user/#{user}", options
+      end
+      alias :update_user :edit_user
+
+      def update_email(user, options = {})
+
+      end
+
+
+      def delete_user(user, options = {})
+        delete "users/#{user}", options
+      end
+
+      # Validate user username and password
+      #
+      # @param options [Hash] User credentials
+      # @option options [String] :email Nearmiss login email
+      # @option options [String] :password Nearmiss password
+      # @return [Boolean] True if credentials are valid
+      def validate_credentials(options = {})
+        !self.class.new(options).user.nil?
+      rescue Toolhound::Unauthorized
+        false
+      end
+
+
+
+    end
+  end
+end

data/lib/toolhound-ruby/configurable.rb

@@ -0,0 +1,47 @@
+module Toolhound
+  module Configurable
+
+    # attr_accessor :auto_paginate, :per_page
+    attr_writer :dataserver, :port, :username, :password
+
+    # Define static methods
+    class << self
+
+      def keys
+        @keys ||= [
+          :dataserver,
+          :port,
+          :username,
+          :password
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Toolhound::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Toolhound::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    # def api_endpoint
+    #   File.join(@api_endpoint, "")
+    # end
+
+    def options
+      Hash[Toolhound::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+  private
+
+
+
+  end
+end

data/lib/toolhound-ruby/core_ext/string.rb

@@ -0,0 +1,16 @@
+class String
+
+  def underscore()
+    camel_cased_word = self
+    acronym_regex = /#{["REST"].join("|")}/
+    return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+    word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
+    word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+    word.tr!("-".freeze, "_".freeze)
+    word.downcase!
+    word
+  end
+
+end

data/lib/toolhound-ruby/default.rb

@@ -0,0 +1,57 @@
+# require "bim360/version" unless defined?(Nearmiss::VERSION)
+# require 'bim360/response/raise_error'
+
+module Toolhound
+
+
+  # Default configuration options for {Client}
+  module Default
+
+    # Default User Agent header string
+
+    PORT          = 1433.freeze
+
+    class << self
+
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[Toolhound::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+
+
+      def config
+        @config ||= {}
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def dataserver
+        ENV['TOOLHOUND_DATASERVER'] || config['dataserver']
+      end
+
+      def port
+        ENV['TOOLHOUND_PORT'] || config['port'] || PORT
+      end
+
+      # Default BIM360-Field username for Basic Auth from ENV
+      # @return [String]
+      def username
+        ENV['TOOLHOUND_USERNAME'] || config['username']
+        # ENV['NEARMISS_EMAIL'] || config['email']
+      end
+
+      # Default BIM360-Field password for Basic Auth from ENV
+      # @return [String]
+      def password
+        ENV['TOOLHOUND_PASSWORD'] || config['password']
+      end
+
+
+
+
+    end
+
+  end
+end

data/lib/toolhound-ruby/error.rb

@@ -0,0 +1,186 @@
+module Toolhound
+  # Custom error class for rescuing from all GitHub errors
+  class Error < StandardError
+
+    # Returns the appropriate Nearmiss::Error sublcass based
+    # on status and response message
+    #
+    # @param [Hash] response HTTP response
+    # @return [Nearmiss::Error]
+    def self.from_response(response)
+      status  = response[:status].to_i
+      body    = response[:body].to_s
+      headers = response[:response_headers]
+
+
+
+      if klass =  case status
+                  when 400      then Nearmiss::BadRequest
+                  when 401      then Nearmiss::Unauthorized
+                  when 403      then Nearmiss::Forbidden
+                  when 404      then Nearmiss::NotFound
+                  when 405      then Nearmiss::MethodNotAllowed
+                  when 406      then Nearmiss::NotAcceptable
+                  when 409      then Nearmiss::Conflict
+                  when 415      then Nearmiss::UnsupportedMediaType
+                  when 422      then Nearmiss::UnprocessableEntity
+                  when 400..499 then Nearmiss::ClientError
+                  when 500      then Nearmiss::InternalServerError
+                  when 501      then Nearmiss::NotImplemented
+                  when 502      then Nearmiss::BadGateway
+                  when 503      then Nearmiss::ServiceUnavailable
+                  when 500..599 then Nearmiss::ServerError
+                  end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response=nil)
+      @response = response
+      super(build_error_message)
+    end
+
+    # Array of validation errors
+    # @return [Array<Hash>] Error info
+    def errors
+      if data && data.is_a?(Hash)
+        data[:errors] || []
+      else
+        []
+      end
+    end
+
+  # private
+
+    def data
+      @data ||=
+        if (body = @response[:body]) && !body.empty?
+          if body.is_a?(String) &&
+            @response[:response_headers] &&
+            @response[:response_headers][:content_type] =~ /json/
+
+            # Sawyer::Agent.serializer.decode(body)
+          else
+            body
+          end
+        else
+          nil
+        end
+    end
+
+    def response_message
+      case data
+      when Hash
+        data[:message]
+      when String
+        data
+      end
+    end
+
+    def response_error
+      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
+    end
+
+    def response_error_summary
+      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
+
+      summary = "\nError summary:\n"
+      # summary << data[:errors].map do |hash|
+        # hash.map { |k,v| "  #{k}: #{v}" }
+      # end.join("\n")
+      summary << data[:errors].join("\n")
+      summary
+    end
+
+    def build_error_message
+      return nil if @response.nil?
+
+
+
+      message =  "#{@response[:method].to_s.upcase} "
+      message << redact_url(@response[:url].to_s) + ": "
+      message << "#{@response[:status]} - "
+      message << "#{response_message}" unless response_message.nil?
+      message << "#{response_error}" unless response_error.nil?
+      message << "#{response_error_summary}" unless response_error_summary.nil?
+      # message << MultiJson.dump(@response)
+      message
+    end
+
+    def redact_url(url_string)
+      %w[client_secret access_token].each do |token|
+        url_string.gsub!(/#{token}=\S+/, "#{token}=(redacted)") if url_string.include? token
+      end
+      url_string
+    end
+
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when Nearmiss-Field returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 401 HTTP status code
+  class Unauthorized < ClientError; end
+  # Raised when Nearmiss-Field returns a 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 403 HTTP status code
+  # and body matches 'rate limit exceeded'
+  class TooManyRequests < Forbidden; end
+
+  # Raised when Nearmiss-Field returns a 403 HTTP status code
+  # and body matches 'login attempts exceeded'
+  class TooManyLoginAttempts < Forbidden; end
+
+  # Raised when Nearmiss-Field returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 405 HTTP status code
+  class MethodNotAllowed < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 409 HTTP status code
+  class Conflict < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 414 HTTP status code
+  class UnsupportedMediaType < ClientError; end
+
+  # Raised when Nearmiss-Field returns a 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when Nearmiss-Field returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when Nearmiss-Field returns a 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when Nearmiss-Field returns a 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when Nearmiss-Field returns a 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+
+  # Raised when client fails to provide valid Content-Type
+  class MissingContentType < ArgumentError; end
+
+  # Raised when a method requires an application client_id
+  # and secret but none is provided
+  class ApplicationCredentialsRequired < StandardError; end
+
+  class MissingParams < Error
+    def initialize(msg)
+
+      msg
+    end
+  end
+
+
+end