lazy_resource 0.4.0 → 0.5.0

data/lib/lazy_resource/ext/typhoeus.rb

@@ -1,17 +1,33 @@
 module Typhoeus
   class Hydra
+    def items_queued?
+      @multi.items_queued? || self.queued_requests.size > 0
+    end
+
     def run_with_logging
-      log = LazyResource.debug && LazyResource.logger && @multi.items_queued_but_not_running?
-      if log
-        LazyResource.logger.info "Processing requests:"
-        start_time = Time.now
+      if log?
+        log { run_without_logging }
+      else
+        run_without_logging
       end
+    end
 
-      run_without_logging
+    private
+    def log?
+      LazyResource.debug && LazyResource.logger && items_queued? && !running?
+    end
 
-      if log
-        LazyResource.logger.info "Requests processed in #{((Time.now - start_time) * 1000).ceil}ms"
-      end
+    def running?
+      @running || @multi.running?
+    end
+
+    def log(&block)
+      start_time = Time.now
+      ActiveSupport::Notifications.instrument('request_group_started.lazy_resource', start_time: start_time)
+
+      yield
+
+      ActiveSupport::Notifications.instrument('request_group_finished.lazy_resource', start_time: start_time, end_time: Time.now)
     end
 
     alias_method :run_without_logging, :run
@@ -21,8 +37,25 @@ end
 
 module Ethon
   class Multi
-    def items_queued_but_not_running?
-      easy_handles.size > 0 && running_count <= 0
+    def running?
+      running_count > 0
+    end
+
+    def running_count
+      @running_count ||= 0
+    end
+
+    def items_queued?
+      easy_handles.size > 0
+    end
+  end
+
+  def self.logger
+    @logger ||= DevNull.new
+  end
+
+  class DevNull
+    def method_missing(*args, &block)
     end
   end
 end

data/lib/lazy_resource/log_subscriber.rb

@@ -0,0 +1,17 @@
+module LazyResource
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def request(event)
+      info "\s\s\s\s[#{event.payload[:code]}](#{((event.payload[:time] || 0) * 1000).ceil}ms) #{event.payload[:url]}"
+    end
+
+    def request_group_started(event)
+      info "Processing requests:"
+    end
+
+    def request_group_finished(event)
+      info "Requests finished in #{((event.payload[:end_time] - event.payload[:start_time]) * 1000).ceil}ms"
+    end
+  end
+end
+
+LazyResource::LogSubscriber.attach_to(:lazy_resource)

data/lib/lazy_resource/mapping.rb

@@ -2,7 +2,7 @@ module LazyResource
   module Mapping
     extend ActiveSupport::Concern
 
-    attr_accessor :fetched, :persisted, :other_attributes
+    attr_accessor :fetched, :persisted, :other_attributes, :request_error
 
     def fetched?
       @fetched

data/lib/lazy_resource/relation.rb

@@ -8,12 +8,17 @@ module LazyResource
       end
     end
 
-    attr_accessor :fetched, :klass, :values, :from, :site, :other_attributes
+    attr_accessor :fetched, :klass, :values, :from, :site, :other_attributes, :request_error
+    attr_writer :method
+    attr_reader :route
 
     def initialize(klass, options = {})
       @klass = klass
+      @route = options.fetch(:where_values, {}).delete(:_route)
       @values = options.slice(:where_values, :order_value, :limit_value, :offset_value, :page_value)
       @fetched = options[:fetched] || false
+      @method = options[:method]
+
       unless fetched?
         resource_queue.queue(self)
       end
@@ -29,6 +34,10 @@ module LazyResource
       from
     end
 
+    def method
+      @method ? @method.downcase.to_sym : nil
+    end
+
     def to_params
       params = {}
       params.merge!(where_values) unless where_values.nil?
@@ -117,6 +126,7 @@ module LazyResource
 
     def to_a
       resource_queue.run if !fetched?
+      raise self.request_error if self.request_error.present?
       result
     end
 

data/lib/lazy_resource/request.rb

@@ -1,23 +1,39 @@
 module LazyResource
   class Request < Typhoeus::Request
-    SUCCESS_STATUSES = [200, 201]
+    SUCCESS_STATUSES = 200...300
 
     attr_accessor :resource, :response
 
     def initialize(url, resource, options={})
       options = options.dup
-      options[:headers] ||= {}
+      options[:headers] = (options[:headers] || {}).dup
       options[:headers][:Accept] ||= 'application/json'
       options[:headers].merge!(Thread.current[:default_headers]) unless Thread.current[:default_headers].nil?
+
+      params = (URI.parse(url).query || '')
+                  .split('&')
+                  .map { |param| param.split('=') }
+                  .inject({}) { |memo, (k,v)| memo[URI.unescape(k)] = v.nil? ? v : URI.unescape(v); memo }
+
+      url.gsub!(/\?.*/, '')
+
+      options[:params] ||= {}
+      options[:params].merge!(params)
+      options[:params].merge!(Thread.current[:default_params]) unless Thread.current[:default_params].nil?
+
       options[:method] ||= :get
 
+      if [:post, :put].include?(options[:method])
+        options[:headers]['Content-Type'] = 'application/json'
+      end
+
       super(url, options)
 
       @resource = resource
+
       self.on_complete do
         log_response(response) if LazyResource.debug && LazyResource.logger
         @response = response
-        handle_errors unless SUCCESS_STATUSES.include?(@response.code)
         parse
       end
 
@@ -25,39 +41,43 @@ module LazyResource
     end
 
     def log_response(response)
-      LazyResource.logger.info "\t[#{response.code}](#{((response.time || 0) * 1000).ceil}ms): #{self.url}"
+      ActiveSupport::Notifications.instrument('request.lazy_resource', code: response.code, time: response.time, url: url)
     end
 
     def parse
+      unless SUCCESS_STATUSES.include?(@response.code)
+        @resource.request_error = error
+      end
+
       unless self.response.body.nil? || self.response.body == ''
         @resource.load(JSON.parse(self.response.body))
       end
     end
 
-    def handle_errors
+    def error
       case @response.code
       when 300...400
-        raise Redirection.new(@response)
+        Redirection.new(@response)
       when 400
-        raise BadRequest.new(@response)
+        BadRequest.new(@response)
       when 401
-        raise UnauthorizedAccess.new(@response)
+        UnauthorizedAccess.new(@response)
       when 403
-        raise ForbiddenAccess.new(@response)
+        ForbiddenAccess.new(@response)
       when 404
-        raise ResourceNotFound.new(@response)
+        ResourceNotFound.new(@response)
       when 405
-        raise MethodNotAllowed.new(@response)
+        MethodNotAllowed.new(@response)
       when 409
-        raise ResourceConflict.new(@response)
+        ResourceConflict.new(@response)
       when 410
-        raise ResourceGone.new(@response)
+        ResourceGone.new(@response)
       when 422
-        raise UnprocessableEntity.new(@response)
+        UnprocessableEntity.new(@response)
       when 400...500
-        raise ClientError.new(@response)
+        ClientError.new(@response)
       when 500...600
-        raise ServerError.new(@response)
+        ServerError.new(@response)
       end
     end
   end

data/lib/lazy_resource/resource.rb

@@ -69,11 +69,12 @@ module LazyResource
       end
 
       def request_queue
-        Thread.current[:request_queue] ||= Typhoeus::Hydra.new
+        Thread.current[:request_queue] ||= Typhoeus::Hydra.new(:max_concurrency => LazyResource.max_concurrency)
       end
 
       def find(id, params={}, options={})
-        self.new(self.primary_key_name => id).tap do |resource|
+        self.new.tap do |resource|
+          resource.instance_variable_set("@#{self.primary_key_name}", id)
           resource.fetched = false
           resource.persisted = true
           options[:headers] ||= {}
@@ -98,7 +99,7 @@ module LazyResource
       def offset(offset_value)
         Relation.new(self, :offset_value => offset_value)
       end
-      
+
       def page(page_value)
         Relation.new(self, :page_value => page_value)
       end
@@ -163,7 +164,7 @@ module LazyResource
 
     def create
       run_callbacks :create do
-        request = Request.new(self.collection_url, self, { :method => :post, :params => attribute_params })
+        request = Request.new(self.collection_url, self, { :method => :post, :body => attribute_params.to_json })
         self.class.request_queue.queue(request)
         self.class.fetch_all
         self.changed_attributes.clear
@@ -172,7 +173,7 @@ module LazyResource
 
     def update
       run_callbacks :update do
-        request = Request.new(self.element_url, self, { :method => :put, :params => attribute_params })
+        request = Request.new(self.element_url, self, { :method => :put, :body => attribute_params.to_json })
         self.class.request_queue.queue(request)
         self.class.fetch_all
         self.changed_attributes.clear

data/lib/lazy_resource/resource_queue.rb

@@ -15,26 +15,52 @@ module LazyResource
     end
 
     def request_queue
-      Thread.current[:request_queue] ||= Typhoeus::Hydra.new
+      Thread.current[:request_queue] ||= Typhoeus::Hydra.new(:max_concurrency => LazyResource.max_concurrency)
     end
 
     def run
       send_to_request_queue!
-      request_queue.run
+      request_queue.run if request_queue.items_queued?
     end
 
     def send_to_request_queue!
       while(relation = @queue.pop)
-        request = Request.new(url_for(relation), relation, :headers => relation.headers)
+        options = { :headers => relation.headers, :method => relation.method }
+
+        if [:post, :put].include?(relation.method)
+          options[:body] = relation.to_params.to_json
+        end
+
+        request = Request.new(url_for(relation), relation, options)
         request_queue.queue(request)
       end
     end
 
     def url_for(relation)
-      url = ''
-      url << relation.klass.site
-      url << self.class.collection_path(relation.to_params, nil, relation.from)
-      url
+      if relation.route.nil?
+        include_query = ![:post, :put].include?(relation.method)
+
+        url = ''
+        url << relation.klass.site
+        url << relation.klass.collection_path(relation.to_params, nil, relation.from, include_query)
+        url
+      else
+        url = relation.route
+        url.gsub!(/:\w*/) do |match|
+          attr = match[1..-1].to_sym
+          if relation.where_values.has_key?(attr)
+            relation.where_values[attr]
+          else
+            match
+          end
+        end
+
+        if url =~ /http/
+          url
+        else
+          relation.klass.site + url
+        end
+      end
     end
   end
 end

data/lib/lazy_resource/url_generation.rb

@@ -3,7 +3,7 @@ module LazyResource
     extend ActiveSupport::Concern
 
     def element_path(options = nil)
-      self.class.element_path(self.primary_key, options)
+      self.class.element_path(self.instance_variable_get("@#{self.class.primary_key_name}"), options)
     end
 
     def element_url(options = nil)
@@ -72,10 +72,12 @@ module LazyResource
       # * +prefix_options+ - A hash to add a prefix to the request for nested URLs (e.g., <tt>:account_id => 19</tt>
       #   would yield a URL like <tt>/accounts/19/purchases.json</tt>).
       # * +query_options+ - A hash to add items to the query string for the request.
-      def collection_path(prefix_options = {}, query_options = nil, from = nil)
+      def collection_path(prefix_options = {}, query_options = nil, from = nil, include_query = true)
         prefix_options, query_options = split_options(prefix_options) if query_options.nil?
         from = self.from if from.nil? && respond_to?(:from)
-        "#{prefix(prefix_options)}#{from || collection_name}#{query_string(query_options)}"
+        path = "#{prefix(prefix_options)}#{from || collection_name}"
+        path += "#{query_string(query_options)}" if include_query
+        path
       end
 
       # Builds the query string for the request.
@@ -90,7 +92,7 @@ module LazyResource
 
           (options || {}).each do |key, value|
             next if key.blank?
-            (key =~ /\w*_id/ ? prefix_options : query_options)[key.to_sym] = value
+            (key =~ /\w*_id$/ ? prefix_options : query_options)[key.to_sym] = value
           end
 
           [prefix_options, query_options]

data/lib/lazy_resource/version.rb

@@ -1,3 +1,3 @@
 module LazyResource
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/lazy_resource/attributes_spec.rb

@@ -1,9 +1,12 @@
 require 'spec_helper'
 
+# We need a reference to this exact proc in two spots
+LAMBDA_ROUTE = lambda { "/path/to/#{name}" }
+
 class AttributeObject
   include LazyResource::Attributes
 
-  attr_accessor :fetched
+  attr_accessor :fetched, :request_error
 
   def self.resource_queue
     @resource_queue ||= LazyResource::ResourceQueue.new
@@ -62,6 +65,11 @@ describe LazyResource::Attributes do
         @foo.name
       end
 
+      it 'raises the error at request_error if it exists' do
+        @foo.request_error = StandardError.new
+        lambda { @foo.name }.should raise_error(StandardError)
+      end
+
       describe 'associations' do
         before :each do
           AttributeObject.attribute(:posts, [Post])
@@ -80,33 +88,45 @@ describe LazyResource::Attributes do
           @foo.user
         end
 
-        describe ':using' do
+        context ':route' do
           before :each do
             AttributeObject.attribute(:posts_url, String)
-            AttributeObject.attribute(:user_url, String)
-            AttributeObject.attribute(:posts, [Post], :using => :posts_url)
-            AttributeObject.attribute(:user, User, :using => :user_url)
-            @foo.send(:instance_variable_set, "@posts_url", 'http://example.com/path/to/posts')
-            @foo.send(:instance_variable_set, "@user_url", 'http://example.com/path/to/user')
+            AttributeObject.attribute(:posts, [Post], :route => :posts_url)
+            AttributeObject.attribute(:user, User, :route => "/path/to/user")
+            @foo.send(:instance_variable_set, "@posts_url", '/path/to/posts')
           end
 
           it 'finds a collection using the specified url' do
-            relation = LazyResource::Relation.new(Post, :headers => {})
-            request = LazyResource::Request.new(@foo.posts_url, relation)
-            LazyResource::Request.should_receive(:new).with(@foo.posts_url, relation, :headers => relation.headers).and_return(request)
-            LazyResource::Relation.should_receive(:new).with(Post, :fetched => true).and_return(relation)
-            @foo.class.request_queue.should_receive(:queue).with(request)
-            @foo.fetched = false
-            @foo.posts
+            @foo.posts.route.should == '/path/to/posts'
           end
 
           it 'finds a singular resource with the specified url' do
-            resource = User.load({})
-            request = LazyResource::Request.new(@foo.user_url, resource)
-            LazyResource::Request.should_receive(:new).with(@foo.user_url, resource).and_return(request)
-            @foo.class.request_queue.should_receive(:queue).with(request)
-            @foo.fetched = false
-            @foo.user
+            @foo.user.route.should == '/path/to/user'
+          end
+
+          context 'as a proc' do
+            before :each do
+              AttributeObject.any_instance.stub(:name).and_return("foobar")
+              AttributeObject.attribute(:comments, [Post], :route => LAMBDA_ROUTE)
+            end
+
+            it 'evaluates the proc to generate the url' do
+              @foo.comments.route.should == '/path/to/foobar'
+            end
+          end
+        end
+
+        context ':using' do
+          after :all do
+            AttributeObject.attribute(:posts_url, String)
+            AttributeObject.attribute(:user_url, String)
+            AttributeObject.attribute(:posts, [Post], :route => :posts_url)
+            AttributeObject.attribute(:user, User, :route => :user_url)
+          end
+
+          it 'generates a deprecation warning when using :using' do
+            LazyResource.should_receive(:deprecate).with("Attribute option :using is deprecated. Please use :route instead.", anything, anything)
+            AttributeObject.attribute(:posts, [Post], :using => :posts_url)
           end
         end
       end
@@ -141,10 +161,11 @@ describe LazyResource::Attributes do
   describe '.attributes' do
     it 'returns a hash of the defined attributes' do
       AttributeObject.attributes.should == { :name => { :type => String, :options => {} },
-                                             :posts => { :type => [Post], :options => { :using => :posts_url } },
-                                             :user => { :type => User, :options => { :using => :user_url } },
+                                             :posts => { :type => [Post], :options => { :route => :posts_url } },
+                                             :user => { :type => User, :options => { :route => :user_url } },
                                              :posts_url => { :type => String, :options => {} },
-                                             :user_url => { :type => String, :options => {} } }
+                                             :user_url => { :type => String, :options => {} },
+                                             :comments => { :type => [Post], :options => { :route => LAMBDA_ROUTE } } }
     end
   end