resource 0.1.0

data/lib/api_resource/formats/xml_format.rb

@@ -0,0 +1,36 @@
+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/log_subscriber.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,249 @@
+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
+        def http(path)
+          Interface.new(path)
+        end
+      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)
+      path = request.path.split("?").first
+      path = path.split(/\./).first
+      # these are stored as [[Request, Response], [Request, Response]]
+      responses_and_params = self.matching(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
+
+    # returns a hash {:responses => [[Request, Response],[Request,Response]], :params => {...}}
+    # if there is no match returns nil
+    def self.matching(path)
+      # 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
+
+    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
+
+    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 = sorted_params(URI.decode(opts[:params].to_query))
+          # otherwise, we need to check either the query string or the body
+          # depending on the http verb
+        else
+          case @method
+            when :post, :put
+              @params = sorted_params(JSON.parse((opts[:body] || "")).to_query)
+            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 |val|
+          val = val.split("=")
+          ret[val.first] = val.last
+        end
+        ret.sort
+      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?
+        return PathString.as_sorted_json(self.params) == PathString.as_sorted_json(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(response[:params])}
+              else
+                raise Exception.new("
+                  Could not find a response recorded for \#{request.to_s}
+                  Valid Responses Are:
+                    \#{Mocks.endpoints.collect{|url, reqs| [url, reqs.collect(&:first)].to_s }.join("\n")}
+                ")
+              end
+            end
+          EOE
+        end
+      end
+    end
+  end
+end

data/lib/api_resource/model_errors.rb

@@ -0,0 +1,86 @@
+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
+    
+    module InstanceMethods
+      
+      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
+          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
+  
+end

data/lib/api_resource/observing.rb

@@ -0,0 +1,29 @@
+module ApiResource
+  
+  module Observing
+    
+    extend ActiveSupport::Concern
+    include ActiveModel::Observing
+    
+    # Redefine these methods to 
+    included do
+      %w( create save update destroy ).each do |method|
+        alias_method_chain method, :observers
+    end
+    
+    module InstanceMethods
+      %w( create save update destroy ).each do |method|
+        module_eval <<-EOE, __FILE__, __LINE__ + 1
+          def #{method}_with_observers(*args)
+            notify_observers(:before_#method)
+            if result = #{method}_without_observers(*args)
+              notify_observers(:after_#{method})
+            end
+            return result
+          end
+        EOE
+      end
+    end
+    
+  end
+end

data/resource.gemspec

@@ -0,0 +1,125 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resource}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Ethan Langevin}]
+  s.date = %q{2011-08-26}
+  s.description = %q{A replacement for ActiveResource for RESTful APIs that handles associated object and multiple data sources}
+  s.email = %q{ejl6266@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/api_resource.rb",
+    "lib/api_resource/associations.rb",
+    "lib/api_resource/attributes.rb",
+    "lib/api_resource/base.rb",
+    "lib/api_resource/callbacks.rb",
+    "lib/api_resource/connection.rb",
+    "lib/api_resource/core_extensions.rb",
+    "lib/api_resource/custom_methods.rb",
+    "lib/api_resource/exceptions.rb",
+    "lib/api_resource/formats.rb",
+    "lib/api_resource/formats/json_format.rb",
+    "lib/api_resource/formats/xml_format.rb",
+    "lib/api_resource/log_subscriber.rb",
+    "lib/api_resource/mocks.rb",
+    "lib/api_resource/model_errors.rb",
+    "lib/api_resource/observing.rb",
+    "resource.gemspec",
+    "spec/lib/associations_spec.rb",
+    "spec/lib/attributes_spec.rb",
+    "spec/lib/base_spec.rb",
+    "spec/lib/callbacks_spec.rb",
+    "spec/lib/model_errors_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/mocks/association_mocks.rb",
+    "spec/support/mocks/error_resource_mocks.rb",
+    "spec/support/mocks/test_resource_mocks.rb",
+    "spec/support/requests/association_requests.rb",
+    "spec/support/requests/error_resource_requests.rb",
+    "spec/support/requests/test_resource_requests.rb",
+    "spec/support/test_resource.rb"
+  ]
+  s.homepage = %q{http://github.com/ejlangev/resource}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.8}
+  s.summary = %q{A replacement for ActiveResource for RESTful APIs that handles associated object and multiple data sources}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, ["= 3.0.9"])
+      s.add_runtime_dependency(%q<activeresource>, ["= 3.0.9"])
+      s.add_runtime_dependency(%q<hash_dealer>, [">= 0"])
+      s.add_runtime_dependency(%q<rest-client>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_development_dependency(%q<growl>, [">= 0"])
+      s.add_development_dependency(%q<rspec-rails>, [">= 0"])
+      s.add_development_dependency(%q<factory_girl>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<faker>, [">= 0"])
+      s.add_development_dependency(%q<guard>, [">= 0"])
+      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, ["= 3.0.9"])
+      s.add_dependency(%q<activeresource>, ["= 3.0.9"])
+      s.add_dependency(%q<hash_dealer>, [">= 0"])
+      s.add_dependency(%q<rest-client>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_dependency(%q<growl>, [">= 0"])
+      s.add_dependency(%q<rspec-rails>, [">= 0"])
+      s.add_dependency(%q<factory_girl>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<faker>, [">= 0"])
+      s.add_dependency(%q<guard>, [">= 0"])
+      s.add_dependency(%q<guard-rspec>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, ["= 3.0.9"])
+    s.add_dependency(%q<activeresource>, ["= 3.0.9"])
+    s.add_dependency(%q<hash_dealer>, [">= 0"])
+    s.add_dependency(%q<rest-client>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
+    s.add_dependency(%q<growl>, [">= 0"])
+    s.add_dependency(%q<rspec-rails>, [">= 0"])
+    s.add_dependency(%q<factory_girl>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<faker>, [">= 0"])
+    s.add_dependency(%q<guard>, [">= 0"])
+    s.add_dependency(%q<guard-rspec>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+