ihoka-friendly 0.6.2

data/lib/friendly/scope.rb

@@ -0,0 +1,100 @@
+module Friendly
+  class Scope
+    attr_reader :klass, :parameters
+
+    def initialize(klass, parameters)
+      @klass      = klass
+      @parameters = parameters
+    end
+
+    # Fetch all documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def all(extra_parameters = {})
+      klass.all(params(extra_parameters))
+    end
+
+    # Fetch the first document at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def first(extra_parameters = {})
+      klass.first(params(extra_parameters))
+    end
+
+    # Paginate the documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    # @return WillPaginate::Collection
+    #
+    def paginate(extra_parameters = {})
+      klass.paginate(params(extra_parameters))
+    end
+
+    # Build an object at this scope.
+    #
+    #   e.g.
+    #     Post.scope(:name => "James").build.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def build(extra_parameters = {})
+      klass.new(params_without_modifiers(extra_parameters))
+    end
+
+    # Create an object at this scope.
+    #
+    #   e.g.
+    #     @post = Post.scope(:name => "James").create
+    #     @post.new_record? # => false
+    #     @post.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def create(extra_parameters = {})
+      klass.create(params_without_modifiers(extra_parameters))
+    end
+
+    # Override #respond_to? so that we can return true when it's another named_scope.
+    #
+    # @override
+    #
+    def respond_to?(method_name, include_private = false)
+      klass.has_named_scope?(method_name) || super
+    end
+
+    # Use method_missing to respond to other named scopes on klass.
+    # 
+    # @override
+    #
+    def method_missing(method_name, *args, &block)
+      respond_to?(method_name) ? chain_with(method_name) : super
+    end
+
+    # Chain with another one of klass's named_scopes.
+    #
+    # @param [Symbol] scope_name The name of the scope to chain with.
+    #
+    def chain_with(scope_name)
+      self + klass.send(scope_name)
+    end
+
+    # Create a new Scope that is the combination of self and other, where other takes priority
+    #
+    # @param [Friendly::Scope] other The scope to merge with.
+    #
+    def +(other_scope)
+      self.class.new(klass, parameters.merge(other_scope.parameters))
+    end
+
+    protected
+      def params(extra)
+        parameters.merge(extra)
+      end
+
+      def params_without_modifiers(extra)
+        params(extra).reject { |k,v| k.to_s =~ /!$/ }
+      end
+  end
+end

data/lib/friendly/scope_proxy.rb

@@ -0,0 +1,43 @@
+module Friendly
+  class ScopeProxy
+    attr_reader :klass, :scope_klass, :scopes
+
+    def initialize(klass, scope_klass = Scope)
+      @klass       = klass
+      @scope_klass = scope_klass
+      @scopes      = {}
+    end
+
+    def add_named(name, parameters)
+      scopes[name] = parameters
+      add_scope_method_to_klass(name)
+    end
+
+    def get(name)
+      scopes[name]
+    end
+
+    def get_instance(name)
+      scope_klass.new(klass, get(name))
+    end
+
+    def ad_hoc(parameters)
+      scope_klass.new(klass, parameters)
+    end
+
+    def has_named_scope?(name)
+      scopes.has_key?(name)
+    end
+
+    protected
+      def add_scope_method_to_klass(scope_name)
+        klass.class_eval do
+          eval <<-__END__
+            def self.#{scope_name}
+              scope_proxy.get_instance(:#{scope_name})
+            end
+          __END__
+        end
+      end
+  end
+end

data/lib/friendly/sequel_monkey_patches.rb

@@ -0,0 +1,34 @@
+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,111 @@
+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
+
+    def index_for_fields(fields)
+      tables.detect do |t|
+        t.respond_to?(:fields) && t.fields == fields
+      end.tap do |i|
+        raise MissingIndex, "No index found matching #{fields.join(", ")}." if i.nil?
+      end
+    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,48 @@
+module Friendly
+  class TableCreator
+    attr_reader :db, :attr_klass
+
+    def initialize(db = Friendly.db, attr_klass = Friendly::Attribute)
+      @db         = db
+      @attr_klass = attr_klass
+    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)
+        attr = attr_klass # close around this please
+
+        db.create_table(table.table_name) do
+          binary :id, :size => 16
+          table.fields.flatten.each do |f|    
+            klass = table.klass.attributes[f].type
+            type  = attr.custom_type?(klass) ? attr.sql_type(klass) : klass
+            column(f, type)
+          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,35 @@
+require "rufus-json"
+
+module Friendly
+  class Translator
+    RESERVED_ATTRS = [:id, :created_at, :updated_at].freeze
+
+    attr_reader :serializer, :time
+
+    def initialize(serializer = Rufus::Json, time = Time)
+      @serializer = serializer
+      @time       = time
+    end
+
+    def to_object(klass, record)
+      record.delete(:added_id)
+      attributes = serializer.decode(record.delete(:attributes))
+      attributes.merge!(record).merge!(:new_record => false)
+      klass.new_without_change_tracking attributes
+    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.encode(attrs)
+      end
+  end
+end
+