lazy_resource 0.1.0

data/lib/lazy_resource/resource_queue.rb

@@ -0,0 +1,40 @@
+module LazyResource
+  class ResourceQueue
+    include LazyResource::UrlGeneration
+
+    def initialize
+      @queue = []
+    end
+
+    def queue(relation)
+      @queue.push(relation)
+    end
+
+    def flush!
+      @queue = []
+    end
+
+    def request_queue
+      Thread.current[:request_queue] ||= Typhoeus::Hydra.new
+    end
+
+    def run
+      send_to_request_queue!
+      request_queue.run
+    end
+
+    def send_to_request_queue!
+      while(relation = @queue.pop)
+        request = Request.new(url_for(relation), relation)
+        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
+    end
+  end
+end

data/lib/lazy_resource/types.rb

@@ -0,0 +1,53 @@
+module LazyResource
+  module Types
+    class Array < ::Array
+      def self.parse(o)
+        o.to_a
+      end
+    end
+
+    class String < ::String
+      def self.parse(o)
+        o.to_s
+      end
+    end
+
+    class Fixnum < ::Fixnum
+      def self.parse(o)
+        o.to_i
+      end
+    end
+
+    class Boolean
+      def self.parse(o)
+        if [true, '1', 'true'].include? o
+          true
+        else
+          false
+        end
+      end
+    end
+
+    class Float < ::Float
+      def self.parse(o)
+        o.to_f
+      end
+    end
+
+    class Hash < ::Hash
+      def self.parse(o)
+        o
+      end
+    end
+
+    class DateTime < ::DateTime
+      def self.parse(o)
+        if o.is_a?(::DateTime)
+          o
+        else
+          super(o)
+        end
+      end
+    end
+  end
+end

data/lib/lazy_resource/url_generation.rb

@@ -0,0 +1,98 @@
+module LazyResource
+  module UrlGeneration
+    extend ActiveSupport::Concern
+
+    def element_path(options = nil)
+      self.class.element_path(self.primary_key, options)
+    end
+
+    def element_url(options = nil)
+      url = self.class.site.to_s.gsub(/\/$/, '')
+      url << self.element_path(options)
+    end
+
+    def new_element_path
+      self.class.new_element_path
+    end
+
+    def collection_path(options = nil)
+      self.class.collection_path(options)
+    end
+
+    def collection_url(options = nil)
+      url = self.class.site.to_s.gsub(/\/$/, '')
+      url << self.collection_path(options)
+    end
+
+    def split_options(options = {})
+      self.class.split_options(options)
+    end
+
+    module ClassMethods
+      # Gets the \prefix for a resource's nested URL (e.g., <tt>prefix/collectionname/1</tt>)
+      def prefix(options={})
+        path = '/'
+        options = options.to_a.uniq
+        path = options.inject(path) do |uri, option|
+          key, value = option[0].to_s, option[1]
+          uri << ActiveSupport::Inflector.pluralize(key.gsub("_id", ''))
+          uri << "/#{value}/"
+        end
+      end
+
+      
+      # Gets the element path for the given ID in +id+. If the +query_options+ parameter is omitted, Rails
+      # will split from the \prefix options.
+      #
+      # ==== Options
+      # +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 element_path(id, prefix_options = {}, query_options = nil, from = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "#{prefix(prefix_options)}#{from || collection_name}/#{URI.escape id.to_s}#{query_string(query_options)}"
+      end
+
+      # Gets the new element path for REST resources.
+      #
+      # ==== Options
+      # * +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/new.json</tt>).
+      def new_element_path(prefix_options = {}, from = nil)
+        "#{prefix(prefix_options)}#{from || collection_name}/new"
+      end
+
+      # Gets the collection path for the REST resources. If the +query_options+ parameter is omitted, Rails
+      # will split from the +prefix_options+.
+      #
+      # ==== Options
+      # * +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)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "#{prefix(prefix_options)}#{from || collection_name}#{query_string(query_options)}"
+      end
+
+      # Builds the query string for the request.
+      def query_string(options)
+        "?#{options.to_query}" unless options.nil? || options.empty?
+      end
+
+      # split an option hash into two hashes, one containing the prefix options,
+      # and the other containing the leftovers.
+      def split_options(options = {})
+          prefix_options, query_options = {}, {}
+
+          (options || {}).each do |key, value|
+            next if key.blank?
+            (key =~ /\w*_id/ ? prefix_options : query_options)[key.to_sym] = value
+          end
+
+          [prefix_options, query_options]
+      end
+    end
+  end
+end
+

data/lib/lazy_resource/version.rb

@@ -0,0 +1,3 @@
+module LazyResource
+  VERSION = "0.1.0"
+end

data/spec/fixtures/comment.rb

@@ -0,0 +1,6 @@
+class Comment
+  include LazyResource::Resource
+
+  attribute :id, Fixnum
+  attribute :body, String
+end

data/spec/fixtures/post.rb

@@ -0,0 +1,6 @@
+class Post
+  include LazyResource::Resource
+
+  attribute :id, Fixnum
+  attribute :title, String
+end

data/spec/fixtures/user.rb

@@ -0,0 +1,9 @@
+class User
+  include LazyResource::Resource
+
+  attribute :id,   Fixnum
+  attribute :name, String
+  attribute :created_at, DateTime
+  attribute :post, Post
+  attribute :comments, [Comment]
+end

data/spec/lazy_resource/attributes_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+class AttributeObject
+  include LazyResource::Attributes
+
+  attr_accessor :fetched
+
+  def self.resource_queue
+    @resource_queue ||= LazyResource::ResourceQueue.new
+  end
+
+  def self.request_queue
+    @request_queue ||= Typhoeus::Hydra.new
+  end
+
+  def fetched?
+    @fetched
+  end
+
+  def element_name
+    "attribute_object"
+  end
+
+  def id
+    1
+  end
+end
+
+describe LazyResource::Attributes do
+  before :each do
+    AttributeObject.attribute(:name, String)
+    @foo = AttributeObject.new
+  end
+  
+  describe '.attribute' do
+    it 'adds the attribute to the attributes hash' do
+      AttributeObject.attributes[:name].should == { :type => String, :options => {} }
+    end
+    
+    it 'creates a getter method' do
+      @foo.respond_to?(:name).should == true
+    end
+
+    it 'creates a setter method' do
+      @foo.respond_to?(:name=).should == true
+    end
+
+    it 'creates a question method' do
+      @foo.respond_to?(:name?).should == true
+    end
+
+    describe 'getter' do
+      it 'runs fetch_all if the current object is not fetched' do
+        @foo.fetched = false
+        AttributeObject.should_receive(:fetch_all)
+        @foo.name
+      end
+
+      it 'does not run fetch_all if the current object is fetched' do
+        @foo.fetched = true
+        AttributeObject.should_not_receive(:fetch_all)
+        @foo.name
+      end
+
+      describe 'associations' do
+        before :each do
+          AttributeObject.attribute(:posts, [Post])
+          AttributeObject.attribute(:user, User)
+        end
+
+        it 'returns a relation with the specified where values' do
+          Post.should_receive(:where).with(:attribute_object_id => 1)
+          @foo.fetched = false
+          @foo.posts
+        end
+
+        it 'finds a singular resource' do
+          User.should_receive(:where).with(:attribute_object_id => 1)
+          @foo.fetched = false
+          @foo.user
+        end
+
+        describe ':using' 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')
+          end
+
+          it 'finds a collection using the specified url' do
+            relation = LazyResource::Relation.new(Post)
+            request = LazyResource::Request.new(@foo.posts_url, relation)
+            LazyResource::Request.should_receive(:new).with(@foo.posts_url, relation).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
+          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
+          end
+        end
+      end
+    end
+  end
+
+  describe '.primary_key_name' do
+    after :all do
+      AttributeObject.primary_key_name = 'id'
+    end
+
+    it 'defaults to id' do
+      AttributeObject.primary_key_name.should == 'id'
+    end
+
+    it 'returns the primary_key_name instance variable' do
+      AttributeObject.primary_key_name.should == AttributeObject.instance_variable_get("@primary_key_name")
+    end
+  end
+
+  describe '.primary_key_name=' do
+    after :all do
+      AttributeObject.primary_key_name = 'id'
+    end
+
+    it 'sets the primary_key_name' do
+      AttributeObject.primary_key_name = 'name'
+      AttributeObject.instance_variable_get("@primary_key_name").should == 'name'
+    end
+  end
+
+  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_url => { :type => String, :options => {} },
+                                             :user_url => { :type => String, :options => {} } }
+    end
+  end
+
+  describe '#primary_key' do
+    it 'returns the value at the primary_key_name' do
+      obj = AttributeObject.new
+      obj.primary_key.should == obj.send(AttributeObject.primary_key_name)
+    end
+  end
+end

data/spec/lazy_resource/errors_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe LazyResource::ConnectionError do
+  describe '#to_s' do
+    it 'prints a message with the response code and message' do
+      error = LazyResource::ConnectionError.new(Typhoeus::Response.new(:code => 300, :body => 'redirect'))
+      error.to_s.should match(/300/)
+      error.to_s.should match(/redirect/)
+    end
+  end
+end
+
+describe LazyResource::Redirection do
+  describe '#to_s' do
+    it 'prints the response\'s redirection location' do
+      error = LazyResource::Redirection.new(Typhoeus::Response.new(:code => 300, :body => 'redirect', :headers => { :Location => 'http://example.com' }))
+      error.to_s.should match(/example\.com/)
+    end
+  end
+end
+
+describe LazyResource::MethodNotAllowed do
+  describe '#allowed_methods' do
+    it 'prints the allowed methods' do
+      error = LazyResource::MethodNotAllowed.new(Typhoeus::Response.new(:code => 405, :headers => { 'Allow' => 'put' }))
+      error.allowed_methods.should == [:put]
+    end
+  end
+end
+
+describe LazyResource::TimeoutError do
+  describe '#new' do
+    it 'only accepts a message' do
+      error = LazyResource::TimeoutError.new('timed out')
+      error.to_s.should == 'timed out'
+    end
+  end
+end
+
+describe LazyResource::SSLError do
+  describe '#new' do
+    it 'only accepts a message' do
+      error = LazyResource::SSLError.new('timed out')
+      error.to_s.should == 'timed out'
+    end
+  end
+end
+

data/spec/lazy_resource/mapping_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+class Foo
+  include LazyResource::Mapping
+  include LazyResource::Types
+
+  attr_accessor :id, :name, :created_at, :post, :comments, :comments_text
+
+  def self.attributes
+    @attributes ||= {
+      :id => { :type => Fixnum },
+      :name => { :type => String },
+      :created_at => { :type => DateTime },
+      :post => { :type => Bar },
+      :comments => { :type => [Buzz] },
+      :comments_text => { :type => [String] }
+    }
+  end
+end
+
+class Bar
+  include LazyResource::Mapping
+  include LazyResource::Types
+
+  attr_accessor :title
+
+  def self.attributes
+    @attributes ||= {
+      :title => { :type => String }
+    }
+  end
+end
+
+class Buzz
+  include LazyResource::Mapping
+  include LazyResource::Types
+
+  attr_accessor :body
+
+  def self.attributes
+    @attributes ||= {
+      :body => { :type => String }
+    }
+  end
+end
+
+describe LazyResource::Mapping do
+  describe '.load' do
+    before :each do 
+      @now = DateTime.now
+      @now_as_sting = @now.to_s
+      @post = Bar.new
+      @post.title = "Lorem Ipsum"
+      @comments = []
+      4.times do
+        comment = Buzz.new
+        comment.body = "Lorem Ipsum"
+        @comments << comment
+      end
+    end
+
+    it 'loads single objects' do
+      user = Foo.load({
+        :id => 123, 
+        :name => 'Andrew',
+        :created_at => @now,
+        :post => @post,
+        :comments => @comments
+      })
+
+      user.id.should == 123
+      user.name.should == 'Andrew'
+      user.created_at.should == @now
+      user.post.should == @post
+      user.comments.should == @comments
+    end
+
+    it 'loads an array of objects' do
+      users = Foo.load([
+        {
+          :id => 123
+        },
+        {
+          :id => 123
+        }
+      ])
+
+      users.each do |user|
+        user.id.should == 123
+      end
+    end
+  end
+
+  describe '.root_node_name' do
+    after :each do
+      LazyResource::Mapping.root_node_name = nil
+      Foo.root_node_name = nil
+    end
+
+    it 'defaults to nil' do
+      Foo.root_node_name.should == nil
+    end
+
+    it 'specifies the root node name' do
+      Foo.root_node_name = :data
+      Foo.root_node_name.should == :data
+    end
+
+    it 'maps the object at that value' do
+      Foo.root_node_name = :data
+      user = Foo.load({ 'data' => { :id => 123 } })
+      user.id.should == 123
+    end
+
+    it 'maps objects without root node names, even if a root node name is defined' do
+      Foo.root_node_name = :data
+      user = Foo.load({ :id => 123 })
+      user.id.should == 123
+    end
+
+    it 'maps collections at the root node name' do
+      Foo.root_node_name = :data
+      users = Foo.load({ 'data' => [{ :id => 123 }, { :id => 124 }]})
+      users.map(&:id).should == [123,124]
+    end
+
+    it 'maps collections without root node names, even if a root node name is defined' do
+      Foo.root_node_name = :data
+      users = Foo.load([{ :id => 123 }, { :id => 124 }])
+      users.map(&:id).should == [123,124]
+    end
+    
+    it 'looks in the module for the root node name' do
+      LazyResource::Mapping.root_node_name = :data
+      Foo.root_node_name.should == :data
+    end
+
+    it 'handles root node names that are strings or symbols' do
+      Foo.root_node_name = :data
+      user = Foo.load('data' => { :id => 123 })
+      user.id.should == 123
+      Foo.root_node_name = 'data'
+      user = Foo.load('data' => { :id => 123 })
+      user.id.should == 123
+    end
+  end
+
+  describe '#load' do
+    before :each do 
+      @now = DateTime.now
+      @now_as_string = @now.to_s
+      @post = Bar.new
+      @post.title = "Lorem Ipsum"
+      @comments = []
+      4.times do
+        comment = Buzz.new
+        comment.body = "Lorem Ipsum"
+        @comments << comment
+      end
+    end
+
+    it 'loads attributes' do
+      user = Foo.new
+      user.load({ :name => 'Bob' })
+      user.name.should == 'Bob'
+    end
+
+    it 'overwrites existing attributes' do
+      user = Foo.new
+      user.name = 'Andrew'
+      user.load({ :name => 'Bob' })
+      user.name.should == 'Bob'
+    end
+
+    it 'loads objects based on their type in the attributes method' do
+      user = Foo.new
+      user.load({
+        :id => "123",
+        :name => "Andrew",
+        :created_at => @now_as_string
+      })
+
+      user.id.should == 123
+      user.name.should == 'Andrew'
+      user.created_at.to_s.should == @now_as_string
+    end
+
+    it 'loads associations' do
+      user = Foo.new
+      user.load({
+        :post => {
+          :title => 'Lorem Ipsum'
+        }
+      })
+
+      user.post.title.should == 'Lorem Ipsum'
+    end
+
+    it 'loads association arrays' do
+      user = Foo.new
+      user.load({
+        :comments => [
+          { :body => 'Lorem Ipsum' },
+          { :body => 'Lorem Ipsum' }
+        ]
+      })
+
+      user.comments.each do |comment|
+        comment.body.should == 'Lorem Ipsum'
+      end
+    end
+
+    it 'loads arrays' do
+      user = Foo.new
+      user.load({
+        :comments_text => [
+          'Lorem Ipsum',
+          'Lorem Ipsum'
+        ]
+      })
+
+      user.comments_text.each do |comment|
+        comment.should == 'Lorem Ipsum'
+      end
+    end
+
+    it 'skips unknown attributes' do
+      user = Foo.new
+      user.load({
+        :fizz => '',
+        :name => 'Andrew'
+      })
+
+      user.name.should == 'Andrew'
+    end
+  end
+end