wayne-friendly 0.5.1

data/lib/friendly/document/convenience.rb

@@ -0,0 +1,41 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Convenience
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :collection_klass
+        
+        def collection_klass
+          @collection_klass ||= WillPaginate::Collection
+        end
+
+        def find(id)
+          doc = first(:id => id)
+          raise RecordNotFound, "Couldn't find #{name}/#{id}" if doc.nil?
+          doc
+        end
+
+        def paginate(conditions)
+          query      = query(conditions)
+          count      = count(query)
+          collection = collection_klass.new(query.page, query.per_page, count)
+          collection.replace(all(query))
+        end
+
+        def create(attributes = {})
+          doc = new(attributes)
+          doc.save
+          doc
+        end
+      end
+
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+    end
+  end
+end

data/lib/friendly/document/mixin.rb

@@ -0,0 +1,15 @@
+module Friendly
+  module Document
+    module Mixin
+      # FIXME: I'm not in love with this. But, I also don't think it's the
+      # end of the world.
+      def included(klass)
+        if klass.const_defined?(:ClassMethods)
+          klass.const_get(:ClassMethods).send(:include, const_get(:ClassMethods))
+        else
+          klass.send(:extend, const_get(:ClassMethods))
+        end
+      end
+    end
+  end
+end

data/lib/friendly/document/scoping.rb

@@ -0,0 +1,66 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Scoping
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :scope_proxy
+        
+        def scope_proxy
+          @scope_proxy ||= ScopeProxy.new(self)
+        end
+
+        # Add a named scope to this Document.
+        #
+        # e.g.
+        #     
+        #     class Post
+        #       indexes     :created_at
+        #       named_scope :recent, :order! => :created_at.desc
+        #     end
+        #
+        # Then, you can access the recent posts with:
+        #
+        #     Post.recent.all
+        # ...or...
+        #     Post.recent.first
+        #
+        # Both #all and #first also take additional parameters:
+        #
+        #     Post.recent.all(:author_id => @author.id)
+        #
+        # Scopes are also chainable. See the README or Friendly::Scope docs for details.
+        #
+        # @param [Symbol] name the name of the scope.
+        # @param [Hash] parameters the query that this named scope will perform.
+        #
+        def named_scope(name, parameters)
+          scope_proxy.add_named(name, parameters)
+        end
+
+        # Returns boolean based on whether the Document has a scope by a particular name.
+        #
+        # @param [Symbol] name The name of the scope in question.
+        #
+        def has_named_scope?(name)
+          scope_proxy.has_named_scope?(name)
+        end
+
+        # Create an ad hoc scope on this Document.
+        #
+        # e.g.
+        #     
+        #     scope = Post.scope(:order! => :created_at)
+        #     scope.all # => [#<Post>, #<Post>]
+        #
+        # @param [Hash] parameters the query parameters to create the scope with.
+        #
+        def scope(parameters)
+          scope_proxy.ad_hoc(parameters)
+        end
+      end
+    end
+  end
+end

data/lib/friendly/document/storage.rb

@@ -0,0 +1,63 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Storage
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :storage_proxy, :query_klass
+        
+        def create_tables!
+          storage_proxy.create_tables!
+        end
+
+        def storage_proxy
+          @storage_proxy ||= StorageProxy.new(self)
+        end
+
+        def indexes(*args)
+          storage_proxy.add(args)
+        end
+
+        def caches_by(*fields)
+          options = fields.last.is_a?(Hash) ? fields.pop : {}
+          storage_proxy.cache(fields, options)
+        end
+
+        def first(query)
+          storage_proxy.first(query(query))
+        end
+
+        def all(query)
+          storage_proxy.all(query(query))
+        end
+
+        def count(conditions)
+          storage_proxy.count(query(conditions))
+        end
+
+        def query_klass
+          @query_klass ||= Query
+        end
+
+        protected
+          def query(conditions)
+            conditions.is_a?(Query) ? conditions : query_klass.new(conditions)
+          end
+      end
+      
+      def save
+        new_record? ? storage_proxy.create(self) : storage_proxy.update(self)
+      end
+
+      def destroy
+        storage_proxy.destroy(self)
+      end
+
+      def storage_proxy
+        self.class.storage_proxy
+      end
+    end
+  end
+end

data/lib/friendly/document_table.rb

@@ -0,0 +1,56 @@
+require 'friendly/table'
+
+module Friendly
+  class DocumentTable < Table
+    attr_reader :klass, :translator
+
+    def initialize(klass, datastore=Friendly.datastore, translator=Translator.new)
+      super(datastore)
+      @klass      = klass
+      @translator = translator
+    end
+
+    def table_name
+      klass.table_name
+    end
+
+    def satisfies?(query)
+      query.conditions.keys == [:id] && !query.order
+    end
+
+    def create(document)
+      record = translator.to_record(document)
+      datastore.insert(document, record)
+      update_document(document, record)
+    end
+
+    def update(document)
+      record = translator.to_record(document)
+      datastore.update(document, document.id, record)
+      update_document(document, record)
+    end
+
+    def destroy(document)
+      datastore.delete(document, document.id)
+    end
+
+    def first(query)
+      record = datastore.first(klass, query)
+      record && to_object(record)
+    end
+
+    def all(query)
+      datastore.all(klass, query).map { |r| to_object(r) }
+    end
+
+    protected
+      def update_document(document, record)
+        attrs = record.reject { |k,v| k == :attributes }.merge(:new_record => false)
+        document.attributes = attrs
+      end
+
+      def to_object(record)
+        translator.to_object(klass, record)
+      end
+  end
+end

data/lib/friendly/index.rb

@@ -0,0 +1,73 @@
+require 'friendly/table'
+
+module Friendly
+  class Index < Table
+    attr_reader :klass, :fields, :datastore
+
+    def initialize(klass, fields, datastore = Friendly.datastore)
+      @klass     = klass
+      @fields    = fields
+      @datastore = datastore
+    end
+
+    def table_name
+      ["index", klass.table_name, "on", fields.join("_and_")].join("_")
+    end
+
+    def satisfies?(query)
+      exact_match?(query) || valid_partial_match?(query)
+    end
+
+    def first(query)
+      row = datastore.first(self, query)
+      row && klass.first(:id => row[:id])
+    end
+
+    def all(query)
+      ids = datastore.all(self, query).map { |row| row[:id] }
+      klass.all(:id => ids, :preserve_order! => !query.order.nil?)
+    end
+
+    def count(query)
+      datastore.count(self, query)
+    end
+
+    def create(document)
+      datastore.insert(self, record(document))
+    end
+
+    def update(document)
+      datastore.update(self, document.id, record(document))
+    end
+
+    def destroy(document)
+      datastore.delete(self, document.id)
+    end
+
+    protected
+      def exact_match?(query)
+        query.conditions.keys.map { |f| f.to_s }.sort == 
+          fields.map { |f| f.to_s }.sort && 
+            valid_order?(query.order)
+      end
+
+      def valid_partial_match?(query)
+        condition_fields = query.conditions.keys
+        sorted = condition_fields.sort { |a,b| field_index(a) <=> field_index(b) }
+        sorted << query.order.expression if query.order
+        sorted.zip(fields).all? { |a,b| a == b }
+      end
+
+      def valid_order?(order)
+        order.nil? || order.expression == fields.last
+      end
+
+      def field_index(attr)
+        fields.index(attr) || 0
+      end
+
+      def record(document)
+        Hash[*(fields + [:id]).map { |f| [f, document.send(f)] }.flatten]
+      end
+  end
+end

data/lib/friendly/indexer.rb

@@ -0,0 +1,50 @@
+module Friendly
+  class Indexer
+    class << self
+      attr_accessor :objects_per_iteration
+
+      def populate(klass, *fields)
+        instance.populate(klass, klass.storage_proxy.index_for_fields(fields))
+      end
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    self.objects_per_iteration = 100
+
+    attr_reader :datastore, :translator
+
+    def initialize(datastore  = Friendly.datastore, translator = Translator.new)
+      @datastore  = datastore
+      @translator = translator
+    end
+
+    def populate(klass, index)
+      count  = 0
+      loop do
+        rows = datastore.all(klass, Query.new(:offset! => count, 
+                                              :limit!  => objects_per_iteration, 
+                                              :order!  => :added_id.asc))
+        rows.each do |attrs|
+          begin
+            index.create(translator.to_object(klass, attrs))
+          rescue Sequel::DatabaseError
+            # we can safely swallow this exception because if we've gotten
+            # to this point, we can be pretty sure that it's a duplicate
+            # key error, which just means that the object already exists
+            # in the index
+          end
+        end
+        break if rows.length < objects_per_iteration
+        count += objects_per_iteration
+      end
+    end
+
+    protected
+      def objects_per_iteration
+        self.class.objects_per_iteration
+      end
+  end
+end

data/lib/friendly/memcached.rb

@@ -0,0 +1,48 @@
+module Friendly
+  class Memcached
+    attr_reader :cache
+
+    def initialize(cache)
+      @cache = cache
+    end
+
+    def set(key, value)
+      @cache.set(key, value)
+    end
+
+    def get(key)
+      @cache.get(key)
+    rescue ::Memcached::NotFound
+      if block_given?
+        miss(key) { yield }
+      end
+    end
+
+    def multiget(keys)
+      return {} if keys.empty?
+
+      hits         = @cache.get(keys)
+      missing_keys = keys - hits.keys
+
+      if !missing_keys.empty? && block_given?
+        missing_keys.each do |missing_key|
+          hits.merge!(missing_key => miss(missing_key) { yield(missing_key) })
+        end
+      end
+
+      hits
+    end
+
+    def delete(key)
+      cache.delete(key)
+    rescue ::Memcached::NotFound
+    end
+
+    protected
+      def miss(key)
+        value = yield
+        @cache.set(key, value)
+        value
+      end
+  end
+end

data/lib/friendly/newrelic.rb

@@ -0,0 +1,6 @@
+Friendly::Memcached.class_eval do
+  add_method_tracer :miss, "Friendly::Memcached/miss"
+  add_method_tracer :get, "Friendly::Memcached/get"
+  add_method_tracer :multiget, "Friendly::Memcached/multiget"
+end
+

data/lib/friendly/query.rb

@@ -0,0 +1,42 @@
+module Friendly
+  class Query
+    attr_reader :conditions, :limit, :order, 
+                :preserve_order, :offset, :uuid_klass,
+                :page, :per_page
+
+    def initialize(parameters, uuid_klass = UUID)
+      @uuid_klass = uuid_klass
+      @conditions = parameters.reject { |k,v| k.to_s =~ /!$/ }
+      @page       = (parameters[:page!] || 1).to_i
+      
+      [:per_page!, :limit!, :offset!, :order!, :preserve_order!].each do |p|
+        instance_variable_set("@#{p.to_s.gsub(/!/, '')}", parameters[p])
+      end
+
+      handle_pagination if per_page
+      convert_ids_to_uuids
+    end
+
+    def preserve_order?
+      preserve_order
+    end
+
+    def offset?
+      offset
+    end
+
+    protected
+      def convert_ids_to_uuids
+        if conditions[:id] && conditions[:id].is_a?(Array)
+          conditions[:id] = conditions[:id].map { |i| uuid_klass.new(i) }
+        elsif conditions[:id]
+          conditions[:id] = uuid_klass.new(conditions[:id])
+        end
+      end
+
+      def handle_pagination
+        @limit  = per_page
+        @offset = (page - 1) * per_page
+      end
+  end
+end