bitly 1.1.2 → 2.0.0.beta.1

data/lib/bitly/api/shorten_counts.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require_relative "./base"
+
+module Bitly
+  module API
+    class ShortenCounts
+      include Base
+
+      def self.attributes
+        [:units, :facet, :unit_reference, :unit]
+      end
+
+      attr_reader(*attributes)
+      attr_reader :metrics
+
+      Metric = Struct.new(:key, :value)
+
+      ##
+      # Shorten counts by group
+      # [`GET /v4/groups/{group_guid}/shorten_counts`](https://dev.bitly.com/v4/#operation/getGroupShortenCounts)
+      #
+      # @example
+      #     shorten_counts = Bitly::API::ShortenCounts.by_group(client: client, group_guid: group_guid)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param group_guid [String] The guid of the group for which you want
+      #      shorten counts
+      #
+      # @return [Bitly::API::ShortenCounts]
+      def self.by_group(client:, group_guid:)
+        response = client.request(path: "/groups/#{group_guid}/shorten_counts")
+        new(data: response.body, response: response)
+      end
+
+      ##
+      # Shorten counts by organization
+      # [`GET /v4/organizations/{organization_guid}/shorten_counts`](https://dev.bitly.com/v4/#operation/getOrganizationShortenCounts)
+      #
+      # @example
+      #     shorten_counts = Bitly::API::ShortenCounts.by_organization(client: client, organization_guid: organization_guid)
+      #
+      # @param client [Bitly::API::Client] An authorized API client
+      # @param organization_guid [String] The guid of the organization for which
+      #      you want shorten counts
+      #
+      # @return [Bitly::API::ShortenCounts]
+      def self.by_organization(client:, organization_guid:)
+        response = client.request(path: "/organizations/#{organization_guid}/shorten_counts")
+        new(data: response.body, response: response)
+      end
+
+      def initialize(data:, response: nil)
+        assign_attributes(data)
+        @metrics = data["metrics"].map do |metric|
+          Metric.new(metric["key"], metric["value"])
+        end
+        @response = response
+      end
+    end
+  end
+end

data/lib/bitly/api/user.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require_relative "./base"
+
+module Bitly
+  module API
+    ##
+    # A User represents the authorized user
+    class User
+      class Email
+        attr_reader :email, :is_verified, :is_primary
+        def initialize(data)
+          @email = data["email"]
+          @is_verified = data["is_verified"]
+          @is_primary = data["is_primary"]
+        end
+      end
+
+      include Base
+      ##
+      # Gets the authorized user from the API.
+      # [`GET /v4/user`](https://dev.bitly.com/v4/#operation/getUser)
+      #
+      # @example
+      #     user = Bitly::API::User.fetch(client: client)
+      #
+      # @param client [Bitly::API::Client] The authorized API client
+      #
+      # @return [Bitly::API::User]
+      def self.fetch(client:)
+        response = client.request(path: "/user")
+        new(data: response.body, client: client, response: response)
+      end
+
+      # @return [Array<Symbol>] The attributes the API returns for a user
+      def self.attributes
+        [:login, :is_active, :is_2fa_enabled, :name, :is_sso_user, :default_group_guid]
+      end
+      # @return [Array<Symbol>] The attributes the API returns that need to be
+      # converted to `Time` objects.
+      def self.time_attributes
+        [:created, :modified]
+      end
+
+      attr_reader(*(attributes + time_attributes))
+      attr_reader :emails
+
+      ##
+      # Creates a Bitly::API::User object.
+      #
+      # @example
+      #     user = Bitly::API::User.new(data: user_data, client: client)
+      #
+      # @param data [Hash<String, String | Boolean>] The user data from the API
+      # @param client [Bitly::API::Client] The authorized API client
+      # @param response [Bitly::HTTP::Response] The original HTTP response
+      #
+      # @return [Bitly::API::User]
+      def initialize(data:, client:, response: nil)
+        assign_attributes(data)
+        @client = client
+        @response = response
+        if data["emails"]
+          @emails = data["emails"].map { |e| Email.new(e) }
+        end
+      end
+
+      ##
+      # Returns the default group for the user from the default group guid
+      #
+      # @example
+      #     user.default_group
+      #
+      # @returns [Bitly::API::Group]
+      def default_group
+        @default_group ||= Group.fetch(client: @client, guid: default_group_guid)
+      end
+
+      ##
+      # Allows you to update the authorized user's name or default group guid.
+      # If you update the default group ID and have already loaded the default
+      # group, it is nilled out so it can be reloaded with the correct ID.
+      # [`PATCH /v4/user`](https://dev.bitly.com/v4/#operation/updateUser)]
+      #
+      # @example
+      #     user.update(name: "New Name", default_group_guid: "aaabbb")
+      #
+      # @param name [String] A new name
+      # @param default_group_guid [String] A new default guid
+      #
+      # @return [Bitly::API::User]
+      def update(name: nil, default_group_guid: nil)
+        params = { "name" => name }
+        if default_group_guid
+          params["default_group_guid"] = default_group_guid
+          @default_group = nil
+        end
+        @response = @client.request(
+          path: "/user",
+          method: "PATCH",
+          params: params
+        )
+        assign_attributes(@response.body)
+        self
+      end
+    end
+  end
+end

data/lib/bitly/error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Bitly
+  ##
+  # An error class that covers all potential errors from the Bitly API. In an
+  # error scenario, the API is only guaranteed to return a status_code and
+  # status_txt: https://dev.bitly.com/formats.html
+  class Error < StandardError
+    ##
+    # @return [String] The status code of the failed request
+    attr_reader :status_code
+
+    ##
+    # @return [String] The description of the failed request
+    attr_reader :description
+
+    ##
+    # @return [Bitly::HTTP::Response] The response that caused the error
+    attr_reader :response
+
+    ##
+    # Creates a new Bitly::Error object
+    #
+    # @param [Bitly::HTTP::Response] response The parsed response to the HTTP request
+    def initialize(response)
+      @response = response
+      @status_code = response.status
+      @description = response.body["description"]
+      @message = "[#{@status_code}] #{response.body["message"]}"
+      super(@message)
+    end
+  end
+end

data/lib/bitly/http.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "./http/adapters/net_http"
+require_relative "./http/response"
+require_relative "./http/request"
+require_relative "./http/client"

data/lib/bitly/http/adapters/net_http.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Bitly
+  module HTTP
+    module Adapters
+      class NetHTTP
+        def request(request)
+          Net::HTTP.start(request.uri.host, request.uri.port, use_ssl: true) do |http|
+            method = Object.const_get("Net::HTTP::#{request.method.capitalize}")
+            full_path = request.uri.path
+            full_path += "?#{request.uri.query}" if request.uri.query
+            http_request = method.new full_path
+            http_request.body = request.body
+            request.headers.each do |header, value|
+              http_request[header] = value
+            end
+            response = http.request http_request
+            success = response.kind_of? Net::HTTPSuccess
+            return [response.code, response.body, response.to_hash, success]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitly/http/client.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Bitly
+  module HTTP
+    class Client
+      def initialize(adapter=Bitly::HTTP::Adapters::NetHTTP.new)
+        @adapter = adapter
+        raise ArgumentError, "Adapter must have a request method." unless @adapter.respond_to?(:request)
+      end
+
+      ##
+      # The main method for the HTTP client. It receives a Bitly::HTTP::Request
+      # object, makes the request described and returns a Bitly::HTTP::Response.
+      #
+      # @param [Bitly::HTTP::Request] request The request that should be made
+      #
+      # @return [Bitly::HTTP::Response] The response from the request.
+      #
+      # @raise [Bitly::Error] If the response is not a successful response
+      #   in the 2xx range, then we raise an error with the response passed as
+      #   an argument. It is up to the application to catch this error.
+      def request(request)
+        status, body, headers, success = @adapter.request(request)
+        response = Bitly::HTTP::Response.new(status: status, body: body, headers: headers, request: request)
+        if success
+          return response
+        else
+          raise Bitly::Error, response
+        end
+      end
+    end
+  end
+end

data/lib/bitly/http/request.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Bitly
+  module HTTP
+    class Request
+      # @return [String] The HTTP method that the request should be.
+      attr_reader :method
+
+      # @return [Hash] A hash of parameters that will be turned into query
+      #   parameters or a request body
+      attr_reader :params
+
+      # @return [Hash] A hash of HTTP headers that will be included with the
+      #   request
+      attr_reader :headers
+
+      ##
+      # Creates a new Bitly::HTTP::Request object, which is to be used by the
+      # [Bitly::HTTP::Client].
+      #
+      # @example
+      #     request = Bitly::HTTP::Request.new(uri: URI.parse('https://api-ssl.bitly.com/v3/shorten'), method: "GET")
+      #
+      # @param [URI] uri A [URI] that you want to make the request to.
+      # @param [String] method The HTTP method that should be used to make the
+      #   request.
+      # @param [Hash] params The parameters to be sent as part of the request.
+      #   GET parameters will be sent as part of the query string and other
+      #   methods will be added to the request body.
+      def initialize(uri: , method: "GET", params: {}, headers: {})
+        errors = []
+        @uri = uri
+        errors << "uri must be an object of type URI. Received a #{uri.class}" unless uri.kind_of?(URI)
+        @method = method
+        errors << "method must be a valid HTTP method. Received: #{method}." unless HTTP_METHODS.include?(method)
+        @params = params
+        errors << "params must be a hash. Received: #{params.inspect}." unless params.kind_of?(Hash)
+        @headers = headers
+        errors << "headers must be a hash. Received: #{headers.inspect}." unless headers.kind_of?(Hash)
+        raise ArgumentError, errors.join("\n") if errors.any?
+      end
+
+      ##
+      # Returns the uri for the request. If the request is an HTTP method that
+      # uses a body to send data, then the uri is the one that the request was
+      # initialised with. If the request uses query parameters, then the
+      # parameters are serialised and added to the uri's query.
+      #
+      # @example
+      #     uri = URI.parse("https://api-ssl.bitly.com/v3/shorten")
+      #     request = Bitly::HTTP::Request.new(uri: uri, params: { foo: "bar" })
+      #     request.uri.to_s
+      #     # => "https://api-ssl.bitly.com/v3/shorten?foo=bar"
+      #
+      # @return [URI] The full URI for the request
+      def uri
+        uri = @uri.dup
+        return uri if HTTP_METHODS_WITH_BODY.include?(@method)
+        if uri.query
+          existing_query = URI.decode_www_form(uri.query)
+          new_query = hash_to_arrays(@params)
+          uri.query = URI.encode_www_form((existing_query + new_query).uniq)
+        else
+          uri.query = URI.encode_www_form(@params) if @params.any?
+        end
+        uri
+      end
+
+      ##
+      # Returns the body of the request if the request is an HTTP method that
+      # uses a body to send data. The body is a JSON string of the parameters.
+      # If the request doesn't use a body to send data, this returns nil.
+      #
+      # @example
+      #     uri = URI.parse("https://api-ssl.bitly.com/v3/shorten")
+      #     request = Bitly::HTTP::Request.new(uri: uri, method: 'POST', params: { foo: "bar" })
+      #     request.body
+      #     # => "{\"foo\":\"bar\"}"
+      #
+      # @return [String] The request body
+      def body
+        return nil if HTTP_METHODS_WITHOUT_BODY.include?(@method)
+        return JSON.generate(params)
+      end
+
+      private
+
+      def hash_to_arrays(hash)
+        hash.map do |key, value|
+          if value.is_a?(Array)
+            value.map { |v| [key, v] }
+          else
+            [[key, value]]
+          end
+        end.flatten(1)
+      end
+
+      HTTP_METHODS_WITHOUT_BODY = [
+        "GET",
+        "HEAD",
+        "DELETE",
+        "TRACE",
+        "OPTIONS"
+      ]
+
+      HTTP_METHODS_WITH_BODY = [
+        "POST",
+        "PUT",
+        "PATCH",
+        "CONNECT"
+      ]
+
+      HTTP_METHODS = HTTP_METHODS_WITH_BODY + HTTP_METHODS_WITHOUT_BODY
+    end
+  end
+end

data/lib/bitly/http/response.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Bitly
+  module HTTP
+    ##
+    # The Response class handles generic responses from the API. It is made up
+    # of a status code, body and headers. The body is expected to be JSON and it
+    # will parse the body. The status should lie within the range 100 - 599 and
+    # the headers should be a hash.
+    class Response
+
+      # @return [String] The response's status code
+      attr_reader :status
+
+      # @return [Hash] The response's parsed body
+      attr_reader :body
+
+      # @return [Hash] The response's headers
+      attr_reader :headers
+
+      # @return [Bitly::HTTP::Request] The request that caused this response
+      attr_reader :request
+
+      ##
+      # Creates a new Bitly::HTTP::Response object, which can be used by other
+      # objects in the library.
+      #
+      # @example
+      #     response = Bitly::HTTP::Response.new(status: "200", body: "{}", headers: {})
+      #
+      # @param [String] status The status code of the response, which should be
+      #   between 100 and 599
+      # @param [String] body The body of the response, a String that is valid
+      #   JSON and will be parsed
+      # @param [Hash] headers The response headers
+      def initialize(status:, body:, headers:, request: nil)
+        errors = []
+        @status = status
+        errors << "Status must be a valid HTTP status code. Received #{status}" unless is_status?(status)
+        if body.nil? || body.empty?
+          @body = nil
+        else
+          begin
+            @body = JSON.parse(body)
+          rescue JSON::ParserError
+            @body = {
+              "message" => body
+            }
+          end
+        end
+        @headers = headers
+        errors << "Headers must be a hash. Received #{headers}" unless headers.is_a?(Hash)
+        @request = request
+        errors << "Request must be a Bitly::HTTP::Request. Received #{request}" if request && !request.is_a?(Request)
+        raise ArgumentError, errors.join("\n"), caller if errors.any?
+      end
+
+      private
+
+      def is_status?(status)
+        !!status.match(/\A[1-5][0-9][0-9]\z/)
+      end
+    end
+  end
+end