acfs 0.2.0 → 0.3.0

data/lib/acfs/model/attributes/integer.rb

@@ -0,0 +1,18 @@
+module Acfs::Model
+  module Attributes
+
+    # Integer attribute type. Use it in your model as an attribute type:
+    #
+    #   class User
+    #     include Acfs::Model
+    #     attribute :name, :integer
+    #   end
+    #
+    module Integer # :nodoc:
+
+      def self.cast(obj)
+        obj.to_i
+      end
+    end
+  end
+end

data/lib/acfs/model/attributes/string.rb

@@ -0,0 +1,18 @@
+module Acfs::Model
+  module Attributes
+
+    # String attribute type. Use it in your model as an attribute type:
+    #
+    #   class User
+    #     include Acfs::Model
+    #     attribute :name, :string
+    #   end
+    #
+    module String # :nodoc:
+
+      def self.cast(obj)
+        obj.to_s
+      end
+    end
+  end
+end

data/lib/acfs/{initialization.rb → model/initialization.rb}

@@ -1,4 +1,7 @@
-module Acfs
+module Acfs::Model
+
+  # Initialization drop-in for pre-4.0 ActiveModel.
+  #
   module Initialization
 
     # Initializes a new model with the given +params+.

data/lib/acfs/model/loadable.rb

@@ -0,0 +1,18 @@
+module Acfs::Model
+
+  module Loadable
+    extend ActiveSupport::Concern
+
+    # Check if model is loaded or if request is still queued.
+    #
+    def loaded?
+      !!@loaded
+    end
+
+    # Mark model as loaded.
+    #
+    def loaded!
+      @loaded = true
+    end
+  end
+end

data/lib/acfs/model/locatable.rb

@@ -0,0 +1,24 @@
+module Acfs::Model
+
+  # Provide methods for generation URLs for resources.
+  #
+  # Example
+  #   class User
+  #     service AccountService # With base URL `http://acc.svr`
+  #   end
+  #   User.url             #=> "http://acc.svr/users"
+  #   User.url(5)          #=> "http://acc.svr/users/5"
+  #
+  module Locatable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Return URL for this resource.
+      #
+      def url(suffix = nil)
+        service.url_for(self, suffix: suffix)
+      end
+    end
+  end
+end

data/lib/acfs/model/query_methods.rb

@@ -0,0 +1,66 @@
+module Acfs::Model
+
+  # Methods providing the query interface for finding resouces.
+  #
+  # Example
+  #   class MyUser
+  #     include Acfs::Model
+  #   end
+  #
+  #   MyUser.find(5)               # Find single resource
+  #   MyUser.all                   # Full or partial collection of
+  #                                # resources
+  #   Comment.where(user: user.id) # Collection with additional parameter
+  #                                # to filter resources
+  #
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Try to load a resource by given id.
+      #
+      # Example
+      #   User.find(5) # Will query `http://base.url/users/5`
+      #
+      def find(id, options = {}, &block)
+        model = self.new
+
+        request = case id
+                    when Hash
+                      Acfs::Request.new url, params: id
+                    else
+                      Acfs::Request.new url(id.to_s)
+                  end
+
+        service.queue(request) do |response|
+          model.attributes = response.data
+          model.loaded!
+          block.call model unless block.nil?
+        end
+
+        model
+      end
+
+      # Try to load all resources.
+      #
+      def all(params = {}, &block)
+        collection = ::Acfs::Collection.new
+
+        service.queue(Acfs::Request.new(url, params: params)) do |response|
+          response.data.each do |obj|
+            collection << self.new.tap do |m|
+              m.attributes = obj
+              m.loaded!
+            end
+          end
+          collection.loaded!
+          block.call collection unless block.nil?
+        end
+
+        collection
+      end
+      alias :where :all
+    end
+  end
+end

data/lib/acfs/model/relations.rb

@@ -0,0 +1,10 @@
+module Acfs::Model
+
+  module Relations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+    end
+  end
+end

data/lib/acfs/model/service.rb

@@ -0,0 +1,29 @@
+module Acfs::Model
+
+  # Included by Acfs::Model. Allows a model to belong to a service.
+  #
+  module Service
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Link to service this model belongs to. Connection settings like base URL
+      # are fetched from service. Return assigned service if no arguments are given.
+      #
+      # Example
+      #   class AccountService < Acfs::Client
+      #     self.base_url = 'http://acc.serv.org'
+      #   end
+      #
+      #   class MyUser
+      #     service AccountService
+      #   end
+      #   MyUser.find 5 # Will fetch `http://acc.serv.org/users/5`
+      #
+      def service(klass = nil, options = {})
+        return @service unless klass
+        @service = klass.new options
+      end
+    end
+  end
+end

data/lib/acfs/request.rb

@@ -0,0 +1,33 @@
+require 'acfs/request/callbacks'
+
+module Acfs
+
+  class Request
+    attr_accessor :body, :format
+    attr_reader :url, :headers, :params, :data
+
+    include Request::Callbacks
+
+    def initialize(url, options = {})
+      @url = URI.parse(url).tap do |url|
+        @data    = options.delete(:data) || nil
+        @format  = options.delete(:format) || :json
+        @headers = options.delete(:headers) || {}
+        @params  = options.delete(:params) || {}
+
+        url.query = nil # params.any? ? params.to_param : nil
+      end.to_s
+    end
+
+    def data?
+      !data.nil?
+    end
+
+    class << self
+      def new(*attrs)
+        return attrs[0] if attrs[0].is_a? self
+        super
+      end
+    end
+  end
+end

data/lib/acfs/request/callbacks.rb

@@ -0,0 +1,46 @@
+module Acfs
+  class Request
+
+    # Module containing callback handling for Requests.
+    # Current the only callback type is `on_complete`:
+    #
+    #   request = Request.new 'URL'
+    #   request.on_complete { |response| ... }
+    #
+    module Callbacks
+
+      # Add a new `on_complete` callback for this request.
+      #
+      # @example Set on_complete.
+      #   request.on_complete { |response| print response.body }
+      #
+      # @param [ Block ] block The callback block to execute.
+      #
+      # @yield [ Acfs::Response ]
+      #
+      # @return [ Acfs::Request ] The request itself.
+      #
+      def on_complete(&block)
+        callbacks << block if block_given?
+        self
+      end
+
+      # Return array of all callbacks.
+      #
+      # @return [ Array<Block> ] All callbacks.
+      #
+      def callbacks
+        @callbacks ||= []
+      end
+
+      # Trigger all callback for given response.
+      #
+      # @return [ Acfs::Request ] The request itself.
+      #
+      def complete!(response)
+        callbacks.each { |cb| cb.call response }
+        self
+      end
+    end
+  end
+end

data/lib/acfs/response.rb

@@ -0,0 +1,21 @@
+require 'acfs/response/formats'
+
+module Acfs
+
+  # This represents a response. In addition to an standard HTTP
+  # it has a field `data` for storing the encoded body.
+  #
+  class Response
+    attr_accessor :data
+    attr_reader :request, :status, :headers, :body
+
+    include Response::Formats
+
+    def initialize(request, status = 200, headers = {}, body = nil)
+      @request = request
+      @status  = status
+      @headers = headers
+      @body    = body
+    end
+  end
+end

data/lib/acfs/response/formats.rb

@@ -0,0 +1,12 @@
+module Acfs
+  class Response
+
+    # Quick accessors for format handling.
+    module Formats
+
+      def json?
+        headers['Content-Type'] == 'application/json'
+      end
+    end
+  end
+end

data/lib/acfs/service.rb

@@ -0,0 +1,30 @@
+module Acfs
+
+  # Service object.
+  #
+  class Service
+    attr_accessor :options
+    class_attribute :base_url
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def options
+      @options
+    end
+
+    def url_for(resource_class, options = {})
+      options.reverse_merge! self.options
+
+      url  = self.class.base_url.to_s
+      url += "/#{(options[:path] || resource_class.name.pluralize.underscore).to_s}"
+      url += "/#{options[:suffix].to_s}" if options[:suffix]
+      url
+    end
+
+    def queue(request, &block)
+      Acfs.queue request, &block
+    end
+  end
+end

data/lib/acfs/version.rb

@@ -1,7 +1,7 @@
 module Acfs
   module VERSION
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     PATCH = 0
     STAGE = nil
 

data/spec/acfs/middleware/json_decoder_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Acfs::Middleware::JsonDecoder do
+  let(:data)     { [{id: 1, name: "Anon"},{id: 2, name:"John", friends: [ 1 ]}] }
+  let(:body)     { data.to_param }
+  let(:headers)  { {} }
+  let(:request)  { Acfs::Request.new "fubar" }
+  let(:response) { Acfs::Response.new request, 200, headers, body }
+  let(:decoder)  { Acfs::Middleware::JsonDecoder.new lambda { |req| req } }
+
+  before do
+    decoder.call request
+  end
+
+  context 'with JSON response' do
+    let(:headers) { { 'Content-Type' => 'application/json' } }
+    let(:body)    { data.to_json }
+
+    it 'should decode body data' do
+      request.complete! response
+
+      expect(response.data).to be == data.map(&:stringify_keys)
+    end
+  end
+
+  context 'with invalid JSON response' do
+    let(:headers) { { 'Content-Type' => 'application/json' } }
+    let(:body)    { data.to_json[4..-4] }
+
+    it 'should raise an error' do
+      expect { request.complete! response }.to raise_error(MultiJson::LoadError)
+    end
+  end
+
+  context 'without JSON response' do
+    let(:headers) { { 'Content-Type' => 'application/text' } }
+    let(:body)    { data.to_json }
+
+    it 'should not decode non-JSON encoded responses' do
+      request.complete! response
+
+      expect(response.data).to be_nil
+    end
+  end
+end

data/spec/acfs/request/callbacks_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Acfs::Request::Callbacks do
+  let(:callback) { lambda { |res| } }
+  let(:request)  { Acfs::Request.new('fubar') }
+
+  describe '#on_complete' do
+    it 'should store a given callback' do
+      request.on_complete &callback
+
+      expect(request.callbacks).to have(1).item
+      expect(request.callbacks[0]).to be == callback
+    end
+
+    it 'should store multiple callback' do
+      request.on_complete { |res| "abc" }
+      request.on_complete &callback
+
+      expect(request.callbacks).to have(2).item
+      expect(request.callbacks[1]).to be == callback
+    end
+  end
+
+  describe '#complete!' do
+    let(:response) { Acfs::Response.new(request) }
+
+    it 'should trigger registered callbacks with given response' do
+      callback.should_receive(:call).with(response)
+
+      request.on_complete &callback
+      request.complete! response
+    end
+  end
+end