activerecord-datastore-adapter 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+pkg/*
+*.gem
+.bundle
+*.sqlite3
+database.yml
+indexs.yml
+*.log
+WEB-INF

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dstore.gemspec
+gemspec
+
+gem 'rspec'
+gem 'appengine-sdk', '1.4.0'

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    activerecord-datastore-adapter (0.0.1)
+      activerecord (>= 3.0.3)
+      appengine-apis (= 0.0.22)
+      arel (>= 2.0.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.5)
+    appengine-apis (0.0.22)
+      appengine-rack
+    appengine-rack (0.0.12)
+      jruby-jars (>= 1.5.1)
+      jruby-rack (>= 1.0.1)
+      rack
+    appengine-sdk (1.4.0)
+    arel (2.0.9)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    jruby-jars (1.6.0)
+    jruby-rack (1.0.7)
+    rack (1.2.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    tzinfo (0.3.25)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  activerecord-datastore-adapter!
+  appengine-sdk (= 1.4.0)
+  rspec

data/README.textile

@@ -0,0 +1,38 @@
+h1. Datastore Adapter
+
+ActiveRecord Adatper for AppEngine Datastore. The AppEngine Datastore is not a relational database system. So, this adapter only support some basic features. 
+
+h2. Installation( under-construction )
+
+Use appengine-sdk (1.4.0)
+
+Create Rails 3 application:
+
+bc. rails new app_name -m http://siddick.github.com/datastore/rails3.rb
+cd app_name
+appcfg.rb run bin/rails g scaffold post title:string content:text  
+appcfg.rb run bin/rake db:migrate
+
+Run the server:
+
+bc. dev_appserver.rb .
+
+h2. Supported Features
+
+# has_many and belongs_to
+# migration
+# table indexes
+# operators( =, >, >=, <=, <>, in, and )
+
+h2. Not Supported
+
+Datastore is not a Relational Database system. So, you can't expect more.
+
+# Joins
+# operators( or, between, like, etc )
+
+h2. Bugs
+
+Please report the bugs.
+
+https://github.com/siddick/datastore/issues

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "Test examples"
+task :test do
+  raise "Need jruby" if RUBY_ENGINE != "jruby"
+  system 'rspec spec/*_spec.rb'
+end
+

data/activerecord-datastore-adapter.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "activerecord-datastore-adapter"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mohammed Siddick"]
+  s.email       = ["siddick@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/datastore"
+  s.summary     = %q{ActiveRecord Adapter for Appengine Datastore}
+  s.description = %q{Just an ActiveRecord Adapter for the Appengine Datastore. 
+    Create Rails3 application: rails new app_name -m http://siddick.github.com/datastore/rails3.rb}
+
+  s.rubyforge_project = "activerecord-datastore-adapter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency( 'appengine-apis', '0.0.22' )
+  s.add_dependency( 'activerecord', '>= 3.0.3' )
+  s.add_dependency( 'arel', '>= 2.0.7' )
+end

data/examples/rails3.rb

@@ -0,0 +1,71 @@
+
+remove_file 'Gemfile'
+create_file 'Gemfile' do
+<<-GEMFILE
+
+disable_system_gems
+disable_rubygems
+bundle_path ".gems/bundler_gems"
+
+gem 'rails', '~> 3.0.5'
+gem 'activerecord-datastore-adapter'
+gem 'jruby-rack', '1.0.5'
+
+GEMFILE
+end
+
+remove_file 'config/boot.rb'
+create_file 'config/boot.rb' do
+<<-BOOT
+
+String.class_eval do
+  alias :old_plus :+
+  def +( val )
+    if( val.is_a? Array )
+      [ self ] + val
+    else
+      old_plus val
+    end
+  end
+end
+BOOT
+end
+
+
+remove_file 'config/database.yml'
+create_file 'config/database.yml' do
+<<-DATABASE
+development:
+  adapter: datastore
+  database: db/database.yml
+
+test:
+  adapter: datastore
+  database: db/test.yml
+
+production:
+  adapter: datastore
+  database: db/database.yml
+DATABASE
+end
+
+gsub_file 'config/application.rb', /Bundler/ do
+    "# Bundler"
+end
+
+gsub_file 'config/application.rb', /class Application < Rails::Application$/ do
+  "class Application < Rails::Application
+      require 'appengine-apis/logger'
+      config.logger = AppEngine::Logger.new
+  "
+end
+
+create_file 'config/initializers/cache_store.rb' do
+<<-CACHE_STORE
+#require 'appengine-apis/memcache'
+#ActionController::Base.cache_store = AppEngine::Memcache.new
+CACHE_STORE
+end
+
+
+system "appcfg.rb generate_app ."

data/examples/rails3_local.rb

@@ -0,0 +1,81 @@
+
+remove_file 'Gemfile'
+create_file 'Gemfile' do
+<<-GEMFILE
+
+disable_system_gems
+disable_rubygems
+bundle_path ".gems/bundler_gems"
+
+gem 'rails', '~> 3.0.5'
+gem 'appengine-apis', '>= 0.0.22'
+
+GEMFILE
+end
+
+remove_file 'config/boot.rb'
+create_file 'config/boot.rb' do
+<<-BOOT
+  
+String.class_eval do
+  alias :old_plus :+
+  def +( val )
+    if( val.is_a? Array )
+      [ self ] + val
+    else
+      old_plus val
+    end
+  end
+end
+
+File.class_eval do
+  class << self
+    alias :old_expand_path :expand_path
+    def expand_path( *args )
+      fn = old_expand_path( *args )
+      fn.sub(/^.*file:/, 'file:') if fn
+    end
+  end
+end
+
+$LOAD_PATH.push( '../../lib' )
+BOOT
+end
+
+remove_file 'config/database.yml'
+create_file 'config/database.yml' do
+<<-DATABASE
+development:
+  adapter: datastore
+  database: development.yml
+
+test:
+  adapter: datastore
+  database: test.yml
+
+production:
+  adapter: datastore
+  database: development.yml
+DATABASE
+end
+
+gsub_file 'config/application.rb', /Bundler/ do
+    "# Bundler"
+end
+
+gsub_file 'config/application.rb', /class Application < Rails::Application$/ do
+  "class Application < Rails::Application
+      require 'appengine-apis/logger'
+      config.logger = AppEngine::Logger.new
+  "
+end
+
+create_file 'config/initializers/cache_store.rb' do
+<<-CACHE_STORE
+#require 'appengine-apis/memcache'
+#ActionController::Base.cache_store = AppEngine::Memcache.new
+CACHE_STORE
+end
+
+
+system "appcfg.rb generate_app ."

data/lib/active_record/connection_adapters/datastore_adapter.rb

@@ -0,0 +1,266 @@
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_support/core_ext/kernel/requires'
+require 'active_support/core_ext/object/blank'
+require 'set'
+
+# Patch
+require 'active_record/datastore_associations_patch'
+
+require 'yaml'
+require 'arel/visitors/datastore'
+
+module ActiveRecord
+  class Base
+    def self.datastore_connection(config) # :nodoc:
+      ConnectionAdapters::DatastoreAdapter.new( ConnectionAdapters::DatastoreAdapter::DB.new( config.symbolize_keys ), logger )
+    end
+  end
+
+  module ConnectionAdapters
+    class DatastoreAdapter < AbstractAdapter
+      ADAPTER_NAME = "Datastore"
+
+      def adapter_name #:nodoc:
+        ADAPTER_NAME
+      end
+      
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      def supports_primary_key? #:nodoc:
+        true
+      end
+
+      def supports_autoincrement? #:nodoc:
+        true
+      end
+
+      def select( sql, name = nil, binds = [] )
+        log( sql.inspect, name ) {
+          @connection.select_query( sql.q, sql.options )
+        }
+      end
+
+      def select_rows(sql, name = nil)
+        select(sql, name).map{|r| r.map{|k,v| v } }
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        log( "Insert: " + sql.inspect, name ){
+          @connection.insert_query( sql )
+        }
+      end
+
+      def update( sql, name = nil)
+        log( "Update: VALUES(#{sql.options[:values].collect{|k,v|k.to_s + " = " + v.inspect}.join(", ")}) " + sql.inspect, name ) {
+          @connection.update_query( sql.q, sql.options[:values] )
+        }
+      end
+      
+      def delete(sql, name = nil)
+        log( "Delete: " + sql.inspect, name ) {
+          @connection.delete_query( sql.q )
+        }
+      end
+
+
+      def execute(sql, name = nil)
+        log("Not Support: " + sql, name) {
+          #@connection.execute( sql )
+        } 
+      end
+
+      def create_table( table_name, options = {} )
+        log( "CREATE TABLE #{table_name}", "Datastore Adapter" ) {
+          td = TableDefinition.new(self)
+          td.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
+
+          yield td if block_given?
+
+          fields = {}
+          td.columns.each{|c| fields[c.name.to_s] = { "default" => c.default, "type" => c.type.to_s, "null" => c.null } }
+          @connection.create_table( table_name, fields )
+          td
+        }
+      end
+
+      def drop_table( tname, options = {} )
+        @connection.drop_table( tname )
+      end
+
+      def rename_table( tname, ntname )
+        @connection.drop_table( tname, ntname )
+      end
+
+      def add_column(table_name, column_name, type, options = {})
+        @connection.add_column( table_name, column_name, type, options )
+      end
+
+      alias :change_column :add_column
+
+      def add_index(table_name, column_name, options = {})
+        @connection.add_index( table_name, column_name, options )
+      end
+
+      def remove_index(table_name, column_name )
+        @connection.remove_index( table_name, column_name )
+      end
+
+      def tables
+        @connection.tables.keys
+      end
+
+      def columns( table_name, name = nil)
+        @connection.columns( table_name, name ).collect{|k,opt|
+          is_primary = opt["type"] == "primary_key"
+          c = Column.new( k, opt["default"], is_primary ? "integer" : opt["type"].to_s, opt["null"] )
+          c.primary = true if is_primary
+          c
+        } 
+      end
+      
+      def primary_key( table_name )
+        column = @connection.columns( table_name ).find{|k,opt|
+          opt["type"] == "primary_key"
+        }
+        column ? column[0] : nil
+      end
+
+      class DB
+        def initialize( config )
+          @config = { :database => 'database.yaml', :index => 'index.yaml', :namespace => 'dev' }.merge( config )
+          if( @config[:database] and File.exist? @config[:database] )
+            @tables = YAML.load( File.open( @config[:database], "r" ) )
+          else
+            @tables = {}
+          end
+
+          if( @config[:index] and File.exist? @config[:index] )
+            @indexes = YAML.load( File.open( @config[:index], "r" ) )
+            @indexes = @indexes[:indexes] || []
+          else
+            @indexes = []
+          end
+        end
+
+        def create_table( tname, fields )
+          @tables[tname] = fields
+          save_schema
+        end
+
+        def drop_table( tname, options = {} )
+          @tables.delete(tname)
+          save_schema
+        end
+
+        def rename_table( tname, ntname )
+          value = @tables.delete(tname)
+          if( value )
+            @tables[ntname] = value 
+            save_schema
+          end
+        end
+
+        def add_column(table_name, column_name, type, options = {})
+          @tables[table_name][column_name] = { "type" => type.to_s, "default" => options[:default], "null" => options[:null] }
+          save_schema
+        end
+
+        alias :change_column :add_column
+
+        def add_index(table_name, column_name, options = {})
+          table_name  = table_name.to_s
+          column_name = [ column_name ] unless column_name.is_a? Array
+          column_name.map!{|c| c.to_s }
+          inds = @indexes.find_all{|i| i["kind"] == table_name and i["properties"].map{|p| p["name"] } == column_name }
+          if inds.empty?
+            @indexes.push( { "kind" => table_name, "properties" => column_name.map{|c| { "name" => c } } } )
+            save_indexes
+          end
+        end
+
+        def remove_index(table_name, column_name )
+          table_name  = table_name.to_s
+          column_name = column_name[:column] if column_name.is_a? Hash
+          column_name = [ column_name ] unless column_name.is_a? Array
+          column_name.map!{|c| c.to_s }
+          inds = @indexes.delete_all{|i| i["kind"] == table_name and i["properties"].map{|p| p["name"] } == column_name }
+          save_indexes
+        end
+
+        def save_indexes
+          f = File.open( @config[:index], 'w' )
+          f.write( { "indexes" => @indexes }.to_yaml )
+          f.close
+        end
+
+        def save_schema
+          f = File.open( @config[:database], 'w' )
+          f.write( @tables.to_yaml )
+          f.close
+        end
+        
+        def tables
+          @tables
+        end
+
+        def columns( table_name, name = nil )
+          if tables[table_name]
+            tables[table_name]
+          end
+        end
+
+        def primary_key( tname )
+          'id'
+        end
+
+        def select_query( q, options = {} )
+          output = []
+          if( options[:empty] )
+            []
+          elsif( options[:count] )
+            output.push( { "count" => q.count() } )
+          else
+            t_name = q.kind
+            p_key  = primary_key( t_name )
+            column_list = columns( t_name )  
+            q.fetch(options).each{|e| 
+              h = {}
+              column_list.each{|n,opt|
+                h[n] = ( n == p_key ? e.key.id : e[n] )
+              }
+              output.push( h )
+            }
+          end
+          output
+        end
+
+        def insert_query( q )
+          AppEngine::Datastore.put q
+          q.key.id
+        end
+
+        def update_query( q, values = nil )
+          if( values and values.size > 0 )
+            entities = []
+            q.each{|e|
+              values.each{|k,v| e[k] = v }
+              entities.push(e)
+            }
+            AppEngine::Datastore.put entities 
+          end
+        end
+
+        def delete_query( q )
+          keys = []
+          q.each{|e| keys.push e.key }
+          AppEngine::Datastore.delete keys
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/active_record/datastore_associations_patch.rb

@@ -0,0 +1,65 @@
+require 'active_record/associations'
+require 'active_record/associations/has_many_association'
+require 'active_record/associations/has_many_through_association'
+
+ActiveRecord::Associations::HasManyAssociation.class_eval do
+  def owner_id
+    if @reflection.options[:primary_key]
+      @owner.send(@reflection.options[:primary_key])
+    else
+      @owner.id
+    end
+  end
+
+  def construct_sql
+    case
+    when @reflection.options[:finder_sql]
+      @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+    when @reflection.options[:as]
+      @finder_sql = { ( @reflection.options[:as]+ "_id" ) => owner_id,
+        ( @reflection.options[:as] + "_type" ) => @owner.class.quote_value(@owner.class.base_class.name.to_s) }
+      @finder_sql.merge!( conditions ) if conditions
+    else
+      @finder_sql = { @reflection.primary_key_name => owner_id }
+      @finder_sql.merge!( conditions ) if conditions
+    end
+
+    construct_counter_sql
+  end
+end
+
+ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
+
+  def owner_id
+    if @reflection.options[:primary_key]
+      @owner.send(@reflection.options[:primary_key])
+    else
+      @owner.id
+    end
+  end
+
+
+  def construct_conditions
+    if @reflection.source_reflection.macro == :belongs_to
+      source_primary_key = @reflection.source_reflection.primary_key_name
+    else
+      source_primary_key = @reflection.through_reflection.klass.primary_key
+    end
+    ids = @owner.send(@reflection.options[:through]).map{|t| t.send(source_primary_key) }
+    conditions = { :id => ids }
+  end
+
+
+  def construct_scope
+    { :create => construct_owner_attributes(@reflection),
+      :find   => { :conditions  => construct_conditions,
+#        :joins       => construct_joins,
+        :include     => @reflection.options[:include] || @reflection.source_reflection.options[:include],
+        :select      => construct_select,
+        :order       => @reflection.options[:order],
+        :limit       => @reflection.options[:limit],
+        :readonly    => @reflection.options[:readonly],
+    } }
+  end
+
+end

data/lib/arel/visitors/datastore.rb

@@ -0,0 +1,144 @@
+require 'arel'
+require 'arel/visitors'
+require 'arel/visitors/to_sql'
+require 'appengine-apis/datastore'
+
+module Arel
+  module Visitors
+    class Datastore < Arel::Visitors::ToSql
+
+      class QString
+        attr :kind
+        attr :q 
+        attr :options
+        attr :connection
+
+        def initialize( conn, kind, options = {} )
+          @connection = conn
+          @kind = kind
+          @q = AppEngine::Datastore::Query.new( kind )
+          @options = options
+        end
+
+        def to_s
+          out = q.inspect 
+          out += " OFFSET #{options[:offset]} " if options[:offset]  
+          out += " LIMIT  #{options[:limit]} "  if options[:limit]  
+          out
+        end
+
+        alias :inspect :to_s
+
+        def projections( projs )
+          projs.each{|p|
+            if( p.is_a? Arel::Nodes::Count )
+              options[:count] = true
+            end
+          }
+          self
+        end
+
+        def wheres( conditions )
+          conditions.each{|w|
+            w_expr  = w.expr rescue w
+            if( w_expr.class != Arel::Nodes::SqlLiteral )
+              key     = w_expr.left.name
+              val     = w_expr.right
+              opt     = w_expr.operator
+              apply_filter( key, opt, val )
+            else
+              parese_expression_string( w_expr.to_s )
+            end
+          }
+          self
+        end
+
+        TypeCast = {
+          :primary_key => lambda{|k,v| AppEngine::Datastore::Key.from_path( k, v.to_i ) },
+          :integer     => lambda{|k,i| i.to_i },
+          :datetime    => lambda{|k,t| t.is_a?(Time)? t : Time.parse(t.to_s) },
+          :date        => lambda{|k,t| t.is_a?(Date)? t : Date.parse(t.to_s) },
+          :float       => lambda{|k,f| f.to_f }
+        }
+        InScan = /'((\\.|[^'])*)'|(\d+)/
+        def apply_filter( key, opt, value )
+          key, opt = key.to_sym, opt.to_sym
+          column = @connection.columns(kind).find{|c| c.name == key.to_s }
+          opt = :in      if value.is_a? Array
+          type_cast_proc = TypeCast[ column.primary ? :primary_key : column.type ]
+          if opt == :in or opt == :IN
+            value = value.scan(InScan).collect{|d| d.find{|i| i}}   if value.is_a? String
+            value.collect!{|v| type_cast_proc.call(kind,v) }        if type_cast_proc
+            options[:empty], value = true, [ "EMPTY" ]              if value.empty?
+          else
+            value = type_cast_proc.call( kind, value ) if type_cast_proc
+          end
+          key = :__key__ if column.primary
+          q.filter( key, opt, value )
+        end
+
+        
+        RExpr = Regexp.union( /(in)/i,
+                     /\(\s*(('((\\.|[^'])*)'|\d+)(\s*,\s*('((\\.|[^'])*)'|\d+))*)\s*\)/,
+                     /"((\\.|[^"])*)"/,
+                     /'((\\.|[^'])*)'/,
+                     /([\w\.]+)/,
+                     /([^\w\s\.'"]+)/ )
+        Optr      = { "=" => :== }
+        ExOptr    = ["(",")"]
+        def parese_expression_string( query )
+          datas = query.scan( RExpr ).collect{|a| a.find{|i| i } }
+          datas.delete_if{|d| ExOptr.include?(d) }
+          while( datas.size >= 3 )
+            key = datas.shift.sub(/^[^.]*\./,'').to_sym
+            opt = datas.shift
+            val = datas.shift
+            concat_opt = datas.shift
+            apply_filter( key, Optr[opt] || opt.to_sym, val )
+          end
+        end
+
+        def orders( ords )
+          ords.each{|o|
+            if( o.is_a? String )
+              key, dir, notuse = o.split
+            else
+              key, dir = o.expr, o.direction
+            end
+            q.sort( key, dir )
+          }
+          self
+        end
+      end
+
+      def get_limit_and_offset( o )
+        options = {}
+        options[:limit]  = o.limit.expr if o.limit
+        options[:offset] = o.offset.expr if o.offset
+        options
+      end
+
+      def visit_Arel_Nodes_SelectStatement o
+        c    = o.cores.first
+        QString.new( @connection, c.froms.name, get_limit_and_offset(o) ).wheres( c.wheres ).orders(o.orders).projections( c.projections )
+      end
+
+      def visit_Arel_Nodes_InsertStatement o
+        e = AppEngine::Datastore::Entity.new(o.relation.name)
+        o.columns.each_with_index{|c,i| e[c.name] = o.values.left[i] }
+        e
+      end
+
+      def visit_Arel_Nodes_UpdateStatement o
+        QString.new( @connection, o.relation.name, :values => o.values.collect{|v| [ v.left.name, v.right ] } ).wheres( o.wheres )
+      end
+
+      def visit_Arel_Nodes_DeleteStatement o
+        QString.new( @connection, o.relation.name ).wheres( o.wheres )
+      end
+
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['datastore'] = Arel::Visitors::Datastore

data/spec/create_table_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+
+describe AppEngine::Datastore do
+  Datastore = AppEngine::Datastore
+  
+  before :each do
+    AppEngine::Testing.install_test_datastore
+  end
+
+  it "should support get/put" do
+
+  end
+
+end

data/spec/datatypes_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class User < ActiveRecord::Base
+
+  validates_uniqueness_of :name
+
+  connection.create_table table_name, :force => true do |t|
+    t.string      :name,  :limit => 25
+    t.datetime    :dob
+    t.integer     :rating
+    t.float       :score
+
+    t.timestamps
+  end
+end
+
+describe Person do
+
+  before :each do
+    AppEngine::Testing.install_test_datastore
+  end
+
+  it "time object" do
+    name = "guest"
+    dob  = Time.now
+    user = User.create!( :name => "guest", :dob => dob )
+    user.dob.should == dob
+
+    user = User.first
+    user.dob.should == dob
+
+    user = User.find_by_dob( dob )
+    user.dob.should == dob
+  end
+
+  it "rating object" do
+    5.times{|i|
+      User.create!( :name => "guest#{i}", :rating => i )
+    }
+    users = User.where( " rating >= 1 and rating <= 3 " )
+    users.all.size.should == 3
+  end
+end

data/spec/operators_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Person do
+  before :each do
+    AppEngine::Testing.install_test_datastore
+  end
+
+  it " in operator" do
+    Person.create!( :name => "guest" )
+    people = Person.where( " created_at <= ? ", Time.now + 1 )
+    people.all.size.should_not == 0
+
+    people = Person.where( :name => [ "guest", "not_guest" ] )
+    people.all.size.should == 1
+
+    people = Person.where( " name in('guest','not_guest')" )
+    people.all.size.should == 1
+
+    people = Person.where( " name in( 'guest', 'not_guest' )" )
+    people.all.size.should == 1
+
+    people = Person.where( "( name in( 'guest', 'not_guest' ) )" )
+    people.all.size.should == 1
+
+    people = Person.where( "(name in( 'guest', 'not_guest' ))" )
+    people.all.size.should == 1
+  end
+
+end

data/spec/query_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+
+describe Person do
+  before :each do
+    AppEngine::Testing.install_test_datastore
+  end
+
+  it "init record" do
+    person_name = "guest"
+    person = Person.new( :name => person_name )
+    person.id.should == nil
+    person.name.should == person_name
+  end
+
+  it "save record" do
+    person_name = "guest"
+    person = Person.new( :name => person_name )
+    person.save.should == true
+  end
+
+  it "record have id" do
+    person_name = "guest"
+    person = Person.new( :name => person_name )
+    person.save.should == true
+    person.id.should_not  == nil
+  end
+
+  it "retrive the record by id" do
+    person_name = "guest"
+    person = Person.new( :name => person_name )
+    person.save
+    find_person = Person.find( person.id )
+    find_person.name.should == person_name
+  end
+
+  it "retrive the record by name" do
+    person_name = "guest"
+    person = Person.new( :name => person_name )
+    person.save
+    find_person = Person.find_by_name( person_name )
+    find_person.name.should == person_name
+  end
+
+  it "retrive the record by name and description" do
+    person_name = "guest"
+    person_description = "description"
+    Person.create!( :name => person_name, :description => person_description )
+    find_person = Person.where( :name => person_name, :description => person_description ).first
+    find_person.name.should == person_name
+    find_person.description.should == person_description
+  end
+
+  it "update the record" do
+    person_name     = "guest"
+    new_person_name = "new_guest"
+    person = Person.create!( :name => person_name )
+    person.name.should        == person_name
+
+    person.update_attributes( :name => new_person_name ).should == true
+    person.name.should  == new_person_name
+
+    person = Person.find_by_name( new_person_name )
+    person.name.should  == new_person_name 
+  end
+
+  it "destroy the record" do
+    person_name = "guest"
+    person = Person.create!( :name => person_name )
+    person.should_not == nil
+
+    person = Person.find_by_name( person_name )
+    person.should_not == nil
+
+    person.destroy
+
+    person = Person.find_by_name( person_name )
+    person.should == nil
+  end
+
+end

data/spec/relations_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Person do
+  before :each do
+    AppEngine::Testing.install_test_datastore
+  end
+
+  it "create person on role" do
+    person = Person.create!( :name => "guest" )
+    role   = Role.create!( :name => "guest" )
+    person.roles.push( role )
+
+    person.save.should == true
+
+    person = Person.find_by_name( "guest" )
+    person.roles.size.should == 1
+
+    role   = Role.find_by_name( "guest" )
+    role.people.size.should == 1
+
+    person.roles.build( :name => "admin" )
+    person.save.should == true
+
+    person = Person.find_by_name( "guest" )
+    person.roles.size.should == 2
+
+    Role.all.size.should == 2
+    PersonRole.all.size.should == 2
+
+    person = Person.find_by_name( "guest" )
+    person.destroy
+
+    PersonRole.all.size.should == 0
+    Person.all.size.should == 0
+    Role.all.size.should == 2
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+require 'rubygems'
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+Bundler.require(:default)
+
+require 'appengine-sdk'
+require 'appengine-apis/testing'
+AppEngine::Testing.setup
+
+require 'appengine-apis/datastore'
+
+require 'active_record'
+require 'logger'
+
+
+ActiveRecord::Base.logger = Logger.new( File.open( File.expand_path('../test.log', __FILE__),  "w") )
+db_config_path    = File.expand_path('../database.yml', __FILE__)
+index_config_path = File.expand_path('../indexs.yml', __FILE__)
+ActiveRecord::Base.establish_connection( :adapter => 'datastore', :database => db_config_path, :index => index_config_path )
+require 'table_schema'
+
+
+class ProtoMatcher
+  def compare(hash, proto, prefix='')
+    hash.each do |key, value|
+      name = "#{prefix}#{key}"
+      case value
+      when Array
+        if value[0].kind_of? Hash
+          count = proto.send("#{key}_size")
+          compare_value("#{name}.size", value.size, count)
+          value.each_with_index do |item, index|
+            break if index == count
+            compare(item, proto.send(key, index), "#{name}[#{index}].")
+          end
+        else
+          actual = proto.send("#{key}s").to_a
+          compare_value(name, value, actual)
+        end
+      when Hash
+        compare(value, proto.send(key), "#{name}.")
+      else
+        compare_value(name, value, proto.send(key))
+      end
+    end
+  end
+
+  def compare_value(label, expected, actual)
+    if expected != actual
+      @failures << "%s differs. expected: %s actual: %s" %
+          [label, expected.inspect, actual.inspect]
+    end
+  end
+
+  def initialize(klass, expected)
+    @klass = klass
+    @expected = expected
+  end
+
+  def matches(bytes)
+    @failures = []
+    @proto = @klass.new
+    @proto.parse_from(bytes)
+    compare(@expected, @proto)
+    @failures.empty?
+  end
+
+  def ==(bytes)
+    Spec::Expectations.fail_with(failure_message) unless matches(bytes)
+    true
+  end
+
+  def failure_message
+    @failures.join("\n")
+  end
+end
+
+module ProtoMethods
+  def proto(klass, hash)
+    ProtoMatcher.new(klass, hash)
+  end
+  alias be_proto proto
+
+  def mock_delegate
+    delegate = mock("apiproxy")
+    delegate.instance_eval do
+      class << self
+        include AppEngine::ApiProxy::Delegate
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ProtoMethods)
+end

data/spec/table_schema.rb

@@ -0,0 +1,40 @@
+class Person < ActiveRecord::Base
+  has_many :person_roles, :dependent => :destroy
+  has_many :roles, :through => :person_roles
+
+  validates_uniqueness_of :name
+
+  connection.create_table table_name, :force => true do |t|
+    t.string :name
+    t.string :description
+    t.text   :data
+
+    t.timestamps
+  end
+end
+
+class Role < ActiveRecord::Base
+  has_many :person_roles, :dependent => :destroy
+  has_many :people, :through => :person_roles
+
+  connection.create_table table_name, :force => true do |t|
+    t.string :name
+
+    t.timestamps
+  end
+end
+
+class PersonRole < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :role
+
+
+  connection.create_table table_name, :force => true do |t|
+    t.integer :person_id
+    t.integer :role_id
+
+    t.timestamps
+  end
+
+  connection.add_index table_name, [ :person_id, :role_id ]
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-datastore-adapter
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Mohammed Siddick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-06 00:00:00 +05:30
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: appengine-apis
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 0.0.22
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: activerecord
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 3.0.3
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: arel
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.0.7
+    type: :runtime
+    version_requirements: *id003
+description: |-
+  Just an ActiveRecord Adapter for the Appengine Datastore. 
+      Create Rails3 application: rails new app_name -m http://siddick.github.com/datastore/rails3.rb
+email: 
+  - siddick@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - Gemfile
+  - Gemfile.lock
+  - README.textile
+  - Rakefile
+  - activerecord-datastore-adapter.gemspec
+  - examples/rails3.rb
+  - examples/rails3_local.rb
+  - lib/active_record/connection_adapters/datastore_adapter.rb
+  - lib/active_record/datastore_associations_patch.rb
+  - lib/arel/visitors/datastore.rb
+  - spec/create_table_spec.rb
+  - spec/datatypes_spec.rb
+  - spec/operators_spec.rb
+  - spec/query_spec.rb
+  - spec/relations_spec.rb
+  - spec/spec_helper.rb
+  - spec/table_schema.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/datastore
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: activerecord-datastore-adapter
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: ActiveRecord Adapter for Appengine Datastore
+test_files: []
+