lazy_resource 0.1.0

data/lib/lazy_resource/errors.rb

@@ -0,0 +1,72 @@
+module LazyResource
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      message = "Failed."
+      message << "  Response code = #{response.code}." if response.respond_to?(:code)
+      message << "  Response message = #{response.body}." if response.respond_to?(:body)
+      message
+    end
+  end
+
+  # Raised when a Timeout::Error occurs.
+  class TimeoutError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # Raised when a OpenSSL::SSL::SSLError occurs.
+  class SSLError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # 3xx Redirection
+  class Redirection < ConnectionError # :nodoc:
+    def to_s; (response.headers['Location'] || response.headers[:Location]) ? "#{super} => #{response.headers['Location'] || response.headers[:Location]}" : super; end
+  end
+
+  # 4xx Client Error
+  class ClientError < ConnectionError; end # :nodoc:
+
+  # 400 Bad Request
+  class BadRequest < ClientError; end # :nodoc
+
+  # 401 Unauthorized
+  class UnauthorizedAccess < ClientError; end # :nodoc
+
+  # 403 Forbidden
+  class ForbiddenAccess < ClientError; end # :nodoc
+
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 410 Gone
+  class ResourceGone < ClientError; end # :nodoc:
+  
+  # 422 Unprocessable Entity
+  class UnprocessableEntity < ClientError; end # :nodoc:
+
+  # 5xx Server Error
+  class ServerError < ConnectionError; end # :nodoc:
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+    def allowed_methods
+      @response.headers['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+    end
+  end
+end

data/lib/lazy_resource/http_mock.rb

@@ -0,0 +1,23 @@
+module LazyResource
+  class HttpMock
+    class Responder
+      [:post, :put, :get, :delete].each do |method|
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(path, body='', status=200, response_headers={})
+            request_queue.stub(:#{method}, path).and_return(Typhoeus::Response.new(:code => status, :headers => response_headers, :body => body, :time => 0.3))
+          end
+        RUBY
+      end
+
+      def request_queue
+        Thread.current[:request_queue] ||= Typhoeus::Hydra.new
+      end
+    end
+
+    class << self
+      def respond_to(*args)
+        yield Responder.new
+      end
+    end
+  end
+end

data/lib/lazy_resource/mapping.rb

@@ -0,0 +1,73 @@
+module LazyResource
+  module Mapping
+    extend ActiveSupport::Concern
+
+    attr_accessor :fetched, :persisted
+
+    def fetched?
+      @fetched
+    end
+
+    def self.root_node_name=(node)
+      @root_node_name = node
+    end
+
+    def self.root_node_name
+      @root_node_name
+    end
+
+    module ClassMethods
+      def root_node_name=(node)
+        @root_node_name = node
+      end
+
+      def root_node_name
+        @root_node_name || LazyResource::Mapping.root_node_name
+      end
+
+      def load(objects)
+        if objects.is_a?(Array)
+          objects.map do |object|
+            self.new.load(object)
+          end
+        else
+          if self.root_node_name && objects.key?(self.root_node_name.to_s)
+            self.load(objects[self.root_node_name.to_s])
+          else
+            self.new.load(objects)
+          end
+        end
+      end
+    end
+
+    def load(hash, persisted=true)
+      hash.fetched = true and return hash if hash.kind_of?(LazyResource::Mapping)
+
+      self.tap do |resource|
+        resource.persisted = persisted
+        resource.fetched = false
+        
+        hash = hash[resource.class.root_node_name.to_s] if resource.class.root_node_name && hash.key?(resource.class.root_node_name.to_s)
+        hash.each do |name, value|
+          attribute = self.class.attributes[name.to_sym]
+          next if attribute.nil?
+
+          type = attribute[:type]
+          if type.is_a?(::Array)
+            if type.first.include?(LazyResource::Mapping)
+              resource.send(:"#{name}=", type.first.load(value))
+            else
+              resource.send(:"#{name}=", value.map { |object| type.first.parse(object) })
+            end
+          elsif type.include?(LazyResource::Mapping)
+            resource.send(:"#{name}=", type.load(value))
+          else
+            resource.send(:"#{name}=", type.parse(value)) rescue StandardError
+          end
+        end
+
+        resource.fetched = true
+      end
+    end
+  end
+end

data/lib/lazy_resource/relation.rb

@@ -0,0 +1,132 @@
+require 'active_support/core_ext/hash/slice'
+
+module LazyResource
+  class Relation
+    class << self
+      def resource_queue
+        Thread.current[:resource_queue] ||= ResourceQueue.new
+      end
+    end
+
+    attr_accessor :fetched, :klass, :values, :from, :site
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @values = options.slice(:where_values, :order_value, :limit_value, :offset_value, :page_value)
+      @fetched = options[:fetched] || false
+      unless fetched?
+        resource_queue.queue(self)
+      end
+
+      self
+    end
+
+    def from
+      @from || self.klass.collection_name
+    end
+
+    def collection_name
+      from
+    end
+
+    def to_params
+      params = {}
+      params.merge!(where_values) unless where_values.nil?
+      params.merge!(:order => order_value) unless order_value.nil?
+      params.merge!(:limit => limit_value) unless limit_value.nil?
+      params.merge!(:offset => offset_value) unless offset_value.nil?
+      params.merge!(:page => page_value) unless page_value.nil?
+      params
+    end
+
+    def load(objects)
+      @fetched = true
+      @result = @klass.load(objects)
+    end
+
+    def resource_queue
+      self.class.resource_queue
+    end
+
+    def where(where_values)
+      if @values[:where_values].nil?
+        @values[:where_values] = where_values
+      else
+        @values[:where_values].merge!(where_values)
+      end
+
+      self
+    end
+
+    def order(order_value)
+      @values[:order_value] = order_value
+      self
+    end
+
+    def limit(limit_value)
+      @values[:limit_value] = limit_value
+      self
+    end
+
+    def offset(offset_value)
+      @values[:offset_value] = offset_value
+      self
+    end
+
+    def page(page_value)
+      @values[:page_value] = page_value
+      self
+    end
+
+    def where_values
+      @values[:where_values]
+    end
+
+    def order_value
+      @values[:order_value] 
+    end
+
+    def limit_value
+      @values[:limit_value]
+    end
+
+    def offset_value
+      @values[:offset_value]
+    end
+
+    def page_value
+      @values[:page_value]
+    end
+
+    def fetched?
+      @fetched
+    end
+
+    def to_a
+      resource_queue.run if !fetched?
+      result
+    end
+
+    def result
+      @result ||= []
+    end
+
+    def respond_to?(method, include_private = false)
+      super || result.respond_to?(method, include_private)
+    end
+
+    def as_json(options = {})
+      to_a.map do |record|
+        record.as_json
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if result.respond_to?(name)
+        self.to_a.send(name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lazy_resource/request.rb

@@ -0,0 +1,63 @@
+module LazyResource
+  class Request < Typhoeus::Request
+    SUCCESS_STATUSES = [200, 201]
+
+    attr_accessor :resource, :response
+
+    def initialize(url, resource, options={})
+      options = options.dup
+      options[:headers] ||= {}
+      options[:headers][:Accept] ||= 'application/json'
+      options[:headers].merge!(Thread.current[:default_headers]) unless Thread.current[:default_headers].nil?
+      options[:method] ||= :get
+
+      super(url, options)
+
+      @resource = resource
+      self.on_complete = on_complete_proc
+
+      self
+    end
+
+    def on_complete_proc
+      Proc.new do |response|
+        @response = response
+        handle_errors unless SUCCESS_STATUSES.include?(@response.code)
+        parse
+      end
+    end
+
+    def parse
+      unless self.response.body.nil? || self.response.body == ''
+        @resource.load(JSON.parse(self.response.body))
+      end
+    end
+
+    def handle_errors
+      case @response.code
+      when 300...400
+        raise Redirection.new(@response)
+      when 400
+        raise BadRequest.new(@response)
+      when 401
+        raise UnauthorizedAccess.new(@response)
+      when 403
+        raise ForbiddenAccess.new(@response)
+      when 404
+        raise ResourceNotFound.new(@response)
+      when 405
+        raise MethodNotAllowed.new(@response)
+      when 409
+        raise ResourceConflict.new(@response)
+      when 410
+        raise ResourceGone.new(@response)
+      when 422
+        raise UnprocessableEntity.new(@response)
+      when 400...500
+        raise ClientError.new(@response)
+      when 500...600
+        raise ServerError.new(@response)
+      end
+    end
+  end
+end

data/lib/lazy_resource/resource.rb

@@ -0,0 +1,197 @@
+module LazyResource
+  module Resource
+    extend ActiveSupport::Concern
+    include ActiveModel::Conversion
+    include Attributes, Mapping, Types, UrlGeneration
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :create, :update, :save, :destroy
+
+      include ActiveModel::Validations
+    end
+
+    def self.site=(site)
+      @site = site
+    end
+
+    def self.site
+      @site
+    end
+
+    def self.root_node_name=(node_name)
+      LazyResource::Mapping.root_node_name = node_name
+    end
+
+    module ClassMethods
+      # Gets the URI of the REST resources to map for this class.  The site variable is required for
+      # Active Async's mapping to work.
+      def site
+        if defined?(@site)
+          @site
+        else
+          LazyResource::Resource.site
+        end
+      end
+
+      # Sets the URI of the REST resources to map for this class to the value in the +site+ argument.
+      # The site variable is required for Active Async's mapping to work.
+      def site=(site)
+        @site = site
+      end
+
+      def request_queue
+        Thread.current[:request_queue] ||= Typhoeus::Hydra.new
+      end
+
+      def find(id, params={}, options={})
+        self.new(self.primary_key_name => id).tap do |resource|
+          resource.fetched = false
+          resource.persisted = true
+          request = Request.new(resource.element_url(params), resource, options)
+          request_queue.queue(request)
+        end
+      end
+
+      def where(where_values)
+        Relation.new(self, :where_values => where_values)
+      end
+
+      def order(order_value)
+        Relation.new(self, :order_value => order_value)
+      end
+
+      def limit(limit_value)
+        Relation.new(self, :limit_value => limit_value)
+      end
+
+      def offset(offset_value)
+        Relation.new(self, :offset_value => offset_value)
+      end
+      
+      def page(page_value)
+        Relation.new(self, :page_value => page_value)
+      end
+
+      def all
+        Relation.new(self)
+      end
+
+      def create(attributes={})
+        new(attributes).tap do |resource|
+          resource.create
+        end
+      end
+    end
+
+    def initialize(attributes={})
+      self.tap do |resource|
+        resource.load(attributes, false)
+      end
+    end
+
+    # Tests for equality. Returns true iff +other+ is the same object or
+    # other is an instance of the same class and has the same attributes.
+    def ==(other)
+      return true if other.equal?(self)
+      return false unless other.instance_of?(self.class)
+
+      self.class.attributes.inject(true) do |memo, attribute|
+        attribute_name = attribute.first
+        attribute_type = attribute.last[:type]
+
+        # Skip associations
+        if attribute_type.include?(LazyResource::Resource) || (attribute_type.is_a?(::Array) && attribute_type.first.include?(LazyResource::Resource))
+          memo
+        else
+          memo && self.send(:"#{attribute_name}") == other.send(:"#{attribute_name}")
+        end
+      end
+    end
+    
+    def eql?(other)
+      self == other
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    alias :new? :new_record?
+
+    def save
+      return true if !changed?
+      run_callbacks :save do
+        new_record? ? create : update
+        self.persisted = true
+      end
+    end
+
+    def create
+      run_callbacks :create do
+        request = Request.new(self.collection_url, self, { :method => :post, :params => attribute_params })
+        self.class.request_queue.queue(request)
+        self.class.fetch_all
+        self.changed_attributes.clear
+      end
+    end
+
+    def update
+      run_callbacks :update do
+        request = Request.new(self.element_url, self, { :method => :put, :params => attribute_params })
+        self.class.request_queue.queue(request)
+        self.class.fetch_all
+        self.changed_attributes.clear
+      end
+    end
+
+    def destroy
+      run_callbacks :destroy do
+        request = Request.new(self.element_url, self, { :method => :delete })
+        self.class.request_queue.queue(request)
+        self.class.fetch_all
+      end
+    end
+
+    def update_attributes(attributes={})
+      attributes.each do |name, value|
+        self.send("#{name}=", value)
+      end
+      self.update
+    end
+
+    def attribute_params
+      { self.class.element_name.to_sym => changed_attributes.inject({}) do |hash, changed_attribute|
+        hash.tap do |hash|
+          hash[changed_attribute.first] = self.send(changed_attribute.first)
+        end
+      end }
+    end
+
+    def as_json(options={})
+      self.class.attributes.inject({}) do |hash, (attribute_name, attribute_options)|
+        attribute_type = attribute_options[:type]
+
+        # Skip nil attributes (need to use instance_variable_get to avoid the stub relations that get added for associations."
+        unless self.instance_variable_get("@#{attribute_name}").nil?
+          value = self.send(:"#{attribute_name}")
+
+          if (attribute_type.is_a?(::Array) && attribute_type.first.include?(LazyResource::Resource))
+            value = value.map { |v| v.as_json }
+          elsif attribute_type.include?(LazyResource::Resource)
+            value = value.as_json
+          elsif attribute_type == DateTime
+            value = value.to_s
+          end
+
+          hash[attribute_name.to_sym] = value
+        end
+        hash
+      end
+    end
+  end
+end