friendly 0.3.3

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/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

data/lib/friendly/sequel_monkey_patches.rb

@@ -0,0 +1,35 @@
+require 'sequel'
+
+# Out of the box, Sequel uses IS TRUE/FALSE for boolean parameters
+# This prevents MySQL from using indexes.
+#
+# This patch fixes that.
+module Sequel
+  module SQL
+    class BooleanExpression
+      def self.from_value_pairs(pairs, op=:AND, negate=false)
+        pairs = pairs.collect do |l,r|
+          ce = case r
+          when Range
+            new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
+          when Array, ::Sequel::Dataset, SQLArray
+            new(:IN, l, r)
+          when NegativeBooleanConstant
+            new(:"IS NOT", l, r.constant)
+          when BooleanConstant
+            new(:IS, l, r.constant)
+          when NilClass
+            new(:IS, l, r)
+          when Regexp
+            StringExpression.like(l, r)
+          else
+            new(:'=', l, r)
+          end
+          negate ? invert(ce) : ce
+        end
+        pairs.length == 1 ? pairs.at(0) : new(op, *pairs)
+      end
+    end
+  end
+end
+

data/lib/friendly/storage.rb

@@ -0,0 +1,31 @@
+module Friendly
+  class Storage
+    def create(document)
+      raise NotImplementedError, "#{self.class.name}#create is not implemented."
+    end
+
+    def update(document)
+      raise NotImplementedError, "#{self.class.name}#update is not implemented."
+    end
+
+    def destroy(document)
+      raise NotImplementedError, "#{self.class.name}#destroy is not implemented."
+    end
+
+    def first(conditions)
+      raise NotImplementedError, "#{self.class.name}#first is not implemented."
+    end
+
+    def all(conditions)
+      raise NotImplementedError, "#{self.class.name}#all is not implemented."
+    end
+
+    def count(query)
+      raise NotImplementedError, "#{self.class.name}#count is not implemented."
+    end
+
+    def satisfies?(conditions)
+      raise NotImplementedError, "#{self.class.name}#satisfies? is not implemented."
+    end
+  end
+end

data/lib/friendly/storage_factory.rb

@@ -0,0 +1,24 @@
+module Friendly
+  class StorageFactory
+    attr_reader :table_klass, :index_klass, :cache_klass
+
+    def initialize(table_klass = DocumentTable, index_klass = Index,
+                   cache_klass = Cache)
+      @table_klass = table_klass
+      @index_klass = index_klass
+      @cache_klass = cache_klass
+    end
+
+    def document_table(*args)
+      table_klass.new(*args)
+    end
+
+    def index(*args)
+      index_klass.new(*args)
+    end
+
+    def cache(*args)
+      cache_klass.cache_for(*args)
+    end
+  end
+end

data/lib/friendly/storage_proxy.rb

@@ -0,0 +1,103 @@
+require 'friendly/storage_factory'
+require 'friendly/table_creator'
+
+module Friendly
+  class StorageProxy
+    attr_reader :klass, :storage_factory, :tables, :table_creator, :caches
+
+    def initialize(klass, storage_factory = StorageFactory.new,
+                    table_creator=TableCreator.new)
+      super()
+      @klass           = klass
+      @storage_factory = storage_factory
+      @table_creator   = table_creator
+      @tables          = [storage_factory.document_table(klass)]
+      @caches          = []
+    end
+
+    def first(conditions)
+      first_from_cache(conditions) do
+        index_for(conditions).first(conditions)
+      end
+    end
+
+    def all(query)
+      objects = perform_all(query).compact
+      if query.preserve_order?
+        order = query.conditions[:id]
+        objects.sort { |a,b| order.index(a.id) <=> order.index(b.id) }
+      else
+        objects
+      end
+    end
+
+    def count(query)
+      index_for(query).count(query)
+    end
+
+    def add(*args)
+      tables << storage_factory.index(klass, *args)
+    end
+
+    def cache(fields, options = {})
+      caches << storage_factory.cache(klass, fields, options)
+    end
+
+    def create(document)
+      each_store { |s| s.create(document) }
+    end
+
+    def update(document)
+      each_store { |s| s.update(document) }
+    end
+
+    def destroy(document)
+      stores.reverse.each { |i| i.destroy(document) }
+    end
+
+    def create_tables!
+      tables.each { |t| table_creator.create(t) }
+    end
+
+    def index_for(conditions)
+      index = tables.detect { |i| i.satisfies?(conditions) }
+      if index.nil?
+        raise MissingIndex, "No index found to satisfy: #{conditions.inspect}."
+      end
+      index
+    end
+
+    protected
+      def each_store
+        stores.each { |s| yield(s) }
+      end
+
+      def stores
+        tables + caches
+      end
+
+      def first_from_cache(query)
+        cache = cache_for(query)
+        if cache
+          cache.first(query) { yield }
+        else
+          yield
+        end
+      end
+
+      def cache_for(query)
+        caches.detect { |c| c.satisfies?(query) }
+      end
+
+      def perform_all(query)
+        cache = cache_for(query)
+        if cache
+          cache.all(query) do |missing_key|
+            index_for(query).first(Query.new(:id => missing_key.split("/").last))
+          end
+        else
+          index_for(query).all(query)
+        end
+      end
+  end
+end

data/lib/friendly/table.rb

@@ -0,0 +1,15 @@
+require 'friendly/storage'
+module Friendly
+  class Table < Storage
+    attr_reader :datastore
+
+    def initialize(datastore)
+      @datastore = datastore
+    end
+
+    def table_name
+      raise NotImplementedError, "#{self.class.name}#table_name is not implemented."
+    end
+  end
+end
+

data/lib/friendly/table_creator.rb

@@ -0,0 +1,43 @@
+module Friendly
+  class TableCreator
+    attr_reader :db
+
+    def initialize(db = Friendly.db)
+      @db = db
+    end
+
+    def create(table)
+      unless db.table_exists?(table.table_name)
+        case table
+        when DocumentTable
+          create_document_table(table) 
+        when Index
+          create_index_table(table)
+        end
+      end
+    end
+
+    protected
+      def create_document_table(table)
+        db.create_table(table.table_name) do
+          primary_key :added_id
+          binary      :id,         :size => 16
+          String      :attributes, :text => true
+          Time        :created_at
+          Time        :updated_at
+        end
+      end
+
+      def create_index_table(table)
+        db.create_table(table.table_name) do
+          binary      :id,         :size => 16
+          table.fields.flatten.each do |f|
+            method(table.klass.attributes[f].type.name.to_sym).call(f)
+          end
+          primary_key table.fields.flatten + [:id]
+          unique :id
+        end
+      end
+  end
+end
+

data/lib/friendly/time.rb

@@ -0,0 +1,14 @@
+# This class was extracted from the cassandra gem by Evan Weaver
+# As such, it is distributed under the terms of the apache license.
+# See the APACHE-LICENSE file in the root of this project for more information.
+#
+class Time
+  def self.stamp
+    Time.now.stamp
+  end
+  
+  def stamp
+    to_i * 1_000_000 + usec
+  end
+end
+

data/lib/friendly/translator.rb

@@ -0,0 +1,32 @@
+module Friendly
+  class Translator
+    RESERVED_ATTRS = [:id, :created_at, :updated_at].freeze
+
+    attr_reader :serializer, :time
+
+    def initialize(serializer = JSON, time = Time)
+      @serializer = serializer
+      @time       = time
+    end
+
+    def to_object(klass, record)
+      record.delete(:added_id)
+      attributes = serializer.parse(record.delete(:attributes))
+      klass.new attributes.merge(record).merge(:new_record => false)
+    end
+
+    def to_record(document)
+      { :id         => document.id,
+        :created_at => document.created_at,
+        :updated_at => time.new,
+        :attributes => serialize(document) }
+    end
+
+    protected
+      def serialize(document)
+        attrs = document.to_hash.reject { |k,v| RESERVED_ATTRS.include?(k) }
+        serializer.generate(attrs)
+      end
+  end
+end
+

data/lib/friendly/uuid.rb

@@ -0,0 +1,143 @@
+require 'friendly/time'
+# This class was extracted from the cassandra gem by Evan Weaver
+# As such, it is distributed under the terms of the apache license.
+# See the APACHE-LICENSE file in the root of this project for more information.
+#
+module Friendly
+  # UUID format version 1, as specified in RFC 4122, with jitter in place of the mac address and sequence counter.
+  class UUID
+
+    class InvalidVersion < StandardError; end
+    class TypeError < ::TypeError; end
+
+    GREGORIAN_EPOCH_OFFSET = 0x01B2_1DD2_1381_4000 # Oct 15, 1582
+
+    VARIANT = 0b1000_0000_0000_0000
+
+    def initialize(bytes = nil)
+      case bytes
+      when self.class # UUID
+        @bytes = bytes.to_s
+      when String
+        case bytes.size
+        when 16 # Raw byte array
+          @bytes = bytes
+        when 36 # Human-readable UUID representation; inverse of #to_guid
+          elements = bytes.split("-")
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (malformed UUID representation)" if elements.size != 5
+          @bytes = elements.join.to_a.pack('H32')
+        else
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (invalid bytecount)"
+        end
+
+      when Integer
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (integer out of range)" if bytes < 0 or bytes > 2**128
+        @bytes = [
+          (bytes >> 96) & 0xFFFF_FFFF,
+          (bytes >> 64) & 0xFFFF_FFFF,
+          (bytes >> 32) & 0xFFFF_FFFF,
+          bytes & 0xFFFF_FFFF
+        ].pack("NNNN")
+
+      when NilClass, Time
+        time = (bytes || Time).stamp * 10 + GREGORIAN_EPOCH_OFFSET
+        # See http://github.com/spectra/ruby-uuid/
+        @bytes = [
+          time & 0xFFFF_FFFF,
+          time >> 32,
+          ((time >> 48) & 0x0FFF) | 0x1000,
+          # Top 3 bytes reserved
+          rand(2**13) | VARIANT,
+          rand(2**16),
+          rand(2**32)
+        ].pack("NnnnnN")
+
+      else
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (unknown source class)"
+      end
+    end
+
+    def to_i
+      ints = @bytes.unpack("NNNN")
+      (ints[0] << 96) +
+      (ints[1] << 64) +
+      (ints[2] << 32) +
+      ints[3]
+    end
+
+    def version
+      time_high = @bytes.unpack("NnnQ")[2]
+      version = (time_high & 0xF000).to_s(16)[0].chr.to_i
+      version > 0 and version < 6 ? version : -1
+    end
+
+    def variant
+      @bytes.unpack('QnnN')[1] >> 13
+    end
+
+    def to_guid
+      elements = @bytes.unpack("NnnCCa6")
+      node = elements[-1].unpack('C*')
+      elements[-1] = '%02x%02x%02x%02x%02x%02x' % node
+      "%08x-%04x-%04x-%02x%02x-%s" % elements
+    end
+
+    def to_json(*args)
+      to_guid.to_json(*args)
+    end
+
+    def seconds
+      total_usecs / 1_000_000
+    end
+
+    def usecs
+      total_usecs % 1_000_000
+    end
+
+    def <=>(other)
+      total_usecs <=> other.send(:total_usecs)
+    end
+
+    def inspect(long = false)
+      "<Friendly::UUID##{object_id} time: #{
+        Time.at(seconds).inspect
+      }, usecs: #{
+        usecs
+      } jitter: #{
+        @bytes.unpack('QQ')[1]
+      }" + (long ? ", version: #{version}, variant: #{variant}, guid: #{to_guid}>" :  ">")
+    end
+
+    def <=>(other)
+      self.to_i <=> other.to_i
+    end
+
+    def hash
+      @bytes.hash
+    end
+
+    def eql?(other)
+      other.is_a?(Comparable) and @bytes == other.to_s
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+    def to_s
+      @bytes
+    end
+
+    def sql_literal(dataset)
+      dataset.literal(to_s)
+    end
+
+    private
+
+    def total_usecs
+      elements = @bytes.unpack("NnnQ")
+      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10
+    end
+  end
+end
+

data/lib/friendly.rb

@@ -0,0 +1,49 @@
+require 'friendly/attribute'
+require 'friendly/boolean'
+require 'friendly/cache'
+require 'friendly/cache/by_id'
+require 'friendly/config'
+require 'friendly/data_store'
+require 'friendly/document'
+require 'friendly/document_table'
+require 'friendly/index'
+require 'friendly/memcached'
+require 'friendly/query'
+require 'friendly/sequel_monkey_patches'
+require 'friendly/storage_factory'
+require 'friendly/storage_proxy'
+require 'friendly/translator'
+require 'friendly/uuid'
+
+require 'will_paginate/collection'
+
+module Friendly
+  class << self
+    attr_accessor :datastore, :db, :cache
+
+    def configure(config)
+      self.db        = Sequel.connect(config)
+      self.datastore = DataStore.new(db)
+    end
+
+    def batch
+      begin
+        datastore.start_batch
+        yield
+        datastore.flush_batch
+      ensure
+        datastore.reset_batch
+      end
+    end
+
+    def create_tables!
+      Document.create_tables!
+    end
+  end
+
+  class Error < RuntimeError; end
+  class RecordNotFound < Error; end
+  class MissingIndex < Error; end
+  class NoConverterExists < Friendly::Error; end
+  class NotSupported < Friendly::Error; end
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+config = YAML.load(File.read(RAILS_ROOT + "/config/friendly.yml"))[RAILS_ENV]
+Friendly.configure(config)
+

data/spec/fakes/data_store_fake.rb

@@ -0,0 +1,29 @@
+class DataStoreFake
+  attr_writer :insert, :all, :first
+  attr_reader :inserts, :updates
+
+  def initialize(opts = {})
+    opts.each { |k,v| send("#{k}=", v) }
+    @inserts = []
+    @updates = []
+  end
+
+  def insert(*args)
+    @inserts << args
+    @insert
+  end
+
+  def update(*args)
+    @updates << args
+    @update
+  end
+
+  def all(*args)
+    @all[args]
+  end
+
+  def first(*args)
+    @first[args]
+  end
+end
+