api_resource 0.4.0 → 0.4.1

data/lib/api_resource/formats.rb

@@ -1,22 +0,0 @@
-module ApiResource
-  module Formats
-    autoload :XmlFormat, 'api_resource/formats/xml_format'
-    autoload :JsonFormat, 'api_resource/formats/json_format'
-
-    # Lookup the format class from a mime type reference symbol. Example:
-    #
-    #   ActiveResource::Formats[:xml]  # => ActiveResource::Formats::XmlFormat
-    #   ActiveResource::Formats[:json] # => ActiveResource::Formats::JsonFormat
-    def self.[](mime_type_reference)
-      format_name = ActiveSupport::Inflector.camelize(mime_type_reference.to_s) + "Format"
-      begin
-        ApiResource::Formats.const_get(format_name)
-      rescue NameError => e
-        raise BadFormat.new("#{mime_type_reference} is not a valid format")
-      end
-    end
-
-    class BadFormat < StandardError
-    end
-  end
-end

data/lib/api_resource/formats/json_format.rb

@@ -1,25 +0,0 @@
-require 'active_support/json'
-require 'json'
-module ApiResource
-  module Formats
-    module JsonFormat
-      extend self
-
-      def extension
-        "json"
-      end
-
-      def mime_type
-        "application/json"
-      end
-
-      def encode(hash, options = nil)
-        JSON.dump(hash, options)
-      end
-
-      def decode(json)
-        JSON.parse(json)
-      end
-    end
-  end
-end

data/lib/api_resource/formats/xml_format.rb

@@ -1,36 +0,0 @@
-require 'active_support/core_ext/hash/conversions'
-
-module ApiResource
-  module Formats
-    module XmlFormat
-      extend self
-
-      def extension
-        "xml"
-      end
-
-      def mime_type
-        "application/xml"
-      end
-
-      def encode(hash, options={})
-        hash.to_xml(options)
-      end
-
-      def decode(xml)
-        from_xml_data(Hash.from_xml(xml))
-      end
-
-      private
-        # Manipulate from_xml Hash, because xml_simple is not exactly what we
-        # want for Active Resource.
-        def from_xml_data(data)
-          if data.is_a?(Hash) && data.keys.size == 1
-            data.values.first
-          else
-            data
-          end
-        end
-    end
-  end
-end

data/lib/api_resource/local.rb

@@ -1,12 +0,0 @@
-module ApiResource
-  class Local < Base
-    # nothing to do here
-    def self.set_class_attributes_upon_load
-      true
-    end
-    # shouldn't do anything here either - 
-    def self.reload_class_attributes
-      true
-    end
-  end
-end

data/lib/api_resource/log_subscriber.rb

@@ -1,15 +0,0 @@
-module ApiResource
-  class LogSubscriber < ActiveSupport::LogSubscriber
-    def request(event)
-      result = event[:payload]
-      info "#{event.payload[:method].to_s.upcase} #{even.payload[:request_uri]}"
-      info "--> %d %s %d (%.1fms)" % [result.code, result.message, result.body.to_s.length, event.duration]
-    end
-    
-    def logger
-      Rails.logger
-    end
-  end
-end
-
-ApiResource::LogSubscriber.attach_to :api_resource

data/lib/api_resource/mocks.rb

@@ -1,277 +0,0 @@
-require 'api_resource'
-
-module ApiResource
-  
-  module Mocks
-  
-    @@endpoints = {}
-    @@path = nil
-
-    # A simple interface class to change the new connection to look like the 
-    # old activeresource connection
-    class Interface
-      
-      def initialize(path)
-        @path = path
-      end
-      
-      def get(*args, &block)
-        Connection.send(:get, @path, *args, &block)
-      end
-      def post(*args, &block)
-        Connection.send(:post, @path, *args, &block)
-      end
-      def put(*args, &block)
-        Connection.send(:put, @path, *args, &block)
-      end
-      def delete(*args, &block)
-        Connection.send(:delete, @path, *args, &block)
-      end
-      def head(*args, &block)
-        Connection.send(:head, @path, *args, &block)
-      end
-    end
-
-    # set ApiResource's http 
-    def self.init
-      ::ApiResource::Connection.class_eval do
-        private
-        alias_method :http_without_mock, :http
-        def http(path)
-          Interface.new(path)
-        end
-      end
-    end
-    
-    # set ApiResource's http 
-    def self.remove
-      ::ApiResource::Connection.class_eval do
-        private
-        alias_method :http, :http_without_mock
-      end
-    end
-
-    # clear out the defined mocks
-    def self.clear_endpoints
-      ret = @@endpoints
-      @@endpoints = {}
-      ret
-    end
-    # re-set the endpoints
-    def self.set_endpoints(new_endpoints)
-      @@endpoints = new_endpoints
-    end
-    # return the defined endpoints
-    def self.endpoints
-      @@endpoints
-    end
-    def self.define(&block)
-      instance_eval(&block) if block_given?
-    end
-    # define an endpoint for the mock
-    def self.endpoint(path, &block)
-      path, format = path.split(".")
-      @@endpoints[path] ||= []
-      with_path_and_format(path, format) do
-        instance_eval(&block) if block_given?
-      end
-    end
-    # find a matching response
-    def self.find_response(request)
-      # these are stored as [[Request, Response], [Request, Response]]
-      responses_and_params = self.responses_for_path(request.path)
-      ret = (responses_and_params[:responses] || []).select{|pair| pair.first.match?(request)}
-      raise Exception.new("More than one response matches #{request}") if ret.length > 1
-      return ret.first ? {:response => ret.first[1], :params => responses_and_params[:params]} : nil
-    end
-
-    def self.paths_match?(known_path, entered_path)
-      PathString.paths_match?(known_path, entered_path)
-    end
-
-    # This method assumes that the two are matching paths
-    # if they aren't the behavior is undefined
-    def self.extract_params(known_path, entered_path)
-      PathString.extract_params(known_path, entered_path)
-    end
-
-    # returns a hash {:responses => [[Request, Response],[Request,Response]], :params => {...}}
-    # if there is no match returns nil
-    def self.responses_for_path(path)
-      path = path.split("?").first
-      path = path.split(/\./).first
-      # The obvious case
-      if @@endpoints[path]
-        return {:responses => @@endpoints[path], :params => {}}
-      end
-      # parameter names prefixed with colons should match parts
-      # of the path and push those parameters into the response
-      @@endpoints.keys.each do |possible_path|
-        if self.paths_match?(possible_path, path)
-          return {:responses => @@endpoints[possible_path], :params => self.extract_params(possible_path, path)}
-        end
-      end
-
-      return {:responses => nil, :params => nil}
-    end
-    
-
-    private
-    def self.with_path_and_format(path, format, &block)
-      @@path, @@format = path, format
-      ret = yield
-      @@path, @@format = nil, nil
-      ret
-    end
-    # define the 
-    [:post, :put, :get, :delete, :head].each do |verb|
-      instance_eval <<-EOE, __FILE__, __LINE__ + 1
-        def #{verb}(response_body, opts = {}, &block)
-
-          raise Exception.new("Must be called from within an endpoint block") unless @@path
-          opts = opts.reverse_merge({:status_code => 200, :response_headers => {}, :params => {}})        
-
-          @@endpoints[@@path] << [MockRequest.new(:#{verb}, @@path, :params => opts[:params], :format => @@format), MockResponse.new(response_body, :status_code => opts[:status_code], :headers => opts[:response_headers], :format => @@format, &block)]
-        end
-      EOE
-    end
-
-    class MockResponse
-      attr_reader :body, :headers, :code, :format, :block
-      def initialize(body, opts = {}, &block)     
-        opts = opts.reverse_merge({:headers => {}, :status_code => 200})
-        @body = body
-        @headers = opts[:headers]
-        @code = opts[:status_code]
-        @format = (opts[:format] || :json)
-        @block = block if block_given?
-      end
-      def []=(key, val)
-        @headers[key] = val
-      end
-      def [](key)
-        @headers[key]
-      end
-
-      def body
-        raise Exception.new("Body must respond to to_#{self.format}") unless @body.respond_to?("to_#{self.format}")
-        @body.send("to_#{self.format}")
-      end
-
-      def body_as_object
-        return @body
-      end
-
-      def generate_response(params)
-        @body = @body.instance_exec(params, &self.block) if self.block
-      end
-    end
-
-    class MockRequest
-      attr_reader :method, :path, :body, :headers, :params, :format, :query
-
-      def initialize(method, path, opts = {})
-        @method = method.to_sym
-
-        # set the normalized path, format and query string
-        @path, @query = path.split("?")
-        @path, @format = @path.split(".")
-
-        # if we have params, it is a MockRequest definition
-        if opts[:params]
-          @params = opts[:params]
-          # otherwise, we need to check either the query string or the body
-          # depending on the http verb
-        else
-          case @method
-            when :post, :put
-              @params = JSON.parse(opts[:body] || "")
-            when :get, :delete, :head
-              @params = sorted_params(@query || "")
-          end
-        end
-        @body = opts[:body]
-        @headers = opts[:headers] || {}
-        @headers["Content-Length"] = @body.blank? ? "0" : @body.size.to_s
-      end
-
-      # 
-      def sorted_params(data)
-        ret = {}
-        data.split("&").each do |entry|
-          key, val = entry.split("=")
-          if val.to_s =~ /^\d+$/
-            ret[key] = val.to_i
-          elsif val =~ /^[\d\.]+$/
-            ret[key] = val.to_f
-          elsif val == "true"
-            ret[key] = true
-          elsif val == "false"
-            ret[key] = false  
-          else
-            ret[key] = val || ""
-          end
-        end
-        ret
-      end
-
-      # because of the context these come from, we can assume that the path already matches
-      def match?(request)
-        return false unless self.method == request.method
-        return false unless self.format == request.format || request.format.nil? || self.format.nil?
-        Comparator.diff(self.params, request.params) == {}
-      end
-      # string representation
-      def to_s
-        "#{self.method.upcase} #{self.format} #{self.path} #{self.params}"
-      end
-    end
-    class Connection
-
-      cattr_accessor :requests
-      self.requests = []
-
-      #   body?       methods
-      { true  => %w(post put),
-        false => %w(get delete head) }.each do |has_body, methods|
-        methods.each do |method|
-          # def post(path, body, headers)
-          #   request = ApiResource::Request.new(:post, path, body, headers)
-          #   self.class.requests << request
-          #   if response = LifebookerClient::Mocks.find_response(request)
-          #     response
-          #   else
-          #     raise InvalidRequestError.new("Could not find a response 
-          #     recorded for #{request.to_s} - Responses recorded are: -
-          #       #{inspect_responses}")
-          #   end
-          # end
-          instance_eval <<-EOE, __FILE__, __LINE__ + 1
-            def #{method}(path, #{'body, ' if has_body}headers)
-              opts = {:headers => headers}
-              #{"opts[:body] = body" if has_body}
-              request = MockRequest.new(:#{method}, path, opts)
-              self.requests << request
-              if response = Mocks.find_response(request)
-                response[:response].tap{|resp| 
-                  resp.generate_response(
-                    request.params
-                      .with_indifferent_access
-                      .merge(response[:params].with_indifferent_access)
-                  )
-                }
-              else
-                raise ApiResource::ResourceNotFound.new(
-                  MockResponse.new({}, {:headers => {"Content-type" => "application/json"}, :status_code => 404}),
-                  :message => "\nCould not find a response recorded for \#{request.pretty_inspect}\n" +
-                  "Potential Responses Are:\n" +
-                  "\#{Array.wrap(Mocks.responses_for_path(request.path)[:responses]).collect(&:first).pretty_inspect}"
-                )
-              end
-            end
-          EOE
-        end
-      end
-    end
-  end
-end

data/lib/api_resource/model_errors.rb

@@ -1,82 +0,0 @@
-module ApiResource
-  
-  class Errors < ::ActiveModel::Errors
-    
-    def from_array(messages, save_cache = false)
-      clear unless save_cache
-      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
-      messages.each do |message|
-        attr_message = humanized_attributes.keys.detect do |attr_name|
-          if message[0,attr_name.size + 1] == "#{attr_name} "
-            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
-          end
-        end
-      end
-    end
-    
-    def from_hash(messages, save_cache = false)
-      clear unless save_cache
-      messages.each do |attr, message_array|
-        message_array.each do |message|
-          add attr, message
-        end
-      end
-    end
-
-  end
-  
-  module ModelErrors
-  
-    extend ActiveSupport::Concern
-    include ActiveModel::Validations
-    
-    included do
-      # this is required here because this module will be above Base in the inheritance chain
-      alias_method_chain :save, :validations
-    end
-    
-    def save_with_validations(*args)
-      # we want to leave the original intact
-      options = args.clone.extract_options!
-      
-      perform_validation = options.blank? ? true : options[:validate]
-      
-      @remote_errors = nil
-      if perform_validation && valid? || !perform_validation
-        save_without_validations(*args)
-        true
-      else
-        false
-      end
-    rescue ApiResource::UnprocessableEntity => error
-      @remote_errors = error
-      load_remote_errors(@remote_errors, true)
-      false
-    end
-    
-    def load_remote_errors(remote_errors, save_cache = false)
-      error_data = self.class.format.decode(remote_errors.response.body)['errors'] || {}
-      if error_data.is_a?(Hash)
-        self.errors.from_hash(error_data)
-      elsif error_data.is_a?(Array)
-        self.errors.from_array(error_data)
-      else
-        raise Exception.new
-      end
-    rescue Exception
-      raise "Invalid response for invalid object: expected an array or hash got #{remote_errors}"
-    end
-    
-    # This method runs any local validations but not remote ones
-    def valid?
-      super
-      errors.empty?
-    end
-    
-    def errors
-      @errors ||= ApiResource::Errors.new(self)
-    end
-    
-  end
-  
-end