flapjack-diner 2.0.0b1 → 2.0.0.pre.alpha.1

data/lib/flapjack-diner/log_formatter.rb

@@ -1,22 +0,0 @@
-module Flapjack
-  module Diner
-    class LogFormatter #:nodoc:
-      TAG_NAME = Flapjack::Diner.name
-
-      attr_accessor :level, :logger, :current_time
-
-      def initialize(logger, level)
-        @logger = logger
-        @level  = level.to_sym
-      end
-
-      def format(request, response)
-        current_time   = Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
-        http_method    = request.http_method.name.split("::").last.upcase
-        path           = request.path.to_s
-        content_length = response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
-        @logger.send @level, "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
-      end
-    end
-  end
-end

data/lib/flapjack-diner/query.rb

@@ -1,114 +0,0 @@
-require 'flapjack-diner/utility'
-
-module Flapjack
-  module Diner
-    module Query
-
-      def self.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
-
-      # copied from Rack::Utils -- builds the query string for GETs
-      def self.build_nested(value, prefix = nil)
-        case value
-        when Array
-          build_array(value, prefix)
-        when Hash
-          build_hash(value, prefix)
-        else
-          build_data(value, prefix)
-        end
-      end
-
-      # used for the JSON data hashes in POST, PUT, DELETE
-      def self.prepare_nested(value)
-        case value
-        when Array
-          prepare_array(value)
-        when Hash
-          prepare_hash(value)
-        else
-          prepare_data(value)
-        end
-      end
-
-      def self.unwrap_uuids(*args)
-        ids = args.select {|a| a.is_a?(String) }
-        raise "IDs must be RFC 4122-compliant UUIDs" unless ids.all? {|id|
-          id =~ /^#{Flapjack::Diner::UUID_RE}$/i
-        }
-        ids
-      end
-
-      def self.unwrap_data(*args)
-        data = args.reject {|a| a.is_a?(String) || a.is_a?(Integer) }
-        unless data.all? {|a| a.is_a?(Hash) }
-          raise 'Data must be passed as a Hash, or multiple Hashes'
-        end
-        return Flapjack::Diner::Utility.symbolize(data.first) if data.size == 1
-        data.each_with_object([]) {|d, o| o << Flapjack::Diner::Utility.symbolize(d) }
-      end
-
-      private
-
-      def self.build_array(value, prefix)
-        value.map {|v| build_nested(v, "#{prefix}[]") }.join('&')
-      end
-
-      def self.build_hash(value, prefix)
-        value.map do |k, v|
-          data = prefix ? "#{prefix}[#{k}]" : k
-          build_nested(v, data)
-        end.join('&')
-      end
-
-      def self.build_data(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
-        end
-      end
-
-      def self.escape(s)
-        URI.encode_www_form_component(s)
-      end
-
-      def self.prepare_array(value)
-        value.map {|v| prepare_nested(v) }
-      end
-
-      def self.prepare_hash(value)
-        value.each_with_object({}) do |(k, v), a|
-          a[k] = prepare_nested(v)
-        end
-      end
-
-      def self.prepare_data(value)
-        if value.respond_to?(:iso8601)
-          value.iso8601
-        else
-          case value
-          when Integer, TrueClass, FalseClass, NilClass
-            value
-          else
-            value.to_s
-          end
-        end
-      end
-    end
-  end
-end

data/lib/flapjack-diner/relationships.rb

@@ -1,180 +0,0 @@
-require 'flapjack-diner/query'
-
-module Flapjack
-  module Diner
-    module Relationships
-
-      # FIXME include option for GET should check config settings for includable
-
-      def self.included(base)
-        # base.extend ClassMethods
-        base.class_eval do
-
-          ::Flapjack::Diner::Configuration::RESOURCES.each_pair do |resource, config|
-            mappings = config[:relationships]
-            next if mappings.nil?
-
-            res = config[:resource]
-            resource_id_validator = :uuid
-
-            # # NB: no non-GET singular link methods, so commented out for now
-            # mappings.select {|n, a| a[:post] && a[:link] && :singular.eql?(a[:number]) }.each do |linked, assoc|
-            #   linked_id_validator  = :singular_link_uuid
-
-            #   define_singleton_method("create_#{res}_link_#{linked}") do |resource_id, linked_id|
-            #     validations_proc = proc do
-            #       Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_id => linked_id) do
-            #         validate :query => :resource_id, :as => resource_id_validator
-            #         validate :query => :linked_id, :as => linked_id_validator
-            #       end
-            #     end
-
-            #     resp = Flapjack::Diner::Request.new(
-            #       linked, "/#{resource}/#{resource_id}/relationships/#{linked}",
-            #       :ids => linked_id, :validations_proc => validations_proc
-            #     ).post_links
-            #     @response = Flapjack::Diner::Response.new(resp)
-            #     @response.process
-            #     @response.output
-            #   end
-            # end
-
-            mappings.select {|n, a| a[:post] && a[:link] && :multiple.eql?(a[:number]) }.each do |linked, assoc|
-              type = ::Flapjack::Diner::Configuration::RESOURCES[linked][:resource]
-              linked_ids_validator = :multiple_link_uuid
-
-              define_singleton_method("create_#{res}_link_#{linked}") do |resource_id, *linked_ids|
-                validations_proc = proc do
-                  Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_ids => linked_ids) do
-                    validate :query => :resource_id, :as => resource_id_validator
-                    validate :query => :linked_ids, :as => linked_ids_validator
-                  end
-                end
-
-                resp = Flapjack::Diner::Request.new(
-                  type, "/#{resource}/#{resource_id}/relationships/#{linked}",
-                  :ids => linked_ids, :validations_proc => validations_proc
-                ).post_links
-                @response = Flapjack::Diner::Response.new(resp)
-                @response.process
-                @response.output
-              end
-            end
-
-            mappings.select {|n, a| a[:get] && a[:link] }.each do |linked, assoc|
-              define_singleton_method("#{res}_link_#{linked}") do |resource_id, opts = {}|
-                validations_proc = proc do |data|
-                  Flapjack::Diner::Query.validate_params(:resource_id => resource_id) do
-                    validate :query => :resource_id, :as => resource_id_validator
-                  end
-
-                  Flapjack::Diner::Query.validate_params(opts) do
-                    validate :query => [:fields, :sort, :include], :as => :string_or_array_of_strings
-                    validate :query => :filter, :as => :hash
-                    validate :query => [:page, :per_page], :as => :positive_integer
-                  end
-                end
-
-                resp = Flapjack::Diner::Request.new(
-                  linked, "/#{resource}/#{resource_id}/#{linked}", :data => [opts],
-                  :assoc => linked, :validations_proc => validations_proc
-                ).get
-                @response = Flapjack::Diner::Response.new(resp)
-                @response.process
-                @response.output
-              end
-            end
-
-            # # NB: no non-GET singular link methods, so commented out for now
-            # mappings.select {|n, a| a[:patch] && a[:link] && :singular.eql?(a[:number]) }.each do |linked, assoc|
-            #   linked_id_validator = :singular_link_uuid
-
-            #   define_singleton_method("update_#{res}_link_#{linked}") do |resource_id, linked_id|
-            #     validations_proc = proc do
-            #       Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_id => linked_id) do
-            #         validate :query => :resource_id, :as => resource_id_validator
-            #         validate :query => :linked_id, :as => linked_id_validator
-            #       end
-            #     end
-
-            #     resp = Flapjack::Diner::Request.new(
-            #       linked, "/#{resource}/#{resource_id}/relationships/#{linked}",
-            #       :ids => linked_id, :validations_proc => validation_proc, :single => true
-            #     ).patch_links
-            #     @response = Flapjack::Diner::Response.new(resp)
-            #     @response.process
-            #     @response.output
-            #   end
-            # end
-
-            mappings.select {|n, a| a[:patch] && a[:link] && :multiple.eql?(a[:number]) }.each do |linked, assoc|
-              type = ::Flapjack::Diner::Configuration::RESOURCES[linked][:resource]
-              linked_ids_validator = :multiple_link_uuid
-
-              define_singleton_method("update_#{res}_link_#{linked}") do |resource_id, *linked_ids|
-                validations_proc = proc do
-                  Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_ids => linked_ids) do
-                    validate :query => :resource_id, :as => resource_id_validator
-                    validate :query => :linked_id, :as => linked_ids_validator
-                  end
-                end
-
-                resp = Flapjack::Diner::Request.new(
-                  type, "/#{resource}/#{resource_id}/relationships/#{linked}",
-                  :ids => linked_ids, :validations_proc => validations_proc
-                ).patch_links
-                @response = Flapjack::Diner::Response.new(resp)
-                @response.process
-                @response.output
-              end
-            end
-
-            # # NB: no non-GET singular link methods, so commented out for now
-            # mappings.select {|n, a| a[:delete] && a[:link] && :singular.eql?(a[:number]) }.each do |linked, assoc|
-            #   linked_id_validator  = :singular_link_uuid
-
-            #   define_singleton_method("delete_#{res}_link_#{linked}") do |resource_id, linked_id|
-            #     validations_proc = proc do
-            #       Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_id => linked_id) do
-            #         validate :query => :resource_id, :as => resource_id_validator
-            #         validate :query => :linked_id, :as => linked_id_validator
-            #       end
-            #     end
-
-            #    resp = Flapjack::Diner::Request.new(
-            #       linked, "/#{resource}/#{resource_id}/relationships/#{linked}",
-            #       :ids => linked_ids :validations_proc => validations_proc
-            #     ).delete_links
-            #     @response = Flapjack::Diner::Response.new(resp)
-            #     @response.process
-            #     @response.output
-            #   end
-            # end
-
-            mappings.select {|n, a| a[:delete] && a[:link] && :multiple.eql?(a[:number]) }.each do |linked, assoc|
-              type = ::Flapjack::Diner::Configuration::RESOURCES[linked][:resource]
-              linked_ids_validator = :uuid_or_array_of_uuids
-
-              define_singleton_method("delete_#{res}_link_#{linked}") do |resource_id, *linked_ids|
-                validations_proc = proc do
-                  Flapjack::Diner::Query.validate_params(:resource_id => resource_id, :linked_ids => linked_ids) do
-                    validate :query => :resource_id, :as => resource_id_validator
-                    validate :query => :linked_ids, :as => linked_ids_validator
-                  end
-                end
-
-                resp = Flapjack::Diner::Request.new(
-                  type, "/#{resource}/#{resource_id}/relationships/#{linked}",
-                  :ids => linked_ids, :validations_proc => validations_proc
-                ).delete_links
-                @response = Flapjack::Diner::Response.new(resp)
-                @response.process
-                @response.output
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/flapjack-diner/request.rb

@@ -1,280 +0,0 @@
-require 'set'
-require 'uri'
-
-require 'flapjack-diner/query'
-
-module Flapjack
-  module Diner
-    class Request
-
-      def initialize(type, path, opts = {})
-        @type   = type
-        @path   = path
-        @ids    = opts.key?(:ids) ? opts[:ids] :
-          (opts[:data].nil? ? nil : Flapjack::Diner::Query.unwrap_uuids(*opts[:data]))
-        @data   = opts[:data].nil? ? nil : Flapjack::Diner::Query.unwrap_data(*opts[:data])
-        @assoc  = opts[:assoc]
-
-        unless @data.nil?
-          validations = opts[:validations]
-          unless validations.nil?
-            Flapjack::Diner::Query.validate_params(@data) do
-              validations.each_pair { |k,v| validate :query => k, :as => v }
-            end
-          end
-        end
-
-        validations_proc = opts[:validations_proc]
-        validations_proc.call unless validations_proc.nil?
-      end
-
-      def post
-        req_data = nil
-        jsonapi_ext = ""
-
-        case @data
-        when Array
-          req_data = @data.collect {|d| record_data(d, :post) }
-          jsonapi_ext = "; ext=bulk"
-        when Hash
-          req_data = record_data(@data, :post)
-        end
-        req_uri = build_uri
-
-        # TODO send current character encoding in content-type ?
-        Flapjack::Diner.post(req_uri.request_uri,
-          :body => Flapjack::Diner::Query.prepare_nested(:data => req_data).to_json,
-          :headers => {'Content-Type' => "application/vnd.api+json#{jsonapi_ext}"})
-      end
-
-      def post_links
-        @data = @ids.collect {|id| {:type => @type, :id => id}}
-        @ids = nil
-        req_uri = build_uri
-        Flapjack::Diner.post(req_uri.request_uri,
-          :body => Flapjack::Diner::Query.prepare_nested(:data => @data).to_json,
-          :headers => {'Content-Type' => 'application/vnd.api+json'})
-      end
-
-      def get
-        @data = @data.reduce({}, &:merge) if @data.is_a?(Array)
-        if !@ids.nil? && (@ids.size > 1)
-          if @data[:filter].nil?
-            @data[:filter] = {:id => @ids}
-          elsif !data[:filter].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
-            memo << (@assoc.nil? ? "#{k}:#{value}" :  "#{@assoc}.#{k}:#{value}")
-          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 @assoc.nil?
-              incl.join(",")
-            else
-              incl.map {|i|
-                if i.eql?(@assoc.to_s) || (i =~ /^#{@assoc}\./)
-                  i
-                else
-                  "#{@assoc}.#{i}"
-                end
-              }.join(",")
-            end
-          when String
-            raise ArgumentError.new("Include parameters must not contain commas") if incl =~ /,/
-            unless @assoc.nil? || (incl.eql?(@assoc.to_s)) || (incl =~ /^#{@assoc}\./)
-              @data[:include] = "#{@assoc}.#{incl}"
-            end
-          end
-        end
-
-        req_uri = build_uri(@data)
-        Flapjack::Diner.get(req_uri.request_uri)
-      end
-
-      def patch
-        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, :patch)
-          @ids = [@data[:id]]
-          req_uri = build_uri
-        when Array
-          ids = []
-          req_data = []
-          @data.each do |d|
-            d_id = d.key?(:id) ? d[:id] : nil
-            @ids << d_id unless d_id.nil? || d_id.empty?
-            req_data << record_data(d, :patch)
-          end
-          raise "Update data must each contain :id" unless @ids.size == @data.size
-          req_uri = build_uri
-          jsonapi_ext = "; ext=bulk"
-        end
-
-        opts = if req_data.nil?
-                 {}
-               else
-                 {:body => Flapjack::Diner::Query.prepare_nested(:data => req_data).to_json,
-                  :headers => {'Content-Type' => "application/vnd.api+json#{jsonapi_ext}"}}
-               end
-        Flapjack::Diner.patch(req_uri.request_uri, opts)
-      end
-
-      def patch_links
-        # data = if opts[:single]
-        #   raise "Must provide one ID for a singular link" unless @ids.size == 1
-        #   [nil].eql?(@ids) ? nil : {:type => @type, :id => @ids.first}
-        # else
-        data = [[]].eql?(@ids) ? [] : @ids.collect {|id| {:type => @type, :id => id}}
-        # end
-        @ids = nil
-
-        req_uri = build_uri
-
-        opts = {:body => Flapjack::Diner::Query.prepare_nested(:data => data).to_json,
-                :headers => {'Content-Type' => 'application/vnd.api+json'}}
-        Flapjack::Diner.patch(req_uri.request_uri, opts)
-      end
-
-      def delete
-        type = Flapjack::Diner::Configuration::RESOURCES[@type][:resource]
-
-        req_uri = build_uri
-        opts = if @ids.size == 1
-                 {}
-               else
-                 data = @ids.collect {|id| {:type => type, :id => id} }
-                 {:body => Flapjack::Diner::Query.prepare_nested(:data => data).to_json,
-                  :headers => {'Content-Type' => 'application/vnd.api+json; ext=bulk'}}
-               end
-        Flapjack::Diner.delete(req_uri.request_uri, opts)
-      end
-
-      def delete_links
-        data = @ids.collect {|id| {:type => @type, :id => id}}
-        @ids = nil
-        req_uri = build_uri
-        opts = {:body => Flapjack::Diner::Query.prepare_nested(:data => data).to_json,
-                :headers => {'Content-Type' => 'application/vnd.api+json'}}
-        Flapjack::Diner.delete(req_uri.request_uri, opts)
-      end
-
-      private
-
-      def record_data(source, method)
-        res = Flapjack::Diner::Configuration::RESOURCES[@type]
-        r_type = res[:resource]
-
-        req_data = {}
-        ['id', :id].each do |i|
-          req_data[:id] = source[i] if source.key?(i)
-        end
-        req_data[:type] = r_type
-
-        assocs = res[:relationships] || {}
-
-        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, _|
-          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.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::Configuration::RESOURCES[multiple_link][:resource]
-          [multiple_link, multiple_link.to_s].each do |ml|
-            next if converted || !source.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 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 =~ Flapjack::Diner.base_uri
-
-        protocol = protocol.nil? ? 'http' : protocol.downcase
-        [protocol, host, normalise_port(port, protocol)]
-      end
-
-      def build_uri(params = [])
-        pr, ho, po = protocol_host_port
-        @path += "/#{URI.escape(@ids.first.to_s)}" if !@ids.nil? && @ids.size == 1
-        params = params.reduce({}, &:merge) if params.is_a?(Array)
-        query = params.empty? ? nil : Flapjack::Diner::Query.build_nested(params)
-        URI::HTTP.build(:protocol => pr, :host => ho, :port => po,
-                        :path => @path, :query => query)
-      end
-    end
-  end
-end