tempo-ruby 0.1.0

data/lib/tempo/base.rb

@@ -0,0 +1,486 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'active_support/inflector'
+
+module Tempo
+  class Base
+    # A reference to the Tempo::Client used to initialize this resource.
+    attr_reader :client
+
+    # Returns true if this instance has been fetched from the server
+    attr_accessor :expanded
+
+    # Returns true if this instance has been deleted from the server
+    attr_accessor :deleted
+
+    # The hash of attributes belonging to this instance.  An exact
+    # representation of the JSON returned from the Tempo API
+    attr_accessor :attrs
+
+    alias expanded? expanded
+    alias deleted? deleted
+
+    def initialize(client, options = {})
+      @client   = client
+      @attrs    = options[:attrs] || {}
+      @expanded = options[:expanded] || false
+      @deleted  = false
+
+      # If this class has any belongs_to relationships, a value for
+      # each of them must be passed in to the initializer.
+      self.class.belongs_to_relationships.each do |relation|
+        if options[relation]
+          instance_variable_set("@#{relation}", options[relation])
+          instance_variable_set("@#{relation}_id", options[relation].key_value)
+        elsif options["#{relation}_id".to_sym]
+          instance_variable_set("@#{relation}_id", options["#{relation}_id".to_sym])
+        else
+          raise ArgumentError, "Required option #{relation.inspect} missing" unless options[relation]
+        end
+      end
+    end
+
+    # The class methods are never called directly, they are always
+    # invoked from a BaseFactory subclass instance.
+    def self.all(client, options = {})
+      response = client.get(collection_path(client))
+      json = parse_json(response.body)['results']
+      json = json[endpoint_name.pluralize] if collection_attributes_are_nested
+      json.map do |attrs|
+        new(client, { attrs: attrs }.merge(options))
+      end
+    end
+
+    # Finds and retrieves a resource with the given ID.
+    def self.find(client, key, options = {})
+      instance = new(client, options)
+      instance.attrs[key_attribute.to_s] = key
+      instance.fetch(false, query_params_for_single_fetch(options))
+      instance
+    end
+
+    # Builds a new instance of the resource with the given attributes.
+    # These attributes will be posted to the Tempo Api if save is called.
+    def self.build(client, attrs)
+      new(client, attrs: attrs)
+    end
+
+    # Returns the name of this resource for use in URL components.
+    # E.g.
+    #   Tempo::resource::Issue.endpoint_name
+    #     # => issue
+    def self.endpoint_name
+      name.split('::').last.pluralize.downcase
+    end
+
+    # Returns the full path for a collection of this resource.
+    # E.g.
+    #   Tempo::resource::Issue.collection_path
+    #     # => /tempo/core/3/teams
+    def self.collection_path(client, prefix = '/')
+      client.options[:rest_base_path] + prefix + endpoint_name
+    end
+
+    # Returns the singular path for the resource with the given key.
+    # E.g.
+    #   Tempo::resource::Issue.singular_path('123')
+    #     # => /tempo/core/3/teams/123
+    #
+    # If a prefix parameter is provided it will be injected between the base
+    # path and the endpoint.
+    # E.g.
+    #   Tempo::resource::Member.singular_path('456','/teams/123/')
+    #     # => /tempo/core/3/teams/123/comment/456
+    def self.singular_path(client, key, prefix = '/')
+      "#{collection_path(client, prefix)}/#{key}"
+    end
+
+    def path_base(client, prefix = '/')
+      client.options[:rest_base_path] + prefix
+    end
+
+    # Returns the attribute name of the attribute used for find.
+    # Defaults to :id unless overridden.
+    def self.key_attribute
+      :id
+    end
+
+    def self.parse_json(string) # :nodoc:
+      JSON.parse(string) # TODO: .deep_symbolize_keys
+    end
+
+    # Declares that this class contains a singular instance of another resource
+    # within the JSON returned from the Tempo API.
+    #
+    #   class Example < Tempo::Base
+    #     has_one :child
+    #   end
+    #
+    #   example = client.Example.find(1)
+    #   example.child # Returns a Tempo::resource::Child
+    #
+    # The following options can be used to override the default behaviour of the
+    # relationship:
+    #
+    # [:attribute_key]  The relationship will by default reference a JSON key on the
+    #                   object with the same name as the relationship.
+    #
+    #                     has_one :child # => {"id":"123",{"child":{"id":"456"}}}
+    #
+    #                   Use this option if the key in the JSON is named differently.
+    #
+    #                     # Respond to resource.child, but return the value of resource.attrs['kid']
+    #                     has_one :child, :attribute_key => 'kid' # => {"id":"123",{"kid":{"id":"456"}}}
+    #
+    # [:class]          The class of the child instance will be inferred from the name of the
+    #                   relationship. E.g. <tt>has_one :child</tt> will return a <tt>Tempo::resource::Child</tt>.
+    #                   Use this option to override the inferred class.
+    #
+    #                     has_one :child, :class => Tempo::resource::Kid
+    # [:nested_under]   In some cases, the JSON return from Tempo is nested deeply for particular
+    #                   relationships.  This option allows the nesting to be specified.
+    #
+    #                     # Specify a single depth of nesting.
+    #                     has_one :child, :nested_under => 'foo'
+    #                       # => Looks for {"foo":{"child":{}}}
+    #                     # Specify deeply nested JSON
+    #                     has_one :child, :nested_under => ['foo', 'bar', 'baz']
+    #                       # => Looks for {"foo":{"bar":{"baz":{"child":{}}}}}
+    def self.has_one(resource, options = {})
+      attribute_key = options[:attribute_key] || resource.to_s
+      child_class = options[:class] || "Tempo::resource::#{resource.to_s.classify}".constantize
+      define_method(resource) do
+        attribute = maybe_nested_attribute(attribute_key, options[:nested_under])
+        return nil unless attribute
+        child_class.new(client, attrs: attribute)
+      end
+    end
+
+    # Declares that this class contains a collection of another resource
+    # within the JSON returned from the Tempo API.
+    #
+    #   class Example < Tempo::Base
+    #     has_many :children
+    #   end
+    #
+    #   example = client.Example.find(1)
+    #   example.children # Returns an instance of Jira::resource::HasManyProxy,
+    #                    # which behaves exactly like an array of
+    #                    # Tempo::resource::Child
+    #
+    # The following options can be used to override the default behaviour of the
+    # relationship:
+    #
+    # [:attribute_key]  The relationship will by default reference a JSON key on the
+    #                   object with the same name as the relationship.
+    #
+    #                     has_many :children # => {"id":"123",{"children":[{"id":"456"},{"id":"789"}]}}
+    #
+    #                   Use this option if the key in the JSON is named differently.
+    #
+    #                     # Respond to resource.children, but return the value of resource.attrs['kids']
+    #                     has_many :children, :attribute_key => 'kids' # => {"id":"123",{"kids":[{"id":"456"},{"id":"789"}]}}
+    #
+    # [:class]          The class of the child instance will be inferred from the name of the
+    #                   relationship. E.g. <tt>has_many :children</tt> will return an instance
+    #                   of <tt>JIRA::resource::HasManyProxy</tt> containing the collection of
+    #                   <tt>JIRA::resource::Child</tt>.
+    #                   Use this option to override the inferred class.
+    #
+    #                     has_many :children, :class => Tempo::resource::Kid
+    # [:nested_under]   In some cases, the JSON return from JIRA is nested deeply for particular
+    #                   relationships.  This option allows the nesting to be specified.
+    #
+    #                     # Specify a single depth of nesting.
+    #                     has_many :children, :nested_under => 'foo'
+    #                       # => Looks for {"foo":{"children":{}}}
+    #                     # Specify deeply nested JSON
+    #                     has_many :children, :nested_under => ['foo', 'bar', 'baz']
+    #                       # => Looks for {"foo":{"bar":{"baz":{"children":{}}}}}
+    def self.has_many(collection, options = {})
+      attribute_key = options[:attribute_key] || collection.to_s
+      child_class = options[:class] || "Tempo::resource::#{collection.to_s.classify}".constantize
+      self_class_basename = name.split('::').last.downcase.to_sym
+      define_method(collection) do
+        child_class_options = { self_class_basename => self }
+        attribute = maybe_nested_attribute(attribute_key, options[:nested_under]) || []
+        collection = attribute.map do |child_attributes|
+          child_class.new(client, child_class_options.merge(attrs: child_attributes))
+        end
+        HasManyProxy.new(self, child_class, collection)
+      end
+    end
+
+    def self.belongs_to_relationships
+      @belongs_to_relationships ||= []
+    end
+
+    def self.belongs_to(resource)
+      belongs_to_relationships.push(resource)
+      attr_reader resource
+      attr_reader "#{resource}_id"
+    end
+
+    def self.collection_attributes_are_nested
+      @collection_attributes_are_nested ||= false
+    end
+
+    def self.nested_collections(value)
+      @collection_attributes_are_nested = value
+    end
+
+    def id
+      attrs['id']
+    end
+
+    # Returns a symbol for the given instance, for example
+    # Tempo::resource::Team returns :team
+    def to_sym
+      self.class.endpoint_name.to_sym
+    end
+
+    # Checks if method_name is set in the attributes hash
+    # and returns true when found, otherwise proxies the
+    # call to the superclass.
+    def respond_to?(method_name, _include_all = false)
+      if attrs.key?(method_name.to_s)
+        true
+      else
+        super(method_name)
+      end
+    end
+
+    # Overrides method_missing to check the attribute hash
+    # for resources matching method_name and proxies the call
+    # to the superclass if no match is found.
+    def method_missing(method_name, *_args)
+      if attrs.key?(method_name.to_s)
+        attrs[method_name.to_s]
+      else
+        super(method_name)
+      end
+    end
+
+    # Each resource has a unique key attribute, this method returns the value
+    # of that key for this instance.
+    def key_value
+      @attrs[self.class.key_attribute.to_s]
+    end
+
+    def collection_path(prefix = '/')
+      # Just proxy this to the class method
+      self.class.collection_path(client, prefix)
+    end
+
+    # This returns the URL path component that is specific to this instance,
+    # for example for Issue id 123 it returns '/teams/123'.  For an unsaved
+    # issue it returns '/teams'
+    def path_component
+      path_component = "/#{self.class.endpoint_name}"
+      path_component += "/#{key_value}" if key_value
+      path_component
+    end
+
+    # Fetches the attributes for the specified resource from Tempo unless
+    # the resource is already expanded and the optional force reload flag
+    # is not set
+    def fetch(reload = false, query_params = {})
+      return if expanded? && !reload
+      response = client.get(url_with_query_params(url, query_params))
+      set_attrs_from_response(response)
+      @expanded = true
+    end
+
+    # Saves the specified resource attributes by sending either a POST or PUT
+    # request to Tempo, depending on resource.new_record?
+    #
+    # Accepts an attributes hash of the values to be saved.  Will throw a
+    # Tempo::HTTPError if the request fails (response is not HTTP 2xx).
+    def save!(attrs, path = nil)
+      path ||= new_record? ? url : patched_url
+      http_method = new_record? ? :post : :put
+      response = client.send(http_method, path, attrs.to_json)
+      set_attrs(attrs, false)
+      set_attrs_from_response(response)
+      @expanded = false
+      true
+    end
+
+    # Saves the specified resource attributes by sending either a POST or PUT
+    # request to Tempo, depending on resource.new_record?
+    #
+    # Accepts an attributes hash of the values to be saved. Will return false
+    # if the request fails.
+    #
+    # rubocop:disable Lint/UselessAssignment
+    def save(attrs, path = url)
+      begin
+        save_status = save!(attrs, path)
+      rescue Tempo::HTTPError => exception
+        begin
+          set_attrs_from_response(exception.response) # Merge error status generated by Tempo REST API
+        rescue JSON::ParserError => parse_exception
+          set_attrs('exception' => {
+                      'class' => exception.response.class.name,
+                      'code' => exception.response.code,
+                      'message' => exception.response.message
+                    })
+        end
+        # raise exception
+        save_status = false
+      end
+      save_status
+    end
+    # rubocop:enable Lint/UselessAssignment
+
+    # Sets the attributes hash from a HTTPResponse object from JIRA if it is
+    # not nil or is not a json response.
+    def set_attrs_from_response(response)
+      unless response.body.nil? || (response.body.length < 2)
+        json = self.class.parse_json(response.body)
+        set_attrs(json)
+      end
+    end
+
+    # Set the current attributes from a hash.  If clobber is true, any existing
+    # hash values will be clobbered by the new hash, otherwise the hash will
+    # be deeply merged into attrs.  The target paramater is for internal use only
+    # and should not be used.
+    def set_attrs(hash, clobber = true, target = nil)
+      target ||= @attrs
+      if clobber
+        target.merge!(hash)
+        hash
+      else
+        hash.each do |k, v|
+          if v.is_a?(Hash)
+            set_attrs(v, clobber, target[k])
+          else
+            target[k] = v
+          end
+        end
+      end
+    end
+
+    # Sends a delete request to the Tempo Api and sets the deleted instance
+    # variable on the object to true.
+    def delete
+      client.delete(url)
+      @deleted = true
+    end
+
+    def has_errors?
+      respond_to?(:errors)
+    end
+
+    def url
+      prefix = '/'
+      unless self.class.belongs_to_relationships.empty?
+        prefix = self.class.belongs_to_relationships.inject(prefix) do |prefix_so_far, relationship|
+          "#{prefix_so_far}#{relationship}/#{send("#{relationship}_id")}/"
+        end
+      end
+      if @attrs['self']
+        the_url = @attrs['self']
+        the_url = the_url.sub(@client.options[:site].chomp('/'), '') if @client.options[:site]
+        the_url
+      elsif key_value
+        self.class.singular_path(client, key_value.to_s, prefix)
+      else
+        self.class.collection_path(client, prefix)
+      end
+    end
+
+    # This method fixes issue that there is no / prefix in url. It is happened when we call for instance
+    # Looks like this issue is actual only in case if you use atlassian sdk your app path is not root (like /tempo in example below)
+    # team.save() for existing resource.
+    # As a result we got error 400 from Tempo API:
+    # [07/Jun/2015:15:32:19 +0400] "PUT tempo/core/3/teams/10111 HTTP/1.1" 400 -
+    # After applying this fix we have normal response:
+    # [07/Jun/2015:15:17:18 +0400] "PUT /tempo/core/3/teams/10111 HTTP/1.1" 204 -
+    def patched_url
+      result = url
+      return result if result.start_with?('/', 'http')
+      "/#{result}"
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{object_id} @attrs=#{@attrs.inspect}>"
+    end
+
+    # Returns a JSON representation of the current attributes hash.
+    def to_json(options = {})
+      attrs.to_json(options)
+    end
+
+    # Determines if the resource is newly created by checking whether its
+    # key_value is set. If it is nil, the record is new and the method
+    # will return true.
+    def new_record?
+      key_value.nil?
+    end
+
+    protected
+
+    # This allows conditional lookup of possibly nested attributes.  Example usage:
+    #
+    #   maybe_nested_attribute('foo')                 # => @attrs['foo']
+    #   maybe_nested_attribute('foo', 'bar')          # => @attrs['bar']['foo']
+    #   maybe_nested_attribute('foo', ['bar', 'baz']) # => @attrs['bar']['baz']['foo']
+    #
+    def maybe_nested_attribute(attribute_name, nested_under = nil)
+      self.class.maybe_nested_attribute(@attrs, attribute_name, nested_under)
+    end
+
+    def self.maybe_nested_attribute(attributes, attribute_name, nested_under = nil)
+      return attributes[attribute_name] if nested_under.nil?
+      if nested_under.instance_of? Array
+        final = nested_under.inject(attributes) do |parent, key|
+          break if parent.nil?
+          parent[key]
+        end
+        return nil if final.nil?
+        final[attribute_name]
+      else
+        attributes[nested_under][attribute_name]
+      end
+    end
+
+    def url_with_query_params(url, query_params)
+      self.class.url_with_query_params(url, query_params)
+    end
+
+    def self.url_with_query_params(url, query_params)
+      if query_params.empty?
+        url
+      else
+        "#{url}?#{hash_to_query_string query_params}"
+      end
+    end
+
+    def hash_to_query_string(query_params)
+      self.class.hash_to_query_string(query_params)
+    end
+
+    def self.hash_to_query_string(query_params)
+      query_params.map do |k, v|
+        "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+      end.join('&')
+    end
+
+    # TODO: Remove
+    def self.query_params_for_single_fetch(options)
+      options.select do |k, _v|
+        [].include? k
+      end.to_h
+    end
+
+    # TODO: Remove
+    def self.query_params_for_search(options)
+      options.select do |k, _v|
+        [].include? k
+      end.to_h
+    end
+  end
+end

data/lib/tempo/base_factory.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Tempo
+  # This is the base class for all the Tempo resource factory instances.
+  class BaseFactory
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    # Return the name of the class which this factory generates, i.e.
+    # Tempo::resource::FooFactory creates Tempo::resource::Foo instances.
+    def target_class
+      # Need to do a little bit of work here as Module.const_get doesn't work
+      # with nested class names, i.e. Tempo::resource::Foo.
+      #
+      # So create a method chain from the class components.  This code will
+      # unroll to:
+      #   Module.const_get('Tempo').const_get('resource').const_get('Foo')
+      #
+      target_class_name = self.class.name.sub(/Factory$/, '')
+      class_components = target_class_name.split('::')
+
+      class_components.inject(Module) do |mod, const_name|
+        mod.const_get(const_name)
+      end
+    end
+
+    def self.delegate_to_target_class(*method_names)
+      method_names.each do |method_name|
+        define_method method_name do |*args|
+          target_class.send(method_name, @client, *args)
+        end
+      end
+    end
+
+    # The principle purpose of this class is to delegate methods to the corresponding
+    # non-factory class and automatically prepend the client argument to the argument
+    # list.
+    delegate_to_target_class :all, :find, :collection_path, :singular_path
+
+    # This method needs special handling as it has a default argument value
+    def build(attrs = {})
+      target_class.build(@client, attrs)
+    end
+  end
+end

data/lib/tempo/client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'forwardable'
+require 'ostruct'
+
+module Tempo
+  # This class is the main access point for all Tempo::resource instances.
+  #
+  # The client must be initialized with an options hash containing
+  # configuration options. The available options are:
+  #
+  #   :site               => 'http://localhost:2990',
+  #   :api_key            => 'api_key_from_tempo'
+  #   :context_path       => '/',
+  #   :rest_base_path     => "/core/3",
+  #   :default_headers    => {},
+  #   :read_timeout       => nil,
+  #   :http_debug         => false,
+  #
+  # See the Tempo::Base class methods for all of the available methods on these accessor
+  # objects.
+
+  class Client
+    extend Forwardable
+
+    # The configuration options for this client instance
+    attr_reader :options
+
+    # TODO: MAke sure it's needed
+    def_delegators :@request_client, :init_access_token, :set_access_token, :set_request_token, :request_token, :access_token, :authenticated?
+
+    DEFINED_OPTIONS = %i[
+      site
+      api_key
+      auth_type
+      context_path
+      rest_base_path
+      default_headers
+      read_timeout
+      http_debug
+      issuer
+      base_url
+    ].freeze
+
+    DEFAULT_OPTIONS = {
+      site: 'http://api.tempo.io',
+      context_path: '/',
+      rest_base_path: 'core/3',
+      auth_type: :api_key,
+      api_key: '',
+      http_debug: false,
+      default_headers: {}
+    }.freeze
+
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      @options = options
+      @options[:rest_base_path] = @options[:context_path] + @options[:rest_base_path]
+
+      unknown_options = options.keys.reject { |o| DEFINED_OPTIONS.include?(o) }
+      raise ArgumentError, "Unknown option(s) given: #{unknown_options}" unless unknown_options.empty?
+
+      case options[:auth_type]
+      when :api_key
+        @request_client = HttpClient.new(@options)
+      else
+        raise ArgumentError, 'Options: ":auth_type" must be ":oauth",":oauth_2legged", ":cookie" or ":basic"'
+      end
+
+      @http_debug = @options[:http_debug]
+      @options.freeze
+      # @cache = OpenStruct.new
+    end
+
+    def Team # :nodoc:
+      Tempo::Resource::TeamFactory.new(self)
+    end
+
+    def TeamMember # :nodoc:
+      Tempo::Resource::TeamMemberFactory.new(self)
+    end
+
+    # HTTP methods without a body
+    def delete(path, headers = {})
+      request(:delete, path, nil, merge_default_headers(headers))
+    end
+
+    def get(path, headers = {})
+      request(:get, path, nil, merge_default_headers(headers))
+    end
+
+    def head(path, headers = {})
+      request(:head, path, nil, merge_default_headers(headers))
+    end
+
+    # HTTP methods with a body
+    def post(path, body = '', headers = {})
+      headers = { 'Content-Type' => 'application/json' }.merge(headers)
+      request(:post, path, body, merge_default_headers(headers))
+    end
+
+    def post_multipart(path, file, headers = {})
+      puts "post multipart: #{path} - [#{file}]" if @http_debug
+      @request_client.request_multipart(path, file, headers)
+    end
+
+    def put(path, body = '', headers = {})
+      headers = { 'Content-Type' => 'application/json' }.merge(headers)
+      request(:put, path, body, merge_default_headers(headers))
+    end
+
+    # Sends the specified HTTP request to the REST API through the
+    # appropriate method (oauth, basic).
+    def request(http_method, path, body = '', headers = {})
+      puts "#{http_method}: #{path} - [#{body}]" if @http_debug
+      @request_client.request(http_method, path, body, headers)
+    end
+
+    # Stops sensitive client information from being displayed in logs
+    def inspect
+      "#<Tempo::Client:#{object_id}>"
+    end
+
+    protected
+
+    def merge_default_headers(headers)
+      { 'Accept' => 'application/json' }.merge(@options[:default_headers]).merge(headers)
+    end
+  end
+end