lazy_resource 0.4.0 → 0.5.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTE2MGY4NDk1ZWRjMTY2ZDAxYmQyZmViYzhiNDFlZDQ3ZGRmOTkwYw==
+  data.tar.gz: !binary |-
+    YTVjZTljYzZjMGUwOGM1MGFlNDIyYjc2OTFmOTI5MmYwOGQxZTNmNg==
+SHA512:
+  metadata.gz: !binary |-
+    ZDFkM2FmNTkwNmY5NTlmZWZhNTkyMzA2YzkwNDYyM2YwZDI5N2FiYmQ4NmU1
+    YWVhZGQ1ODAwZDRhYzYyNzgwOGRmNDNmZmJiZGFkOGYyYjM2ZTExOTE1Njk3
+    ZTc0NmIzMzRmYmRkNDRjNzAyZTE4NDhmNmQ3ZGRkODk4Yzk5MzI=
+  data.tar.gz: !binary |-
+    ZTIzMWY3ZTlhNTUxMWMyYjAzNzczNTdmYzU0ZjcyNTgxM2QzZTQ0MWQ0ZmQz
+    MTNlZDM5MDJjMjU1ZWNhMmJlZjE1M2VmZDI2NmU4NmJlNThjYTg2ZWZjMmFj
+    OTFjMTFlZWZlYzVlNzgxYWNkZjM5MzE2ODYzNTY2ZjJiOGY2NGM=

data/.rspec

@@ -1,3 +1,2 @@
---debugger
 --color
 --format documentation

data/.rvmrc

@@ -1 +1 @@
-rvm use 1.9.3@lazy_resource --create
+rvm use 1.9.3-p194@lazy_resource --create

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+branches:
+  only:
+    - master

data/Gemfile

@@ -9,7 +9,7 @@ gem 'debugger'
 gem 'rake'
 gem 'twitter_cldr'
 
-gem 'rspec'
+gem 'rspec', '2.12.0'
 gem 'simplecov', :require => false
 gem 'guard-rspec'
 gem 'growl'

data/NOTES.md

@@ -0,0 +1,36 @@
+Major components/features:
+  * Finder methods
+  * Attributes
+  * Queueing
+  * Generating requests
+  * Handling responses
+  * URL generation
+  * Mapping responses to resources
+    * Mapping attributes
+  * Associations
+  * Logging
+  * Mocking
+
+Goals of next version:
+  * Remove reliance on Thread.current
+    * railtie?
+    * request?
+    * requests are local to a request (if a request object is available)
+  * Easier method of setting options that are request-wide
+    * currently uses an attribute on Thread.current
+  * Allow user to set scope of queue (request-level, application-level,
+    thread-level, etc.)
+  * Remove reliance on modules -- use separate objects
+  * Redefine some of the more obtuse options (e.g., :using)
+  * Class methods on resources should be persisted to relations
+  * Add support for scopes
+  * local_attributes (attributes that are set via to_json/as_json, but
+    are not actually part of the server's response)
+  * Allow queueing to be disabled per-request/per-model
+  * Allow access to attributes returned from the server for which a map
+    does not exist
+  * Fix issue where two a Resource#where that relies on data from a
+    different resource can cause it to prematurely process based on
+    previous calls to #where
+  * Fix issue where Relation does not respect .from= setting
+  * Move queueing logic into a separate module/gem?

data/README.md

@@ -14,6 +14,8 @@ flair. Not only is it faster, it's better-looking, too.
 Don't believe me? Check out some of the examples in the `examples` directory
 to see for yourself.
 
+[![Build Status](https://travis-ci.org/ahlatimer/lazy_resource.png?branch=master)](https://travis-ci.org/ahlatimer/lazy_resource)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -32,61 +34,80 @@ Or install it yourself as:
 
 ### Define a model:
 
-    class User
-      include LazyResource::Resource
+```ruby
+class User
+  include LazyResource::Resource
 
-      self.site = 'http://example.com'
+  self.site = 'http://example.com'
 
-      attribute :id, Integer
-      attribute :first_name, String
-      attribute :last_name, String
-    end
+  attribute :id, Integer
+  attribute :first_name, String
+  attribute :last_name, String
+end
+```
 
 ### Then use it:
 
-    me = User.find(1)                                                    # => GET /users/1
-    bobs = User.where(:first_name => 'Bob')                              # => GET /users?first_name=Bob
-    terry = User.new(:first_name => 'Terry', :last_name => 'Simpson')
-    terry.save                                                           # => POST /users
-    terry.last_name = 'Jackson'
-    terry.save                                                           # => PUT /users/4
-    terry.destroy                                                        # => DELETE /users/4
+```ruby
+me = User.find(1)                                                    # => GET /users/1
+bobs = User.where(:first_name => 'Bob')                              # => GET /users?first_name=Bob
+terry = User.new(:first_name => 'Terry', :last_name => 'Simpson')
+terry.save                                                           # => POST /users
+terry.last_name = 'Jackson'
+terry.save                                                           # => PUT /users/4
+terry.destroy                                                        # => DELETE /users/4
+```
 
 ### What about associations?
 
-    class Post
-      include LazyResource::Resource
+```ruby
+class Post
+  include LazyResource::Resource
 
-      self.site = 'http://example.com'
+  self.site = 'http://example.com'
 
-      attribute :id, Integer
-      attribute :title, String
-      attribute :body, String
-      attribute :user, User
-    end
+  attribute :id, Integer
+  attribute :title, String
+  attribute :body, String
+  attribute :user, User
+end
 
-    class User
-      include LazyResource::Resource
-      # Attributes that have a type in an array are has-many
-      attribute :posts, [Post]
-    end
+class User
+  include LazyResource::Resource
+  # Attributes that have a type in an array are has-many
+  attribute :posts, [Post]
+end
 
-    me = User.find(1)
-    me.posts.all       # => GET /users/1/posts
+me = User.find(1)
+me.posts.all       # => GET /users/1/posts
+```
 
 ### That's cool, but what if my end-point doesn't map with my association name?
 
-    class Photo
-      include LazyResource::Resource
+```ruby
+class Photo
+  include LazyResource::Resource
+
+  attribute :id, Integer
+  attribute :urls, Hash
+  attribute :photographer, User, :from => 'users'
+end
 
-      attribute :id, Integer
-      attribute :urls, Hash
-      attribute :photographer, User, :from => 'users'
-    end
+# similarly, model-level
+class User
+  self.from = 'people'
+end
+```
 
-### I thought you said this was non-blocking?
+### What's this about blocking less?
 
-It is. That original example above with me, the Bobs, Sam, and Terry? Those
+Unlike ActiveResource, LazyResource doesn't initiate a request on every
+find. Instead, whenever you do a find, where, etc. it throws those
+requests into a queue that gets processed when you hit an accessor.
+Built on Typhoeus, all of those queued requests get executed at the same
+time.
+
+That original example above with me, the Bobs, Sam, and Terry? Those
 first four requests would all get executed at the same time, when Terry
 was saved. Pretty neat, eh?
 
@@ -101,32 +122,72 @@ Here you go:
 
 Fetch associations without hitting the URL generation code.
 
-    class Photo
-      include LazyResource::Resource
+```ruby
+class Photo
+  include LazyResource::Resource
+
+  attribute :id, Fixnum
 
-      attribute :id, Fixnum
-      attribute :photographer_url, String
-      attribute :photographer, User, :using => :photographer_url
+  # define the route inline
+  attribute :location, Location, :route => '/location/:lat,:long'
 
-      # or define it yourself
-      def photographer_url
-        "/path/to/photographer"
-      end
-    end
+  # define the route inline using a proc
+  attribute :model, Model, :route => lambda { "/photos/#{id}/model" }
+
+  # define the route using a method or attribute
+  attribute :photographer, User, :route => :photographer_url
+  attribute :photographer_url, String
+  def photographer_url
+    "/photographer/:name"
+  end
+end
+```
 
 Parsing responses like { 'photo': ... }
 
-    class Photo
-      include LazyResource::Resource
+```ruby
+class Photo
+  include LazyResource::Resource
 
-      self.root_node_name = 'photo'
-    end
+  self.root_node_name = 'photo'
+end
+```
 
 or multiple options
 
-    class Photo
-      self.root_node_name = ['photo', 'photos']
-    end
+```ruby
+class Photo
+  include LazyResource::Resource
+
+  self.root_node_name = ['photo', 'photos']
+end
+```
+
+Parsing responses like { 'photos': ..., 'total': 100, 'page': 2, ... }
+
+```ruby
+photos = Photo.where(:user_id => 123)
+photos.other_attributes # => { 'total' => 100, 'page' => 2, ... }
+```
+
+Sending default headers or params
+
+Keep in mind that this can be accomplished by using, .e.g,
+`.where(:access_token => current_user.access_token, :headers => { :"X-Access-Token" => current_user.access_token })`,
+but I prefer this method because it keeps the logic in one place and
+doesn't litter your where calls with stuff that doesn't look
+ActiveRecord-y. Using Thread.current does seem a bit icky, but at least
+it's in one place...
+
+```ruby
+# in an around_filter or similar
+Thread.current[:default_headers] = { :"X-Access-Token" => current_user.access_token }
+Thread.current[:default_params] = { :"access_token" => current_user.access_token }
+yield
+# this is important, otherwise the headers/params could persist amongst various requests
+Thread.current[:default_headers] = nil
+Thread.current[:default_params] = nil
+```
 
 ## Contributing
 
@@ -141,12 +202,6 @@ the version number. If you want to maintain your own version, go for it,
 but put it in a separate commit so I can ignore it when I merge the rest
 of your stuff in.
 
-## It's alpha, yo
-
-I'm not using this in production anywhere (yet), so use at your own
-risk. It's got a pretty comprehensive test suite, but I'm sure there
-are at least a few bugs. If you find one, [report it](https://github.com/ahlatimer/lazy_resource/issues).
-
 ## Recognition
 
 Thanks to:

data/examples/github.rb

@@ -1,8 +1,16 @@
 require 'lazy_resource'
 require 'benchmark'
 
+class SimpleLogger
+  def info(message)
+    puts message
+  end
+end
+
 LazyResource.configure do |config|
   config.site = "https://api.github.com"
+  config.logger = SimpleLogger.new
+  config.debug = true
 end
 
 class User

data/lazy_resource.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = LazyResource::VERSION
 
-  gem.add_dependency 'activemodel', '>= 3.1.0'
-  gem.add_dependency 'activesupport', '>= 3.1.0'
+  gem.add_dependency 'activemodel', '~> 3.1'
+  gem.add_dependency 'activesupport', '~> 3.1'
   gem.add_dependency 'json', '>= 1.5.2'
-  gem.add_dependency 'typhoeus', '0.6.1'
+  gem.add_dependency 'typhoeus', '0.6.6'
 end

data/lib/lazy_resource.rb

@@ -7,6 +7,7 @@ require 'active_support'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/aliasing'
@@ -21,6 +22,8 @@ require 'active_support/core_ext/uri'
 require 'lazy_resource/version'
 require 'lazy_resource/errors'
 
+require 'lazy_resource/log_subscriber'
+
 require 'lazy_resource/ext/typhoeus'
 
 module LazyResource
@@ -55,4 +58,18 @@ module LazyResource
   def self.debug
     @debug = @debug.nil? ? false : @debug
   end
+
+  def self.max_concurrency
+    @max_concurrency ||= 200
+  end
+
+  def self.max_concurrency=(max)
+    @max_concurrency = max
+  end
+
+  def self.deprecate(message, file, line)
+    if self.logger && self.debug
+      self.logger.info "#{message} from #{file}##{line}"
+    end
+  end
 end

data/lib/lazy_resource/attributes.rb

@@ -17,7 +17,7 @@ module LazyResource
 
       def fetch_all
         self.resource_queue.send_to_request_queue! if self.respond_to?(:resource_queue)
-        self.request_queue.run if self.respond_to?(:request_queue)
+        self.request_queue.run if self.respond_to?(:request_queue) && self.request_queue.items_queued?
       end
 
       def attributes
@@ -55,13 +55,27 @@ module LazyResource
       end
 
       def create_getter(name, type, options={})
+        line = __LINE__ + 2
         method = <<-RUBY
           def #{name}
             self.class.fetch_all if !fetched
+            raise self.request_error if self.request_error.present?
         RUBY
 
+        route = options[:using] || options[:route]
+        if options[:using]
+          LazyResource.deprecate("Attribute option :using is deprecated. Please use :route instead.", __FILE__, __LINE__)
+        end
+
+        if route.is_a?(Proc)
+          route_method_name = "_#{name}_route".to_sym
+          define_method(route_method_name, route)
+          protected(route_method_name)
+          route = route_method_name
+        end
+
         if type.is_a?(Array) && type.first.include?(LazyResource::Resource)
-          if options[:using].nil?
+          if route.nil?
             method << <<-RUBY
               if @#{name}.nil?
                 @#{name} = #{type.first}.where(:"\#{self.class.element_name}_id" => self.primary_key)
@@ -69,20 +83,17 @@ module LazyResource
             RUBY
           else
             method << <<-RUBY
-              return [] if self.#{options[:using]}.nil?
-
               if @#{name}.nil?
-                @#{name} = LazyResource::Relation.new(#{type.first}, :fetched => true)
-                request = LazyResource::Request.new(self.#{options[:using]}, @#{name}, :headers => @#{name}.headers)
-                @#{name}.fetched = false
-                self.class.request_queue.queue(request)
+                route = self.respond_to?("#{route}") ? self.send("#{route}") : "#{route}"
+                route = route.is_a?(Proc) ? route.call : route
+                @#{name} = #{type.first}.where(:"\#{self.class.element_name}_id" => self.primary_key, :_route => route)
               end
 
               @#{name}
             RUBY
           end
         elsif type.include?(LazyResource::Resource)
-          if options[:using].nil?
+          if route.nil?
             method << <<-RUBY
               if @#{name}.nil?
                 @#{name} = #{type}.where(:"\#{self.class.element_name}_id" => self.primary_key)
@@ -90,12 +101,10 @@ module LazyResource
             RUBY
           else
             method << <<-RUBY
-              return [] if self.#{options[:using]}.nil?
-
               if @#{name}.nil?
-                @#{name} = #{type}.new
-                request = LazyResource::Request.new(self.#{options[:using]}, @#{name})
-                self.class.request_queue.queue(request)
+                route = self.respond_to?("#{route}") ? self.send("#{route}") : "#{route}"
+                route = route.is_a?(Proc) ? route.call : route
+                @#{name} = #{type}.where(:"\#{self.class.element_name}_id" => self.primary_key, :_route => route)
               end
 
               @#{name}
@@ -108,7 +117,7 @@ module LazyResource
           end
         RUBY
 
-        class_eval method, __FILE__, __LINE__ + 1
+        class_eval method, __FILE__, line
       end
 
       def create_question(name, type, options={})