flapjack-diner 1.4.0 → 2.0.0.a4

data/lib/flapjack-diner/response.rb

@@ -0,0 +1,91 @@
+require 'flapjack-diner/utility'
+
+module Flapjack
+  module Diner
+    class Response
+      SUCCESS_STATUS_CODES = [200, 201, 204]
+
+      attr_reader :output, :context, :error
+
+      def initialize(resp, opts = {})
+        @response = resp
+        @output = nil
+        @context = nil
+        @error = nil
+        @return_keys_as_strings = Flapjack::Diner.return_keys_as_strings
+      end
+
+      def process
+        if 204.eql?(@response.code)
+          @output = true
+          @context = nil
+          @error = nil
+          return
+        end
+        if @response.respond_to?(:parsed_response)
+          parsed = @response.parsed_response
+        end
+        strify = @return_keys_as_strings.is_a?(TrueClass)
+        if [200, 201].include?(@response.code)
+          @output = handle_data(parsed, strify)
+          return
+        end
+        @error = handle_errors(parsed, strify)
+      end
+
+      private
+
+      def flatten_jsonapi_data(data)
+        ret = nil
+        case data
+        when Array
+          ret = data.inject([]) do |memo, d|
+            attrs = d['attributes'] || {}
+            d.each_pair do |k, v|
+              next if 'attributes'.eql?(k)
+              attrs.update(k => v)
+            end
+            memo += [attrs]
+            memo
+          end
+        when Hash
+          ret = data['attributes'] || {}
+          data.each_pair do |k, v|
+            next if 'attributes'.eql?(k)
+            ret.update(k => v)
+          end
+        else
+          ret = data
+        end
+        ret
+      end
+
+      def handle_data(parsed, strify)
+        return parsed if parsed.nil? || !parsed.is_a?(Hash) ||
+                         !parsed.key?('data')
+        @context = {}
+        c_incl_key = strify ? 'included' : :included
+        if parsed.key?('included')
+          incl = flatten_jsonapi_data(parsed['included'])
+          @context[c_incl_key] = incl.each_with_object({}) do |i, memo|
+            memo[i['type']] ||= {}
+            memo[i['type']][i['id']] = strify ? i : Flapjack::Diner::Utility.symbolize(i)
+          end
+        end
+        (%w(relationships meta) & parsed.keys).each do |k|
+          c = parsed[k]
+          @context[strify ? k : k.to_sym] = (strify ? c : Flapjack::Diner::Utility.symbolize(c))
+        end
+        ret = flatten_jsonapi_data(parsed['data'])
+        strify ? ret : Flapjack::Diner::Utility.symbolize(ret)
+      end
+
+      def handle_errors(parsed, strify)
+        return parsed if parsed.nil? || !parsed.is_a?(Hash) ||
+                         !parsed.key?('errors')
+        errs = parsed['errors']
+        strify ? errs : Flapjack::Diner::Utility.symbolize(errs)
+      end
+    end
+  end
+end

data/lib/flapjack-diner/tools.rb

@@ -1,276 +1,72 @@
-require 'uri'
-
 module Flapjack
   module Diner
     module Tools
-      SUCCESS_STATUS_CODES = [200, 201, 204]
-
-      attr_accessor :last_error
-
-      private
-
-      def log_request(method_type, req_uri, data = nil)
-        return if logger.nil? || req_uri.nil?
-        log_msg = "#{method_type} #{req_uri}"
-        unless %w(GET DELETE).include?(method_type) || data.nil?
-          log_msg << "\n  Body: #{data.inspect}"
+      module ClassMethods
+        def included_data
+          return if context.nil?
+          context[return_keys_as_strings ? 'included' : :included]
         end
-        logger.info log_msg
-      end
 
-      def perform_get(name, path, ids = [], data = nil)
-        @last_error = nil
-        req_uri = build_uri(path, ids, data)
-        log_request('GET', req_uri, data)
-        handled = handle_response(get(req_uri.request_uri))
+        def related(record, rel, incl = included_data)
+          return if incl.nil?
 
-        result = (!handled.nil? && handled.is_a?(Hash)) ? handled[name] :
-                 handled
-
-        return_keys_as_strings.is_a?(TrueClass) ? result : symbolize(result)
-      end
-
-      def perform_post(path, ids = [], data = nil)
-        @last_error = nil
-        req_uri = build_uri(path, ids)
-        log_request('POST', req_uri, data)
-        opts = if data.nil?
-                 {}
-               else
-                 {:body => prepare_nested_query(data).to_json,
-                  :headers => {'Content-Type' => 'application/vnd.api+json'}}
-               end
-        handle_response(post(req_uri.request_uri, opts))
-      end
+          type = record[return_keys_as_strings ? 'type' : :type]
+          return if type.nil?
 
-      def perform_patch(path, ids = [], data = nil)
-        @last_error = nil
-        req_uri = build_uri(path, ids)
-        log_request('PATCH', req_uri, data)
-        opts = if data.nil?
-                 {}
-               else
-                 {:body    => prepare_nested_query(data).to_json,
-                  :headers => {'Content-Type' => 'application/json-patch+json'}}
-               end
-        handle_response(patch(req_uri.request_uri, opts))
-      end
-
-      def perform_delete(path, ids = [], data = nil)
-        @last_error = nil
-        req_uri = build_uri(path, ids, data)
-        log_request('DELETE', req_uri, data)
-        handle_response(delete(req_uri.request_uri))
-      end
-
-      def log_response(response)
-        return if logger.nil? || !response.respond_to?(:code)
-        response_message = "  Response Code: #{response.code}"
-        unless response.message.nil? || (response.message.eql?(''))
-          response_message << " #{response.message}"
-        end
-        logger.info response_message
-        return if response.body.nil?
-        logger.info "  Response Body: #{response.body[0..300]}"
-      end
-
-      def handle_response(response)
-        log_response(response)
-        return true if 204.eql?(response.code)
-        parsed = if response.respond_to?(:parsed_response)
-                   response.parsed_response
-                 else
-                   nil
-                 end
-        return parsed if [200, 201].include?(response.code)
-        @last_error = handle_error(response.code, parsed)
-        nil
-      end
-
-      def handle_error(code, parsed)
-        case parsed
-        when Hash
-          err = {'status_code' => code}.merge(parsed)
-          return_keys_as_strings.is_a?(TrueClass) ? err : symbolize(err)
-        else
-          parsed
-        end
-      end
-
-      def validate_params(query = {}, &validation)
-        return unless block_given?
-        case query
-        when Array
-          query.each do |q|
-            ArgumentValidator.new(q).instance_eval(&validation)
+          res = Flapjack::Diner::Configuration::RESOURCES.values.detect do |r|
+            type.eql?(r[:resource])
           end
-        else
-          ArgumentValidator.new(query).instance_eval(&validation)
-        end
-      end
-
-      # copied from Rack::Utils -- builds the query string for GETs
-      def build_nested_query(value, prefix = nil)
-        case value
-        when Array
-          build_array_query(value, prefix)
-        when Hash
-          build_hash_query(value, prefix)
-        else
-          build_data_query(value, prefix)
-        end
-      end
-
-      def build_array_query(value, prefix)
-        value.map {|v| build_nested_query(v, "#{prefix}[]") }.join('&')
-      end
-
-      def build_hash_query(value, prefix)
-        value.map do |k, v|
-          data = prefix ? "#{prefix}[#{escape(k)}]" : escape(k)
-          build_nested_query(v, data)
-        end.join('&')
-      end
+          return if res.nil? || res[:relationships].nil?
 
-      def build_data_query(value, prefix)
-        if value.respond_to?(:iso8601)
-          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
-          "#{prefix}=#{escape(value.iso8601)}"
-        elsif value.is_a?(String) || value.is_a?(Integer)
-          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
-          "#{prefix}=#{escape(value.to_s)}"
-        else
-          prefix
-        end
-      end
+          rel_cfg = res[:relationships][rel.to_sym]
+          return if rel_cfg.nil?
 
-      def escaped_ids(ids = [])
-        ids.map {|id| URI.escape(id.to_s) }.join(',')
-      end
-
-      def escape(s)
-        URI.encode_www_form_component(s)
-      end
-
-      def unwrap_ids(*args)
-        args.select {|a| a.is_a?(String) || a.is_a?(Integer) }
-      end
-
-      def unwrap_params(*args)
-        args.each_with_object({}) do |e, a|
-          a.update(symbolize(e)) if e.is_a?(Hash)
+          rel_type = rel_cfg[:resource]
+          has_data = incl.key?(rel_type)
+          case rel_cfg[:number]
+          when :singular
+            has_data ? singularly_related(record, rel, rel_type, incl) : nil
+          else
+            has_data ? multiply_related(record, rel, rel_type, incl) : []
+          end
         end
-      end
-
-      def unwrap_data(*args)
-        args.select {|a| a.is_a?(Array) && a.all? {|av| av.is_a?(Hash) } }
-            .reduce([], &:'+')
-      end
-
-      def unwrap_create_data(*args)
-        data_h = args.select {|a| a.is_a?(Hash) }
-        data_a = unwrap_data(*args)
-
-        raise 'Create data may be passed as a Hash or an Array of Hashes, ' \
-              'not both' unless data_h.empty? || data_a.empty?
-
-        data = data_h
-        data = data_a if data.empty?
-        data = nil if data.empty?
-        data
-      end
-
-      def patch_replace(type, k, v)
-        {:op    => 'replace',
-         :path  => "/#{type}/0/#{k}",
-         :value => v}
-      end
 
-      def patch_add(type, linked, v)
-        {:op    => 'add',
-         :path  => "/#{type}/0/links/#{linked}/-",
-         :value => v}
-      end
+        private
 
-      def patch_remove(type, linked, v)
-        {:op    => 'remove',
-         :path  => "/#{type}/0/links/#{linked}/#{v}"}
-      end
+        def singularly_related(record, rel, type, incl)
+          relat, data, id_a, rel = related_accessors(rel)
+          return if record[relat].nil? ||
+                    record[relat][rel].nil? ||
+                    record[relat][rel][data].nil?
 
-      # used for the JSON data hashes in POST, PUT, DELETE
-      def prepare_nested_query(value)
-        case value
-        when Array
-          prepare_array_query(value)
-        when Hash
-          prepare_hash_query(value)
-        else
-          prepare_data_query(value)
+          id = record[relat][rel][data][id_a]
+          return if id.nil? || !incl.key?(type)
+          incl[type][id]
         end
-      end
-
-      def prepare_array_query(value)
-        value.map {|v| prepare_nested_query(v) }
-      end
 
-      def prepare_hash_query(value)
-        value.each_with_object({}) do |(k, v), a|
-          a[k] = prepare_nested_query(v)
-        end
-      end
+        def multiply_related(record, rel, type, incl)
+          relat, data, id_a, rel = related_accessors(rel)
+          return [] if record[relat].nil? ||
+                       record[relat][rel].nil? ||
+                       record[relat][rel][data].nil? ||
+                       record[relat][rel][data].empty?
 
-      def prepare_data_query(value)
-        if value.respond_to?(:iso8601)
-          value.iso8601
-        else
-          case value
-          when Integer, TrueClass, FalseClass, NilClass
-            value
-          else
-            value.to_s
-          end
+          ids = record[relat][rel][data].map {|m| m[id_a] }
+          return [] if ids.empty? || !incl.key?(type)
+          incl[type].values_at(*ids)
         end
-      end
 
-      def normalise_port(port_str, protocol)
-        if port_str.nil? || port_str.to_i < 1 || port_str.to_i > 65_535
-          'https'.eql?(protocol) ? 443 : 80
-        else
-          port_str.to_i
+        def related_accessors(*args)
+          acc = [:relationships, :data, :id]
+          return (acc + args).map(&:to_s) if return_keys_as_strings
+          (acc + args.map(&:to_sym))
         end
       end
 
-      def protocol_host_port
-        %r{^(?:(?<protocol>https?)://)
-           (?<host>[a-zA-Z0-9][a-zA-Z0-9\.\-]*[a-zA-Z0-9])
-           (?::(?<port>\d+))?
-        }ix =~ base_uri
-
-        protocol = protocol.nil? ? 'http' : protocol.downcase
-        [protocol, host, normalise_port(port, protocol)]
-      end
-
-      def build_uri(path, ids = [], params = [])
-        pr, ho, po = protocol_host_port
-        path += '/' + escaped_ids(ids) unless ids.nil? || ids.empty?
-        query = if params.nil? || params.empty?
-                  nil
-                else
-                  build_nested_query(params)
-                end
-        URI::HTTP.build(:protocol => pr, :host => ho, :port => po,
-          :path => path, :query => query)
-      end
-
-      def symbolize(obj)
-        case obj
-        when Hash
-          obj.each_with_object({}) {|(k, v), a| a[k.to_sym] = symbolize(v) }
-        when Array
-          obj.each_with_object([]) {|e, a| a << symbolize(e) }
-        else
-          obj
-        end
+      def self.included(base)
+        base.extend ClassMethods
+        # base.class_eval do
+        # end
       end
     end
   end

data/lib/flapjack-diner/utility.rb

@@ -0,0 +1,16 @@
+module Flapjack
+  module Diner
+    module Utility
+      def self.symbolize(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) {|(k, v), a| a[k.to_sym] = symbolize(v) }
+        when Array
+          obj.each_with_object([]) {|e, a| a << symbolize(e) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/flapjack-diner/version.rb

@@ -1,5 +1,5 @@
 module Flapjack
   module Diner
-    VERSION = '1.4.0'
+    VERSION = '2.0.0.a4'
   end
 end

data/lib/flapjack-diner.rb

@@ -1,41 +1,75 @@
 require 'httparty'
 require 'json'
 
+require 'flapjack-diner/log_formatter'
 require 'flapjack-diner/version'
 require 'flapjack-diner/argument_validator'
+require 'flapjack-diner/index_range'
 
-%w(contacts media pagerduty_credentials notification_rules entities checks
-   maintenance_periods notifications reports).each do |resource|
+require 'flapjack-diner/resources'
+require 'flapjack-diner/relationships'
+require 'flapjack-diner/tools'
 
-  require "flapjack-diner/resources/#{resource}"
-end
+# HTTParty master contains a non-hacky way of doing this, but 0.13.5 doesn't
+module HTTParty
+  module Logger
+    def self.build(logger, level, formatter)
+      level ||= :info
+      formatter ||= :apache
 
-require 'flapjack-diner/tools'
+      case formatter
+      when :'flapjack-diner'
+        Flapjack::Diner::LogFormatter.new(logger, level)
+      when :curl
+        Logger::CurlLogger.new(logger, level)
+      else
+        Logger::ApacheLogger.new(logger, level)
+      end
+    end
+  end
+end
 
 # NB: clients will need to handle any exceptions caused by,
 # e.g., network failures or non-parseable JSON data.
-
 module Flapjack
+
   # Top level module for Flapjack::Diner API consumer.
   module Diner
-    include HTTParty
+    UUID_RE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 
+    include HTTParty
     format :json
 
     class << self
-      attr_accessor :logger, :return_keys_as_strings
-
-      include Flapjack::Diner::Resources::Contacts
-      include Flapjack::Diner::Resources::Media
-      include Flapjack::Diner::Resources::PagerdutyCredentials
-      include Flapjack::Diner::Resources::NotificationRules
-      include Flapjack::Diner::Resources::Entities
-      include Flapjack::Diner::Resources::Checks
-      include Flapjack::Diner::Resources::MaintenancePeriods
-      include Flapjack::Diner::Resources::Notifications
-      include Flapjack::Diner::Resources::Reports
-
-      include Flapjack::Diner::Tools
+      attr_accessor :return_keys_as_strings
+
+      # redefine HTTParty logger methods for getter/setter style
+      alias :original_logger :logger
+      def logger=(lgr)
+        original_logger(lgr, :info, :'flapjack-diner')
+      end
+      def logger
+        default_options[:logger]
+      end
+
+      def output
+        return if !instance_variable_defined?('@response') || @response.nil?
+        @response.output
+      end
+
+      def context
+        return if !instance_variable_defined?('@response') || @response.nil?
+        @response.context
+      end
+
+      def error
+        return if !instance_variable_defined?('@response') || @response.nil?
+        @response.error
+      end
     end
+
+    include Flapjack::Diner::Resources
+    include Flapjack::Diner::Relationships
+    include Flapjack::Diner::Tools
   end
 end