bubblez 1.0.0

data/bubblez.gemspec

@@ -0,0 +1,46 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bubblez/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = Bubblez::VersionInformation.package_name
+  spec.version       = Bubblez::VersionInformation.version_name
+  spec.date        = Date.today.strftime("%Y-%m-%d")
+  spec.summary     = 'Bubblez REST Client'
+  spec.homepage    = 'https://github.com/FoamFactory/bubblez'
+  spec.authors     = ['Scott Johnson']
+  spec.email       = 'jaywir3@gmail.com'
+  spec.files       = %w(lib/bubblez.rb lib/bubblez/rest_environment.rb lib/bubblez/version.rb)
+  spec.license     = 'MPL-2.0'
+  spec.summary       = %q{A gem for easily defining client REST interfaces in Ruby}
+  spec.description   = %q{Retrofit, by Square, allows you to easily define annoations that will generate the necessary boilerplate code for your REST interfaces. Bubblez is a Gem that seeks to bring a similar style of boilerplate generation to Ruby.}
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.2.26"
+  spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.3'
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+  spec.add_development_dependency "simplecov", "~> 0.16"
+  spec.add_development_dependency "webmock", "~> 3.5"
+  spec.add_development_dependency "vcr", "~> 3.0"
+  spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "os", "~> 1.1.4"
+  spec.add_dependency "addressable", "~> 2.5"
+  spec.add_dependency "rest-client", "~> 2.0"
+end

data/lib/bubblez/config.rb

@@ -0,0 +1,353 @@
+require 'bubblez/rest_environment'
+require 'bubblez/endpoint'
+require 'base64'
+
+module Bubblez
+  class << self
+    attr_writer :configuration
+  end
+
+  ##
+  # Configure the Bubblez instance.
+  #
+  # Use this method if you want to configure the Bubblez instance, typically during initialization of your Gem or
+  # application.
+  #
+  # @example In app/config/initializers/bubblez.rb
+  #    Bubblez.configure do |config|
+  #      config.endpoints = [
+  #        {
+  #          :type => :get,
+  #          :location => :version,
+  #          :authenticated => false,
+  #          :api_key_required => false
+  #        }
+  #      ]
+  #    end
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  ##
+  # The configuration of the Bubblez rest client.
+  #
+  # Use this class if you want to retrieve configuration values set during initialization.
+  #
+  class Configuration
+    def initialize
+      @environments = Hash.new
+      @endpoints = Hash.new
+    end
+
+    ##
+    # Retrieve the {RestEnvironment} object defined as part of this Configuration having a specified name.
+    #
+    # @param [String] environment_name The name of the {RestEnvironment} to retrieve.
+    #
+    # The +environment_name+ is +nil+ by default, which will return the default configuration, if only one exists.
+    #
+    # @return [RestEnvironment] A new +RestEnvironment+ having the configuration that was created with key
+    #         +environment_name+. Note that +RestEnvironment+s are essentially immutable once they are created, so
+    #         an existing object will _never_ be returned.
+    #
+    def environment(environment_name = nil)
+      if environment_name.nil?
+        if @environments.length > 1
+          raise 'You must specify an environment_name parameter because more than one environment is defined'
+        end
+
+        env_hash = @environments[nil]
+      else
+        env_hash = @environments[environment_name]
+      end
+
+      if env_hash.nil?
+        if environment_name.nil?
+          raise 'No default environment specified'
+        end
+
+        raise 'No environment specified having name {}', environment_name
+      end
+
+      RestEnvironment.new(env_hash[:scheme], env_hash[:host], env_hash[:port], env_hash[:api_key],
+                          env_hash[:api_key_name])
+    end
+
+    ##
+    # Set the environments that can be used.
+    #
+    # @param [Array] environments The environments, as an array with each entry a +Hash+.
+    #
+    # One or more environments may be specified, but if more than one environment is specified, it is required that each
+    # environment have a +:environment_name:+ parameter to differentiate it from other environments.
+    #
+    # @example In app/config/environments/staging.rb:
+    #    Bubblez.configure do |config|
+    #      config.environments = [{
+    #         :scheme => 'https',
+    #         :host => 'stage.api.somehost.com',
+    #         :port => '443',
+    #         :api_key => 'something',
+    #         :api_key_name => 'X-API-Key' # Optional
+    #      }]
+    #    end
+    #
+    def environments=(environments)
+      default = nil
+      environments.each do |environment|
+        if environments.length > 1 && environment[:environment_name].nil?
+          message = 'More than one environment was specified and at least one of the environments does not have an ' \
+                    ':environment_name field. Verify all environments have an :environment_name.'
+
+          raise message
+        end
+
+        @environments = {}
+        env_api_key = 'X-API-Key'
+        env_api_key = environment[:api_key_name] if environment.key? :api_key_name
+
+        @environments[environment[:environment_name]] = {
+          scheme: environment[:scheme],
+          host: environment[:host],
+          port: environment[:port],
+          api_key: environment[:api_key],
+          api_key_name: env_api_key
+        }
+      end
+    end
+
+    ##
+    # Retrieve the list of +Endpoint+s configured in this +Configuration+ object.
+    #
+    # @return {Array} An Array of {Endpoint}s.
+    #
+    def endpoints
+      @endpoints
+    end
+
+    ##
+    # Add all {Endpoint} objects within this {Configuration} instance.
+    #
+    # {Endpoint} objects are defined using two required parameters: type and location, and three optional parameters:
+    # authenticated, api_key_required and name.
+    #   - method: Indicates the HTTP method used to access the endpoint. Must be one of {Endpoint::METHODS}.
+    #   - location: Indicates the path at which the {Endpoint} can be accessed on the host environment.
+    #   - authenticated: (Optional) A true or false value indicating whether the {Endpoint} requires an authorization
+    #                    token to access it. Defaults to false.
+    #   - api_key_required: (Optional) A true or false value indicating whether the {Endpoint} requires a API key to
+    #                       access it. Defaults to false.
+    #   - name: (Optional): A +String+ indicating the name of the method to add. If not provided, the method name will
+    #           be the same as the +location+.
+    #
+    def endpoints=(endpoints)
+      new_endpoints = Hash.new
+      endpoints.each do |ep|
+        endpoint_object = Endpoint.new ep[:method], ep[:location].to_s, ep[:authenticated], ep[:api_key_required], ep[:name], ep[:return_type], ep[:encode_authorization], ep[:headers]
+
+        new_endpoints[endpoint_object.get_key_string] = endpoint_object
+      end
+
+      @endpoints = new_endpoints
+
+      # Define all of the endpoints as methods on RestEnvironment
+      @endpoints.values.each do |endpoint|
+        if endpoint.name != nil
+          endpoint_name_as_sym = endpoint.name.to_sym
+        else
+          endpoint_name_as_sym = endpoint.get_location_string.to_sym
+        end
+
+        if Bubblez::RestEnvironment.instance_methods(false).include?(endpoint_name_as_sym)
+          Bubblez::RestEnvironment.class_exec do
+            remove_method endpoint_name_as_sym
+          end
+        end
+
+        if endpoint.method == :get
+          if endpoint.authenticated?
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                if endpoint.encode_authorization_header?
+                  define_method(endpoint_name_as_sym) do |username, password, uri_params|
+                    login_data = {
+                      :login => username,
+                      :password => password
+                    }
+                    auth_value = RestClientResources.get_encoded_authorization(endpoint, login_data)
+                    RestClientResources.execute_get_authenticated self, endpoint, :basic, auth_value, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                  end
+                else
+                  define_method(endpoint_name_as_sym) do |auth_token, uri_params|
+                    RestClientResources.execute_get_authenticated self, endpoint, :bearer, auth_token, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                  end
+                end
+              else
+                if endpoint.encode_authorization_header?
+                  define_method(endpoint_name_as_sym) do |username, password|
+                    login_data = {
+                      :username => username,
+                      :password => password
+                    }
+                    auth_value = RestClientResources.get_encoded_authorization(endpoint, login_data)
+
+                    RestClientResources.execute_get_authenticated self, endpoint, :basic, auth_value, {}, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                  end
+                else
+                  define_method(endpoint_name_as_sym) do |auth_token|
+                    RestClientResources.execute_get_authenticated self, endpoint, :bearer, auth_token, {}, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                  end
+                end
+              end
+            end
+          else
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |uri_params|
+                  RestClientResources.execute_get_unauthenticated self, endpoint, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do
+                  RestClientResources.execute_get_unauthenticated self, endpoint, {}, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          end
+        elsif endpoint.method == :post
+          if endpoint.authenticated? and !endpoint.encode_authorization_header?
+            Bubblez::RestEnvironment.class_exec do
+              define_method(endpoint_name_as_sym) do |auth_token, data|
+                RestClientResources.execute_post_authenticated self, endpoint, :bearer, auth_token, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+              end
+            end
+          elsif endpoint.encode_authorization_header?
+            Bubblez::RestEnvironment.class_exec do
+              define_method(endpoint_name_as_sym) do |username, password, data = {}|
+                login_data = {
+                  :username => username,
+                  :password => password
+                }
+
+                auth_value = RestClientResources.get_encoded_authorization(endpoint, login_data)
+                # composite_headers = RestClientResources.build_composite_headers(endpoint.additional_headers, {
+                #                                                                   Authorization: 'Basic ' + Base64.strict_encode64(auth_value)
+                #                                                                 })
+                RestClientResources.execute_post_authenticated self, endpoint, :basic, auth_value, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+              end
+            end
+          else
+            Bubblez::RestEnvironment.class_exec do
+              define_method(endpoint_name_as_sym) do |data|
+                composite_headers = endpoint.additional_headers
+                RestClientResources.execute_post_unauthenticated self, endpoint, data, composite_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+              end
+            end
+          end
+        elsif endpoint.method == :delete
+          if endpoint.has_uri_params?
+            if endpoint.authenticated?
+              Bubblez::RestEnvironment.class_exec do
+                define_method(endpoint_name_as_sym) do |auth_token, uri_params|
+                  RestClientResources.execute_delete_authenticated self, endpoint, auth_token, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            else
+              Bubblez::RestEnvironment.class_exec do
+                define_method(endpoint_name_as_sym) do |uri_params|
+                  RestClientResources.execute_delete_unauthenticated self, endpoint, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          else
+            # XXX_jwir3: While MDN states that DELETE requests with a body are allowed, it seems that a number of
+            # documentation sites discourage its use. Thus, it's possible that, depending on the server API
+            # framework, the DELETE request could be rejected. In addition, RestClient doesn't seem to support DELETE
+            # requests with a body, so we're a bit stuck on this one, even if we wanted to support it.
+            raise 'DELETE requests without URI parameters are not allowed'
+          end
+        elsif endpoint.method == :patch
+          if endpoint.authenticated?
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |auth_token, uri_params, data|
+                  RestClientResources.execute_patch_authenticated self, endpoint, auth_token, uri_params, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do |auth_token, data|
+                  RestClientResources.execute_patch_authenticated self, endpoint, auth_token, {}, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          else
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |uri_params, data|
+                  RestClientResources.execute_patch_unauthenticated self, endpoint, uri_params, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do |data|
+                  RestClientResources.execute_patch_unauthenticated self, endpoint, {}, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          end
+        elsif endpoint.method == :put
+          if endpoint.authenticated?
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |auth_token, uri_params, data|
+                  RestClientResources.execute_put_authenticated self, endpoint, auth_token, uri_params, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do |auth_token, data|
+                  RestClientResources.execute_put_authenticated self, endpoint, auth_token, {}, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          else
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |uri_params, data|
+                  RestClientResources.execute_put_unauthenticated self, endpoint, uri_params, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do |data|
+                  RestClientResources.execute_put_unauthenticated self, endpoint, {}, data, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          end
+        elsif endpoint.method == :head
+          if endpoint.authenticated?
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |auth_token, uri_params|
+                  RestClientResources.execute_head_authenticated self, endpoint, auth_token, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do |auth_token|
+                  RestClientResources.execute_head_authenticated self, endpoint, auth_token, {}, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          else
+            Bubblez::RestEnvironment.class_exec do
+              if endpoint.has_uri_params?
+                define_method(endpoint_name_as_sym) do |uri_params|
+                  RestClientResources.execute_head_unauthenticated self, endpoint, uri_params, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              else
+                define_method(endpoint_name_as_sym) do
+                  RestClientResources.execute_head_unauthenticated self, endpoint, {}, endpoint.additional_headers, self.get_api_key_if_needed(endpoint), self.api_key_name
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bubblez/endpoint.rb

@@ -0,0 +1,286 @@
+require 'addressable/template'
+
+module Bubblez
+  ##
+  # Representation of a single API endpoint within the Bubblez infrastructure.
+  #
+  # In order to access an API Endpoint, an {RestEnvironment} must also be provided. This class is an abstract
+  # representation of an +Endpoint+, without any information provided as part of the Environment. In other words, an
+  # Endpoint can be used with any +RestEnvironment+.
+  #
+  class Endpoint
+    ##
+    # Controls the method used to access the endpoint. Must be one of {Endpoint::Methods}.
+    # @return [Symbol] the method used to access the endpoint. Will always be one of the symbols defined in
+    #         {Endpoint::METHODS}.
+    attr_accessor :method
+
+    ##
+    # Controls the location, relative to the web root of the host, used to access the endpoint.
+    # @return [String] the location relative to the web root of the host used to access the endpoint
+    attr_accessor :location
+
+    ##
+    # Controls whether authentication is required to access this endpoint. Defaults to false.
+    # @return [Boolean] true, if authentication is required to access this endpoint; false, otherwise.
+    attr_accessor :authentication_required
+
+    ##
+    # Controls whether an API key is required to access this endpoint. Defaults to false.
+    # @return [Boolean] true, if an API key is required to access this endpoint; false, otherwise.
+    attr_accessor :api_key_required
+
+    ##
+    # Controls what type of object will be returned from the REST API call on success. Must be one of the symbols
+    # defined in {Endpoint::RETURN_TYPES}.
+    #
+    attr_accessor :return_type
+
+    ##
+    # Controls which data values should be encoded as part of an Authorization header. They will be separated with a
+    # colon in the order they are received and Base64-encoded.
+    # @return [Array] An array of +Symbol+s specifying which of the data attributes should be Base64-encoded as part of
+    #         an Authorization header. The values will be encoded in the order they are received.
+    attr_accessor :encode_authorization
+
+    ##
+    # An array of parameters that are specified on the URI of this endpoint for each call.
+    attr_accessor :uri_params
+
+    ## A template for specifying the complete URL for endpoints.
+    API_URL = ::Addressable::Template.new("{scheme}://{host}/{endpoint}")
+
+    ## A template for specifying the complete URL for endpoints, with a port attached to the host.
+    API_URL_WITH_PORT = ::Addressable::Template.new("{scheme}://{host}:{port}/{endpoint}")
+
+    ## The HTTP methods supported by a rest client utilizing Bubblez.
+    METHODS = %w[get post patch put delete head].freeze
+
+    ## The possible return types for successful REST calls. Defaults to :body_as_string.
+    RETURN_TYPES = %w[full_response body_as_string body_as_object].freeze
+
+    ##
+    # Construct a new instance of an Endpoint.
+    #
+    # @param [Symbol] method The type of the new Endpoint to create. Must be one of the methods in
+    #        {Endpoint::METHODS}.
+    # @param [String] location The location, relative to the root of the host, at which the endpoint resides.
+    # @param [Boolean] auth_required If true, then authorization/authentication is required to access this endpoint.
+    #        Defaults to +false+.
+    # @param [Boolean] api_key_required If true, then an API key is required to access this endpoint. Defaults to
+    #        +false+.
+    # @param [String] name An optional name which will be given to the method that will execute this {Endpoint} within
+    #        the context of a {RestClientResources} object.
+    # @param [Array<Symbol>] encode_authorization Parameters that should be treated as authorization parameters and
+    #        encoded using a Base64 encoding.
+    #
+    def initialize(method, location, auth_required = false, api_key_required = false, name = nil, return_type = :body_as_string, encode_authorization = {}, headers = {})
+      @method = method
+      @location = location
+      @auth_required = auth_required
+      @api_key_required = api_key_required
+      @name = name
+      @encode_authorization = encode_authorization
+      @additional_headers = headers
+
+      unless Endpoint::RETURN_TYPES.include? return_type.to_s
+        return_type = :body_as_string
+      end
+
+      @return_type = return_type
+
+      @uri_params = []
+
+      # Strip the leading slash from the endpoint location, if it's there
+      if @location.to_s[0] == '/'
+        @location = @location.to_s.slice(1, @location.to_s.length)
+      end
+
+      # Extract URI parameters and create symbols for them
+      # URI parameters are enclosed by curly braces '{' and '}'
+      @location.to_s.split('/').each do |uri_segment|
+
+        match_data = /\{(.*)\}/.match(uri_segment)
+        unless match_data == nil
+          @uri_params.push(match_data[1].to_sym)
+        end
+      end
+    end
+
+    ##
+    # Retrieve a +String+ that will identify this +Endpoint+ uniquely within a hash table.
+    #
+    # @return [String] A unique identifier for this Endpoint, including its method (get/post/put/etc..), location, whether or not it is authenticated, and whether it needs an API key to successfully execute.
+    #
+    def get_key_string
+      auth_string = '-unauthenticated'
+      if @auth_required
+        auth_string = '-authenticated'
+      end
+
+      api_key_string = ''
+      if @api_key_required
+        api_key_string = '-with-api-key'
+      end
+
+      method.to_s + "-" + @location.to_s + auth_string + api_key_string
+    end
+
+    ##
+    # Retrieve the base URL template for this +Endpoint+, given a +RestEnvironment+.
+    #
+    # @param [RestEnvironment] env The +RestEnvironment+ to use to access this endpoint.
+    #
+    # @return [Addressable::Template] A +Template+ containing the URL to use to access this +Endpoint+.
+    #
+    def get_base_url(env)
+      unless env.port == 80 || env.port == 443
+        return API_URL_WITH_PORT
+      end
+
+      API_URL
+    end
+
+    ##
+    # Retrieve the URL to access this +Endpoint+, as a +String+ with all parameters expanded.
+    #
+    # @param [RestEnvironment] env The +RestEnvironment+ to use to access this +Endpoint+.
+    #
+    # @return [Addressable::URI] An +Addressable::URI+ containing the full URL to access this +Endpoint+ on the given
+    #         +RestEnvironment+.
+    #
+    def get_expanded_url(env, uri_params = {})
+      url = get_base_url env
+
+      if is_complex?
+        special_url_string = '{scheme}://{host}/'
+        unless @port == 80 || @port == 443
+          special_url_string = '{scheme}://{host}:{port}/'
+        end
+
+        special_url_string = special_url_string + @location
+
+        uri_params.each do |param, value|
+          needle = "{#{param.to_s}}"
+          special_url_string = special_url_string.sub(needle, value.to_s)
+        end
+
+        url = ::Addressable::Template.new(special_url_string)
+
+        return url.expand(scheme: env.scheme, host: env.host, port: env.port)
+      end
+
+      url.expand(scheme: env.scheme, host: env.host, port: env.port, endpoint: @location)
+    end
+
+    ##
+    # Determine if the location for this Endpoint is complex.
+    #
+    # @return [Boolean] true, if the location for this Endpoint is complex (contains a '/'); false, otherwise.
+    def is_complex?
+      @location.include? '/'
+    end
+
+    ##
+    # Retrieve a String representing the location of this Endpoint.
+    #
+    # Complex Endpoints will have instances of '/' replaced with '_'.
+    #
+    # @return [String] The string representation of the location of this endpoint.
+    def get_location_string
+      unless is_complex?
+        return @location
+      end
+
+      @location.to_s.gsub('/', '_')
+    end
+
+    ##
+    # Determine if this +Endpoint+ requires authentication/authorization to utilize
+    #
+    # @return [Boolean] true, if this +Endpoint+ requires authentication/authorization to use; false, otherwise.
+    def authenticated?
+      @auth_required
+    end
+
+    ##
+    # Determine if an API key is required
+    #
+    # @return [Boolean] true, if an API key is required to make the request; false, otherwise.
+    def api_key_required?
+      api_key_required
+    end
+
+    ##
+    # Set the name of the method on {RestClientResources} used to access this {Endpoint}.
+    #
+    # @param [String] name The name of the method used to access this {Endpoint}.
+    #
+    def name=(name)
+      @name = name
+    end
+
+    ##
+    # Retrieve the name of the method on {RestClientResources} used to access this {Endpoint}.
+    #
+    # @return [String] A String containing the name of the method on {RestClientResources} used to access this
+    #         {Endpoint}, or +nil+ if one wasn't provided.
+    #
+    def name
+      @name
+    end
+
+    ##
+    # Determine if this {Endpoint} has a method name, different from the +location+ name, specified for it.
+    #
+    # @return [Boolean] true, if this {Endpoint} has a method name that is different than the +location+ name specified
+    #         for the +Endpoint+, to be defined on {RestClientResources}; false, otherwise.
+    #
+    def name?
+      @name != nil
+    end
+
+    ##
+    # Whether or not an Authorization header should be Base64-encoded.
+    #
+    # @return [Boolean] true, if attributes from the data array have been specified to be Base64-encoded as part of an
+    #         Authorization header; false, otherwise.
+    #
+    def encode_authorization_header?
+      !@encode_authorization.nil? and @encode_authorization.length > 0
+    end
+
+    ##
+    # Retrieve the return type of this REST endpoint.
+    #
+    # This will always be one of:
+    #
+    # - +full_response+ : Indicates that the full +Response+ object should be returned so that headers and
+    #   return code can be used.
+    # - +body_as_object+ : Indicates that the body of the +Response+ should be parsed as a full +OpenStruct+
+    #   object and returned.
+    # - +body_as_string+ : Indicates that only the body of the +Response+ object should be returned, as a +String+.
+    #
+    # By default, if this is not specified, it will be +body_as+string+.
+    #
+    def return_type
+      @return_type
+    end
+
+    def has_uri_params?
+      !@uri_params.empty?
+    end
+
+    def additional_headers
+      unless @additional_headers
+        @additional_headers = {}
+      end
+
+      @additional_headers
+    end
+
+    def has_additional_headers?
+      not additional_headers.empty?
+    end
+  end
+end