action_kit_rest 0.1.1

data/lib/action_kit_rest/base.rb

@@ -0,0 +1,37 @@
+module ActionKitRest
+  class Base < Vertebrae::Model
+
+    def list(filters = {})
+      client.get_request(normalized_base_path, filters)
+    end
+
+    def get(id)
+      client.get_request("#{normalized_base_path}#{id}/")
+    end
+
+    def create(params)
+      resp = client.post_json_request(normalized_base_path, params)
+      id = extract_id_from_response(resp)
+      get(id)
+    end
+
+    def update(id, params)
+      client.put_json_request("#{normalized_base_path}#{id}/", params)
+      get(id)
+    end
+
+    def normalized_base_path
+      "#{base_path}/"
+    end
+
+    private
+
+    def extract_id_from_response(resp)
+      extract_id_from_location(resp.response.headers["location"])
+    end
+
+    def extract_id_from_location(location)
+      location.scan(/\/(\d+)\/$/).first.first
+    end
+  end
+end

data/lib/action_kit_rest/client.rb

@@ -0,0 +1,35 @@
+require 'action_kit_rest/api'
+
+module ActionKitRest
+  class Client < API
+
+    def page
+      @page ||= ActionKitRest::Page.new(client: self)
+    end
+
+    def import_page
+      @import_page ||= ActionKitRest::Pages::ImportPage.new(client: self)
+    end
+
+    def signup_page
+      @signup_page ||= ActionKitRest::Pages::SignupPage.new(client: self)
+    end
+
+    def action
+      @action ||= ActionKitRest::Action.new(client: self)
+    end
+
+    def tag
+      @tag ||= ActionKitRest::Tag.new(client: self)
+    end
+    
+    def list
+      @list ||= ActionKitRest::List.new(client: self)
+    end
+    
+    def user
+      @user ||= ActionKitRest::User.new(client: self)
+    end
+
+  end
+end

data/lib/action_kit_rest/list.rb

@@ -0,0 +1,12 @@
+module ActionKitRest
+  class List < Base
+    def base_path
+      'list'
+    end
+
+    def find(name)
+      response = list(name: name)
+      response.obj.first
+    end
+  end
+end

data/lib/action_kit_rest/page.rb

@@ -0,0 +1,11 @@
+module ActionKitRest
+  class Page < Vertebrae::Model
+    def list
+      client.get_request("page/")
+    end
+
+    def get(id)
+      client.get_request("page/#{id}/")
+    end
+  end
+end

data/lib/action_kit_rest/pages/base.rb

@@ -0,0 +1,20 @@
+module ActionKitRest
+  module Pages
+    class Base < ActionKitRest::Base
+      # allows finding by name
+      def find(name)
+        response = list(name: name)
+        response.obj.first
+      end
+      
+      def find_or_create(params)
+        page = find(params[:name])
+        if page.blank?
+          page = create(params)
+        end
+        page
+      end
+    end
+  end
+end
+

data/lib/action_kit_rest/pages/import_page.rb

@@ -0,0 +1,9 @@
+module ActionKitRest
+  module Pages
+    class ImportPage < ActionKitRest::Pages::Base
+      def base_path
+        'importpage'
+      end
+    end
+  end
+end

data/lib/action_kit_rest/pages/signup_page.rb

@@ -0,0 +1,9 @@
+module ActionKitRest
+  module Pages
+    class SignupPage < ActionKitRest::Pages::Base
+      def base_path
+        'signuppage'
+      end
+    end
+  end
+end

data/lib/action_kit_rest/railties.rb

@@ -0,0 +1,7 @@
+module ActionKitRest
+  class Railties < ::Rails::Railtie
+    initializer 'Rails logger' do
+      ActionKitRest.logger = Rails.logger
+    end
+  end
+end

data/lib/action_kit_rest/response/collection.rb

@@ -0,0 +1,25 @@
+# A class responsible for proxing to faraday response &
+# or a pagination collection.
+module ActionKitRest
+  module Response
+    class Collection
+      include Enumerable
+
+      attr_reader :meta
+      attr_reader :objects
+
+
+      def initialize(meta, objects)
+        @meta = meta
+        @objects = objects
+      end
+
+      def each(&block)
+        # todo handle pagination somehow!
+        objects.each do |o|
+          block.call(o)
+        end
+      end
+    end
+  end
+end

data/lib/action_kit_rest/response/raise_error.rb

@@ -0,0 +1,25 @@
+module ActionKitRest
+  module Response
+    class RaiseError < Faraday::Response::Middleware
+
+      def on_complete(response)
+        status_code = response[:status].to_i
+        if (400...600).include? status_code
+          if status_code == 400
+            raise ActionKitRest::Response::ValidationError.new(url: response[:url].to_s, body: response[:body])
+          elsif status_code == 404
+            raise ActionKitRest::Response::NotFound.new(response[:url].to_s)
+          else
+            raise Exception.new(error_message(response))
+          end
+        end
+      end
+
+      def error_message(response)
+        "#{response[:method].to_s.upcase} #{response[:url].to_s}: #{response[:status]} \n\n #{response[:body] if response[:body]}"
+      end
+    end
+
+    class NotFound < Exception ; end
+  end # Response::RaiseError
+end

data/lib/action_kit_rest/response/validation_error.rb

@@ -0,0 +1,19 @@
+module ActionKitRest
+  module Response
+    class ValidationError < StandardError
+      attr_accessor :errors, :url, :body
+
+      def initialize(params)
+        self.url = params[:url]
+        self.body = params[:body]
+        self.errors = JSON.parse(params[:body])['errors']
+        super()
+      end
+
+      def to_s
+        "#{super()} \n url: #{url} \n body: #{body} \n errors: #{errors}"
+      end
+      
+    end
+  end
+end

data/lib/action_kit_rest/response/wrapper.rb

@@ -0,0 +1,120 @@
+module ActionKitRest
+  module Response
+    class Wrapper
+      include Enumerable
+      extend Forwardable
+
+      attr_reader :response
+      attr_reader :kind
+      attr_reader :obj
+
+      def_delegators :body, :empty?, :size, :include?, :length, :to_a, :first, :flatten, :include?, :keys, :[]
+
+      def initialize(response)
+        @response    = response
+
+        if response.body.respond_to?(:meta) && response.body.meta
+          @kind = :collection
+          @obj = ActionKitRest::Response::Collection.new(response.body.meta, response.body.objects)
+        else
+          @kind = :object
+          @obj = response.body
+        end
+      end
+
+      def collection?
+        kind == :collection
+      end
+
+      def object?
+        kind == :object
+      end
+
+      # Request url
+      def url
+        response.env[:url].to_s
+      end
+
+      def body=(value)
+        @body = value
+        @env[:body] = value
+      end
+
+      # Response raw body
+      def body
+        @body ? @body : response.body
+      end
+
+      # Response status
+      def status
+        response.status
+      end
+
+      def success?
+        response.success?
+      end
+
+      def redirect?
+        status.to_i >= 300 && status.to_i < 400
+      end
+
+      def client_error?
+        status.to_i >= 400 && status.to_i < 500
+      end
+
+      def server_error?
+        status.to_i >= 500 && status.to_i < 600
+      end
+
+      # Lookup an attribute from the body if hash, otherwise behave like array index.
+      # Convert any key to string before calling.
+      #
+      def [](key)
+        if self.body.is_a?(Array)
+          self.body[key]
+        else
+          self.body.send(:"#{key}")
+        end
+      end
+
+      # Return response body as string
+      #
+      def to_s
+        body.to_s
+      end
+
+      # Convert the ResponseWrapper into a Hash
+      #
+      def to_hash
+        body.to_hash
+      end
+
+      # Convert the ResponseWrapper into an Array
+      #
+      def to_ary
+        body.to_ary
+      end
+
+      # if a raw object, just delegate
+      def method_missing(method_name, *args, &block)
+        if object?
+          obj.send(method_name, &block)
+        else
+          super
+        end
+      end
+
+      # Iterate over each resource inside the collection
+      #
+      def each(&block)
+        if collection?
+          obj.each do |o|
+            block.call(o)
+          end
+        else
+          raise("can only iterate over collections")
+        end
+      end
+    end
+  end
+end

data/lib/action_kit_rest/tag.rb

@@ -0,0 +1,20 @@
+module ActionKitRest
+  class Tag < Base
+    def base_path
+      'tag'
+    end
+    
+    def find(name)
+      response = list(name: name)
+      response.obj.first
+    end
+    
+    def find_or_create(name)
+      tag = find(name)
+      if tag.blank?
+        tag = create(name: name)
+      end
+      tag
+    end
+  end
+end

data/lib/action_kit_rest/user.rb

@@ -0,0 +1,7 @@
+module ActionKitRest
+  class User < Base
+    def base_path
+      'user'
+    end
+  end
+end

data/lib/action_kit_rest/version.rb

@@ -0,0 +1,10 @@
+module ActionKitRest
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 1
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/spec/action_kit_rest/logger_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ActionKitRest do
+  describe 'logging' do
+    it "should have a logger" do
+      ActionKitRest.respond_to?(:logger).should be_true
+    end
+
+    it "should be able to log debug methods" do
+      ActionKitRest.logger.respond_to?(:debug).should be_true
+    end
+
+    it "should be settable" do
+      ActionKitRest.respond_to?(:logger=).should be_true
+      log = mock()
+      ActionKitRest.logger = log
+      ActionKitRest.logger.should == log
+    end
+  end
+end

data/spec/action_kit_rest/page_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe ActionKitRest::Page do
+  before(:each) do
+    @actionkit = ActionKitRest.new(host: 'test.com')
+
+    logger = mock
+    logger.stub(:debug).and_return(true)
+
+    ActionKitRest.stub(:logger).and_return(logger)
+    Vertebrae::Base.stub(:logger).and_return(logger)
+  end
+
+  describe 'configuration' do
+    it 'should propagate the host to the page' do
+      @actionkit.connection.configuration.host.should == 'test.com'
+    end
+
+    it "should have a client" do
+      @actionkit.page.client.should_not be_nil
+    end
+  end
+
+
+  describe "retrieval" do
+    before(:each) do
+      stub_get(request_path).to_return(:body => body, :status => status,
+                                       :headers => {:content_type => "application/json; charset=utf-8"})
+    end
+
+    describe ".list" do
+      let(:status) { 200 }
+      let(:body) { fixture('page/collection.json') }
+      let(:request_path) { 'page/' }
+
+      it "should allow listing the objects" do
+        pages = @actionkit.page.list
+
+        pages.should be_an_instance_of(ActionKitRest::Response::Wrapper)
+
+        pages.each do | obj |
+          obj.should be_an_instance_of(Hashie::Mash)
+          obj.should respond_to(:goal)
+        end
+      end
+    end
+
+    describe ".page" do
+
+      let(:body) { fixture('page/object.json') }
+      let(:request_path) { 'page/1/' }
+
+      describe "success" do
+        let(:status) { 200 }
+        it "should return a single object" do
+          page = @actionkit.page.get(1)
+          page.goal.should == 10
+        end
+      end
+
+      describe "not found" do
+        let(:status) { 404 }
+
+        it "should return nil" do
+          lambda{ @actionkit.page.get(1).should == nil }.should raise_exception(ActionKitRest::Response::NotFound)
+        end
+      end
+      
+      describe "error" do
+        let(:status) { 400 }
+        let(:body) { fixture('error.json') }
+        
+        it "should raise an ak validation response error" do
+          lambda{ @actionkit.page.get(1) }.should raise_exception(ActionKitRest::Response::ValidationError)
+        end  
+      end
+
+      describe "an error" do
+        let(:status) { 500 }
+
+        it "should return nil" do
+          lambda{ @actionkit.page.get(1).should == nil }.should raise_exception
+        end
+      end
+    end
+  end
+end