amfetamine 0.1.5

data/lib/amfetamine/relationship.rb

@@ -0,0 +1,108 @@
+module Amfetamine
+  class Relationship
+    include Enumerable
+
+    attr_reader :on, :type, :from
+
+    def initialize(opts)
+      @type = opts[:type]
+      @on = opts[:on] # Target class
+      @from = opts[:from] # receiving object
+    end
+
+    def << (other)
+      other.send("#{from_singular_name}_id=", @from.id)
+      other.instance_variable_set("@#{from_singular_name}", Amfetamine::Relationship.new(:on => @from, :from => other, :type => :belongs_to))
+      @children ||= [] # No need to do a request here, but it needs to be an array if it isn't yet.
+      @children << other
+    end
+
+    def on_class
+      if @on.is_a?(Symbol)
+        Amfetamine.parent.const_get(@on.to_s.gsub('/', '::').singularize.gsub('_','').capitalize)
+      else
+        @on.class
+      end
+    end
+
+    # Id of object this relationship references
+    def parent_id
+      if @on.is_a?(Symbol)
+        @from.send(@on.to_s.downcase + "_id") if @type == :belongs_to
+      else
+        @on.id
+      end
+    end
+
+    # Id of the receiving object
+    def from_id
+      @from.id
+    end
+
+    def from_plural_name
+      @from.class.name.to_s.downcase.pluralize
+    end
+
+    def from_singular_name
+      @from.class.name.to_s.downcase
+    end
+
+    def on_plural_name
+      if @on.is_a?(Symbol)
+        @on.to_s.pluralize
+      else
+        @on.class.name.to_s.pluralize.downcase
+      end
+    end
+
+    def rest_path
+      on_class.rest_path(:relationship => self)
+    end
+
+    def find_path(id)
+      on_class.find_path(id, :relationship => self)
+    end
+
+    def singular_path
+      find_path(@from.id)
+    end
+
+    def full_path
+      if @type == :has_many
+        raise InvalidPath if from_id == nil
+        "#{from_plural_name}/#{from_id}/#{on_plural_name}"
+      elsif @type == :belongs_to
+        raise InvalidPath if parent_id == nil
+        "#{on_plural_name}/#{parent_id}/#{from_plural_name}"
+      end
+    end
+
+    def each
+      all.each { |c| yield c }
+    end
+
+    # Delegates the all method to child class with a nested path set
+    def all(opts={})
+      force = opts.delete(:force)
+      request = lambda { on_class.all({ :nested_path => rest_path }.merge(opts)) }
+
+      @children = if force
+                    request.call
+                  else
+                    @children || request.call
+                  end
+    end
+
+    # Delegates the find method to child class with a nested path set
+    def find(id, opts={})
+      on_class.find(id, {:nested_path => find_path(id)}.merge(opts))
+    end
+
+
+    def include?(other)
+      self.all
+      @children.include?(other)
+    end
+
+  end
+end

data/lib/amfetamine/relationships.rb

@@ -0,0 +1,77 @@
+module Amfetamine
+  module Relationships
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(args={})
+      #super(args)
+      if self.class._relationship_children
+        self.class._relationship_children.each do |klass|
+          instance_variable_set("@#{klass}", Amfetamine::Relationship.new(:on => klass, :from => self, :type => :has_many))
+        end
+      end
+
+      if self.class._relationship_parents
+        self.class._relationship_parents.each do |klass|
+          instance_variable_set("@#{klass}", Amfetamine::Relationship.new(:on => klass, :from => self, :type => :belongs_to))
+        end
+      end
+    end
+
+    def belongs_to_relationship?
+      self.class._relationship_parents && self.class._relationship_parents.any?
+    end
+
+    def belongs_to_relationships
+      if self.class._relationship_parents
+        self.class._relationship_parents.collect { |e| self.send(e) }
+      else
+        []
+      end
+    end
+
+    module ClassMethods
+      def has_many_resources(*klasses)
+        self.class_eval do
+          @_relationship_children = []
+          klasses.each do |klass|
+            attr_reader klass
+            @_relationship_children << klass
+
+            parent_id_field = self.name.to_s.downcase.singularize + "_id"
+
+            define_method("build_#{klass.to_s.singularize}") do |*args|
+              args = args.shift || {}
+              Amfetamine.parent.const_get(klass.to_s.gsub('/', '::').singularize.gsub('_','').capitalize).new(args.merge(parent_id_field => self.id))
+            end
+
+            define_method("create_#{klass.to_s.singularize}") do |*args|
+              args = args.shift || {}
+              Amfetamine.parent.const_get(klass.to_s.gsub('/', '::').singularize.gsub('_','').capitalize).create(args.merge(parent_id_field => self.id))
+            end
+          end
+        end
+      end
+
+      def _relationship_children
+        @_relationship_children
+      end
+
+      def belongs_to_resource(*klasses)
+        self.class_eval do
+          @_relationship_parents = []
+          klasses.each do |klass|
+            attr_reader klass
+
+            @_relationship_parents << klass
+          end
+        end
+      end
+
+      def _relationship_parents
+        @_relationship_parents
+      end
+    end
+  end
+end

data/lib/amfetamine/rest_helpers.rb

@@ -0,0 +1,122 @@
+require 'active_support/inflector'
+require 'json'
+
+module Amfetamine
+  module RestHelpers
+
+    RESPONSE_STATUSES = { 422 => :errors, 404 => :notfound, 200 => :success, 201 => :created, 500 => :server_error, 406 => :not_acceptable }
+
+    def rest_path(args={})
+      self.class.rest_path(args)
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def singular_path(args={})
+      self.class.find_path(self.id, args)
+    end
+
+    # This method handles the save response
+    # TODO: Needs refactoring, now just want to make the test pass =)
+    # Making assumption here that when response is nil, it should have possitive result. Needs refactor when slept more
+    def handle_response(response)
+      if response[:status] == :success || response[:status] == :created
+        self.instance_variable_set('@notsaved', false)
+        true
+      elsif response[:status] == :errors
+        Amfetamine.logger.warn "Errors from response"
+        response[:body].each do |attr, mesg|
+          errors.add(attr.to_sym, mesg )
+        end
+        false
+      end
+    end
+
+
+    module ClassMethods
+      def rest_path(params={})
+        result = if params[:relationship]
+          relationship = params[:relationship]
+          "/#{relationship.full_path}"
+        else
+          "/#{self.name.downcase.pluralize}"
+        end
+
+        result = base_uri + result unless params[:no_base_uri]
+        result = result + resource_suffix unless params[:no_resource_suffix]
+        return result
+      end
+
+      def find_path(id, params={})
+        params_for_rest_path = params.merge({:no_base_uri => true, :no_resource_suffix => true})
+        result = "#{self.rest_path(params_for_rest_path)}/#{id.to_s}"
+
+        result = base_uri + result unless params[:no_base_uri]
+        result = result + resource_suffix unless params[:no_resource_suffix]
+        return result
+      end
+
+
+      def base_uri
+        @base_uri || Amfetamine::Config.base_uri
+      end
+
+      # wraps rest requests to the corresponding service
+      # *emerging*
+      def handle_request(method, path, opts={})
+        Amfetamine.logger.warn "Making request to #{path} with #{method} and #{opts.inspect}"
+        case method
+        when :get
+          response = rest_client.get(path, opts)
+        when :post
+          response = rest_client.post(path, opts)
+        when :put
+          response = rest_client.put(path, opts)
+        when :delete
+          response = rest_client.delete(path, opts)
+        else
+          raise UnknownRESTMethod, "handle_request only responds to get, put, post and delete"
+        end
+        parse_response(response)
+      end
+
+      # Returns a hash with human readable status and parsed body
+      def parse_response(response)
+        status = RESPONSE_STATUSES.fetch(response.code) { raise "Response not known" }
+        raise Amfetamine::RecordNotFound if status == :notfound
+        body = if response.body && !(response.body.blank?)
+                 response.parsed_response
+               else
+                 self.to_json
+               end
+        { :status => status, :body => body }
+      end
+
+      def rest_client
+        @rest_client || Amfetamine::Config.rest_client
+      end
+
+      def resource_suffix
+        @resource_suffix || Amfetamine::Config.resource_suffix || ""
+      end
+
+      # Allows setting a different rest client per class
+      def rest_client=(value)
+        raise Amfetamine::ConfigurationInvalid, 'Invalid value for rest_client' if ![:get,:put,:delete,:post].all? { |m| value.respond_to?(m) }
+        @rest_client = value
+      end
+
+      def resource_suffix=(value)
+        raise Amfetamine::ConfigurationInvalid, 'Invalid value for resource suffix' if !value.is_a?(String)
+        @resource_suffix = value
+      end
+
+      def base_uri=(value)
+        raise Amfetamine::ConfigurationInvalid, 'Invalid value for base uri' if !value.is_a?(String)
+        @base_uri = value
+      end
+    end
+  end
+end

data/lib/amfetamine/version.rb

@@ -0,0 +1,3 @@
+module Amfetamine
+  VERSION = "0.1.5"
+end

data/spec/amfetamine/base_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+# Integration tests :)
+describe Amfetamine::Base do
+  describe "Dummy, our ever faitful test subject" do
+    # Some hight level tests, due to the complexity this makes it a lot easier to refactor
+    let(:dummy) { build(:dummy) }
+    subject { dummy }
+
+    it { should be_valid }
+    its(:title) { should ==('Dummy')}
+    its(:description) { should ==('Crash me!')}
+    its(:to_json) { should match(/dummy/) }
+
+  end
+
+  describe "Class dummy, setup with amfetamine::base" do
+    let(:dummy) { build(:dummy) }
+    let(:dummy2) { build(:dummy) }
+    subject { Dummy}
+
+    it { should be_cacheable }
+
+    context "#attributes" do
+      it "should update attribute correctly if I edit it" do
+        dummy.title = "Oh a new title!"
+        dummy.attributes['title'].should == "Oh a new title!"
+      end
+
+      it "should include attributes in json" do
+        dummy.title = "Something new"
+        dummy.to_json.should match(/Something new/)
+      end
+    end
+
+    context "#find" do
+      it "should find dummy" do
+        dummy.instance_variable_set('@notsaved', false)
+        stub_single_response(dummy) do
+          Dummy.find(dummy.id).should == dummy
+        end
+        dummy.should be_cached
+      end
+      
+      it "should return nil if object not found" do
+        lambda {
+        stub_nil_response do
+          Dummy.find(dummy.id * 2).should be_nil
+        end
+        }.should raise_exception(Amfetamine::RecordNotFound)
+      end
+    end
+
+    context "#all" do
+      it "should find all if objects are present" do
+        dummies = []
+        dummy.instance_variable_set('@notsaved', false)
+        dummy2.instance_variable_set('@notsaved', false)
+
+        stub_all_response(dummy, dummy2) do
+          dummies = Dummy.all
+        end
+
+        dummies.should include(dummy)
+        dummies.should include(dummy2)
+        dummies.length.should eq(2)
+      end
+      
+      it "should return empty array if objects are not present" do
+        dummies = []
+        stub_all_nil_response do
+          dummies = Dummy.all
+        end
+
+        dummies.should eq([])
+      end
+    end
+
+    context "#create" do
+      it "should create an object if data is correct" do
+        new_dummy = nil
+        stub_post_response do
+          new_dummy = Dummy.create({:title => 'test', :description => 'blabla'})
+        end
+        new_dummy.should be_a(Dummy)
+        new_dummy.should_not be_new
+        new_dummy.should be_cached
+      end
+
+      it "should return errors if data is incorrect" do
+        new_dummy = nil
+        stub_post_errornous_response do
+          new_dummy = Dummy.create({:title => 'test'})
+        end
+        new_dummy.should be_new
+        new_dummy.errors.messages.should eq({:description => ['can\'t be blank']})
+        new_dummy.should_not be_cached
+      end
+    end
+
+    context "#update" do
+      before(:each) do
+        dummy.send(:notsaved=, false)
+      end
+
+      it "should update if response is succesful" do
+        stub_update_response do
+          dummy.update_attributes({:title => 'zomg'})
+        end
+        dummy.should_not be_new
+        dummy.title.should eq('zomg')
+        dummy.should be_cached
+      end
+
+      it "should show errors if response is not succesful" do
+        stub_update_errornous_response do
+          dummy.update_attributes({:title => ''})
+        end
+        dummy.should_not be_new
+        dummy.errors.messages.should eq({:title => ['can\'t be blank']})
+      end
+
+      it "should not do a request if the data doesn't change" do
+        # Assumes that dummy.update would raise if not within stubbed request.
+        dummy.update_attributes({:title => dummy.title})
+        dummy.errors.should be_empty
+      end
+    end
+
+    context "#save" do
+      before(:each) do
+        dummy.send(:notsaved=, true)
+      end
+
+      it "should update the id if data is received from post" do
+        old_id = dummy.id
+        stub_post_response(dummy) do
+          dummy.send(:id=, nil)
+          dummy.save
+        end
+        dummy.id.should == old_id
+        dummy.attributes[:id].should == old_id
+      end
+
+      it "should update attributes if data is received from update" do
+        dummy.send(:notsaved=, false)
+        old_id = dummy.id
+        dummy.title = "BLABLABLA"
+        stub_update_response(dummy) do
+          dummy.title = "BLABLABLA"
+          dummy.save
+        end
+        dummy.id.should == old_id
+        dummy.title.should == "BLABLABLA"
+        dummy.attributes[:title] = "BLABLABLA"
+      end
+    end
+
+    context "#delete" do
+      before(:each) do
+        dummy.send(:notsaved=, false)
+      end
+
+      it "should delete the object if response is succesful" do
+        stub_delete_response do
+          dummy.destroy
+        end
+        dummy.should be_new
+        dummy.id.should be_nil
+        dummy.should_not be_cached
+      end
+
+      it "should return false if delete failed" do
+        stub_delete_errornous_response do
+          dummy.destroy
+        end
+        dummy.should_not be_new
+        dummy.should_not be_cached
+      end
+    end
+  end
+
+  describe "Features and bugs" do
+    it "should raise an exception if cached args are nil" do
+      lambda { Dummy.build_object(nil) }.should raise_exception(Amfetamine::InvalidCacheData)
+    end
+
+    it "should raise an exception if cached args do not contain an ID" do
+      lambda { Dummy.build_object(:no_id => 'present') }.should raise_exception(Amfetamine::InvalidCacheData)
+    end
+
+    it "should raise correct exception is data is not expected format" do
+      lambda { Dummy.build_object([]) }.should raise_exception(Amfetamine::InvalidCacheData)
+    end
+
+    it "should receive data when doing a post" do
+      Dummy.prevent_external_connections! do
+        dummy = build(:dummy)
+        Dummy.rest_client.should_receive(:post).with("/dummies", :body => dummy.to_json).
+          and_return(Amfetamine::FakeResponse.new('post', 201, lambda { dummy }))
+        dummy.save
+      end
+    end
+
+  end
+      
+end