flapjack-diner 2.0.0.pre.alpha.3 → 2.0.0

data/lib/flapjack-diner/resources.rb

@@ -0,0 +1,64 @@
+require 'flapjack-diner/configuration'
+
+module Flapjack
+  module Diner
+    module Resources
+      def self.included(base)
+        # base.extend ClassMethods
+        base.class_eval do
+          Flapjack::Diner::Configuration::RESOURCES.each_pair do |name, config|
+            requests = config[:requests]
+            next if requests.nil?
+
+            if requests.key?(:post)
+              define_singleton_method("create_#{name}".to_sym) do |*data|
+                resp = Flapjack::Diner::Request.new(
+                  name, "/#{name}", :data => data,
+                  :validations => requests[:post]
+                ).post
+                @response = Flapjack::Diner::Response.new(resp)
+                @response.process
+                @response.output
+              end
+            end
+
+            if requests.key?(:get)
+              define_singleton_method(name) do |*data|
+                resp = Flapjack::Diner::Request.new(
+                  name, "/#{name}", :data => data,
+                  :validations => requests[:get]
+                ).get
+                @response = Flapjack::Diner::Response.new(resp)
+                @response.process
+                @response.output
+              end
+            end
+
+            if requests.key?(:patch)
+              define_singleton_method("update_#{name}".to_sym) do |*data|
+                resp = Flapjack::Diner::Request.new(
+                  name, "/#{name}", :data => data,
+                  :validations => requests[:patch]
+                ).patch
+                @response = Flapjack::Diner::Response.new(resp)
+                @response.process
+                @response.output
+              end
+            end
+
+            next unless requests.key?(:delete)
+            define_singleton_method("delete_#{name}".to_sym) do |*uuids|
+              raise "'#{method_name}' requires at least one #{resource} UUID " \
+                    'parameter' if uuids.nil? || uuids.empty?
+              resp = Flapjack::Diner::Request.new(name, "/#{name}",
+                :ids => uuids).delete
+              @response = Flapjack::Diner::Response.new(resp)
+              @response.process
+              @response.output
+            end
+          end
+        end
+      end
+    end
+  end
+end

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,482 +1,72 @@
-require 'uri'
-
 module Flapjack
   module Diner
     module Tools
-      SUCCESS_STATUS_CODES = [200, 201, 204]
-
-      attr_accessor :last_error, :context
-
-      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}"
-        end
-        logger.info log_msg
-      end
-
-      def perform_get(path, ids = [], data = {}, opts = {})
-        @last_error = nil
-        @context = nil
-
-        data = data.reduce({}, &:merge) if data.is_a?(Array)
-        if (ids.size > 1)
-          if data[:filter].nil?
-            data[:filter] = {:id => ids}
-          elsif !data[:filter].has_key?(:id)
-            data[:filter][:id] = ids
-          else
-            data[:filter][:id] |= ids
-          end
-        end
-
-        filt = data.delete(:filter)
-        unless filt.nil?
-          data[:filter] = filt.each_with_object([]) do |(k, v), memo|
-            value = case v
-            when Array, Set
-              v.to_a.join("|")
-            else
-              v.to_s
-            end
-            if opts[:assoc].nil?
-              memo << "#{k}:#{value}"
-            else
-              memo << "#{opts[:assoc]}.#{k}:#{value}"
-            end
-          end
-        end
-
-        incl = data[:include]
-        unless incl.nil?
-          case incl
-          when Array
-            raise ArgumentError.new("Include parameters must not contain commas") if incl.any? {|i| i =~ /,/}
-            data[:include] = if opts[:assoc].nil?
-              incl.join(",")
-            else
-              incl.map {|i|
-                if i.eql?(opts[:assoc].to_s) || (i =~ /^#{opts[:assoc]}\./)
-                  i
-                else
-                  "#{opts[:assoc]}.#{i}"
-                end
-              }.join(",")
-            end
-          when String
-            raise ArgumentError.new("Include parameters must not contain commas") if incl =~ /,/
-            unless opts[:assoc].nil? || (incl.eql?(opts[:assoc].to_s)) || (incl =~ /^#{opts[:assoc]}\./)
-              data[:include] = "#{opts[:assoc]}.#{incl}"
-            end
-          end
-        end
-
-        req_uri = build_uri(path, ids, data)
-        log_request('GET', req_uri, data)
-        handle_response(get(req_uri.request_uri))
-      end
-
-      def record_data(source, type, method)
-        r_type  = Flapjack::Diner::Resources::Relationships::TYPES[type]
-        req_data = {}
-        ['id', :id].each do |i|
-          req_data[:id] = source[i] if source.has_key?(i)
-        end
-        req_data[:type] = r_type
-
-        assocs = Flapjack::Diner::Resources::Relationships::ASSOCIATIONS[type] || {}
-
-        rel_singular = assocs.inject([]) do |memo, (assoc_name, assoc)|
-          if assoc[method].is_a?(TrueClass) && :singular.eql?(assoc[:number])
-            memo << assoc_name
-          end
-          memo
-        end
-
-        rel_multiple = assocs.inject([]) do |memo, (assoc_name, assoc)|
-          if assoc[method].is_a?(TrueClass) && :multiple.eql?(assoc[:number])
-            memo << assoc_name
-          end
-          memo
-        end
-
-        excluded = [:id, :type] + rel_singular + rel_multiple
-        attrs = source.reject do |k,v|
-          excluded.include?(k.to_sym)
-        end
-
-        req_data[:attributes] = attrs unless attrs.empty?
-
-        rel_data = {}
-
-        rel_singular.each do |singular_link|
-          converted = false
-          [singular_link, singular_link.to_s].each do |sl|
-            next if converted || !source.has_key?(sl)
-            rel_data[singular_link] = {:data => {:type => singular_link.to_s, :id => source[sl]}}
-            converted = true
-          end
-        end
-
-        rel_multiple.each do |multiple_link|
-          converted = false
-          ml_type = Flapjack::Diner::Resources::Relationships::TYPES[multiple_link]
-          [multiple_link, multiple_link.to_s].each do |ml|
-            next if converted || !source.has_key?(ml)
-            rel_data[multiple_link] = {
-              :data =>  source[ml].map {|id|
-                {:type => ml_type, :id => id}
-              }
-            }
-            converted = true
-          end
-        end
-
-        req_data[:relationships] = rel_data unless rel_data.empty?
-
-        req_data
-      end
-
-      def perform_post(type, path, data = {})
-        @last_error = nil
-        @context = nil
-
-        jsonapi_ext = ""
-        req_data = nil
-
-        case data
-        when Array
-          req_data = data.collect {|d| record_data(d, type, :post) }
-          jsonapi_ext = "; ext=bulk"
-        when Hash
-          req_data = record_data(data, type, :post)
+      module ClassMethods
+        def included_data
+          return if context.nil?
+          context[return_keys_as_strings ? 'included' : :included]
         end
-        req_uri = build_uri(path)
-        log_request('POST', req_uri, :data => req_data)
 
-        # TODO send current character encoding in content-type ?
-        opts = {:body => prepare_nested_query(:data => req_data).to_json,
-                :headers => {'Content-Type' => "application/vnd.api+json#{jsonapi_ext}"}}
-        handle_response(post(req_uri.request_uri, opts))
-      end
+        def related(record, rel, incl = included_data)
+          return if incl.nil?
 
-      def perform_post_links(type, path, *ids)
-        @last_error = nil
-        @context = nil
-        data = ids.collect {|id| {:type => type, :id => id}}
-        req_uri = build_uri(path)
-        log_request('POST', req_uri, :data => data)
-        opts = {:body => prepare_nested_query(:data => data).to_json,
-                :headers => {'Content-Type' => 'application/vnd.api+json'}}
-        handle_response(post(req_uri.request_uri, opts))
-      end
+          type = record[return_keys_as_strings ? 'type' : :type]
+          return if type.nil?
 
-      def perform_patch(type, path, data = nil)
-        @last_error = nil
-        @context = nil
-
-        req_uri = nil
-        req_data = nil
-
-        jsonapi_ext = ""
-        case data
-        when Hash
-          raise "Update data does not contain :id" unless data[:id]
-          req_data = record_data(data, type, :patch)
-          ids = [data[:id]]
-          req_uri = build_uri(path, ids)
-        when Array
-          ids = []
-          req_data = []
-          data.each do |d|
-            d_id = d.has_key?(:id) ? d[:id] : nil
-            ids << d_id unless d_id.nil? || d_id.empty?
-            req_data << record_data(d, type, :patch)
+          res = Flapjack::Diner::Configuration::RESOURCES.values.detect do |r|
+            type.eql?(r[:resource])
           end
-          raise "Update data must each contain :id" unless ids.size == data.size
-          req_uri = build_uri(path)
-          jsonapi_ext = "; ext=bulk"
-        end
+          return if res.nil? || res[:relationships].nil?
 
-        log_request('PATCH', req_uri, :data => req_data)
-
-        opts = if req_data.nil?
-                 {}
-               else
-                 {:body => prepare_nested_query(:data => req_data).to_json,
-                  :headers => {'Content-Type' => "application/vnd.api+json#{jsonapi_ext}"}}
-               end
-        handle_response(patch(req_uri.request_uri, opts))
-      end
-
-      def perform_patch_links(type, path, single, *ids)
-        @last_error = nil
-        @context = nil
-        data = if single
-          raise "Must provide one ID for a singular link" unless ids.size == 1
-          [nil].eql?(ids) ? nil : {:type => type, :id => ids.first}
-        else
-          [[]].eql?(ids) ? [] : ids.collect {|id| {:type => type, :id => id}}
-        end
-
-        req_uri = build_uri(path)
-
-        opts = {:body => prepare_nested_query(:data => data).to_json,
-                :headers => {'Content-Type' => 'application/vnd.api+json'}}
-        log_request('PATCH', req_uri, opts)
-        handle_response(patch(req_uri.request_uri, opts))
-      end
+          rel_cfg = res[:relationships][rel.to_sym]
+          return if rel_cfg.nil?
 
-      def perform_delete(type, path, *ids)
-        @last_error = nil
-        @context = nil
-        type = Flapjack::Diner::Resources::Relationships::TYPES[type]
-
-        req_uri = build_uri(path, ids)
-        opts = if ids.size == 1
-                 {}
-               else
-                 data = ids.collect {|id| {:type => type, :id => id} }
-                 {:body => prepare_nested_query(:data => data).to_json,
-                  :headers => {'Content-Type' => 'application/vnd.api+json; ext=bulk'}}
-               end
-        log_request('DELETE', req_uri, opts)
-        handle_response(delete(req_uri.request_uri, opts))
-      end
-
-      def perform_delete_links(type, path, *ids)
-        @last_error = nil
-        @context = nil
-        req_uri = build_uri(path)
-        data = ids.collect {|id| {:type => type, :id => id}}
-        opts = {:body => prepare_nested_query(:data => data).to_json,
-                :headers => {'Content-Type' => 'application/vnd.api+json'}}
-        log_request('DELETE', req_uri, opts)
-        handle_response(delete(req_uri.request_uri, opts))
-      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
-        strify = return_keys_as_strings.is_a?(TrueClass)
-        if [200, 201].include?(response.code)
-          return handle_response_data(parsed, strify)
-        end
-        @last_error = handle_response_errors(parsed, strify)
-        nil
-      end
-
-      def flatten_jsonapi_data(data, opts = {})
-        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)
+          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
-        else
-          ret = data
         end
-        ret
-      end
 
-      def handle_response_errors(parsed, strify)
-        return parsed if parsed.nil? || !parsed.is_a?(Hash) ||
-         !parsed.has_key?('errors')
-        errs = parsed['errors']
-        strify ? errs : symbolize(errs)
-      end
+        private
 
-      def handle_response_data(parsed, strify)
-        return parsed if parsed.nil? || !parsed.is_a?(Hash) ||
-          !parsed.has_key?('data')
-        @context = {}
-        if parsed.has_key?('included')
-          incl = flatten_jsonapi_data(parsed['included'], :allow_relationships => true)
-          @context[:included] = (strify ? incl : symbolize(incl))
-        end
-        (['relationships', 'meta'] & parsed.keys).each do |k|
-          c = parsed[k]
-          @context[k.to_sym] = (strify ? c : symbolize(c))
-        end
-        ret = flatten_jsonapi_data(parsed['data'], :allow_relationships => false)
-        strify ? ret : symbolize(ret)
-      end
-
-      def validate_params(query = {}, &validation)
-        return unless block_given?
-        query = {} if [].eql?(query)
-        case query
-        when Array
-          query.each do |q|
-            ArgumentValidator.new(q).instance_eval(&validation)
-          end
-        else
-          ArgumentValidator.new(query).instance_eval(&validation)
-        end
-      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?
 
-      # 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)
+          id = record[relat][rel][data][id_a]
+          return if id.nil? || !incl.key?(type)
+          incl[type][id]
         end
-      end
 
-      def build_array_query(value, prefix)
-        value.map {|v| build_nested_query(v, "#{prefix}[]") }.join('&')
-      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 build_hash_query(value, prefix)
-        value.map do |k, v|
-          data = prefix ? "#{prefix}[#{k}]" : k
-          build_nested_query(v, data)
-        end.join('&')
-      end
-
-      def build_data_query(value, prefix)
-        if value.respond_to?(:iso8601)
-          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
-          "#{escape(prefix)}=#{escape(value.iso8601)}"
-        elsif value.is_a?(String) || value.is_a?(Integer)
-          raise(ArgumentError, 'Value must be a Hash') if prefix.nil?
-          "#{escape(prefix)}=#{escape(value.to_s)}"
-        else
-          prefix
+          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 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_uuids(*args)
-        ids = args.select {|a| a.is_a?(String) || a.is_a?(Integer) }
-        raise "IDs must be RFC 4122-compliant UUIDs" unless ids.all? {|id|
-          id =~ /^#{Flapjack::Diner::UUID_RE}$/i
-        }
-        ids
-      end
-
-      def unwrap_data(*args)
-        data = args.reject {|a| a.is_a?(String) || a.is_a?(Integer) }
-        raise "Data must be passed as a Hash, or multiple Hashes" unless data.all? {|a| a.is_a?(Hash) }
-        return symbolize(data.first) if data.size == 1
-        data.each_with_object([]) {|d, o| o << symbolize(d) }
-      end
-
-      # 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)
+        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 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 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
-        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
-        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
-         if ids.size == 1
-          path += "/#{URI.escape(ids.first.to_s)}"
-        end
-        params = params.reduce({}, &:merge) if params.is_a?(Array)
-        query = params.empty? ? nil : build_nested_query(params)
-        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