amfetamine 0.1.5

data/lib/amfetamine/cache.rb

@@ -0,0 +1,9 @@
+require "dalli"
+
+module Amfetamine
+  # Class that functions as the general talk-to cache
+  # Seperated from adapter functions to decrease method definitions
+  class Cache
+    include CachingAdapter
+  end
+end

data/lib/amfetamine/caching_adapter.rb

@@ -0,0 +1,66 @@
+module Amfetamine
+  # This adapter wraps methods around memcached (dalli) methods
+  module CachingAdapter
+    def self.included(base)
+      base.extend ClassAndInstanceMethods
+      base.extend CacheServer
+      base.send(:include,ClassAndInstanceMethods)
+    end
+
+
+    def initialize(server, options={})
+      @cache_server ||= Dalli::Client.new(server, options)
+    end
+
+    def cache_server
+      @cache_server
+    end
+
+    private :cache_server
+
+    module ClassAndInstanceMethods
+      def get(key)
+        cache_server.get(key)
+      end
+
+      def set(key,data)
+        cache_server.set(key, data)
+      end
+
+      def add(key, data)
+        cache_server.add(key,data)
+      end
+
+      def delete(key)
+        cache_server.delete(key)
+      end
+
+      def flush
+        cache_server.flush
+      end
+
+      def fetch(key)
+        #cache_server.fetch(key,&block)
+        val = get(key)
+        if val.nil? && block_given?
+          val = yield
+          add(key,val)
+        else
+          Amfetamine.logger.info "Hit! #{key}"
+        end
+        val
+      end
+    end
+
+    module CacheServer
+      private
+      def cache_server
+        Amfetamine::Config.memcached_instance
+      end
+
+  
+
+    end
+  end
+end
+

data/lib/amfetamine/config.rb

@@ -0,0 +1,34 @@
+module Amfetamine
+  class Config
+    class << self
+
+      attr_reader :memcached_instance, :rest_client, :base_uri, :resource_suffix, :logger
+
+      def configure
+        yield(self)
+        @base_uri ||= ""
+      end
+
+      def memcached_instance=(value, options={})
+        raise ConfigurationInvalid, 'Invalid value for memcached_instance' if !value.is_a?(String)
+        @memcached_instance ||= Dalli::Client.new(value, options)
+      end
+
+      def rest_client=(value)
+        raise ConfigurationInvalid, 'Invalid value for rest_client' if ![:get,:put,:delete,:post].all? { |m| value.respond_to?(m) }
+        @rest_client ||= value
+      end
+
+      # Shouldn't be needed as our favourite rest clients are based on httparty, still, added it for opensource reasons
+      def base_uri=(value)
+        raise ConfigurationInvalid, "Invalid value for base uri, should be a string" if !value.is_a?(String)
+        @base_uri ||= value
+      end
+
+      def resource_suffix=(value)
+        raise ConfigurationInvalid, "Invalid value for resource suffix, should be a string" if !value.is_a?(String)
+        @resource_suffix ||= value
+      end
+    end
+  end
+end

data/lib/amfetamine/exceptions.rb

@@ -0,0 +1,9 @@
+module Amfetamine
+  class InvalidPath < Exception; end; # Only used for paths not having parent ids
+  class ConfigurationInvalid < Exception;end; # -red
+  class UnknownRESTMethod < Exception; end; # Only used if rest method is not handled by amfetamine
+  class RecordNotFound < Exception; end;
+  class InvalidCacheData < Exception; end;
+  #class MatcherNotImplemented < Exception; end;
+  class ExternalConnectionsNotAllowed < Exception; end; # Used for test helpers if connection is not allowed and attempt is made to connect
+end

data/lib/amfetamine/helpers/rspec_matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :make_request_to do |expected|
+  match do |actual|
+    raise MatcherNotImplemented
+  end
+end

data/lib/amfetamine/helpers/test_helpers.rb

@@ -0,0 +1,113 @@
+module Amfetamine
+  module TestHelpers
+    # Uses fakeweb to block all connections
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Allows for preventing external connections, also in a block
+      def prevent_external_connections!
+        save_rest_client
+        self.rest_client = NeinNeinNein.new
+
+        if block_given?
+          yield self.rest_client
+          restore_rest_client
+        end
+      end
+
+      def save_rest_client
+        @_old_rest_client = self.rest_client || @_old_rest_client
+      end
+
+      def restore_rest_client
+        self.rest_client = @_old_rest_client || self.rest_client
+      end
+
+      # Prevents external connections and provides a simple dsl
+      #
+      # Dummy.stub_responses! do |r|
+      #   r.get(code: 200, path: '/dummies') { dummy }
+      # end  
+      def stub_responses!
+        prevent_external_connections!
+        yield rest_client
+      end
+    end
+  end
+
+  # Annoying stub for http responses
+  class NeinNeinNein
+    def respond_to?(method)
+      if [:get,:post,:delete, :put].include?(method)
+        true
+      else
+        super
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if [:get,:post,:delete,:put].include?(method)
+        # TODO: Dump and rewrite
+
+        # If this is the dsl calling
+        if args.first.is_a?(Hash) || args.empty?
+          opts = args.first || {}
+          path = opts[:path] || 'default'
+          code = opts[:code] || 200
+          query = opts[:query]
+        else # Else this is a request
+          path = args[0] || 'default'
+          query = args[1][:query]
+        end
+
+        paths_with_values = instance_variable_get("@#{method.to_s}") || {}
+
+        path.gsub!(/\/$/,'') #remove trailing slash
+        old_path = path
+        path += query.to_s.strip
+
+        if block_given?
+          paths_with_values[path]= FakeResponse.new(method, code, block)
+          instance_variable_set("@#{method.to_s}", paths_with_values)
+        end
+
+        response = paths_with_values ? (paths_with_values[path] || paths_with_values[old_path] || paths_with_values['default']) : nil
+
+        return response if response
+
+        raise Amfetamine::ExternalConnectionsNotAllowed, "Tried to do #{method} with #{args}\n Allowed paths: \n #{paths_with_values.keys.join("\n")}"
+      else
+        super
+      end
+    end
+
+  end
+
+  class FakeResponse
+    def initialize(method, code2, block)
+      @method = method
+      @response_code = code2 || 200
+      @inner_body = block.call || {}
+    end
+
+    def code
+      @response_code
+    end
+
+    def body
+      MultiJson.encode(@inner_body) if @inner_body
+    end
+
+    def parsed_response
+      if body
+        MultiJson.decode(body)
+      else
+        {}
+      end
+    end
+
+  end
+end
+

data/lib/amfetamine/logger.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+
+module Amfetamine
+  class Logger
+    include Singleton
+
+    def method_missing(method, args)
+      args = "[Amfetamine] #{args.to_s}"
+      if defined?(Rails)
+        Rails.logger.send(method,args)
+      elsif defined?(Merb)
+        Merb.logger.send(method,args)
+      else
+        puts args
+      end
+    end
+  end
+end

data/lib/amfetamine/query_methods.rb

@@ -0,0 +1,187 @@
+require 'active_support/core_ext' # For to_query
+
+module Amfetamine
+  module QueryMethods
+    # Base method for finding objects
+    # Should this be refactored to a different class that checks if cached and returns object?
+    # Caching methods are called here ONLY.
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def find(id, opts={})
+        begin
+          key = opts[:nested_path] || self.find_path(id)
+          data = get_data(key, opts[:conditions])
+          if data[:status] == :success
+            build_object(data[:body]) 
+          else
+            nil
+          end
+        rescue
+          clean_cache!
+          raise
+        end
+      end
+
+      def all(opts={})
+        begin
+          key = opts[:nested_path] || self.rest_path
+          data = get_data(key, opts[:conditions])
+
+          if data[:status] == :success
+            data[:body].compact.map { |d| build_object(d) }
+          else
+            []
+          end
+        rescue
+          clean_cache!
+          raise
+        end
+      end
+
+      def cache_conditions(key, condition=nil)
+        return nil unless condition
+        conditions = cache.get("#{key}_conditions") || []
+        q_condition = condition.to_query
+
+        if !conditions.include?(q_condition)
+          conditions << condition.to_query
+          cache.set("#{key}_conditions", conditions)
+        end
+      end
+
+      def create(args={})
+        self.new(args).tap do |obj|
+          obj.run_callbacks(:create) { obj.save }
+        end
+      end
+
+      def get_data(key, conditions=nil, method=:get)
+        if cacheable?
+          if conditions
+            cache_key = key + conditions.to_query
+            cache_conditions(key, conditions)
+          else
+            cache_key = key
+          end
+
+          Amfetamine.logger.info "Fetching object from cache: #{cache_key}"
+          cache.fetch(cache_key) do
+            Amfetamine.logger.info "Miss! #{cache_key}"
+            handle_request(method, key, { :query => conditions } )
+          end
+        else
+          handle_request(method,key, { :query => conditions })
+        end
+      end
+
+      def clean_cache!
+        if cacheable?
+          cache.delete(rest_path)
+          condition_keys = cache.get("#{rest_path}_conditions") || []
+          condition_keys.each do |cc|
+            cache.delete(rest_path + cc)
+          end
+          Amfetamine.logger.info "Cleaned cache for #{self.model_name}"
+        end
+      end
+    end
+
+    def save
+      if !valid?
+        return false
+      end
+
+      run_callbacks(:save) do
+        response = if self.new?
+                     path = self.belongs_to_relationship? ? belongs_to_relationships.first.rest_path : rest_path
+                     self.class.handle_request(:post, path, {:body => self.to_json })
+                   else
+                     # Needs cleaning up, also needs to work with multiple belongs_to relationships (optional, I guess)
+                     path = self.belongs_to_relationship? ? belongs_to_relationships.first.singular_path : singular_path
+                     self.class.handle_request(:put, path, {:body => self.to_json})
+                   end
+
+        if handle_response(response)
+          begin
+            update_attributes_from_response(response[:body])
+          ensure
+            clean_cache!
+          end
+          cache.set(singular_path, self.to_cacheable) if cacheable?
+        end
+      end
+    end
+
+    def destroy
+      if self.new?
+        return false
+      end
+
+      path = self.belongs_to_relationship? ? belongs_to_relationships.first.singular_path : singular_path
+      response = self.class.handle_request(:delete, path)
+
+      if handle_response(response)
+        clean_cache!
+        self.notsaved = true # Because its a new object if the server side got deleted
+        self.id = nil # Not saved? No ID.
+      end
+    end
+
+    def clean_cache!
+      if cacheable?
+        cache.delete(singular_path)
+        cache.delete(rest_path)
+        belongs_to_relationships.each do |r|
+          cache.delete(r.singular_path)
+          cache.delete(r.rest_path)
+          condition_keys = cache.get("#{r.rest_path}_conditions") || []
+          condition_keys.each do |cc|
+            cache.delete(r.rest_path + cc)
+          end
+        end
+        
+        condition_keys = cache.get("#{rest_path}_conditions") || []
+        condition_keys.each do |cc|
+          cache.delete(rest_path + cc)
+        end
+        Amfetamine.logger.info "Cleaned cache for #{self.class_name} with ID #{self.id}"
+      end
+    end
+
+
+
+
+    def update_attributes(attrs)
+      return true if attrs.all? { |k,v| self.send(k) == v } # Don't update if no attributes change
+      attrs.each { |k,v| self.send("#{k}=", v) }
+      self.save
+    end
+
+
+    def new?
+      @notsaved
+    end
+
+    def to_cacheable
+      {
+        :status => :success,
+        :body => {
+          self.class.name.downcase.to_sym => self.attributes
+        }
+      }
+    end
+
+    private
+
+    def id=(id)
+      @id = id
+    end
+
+    def notsaved=(bool)
+      @notsaved = bool
+    end
+  end
+end