activerecord-crate-adapter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56df652b663e2d0dd2abcc83154b07b1575ee21b
+  data.tar.gz: f9c8908ea5f6f296d05a16f4502ce12f430d8921
+SHA512:
+  metadata.gz: bf7d9a0a55a82065e81fbb3f9a1406e8524b81fef1f8803c0b0594eb4136b26a0af7fc20cf44439fca7390f49b42c4a6e7fde56dfc332c7a38baa9c9fb0689ff
+  data.tar.gz: 6d0d522e9680e251477fada311f1a023ce349a507e43e13f668ee1210d2f7173997885e5da312c9eea957c5fddef827a88e35e24cc2c8f2cda25c87e441041ae

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+.rvmrc
+crate_test_server*
+*.log
+log/*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-crate-adapter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Christoph Klocker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# Activerecord::Crate::Adapter
+
+The [Crate](http://www.crate.io) adapter for ActiveRecord.
+
+## Work in progress
+
+I've just started coding the adapter and lots of functionality might still not work. Give it a try
+and help bei either contributing (fix it) or add an issue.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-crate-adapter', :git => "https://github.com/crate/activerecord-crate-adapter.git"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-crate-adapter
+
+## Usage
+
+When using Rails update your database.yml
+
+     development:
+       adapter: crate
+       host: 127.0.0.1
+       port: 4200
+
+Crate doesn't come with an autoincrement feature for your model ids. So you need to set
+it yourself. One way is to use SecureRandom.uuid, if you think there is a better one,
+please add an issue so we can discuss.
+
+    class Post < ActiveRecord::Base
+
+      before_validation :set_id
+
+      private
+
+      def set_id
+        self.id = SecureRandom.uuid
+      end
+
+    end
+    
+## Special Data Types
+
+### Array
+You can simply create Array columns by specifying t.array and passing array_type when you create a migration. You need at least the upcoming
+release 0.39 of Crate for this functionality.
+ 
+    t.array :tags, array_type: :string
+    t.array :votes, array_type: :integer
+    t.array :bool_arr, array_type: :boolean
+    
+When you create an object just pass your Array directly
+
+    Post.create!(title: 'Arrays are awesome', tags: %w(hot fresh), votes: [1,2])
+    post = Post.where("'fresh' = ANY (tags)")    
+
+### Object
+Crate allows you to define nested objects. You need at least the upcoming
+release 0.39 of Crate for this functionality. I tried to make it as simply as possible to use and reuse existing AR functionality,
+I therefore ask you to reuse the existing serialize functionality. AR#serialize allows you to define your own serialization
+mechanism and we simply reuse that for serializing an AR object. To get serialize working simply create a #dump and #load method 
+on the class that creates a literal statement that is then used in the SQL. Read up more in this [commit}(https://github.com/crate/crate/commit/16a3d4b3f23996a327f91cdacef573f7ba946017).
+
+I tried to make your guys life easier and created a module that does this automatically for you. Simply make all attributes accessible
+and assign it in the initializer. So a serialized class should look like this:
+
+    require 'active_record/attribute_methods/crate_object'
+    
+    class Address
+      attr_accessor :street, :city, :phones, :zip
+    
+      include CrateObject
+    
+      def initialize(opts)
+        @street = opts[:street]
+        @city = opts[:city]
+        @phones = opts[:phones]
+        @zip = opts[:zip]
+      end
+    
+    end
+
+Check out CrateObject module if you need to write your own serializer. 
+ 
+Then in your model simply use #serialize to have objects working
+
+      class User < ActiveRecord::Base        
+        serialize :address, Address  
+      end
+
+Note: I do not plan to support nested objects inside objects.
+
+#### Object Migrations
+
+In the migrations you can create an object and specify the object behaviour(strict|dynamic|ignored) and it's schema.
+    
+    t.object :address, object_schema_behaviour: :strict,
+                       object_schema: {street: :string, city: :string, phones: {array: :string}, zip: :integer}
+      
+   
+
+## Migrations
+
+Currently adding and dropping indices is not support by Crate. Issue [#733](https://github.com/crate/crate/issues/733)
+
+    # not supported by Crate yet
+    add_index :posts, :comment_count
+    remove_index :posts, :comment_count
+
+
+## Gotchas
+
+Crate is eventually consistent, that means if you create a record and query for it right away it
+won't work (except queries for the primary key!). Read more about it [here](https://github.com/crate/crate/blob/master/docs/sql/dml.txt#L569)
+
+Crate does not support Joins (yet) so joins won't work.
+
+## Tests
+
+First run the test instance of crate
+
+    $ ./spec/test_server.rb
+
+then run the tests
+
+    $ rspec spec
+
+## Contributing
+
+This adapter is a work in progress. If you think something is missing, either follow the steps below
+or log a new issue, so someone else can tackle it.
+
+1. Fork it ( `http://github.com/crate/activerecord-crate-adapter/fork` )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Add tests
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+##Maintainer
+
+* [Christoph Klocker](http://www.vedanova.com), [@corck](http://www.twitter.com/corck)
+
+##License
+MIT License. Copyright 2014 Christoph Klocker. [http://vedanova.com](http://vedanova.com)

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'debugger'
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "bundle exec irb -rubygems -I lib -r ./lib/activerecord-crate-adapter.rb"
+end
+
+

data/activerecord-crate-adapter.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-crate-adapter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-crate-adapter"
+  spec.version       = ActiverecordCrateAdapter::VERSION
+  spec.authors       = ["Christoph Klocker"]
+  spec.email         = ["christoph@vedanova.com"]
+  spec.summary       = "ActiveRecord Crate Data Adapter"
+  spec.description   = "ActiveRecord adapter for Crate, a shared-nothing, fully searchable, document-oriented cluster data store."
+  spec.homepage      = "https://crate.io"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "debugger"
+  spec.add_development_dependency "rspec", "~> 2.14"
+
+  spec.add_dependency('activerecord', '>= 4.0.0')
+  spec.add_dependency('arel', '>= 4.0.0')
+  spec.add_dependency('crate_ruby', '~> 0.0.5')
+
+end

data/history.txt

@@ -0,0 +1,9 @@
+# coding: UTF-8
+
+=== 0.0.1
+
+Initial Release
+
+  * Array data types
+  * Supports regular data types
+  * Supports Migrations

data/lib/active_record/attribute_methods/crate_object.rb

@@ -0,0 +1,31 @@
+module CrateObject
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def load(object)
+      case object
+        when String
+          object.gsub!('=', ':')
+          object = JSON.parse("{#{object}}")
+      end
+      new(object.symbolize_keys)
+    end
+
+    def dump(object)
+      object ? object.to_literals : nil
+    end
+  end
+
+
+  def to_literals
+    arr = []
+    instance_variables.each do |var|
+      v = instance_variable_get(var)
+      value = v.is_a?(Array) ? v : %Q{"#{v}"}
+      arr << %Q{"#{var.to_s.gsub(/@/, '')}"=#{value}}
+    end
+    arr.join(', ')
+  end
+end
+
+

data/lib/active_record/connection_adapters/crate/database_statements.rb

@@ -0,0 +1,59 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+      def exec_query(sql, name = 'SQL', binds = [])
+        result = nil
+        log(sql, name, binds) {
+          result = do_exec_query(sql, name, binds)
+        }
+        fields = result.cols
+        ActiveRecord::Result.new(fields, result.values)
+      end
+
+      # Converts an arel AST to SQL
+      def to_sql(arel, binds = [])
+        if arel.respond_to?(:ast)
+          binds = binds.dup
+          visitor.accept(arel.ast) do
+            quote(*binds.shift.reverse)
+          end
+        else
+          arel
+        end
+      end
+
+      def do_exec_query(sql, name, binds)
+        params = []
+        binds.each_with_index do |(column, value), index|
+          ar_column = column.is_a?(ActiveRecord::ConnectionAdapters::Column)
+          next if ar_column && column.sql_type == 'timestamp'
+          v = value
+          quoted_value = ar_column ? quote(v, column) : quote(v, nil)
+          params << quoted_value
+        end
+        params.each { |p| sql.sub!(/(\?)/, p) }
+        @connection.execute sql
+      end
+
+      # Returns the statement identifier for the client side cache
+      # of statements
+      def sql_key(sql)
+        sql
+      end
+
+      # Executes an SQL statement, returning a ResultSet object on success
+      # or raising a CrateError exception otherwise.
+      def execute(sql, name = nil)
+        log(sql, name) do
+          @connection.execute(sql)
+        end
+      end
+
+      protected
+      def select(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+    end
+  end
+end

data/lib/active_record/connection_adapters/crate/quoting.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Crate
+      module Quoting
+        # Quotes the column value to help prevent
+        # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+        def quote(value, column = nil)
+          # records are quoted as their primary key
+          return value.quoted_id if value.respond_to?(:quoted_id)
+
+          if value.is_a?(Array)
+            "#{value}".gsub('"', "'")
+          elsif column.sql_type == 'object'
+            "{ #{value} }"
+          else
+            super(value, column)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/crate/schema_statements.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Crate
+      class SchemaCreation < AbstractAdapter::SchemaCreation
+
+        private
+
+        def add_column_options!(sql, options)
+          if options[:array] || options[:column].try(:array)
+            sql.gsub!(/(.*)\s(\w+)$/, '\1 array(\2)')
+          end
+          super(sql, options)
+        end
+
+      end
+
+      module SchemaStatements
+        def primary_key(table_name)
+          res = @connection.execute("select constraint_name from information_schema.table_constraints
+where table_name = '#{quote_table_name(table_name)}' and constraint_type = 'PRIMARY_KEY'")
+          res[0].try(:first).try(:first)
+        end
+
+        # overriding as Crate does not support "version primary key" syntax. Need to add the column type.
+        def initialize_schema_migrations_table
+          unless table_exists?('schema_migrations')
+            execute("CREATE TABLE schema_migrations (version string primary key INDEX using plain)")
+          end
+        end
+
+        def add_index(table_name, column_name, options = {}) #:nodoc:
+          puts
+          puts "#########"
+          puts "Adding indices is currently not supported by Crate"
+          puts "See issue: https://github.com/crate/crate/issues/733"
+          puts "#########"
+          puts
+        end
+
+        def remove_index(table_name, column_name, options = {}) #:nodoc:
+          puts
+          puts "#########"
+          puts "Dropping indices is currently not supported by Crate"
+          puts "See issue: https://github.com/crate/crate/issues/733"
+          puts "#########"
+          puts
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/crate_adapter.rb

@@ -0,0 +1,210 @@
+require 'active_record'
+require 'active_record/base'
+require 'active_record/base'
+require 'arel/arel_crate'
+require 'arel/visitors/bind_visitor'
+require 'active_support/dependencies/autoload'
+require 'active_support/callbacks'
+require 'active_support/core_ext/string'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/statement_pool'
+require 'active_record/connection_adapters/column'
+require 'active_record/connection_adapters/crate/schema_statements'
+require 'active_record/connection_adapters/crate/database_statements'
+require 'active_record/connection_adapters/crate/quoting'
+require 'active_support/core_ext/kernel'
+
+begin
+  require 'crate_ruby'
+rescue LoadError => e
+  raise e
+end
+
+module ActiveRecord
+
+  class Base
+    def self.crate_connection(config) #:nodoc:
+      config = config.symbolize_keys
+      ConnectionAdapters::CrateAdapter.new(nil, logger, nil, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class CrateAdapter < AbstractAdapter
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+        attr_accessor :array, :object
+      end
+
+      include Crate::SchemaStatements
+      include DatabaseStatements
+      include Crate::Quoting
+
+      ADAPTER_NAME = 'Crate'.freeze
+
+      def schema_creation # :nodoc:
+        Crate::SchemaCreation.new self
+      end
+
+      NATIVE_DATABASE_TYPES = {
+          boolean: {name: "boolean"},
+          string: {name: "string"},
+          integer: {name: "integer"},
+          float: {name: "float"},
+          binary: {name: "byte"},
+          datetime: {name: "timestamp"},
+          timestamp: {name: "timestamp"},
+          object: {name: "object"},
+          array: {name: "array"}
+      }
+
+      class BindSubstitution < Arel::Visitors::Crate # :nodoc:
+        include Arel::Visitors::BindVisitor
+      end
+
+      def initialize(connection, logger, pool, config)
+        @port = config[:port]
+        @host = config[:host]
+        super(connection, logger, pool)
+        @schema_cache = SchemaCache.new self
+        @visitor = Arel::Visitors::Crate.new self
+        @quoted_column_names = {}
+        connect
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      # Adds `:array` option to the default set provided by the
+      # AbstractAdapter
+      def prepare_column_options(column, types)
+        spec = super
+        spec[:array] = 'true' if column.respond_to?(:array) && column.array
+        spec
+      end
+
+      # Adds `:array` as a valid migration key
+      def migration_keys
+        super + [:array, :object_schema_behaviour, :object_schema_behaviour]
+      end
+
+
+      #TODO check what call to use for active
+      def active?
+        true
+      end
+
+      #TODO
+      def clear_cache!
+      end
+
+      #TODO
+      def reset!
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def connect
+        @connection = CrateRuby::Client.new(["#{@host}:#{@port}"])
+      end
+
+      def columns(table_name) #:nodoc:
+        cols = @connection.table_structure(table_name).map do |field|
+          CrateColumn.new(field[2], nil, field[4], nil)
+        end
+        cols
+      end
+
+      def tables
+        @connection.tables
+      end
+
+      # def quote_column_name(name) #:nodoc:
+      #   @quoted_column_names[name] ||= %Q{"#{name.to_s}"}
+      # end
+
+      class CrateColumn < Column
+
+        def simplified_type(field_type)
+          case field_type
+            when /_array/i
+              :array
+            when /object/i
+              :object
+            else
+              super(field_type)
+          end
+        end
+
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
+        # Crate doesn't support auto incrementing, therefore we need to manually
+        # set a primary key. You need to assure that you always provide an unique
+        # id. This might be done via the
+        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
+        def primary_key(name, type = :primary_key, options = {})
+          options[:primary_key] = true
+          column name, "STRING PRIMARY KEY", options
+        end
+
+        def column(name, type = nil, options = {})
+          super
+          column = self[name]
+          column.array = options[:array]
+          column.object = options[:object]
+          self
+        end
+
+        def object(name, options = {})
+          schema_behaviour = options.delete(:object_schema_behaviour)
+          type = schema_behaviour ? "object(#{schema_behaviour})" : schema_behaviour
+          schema = options.delete(:object_schema)
+          type = "#{type} as (#{object_schema_to_string(schema)})" if schema
+
+          column name, type, options.merge(object: true)
+        end
+
+        def array(name, options = {})
+          array_type = options.delete(:array_type)
+          raise "Array columns must specify an :array_type (e.g. array_type: :string)" unless array_type.present?
+          column name, "array(#{array_type})", options.merge(array: true)
+        end
+
+        private
+
+        def create_column_definition(name, type)
+          ColumnDefinition.new name, type
+        end
+
+        def object_schema_to_string(s)
+          ary = []
+          s.each_pair do |k, v|
+            if v.is_a?(Symbol)
+              ary << "#{k} #{v}"
+            elsif v.is_a?(Hash)
+              a = "array(#{v[:array]})"
+              ary << "#{k} #{a}"
+            end
+          end
+          ary.join(', ')
+        end
+
+
+      end
+
+      def create_table_definition(name, temporary, options, as = nil)
+        TableDefinition.new native_database_types, name, temporary, options, as
+      end
+
+      def native_database_types
+        NATIVE_DATABASE_TYPES
+      end
+    end
+  end
+
+
+end

data/lib/activerecord-crate-adapter.rb

@@ -0,0 +1,2 @@
+require 'active_record/connection_adapters/crate_adapter'
+require 'arel/visitors/crate'

data/lib/activerecord-crate-adapter/version.rb

@@ -0,0 +1,3 @@
+module ActiverecordCrateAdapter
+  VERSION = "0.0.1"
+end

data/lib/arel/arel_crate.rb

@@ -0,0 +1,3 @@
+require 'arel'
+require 'arel/visitors/crate'
+require 'arel/visitors/bind_visitor'

data/lib/arel/visitors/crate.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Visitors
+    class Crate < Arel::Visitors::ToSql
+
+      private
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['crate'] = Arel::Visitors::Crate

data/spec/activerecord/connection_adapters/crate/table_definition_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../../spec_helper'
+
+describe ActiveRecord::ConnectionAdapters::CrateAdapter::TableDefinition do
+
+
+  describe '#object_schema_to_string' do
+
+    let(:td) { ActiveRecord::ConnectionAdapters::CrateAdapter::TableDefinition.new(nil, nil, nil, nil) }
+
+    it 'should simply set the key and values' do
+      s = {street: :string, city: :string}
+      str = td.send(:object_schema_to_string, s)
+      str.should eq "street string, city string"
+    end
+
+    it 'should simply properly parse an array definition' do
+      s = {street: :string, city: :string, phones: {array: :string}}
+      str = td.send(:object_schema_to_string, s)
+      str.should eq "street string, city string, phones array(string)"
+    end
+
+  end
+
+
+end
+

data/spec/data_types/array_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+describe "Post#array" do
+
+  before(:all) do
+    ActiveRecord::Migration.class_eval do
+      create_table :posts do |t|
+        t.string :title
+        t.integer :comment_count
+        t.array :tags, array_type: :string
+        t.array :votes, array_type: :integer
+        t.array :bool_arr, array_type: :boolean
+      end
+    end
+    Post.reset_column_information
+  end
+
+  after(:all) do
+    ActiveRecord::Migration.class_eval do
+      drop_table :posts
+    end
+  end
+
+
+  describe "#array column type" do
+    let(:array) {%w(hot fresh)}
+    let(:votes) {[9,8,7]}
+    let(:bool_arr) {[true, false, true]}
+    let(:post) {Post.create!(title: 'Arrays are awesome', tags: array, votes: votes, bool_arr: bool_arr )}
+
+    it 'should store and return an array' do
+      p = Post.find(post.id)
+      p.tags.should be_a Array
+      p.votes.should be_a Array
+      p.bool_arr.should be_a Array
+      p.tags.should eq array
+      p.votes.should eq votes
+      p.bool_arr.should eq bool_arr
+    end
+
+    it 'should find the post by array value' do
+      post = Post.create!(title: 'Arrays are awesome', tags: array, votes: votes)
+      refresh_posts
+      Post.where("'fresh' = ANY (tags)").should include(post)
+    end
+
+  end
+
+end

data/spec/data_types/object_spec.rb

@@ -0,0 +1,38 @@
+require_relative '../spec_helper'
+
+describe "User#object" do
+
+  before(:all) do
+    ActiveRecord::Migration.class_eval do
+      create_table :users do |t|
+        t.string :name
+        t.object :address, object_schema_behaviour: :strict,
+                 object_schema: {street: :string, city: :string, phones: {array: :string}, zip: :integer}
+      end
+    end
+    User.reset_column_information
+  end
+
+  after(:all) do
+    ActiveRecord::Migration.class_eval do
+      drop_table :users
+    end
+  end
+
+
+  describe "#object column type" do
+    let(:address) {Address.new(street: '1010 W 2nd Ave', city: 'Vancouver', phones: ["123", "987"], zip: 6888)}
+    let(:user) {@user = User.create!(name: 'Mad Max', address: address)}
+
+    it 'should store and return an object' do
+      p = User.find(user.id)
+      p.address.should be_a Address
+      p.address.street.should eq address.street
+      p.address.city.should eq address.city
+      p.address.zip.should eq address.zip # without a object schema numbers are converted to strings
+      p.address.phones.should eq address.phones
+    end
+
+  end
+
+end

data/spec/dummy/app/models/address.rb

@@ -0,0 +1,15 @@
+require 'active_record/attribute_methods/crate_object'
+
+class Address
+  attr_accessor :street, :city, :phones, :zip
+
+  include CrateObject
+
+  def initialize(opts)
+    @street = opts[:street]
+    @city = opts[:city]
+    @phones = opts[:phones]
+    @zip = opts[:zip]
+  end
+
+end

data/spec/dummy/app/models/post.rb

@@ -0,0 +1,9 @@
+class Post < ActiveRecord::Base
+  before_create :set_id
+
+  private
+
+  def set_id
+    self.id = SecureRandom.uuid
+  end
+end

data/spec/dummy/app/models/user.rb

@@ -0,0 +1,11 @@
+class User < ActiveRecord::Base
+  before_create :set_id
+
+  serialize :address, Address
+
+  private
+
+  def set_id
+    self.id = SecureRandom.uuid
+  end
+end

data/spec/models/post_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../spec_helper'
+
+describe Post do
+
+  before(:all) do
+    ActiveRecord::Migration.class_eval do
+      create_table :posts do |t|
+        t.string :title
+        t.integer :views
+      end
+    end
+    Post.reset_column_information
+  end
+
+  after(:all) do
+    ActiveRecord::Migration.class_eval do
+      drop_table :posts
+    end
+  end
+
+  let(:params) { {title: "Crate rocks", views: 10000} }
+
+  context 'initialization' do
+    it 'should initialize a post object with all columns' do
+      post = Post.new(params)
+      post.should be_a(Post)
+      post.title.should eq "Crate rocks"
+      post.views.should eq 10000
+    end
+  end
+
+  context 'persistance' do
+
+    it 'should persist the record to the database' do
+      post = Post.create!(params)
+      post.persisted?.should be_true
+      refresh_posts
+      Post.count.should eq 1
+    end
+
+  end
+
+  context 'deletion' do
+
+    before do
+      @post = Post.create!(params)
+    end
+
+    it 'should destroy the record to the database' do
+      @post.destroy
+      Post.where(id: @post.id).should be_empty
+    end
+  end
+
+  describe 'existing record manipulation' do
+    before do
+      @post = Post.create!(params)
+    end
+
+    after do
+      #@post.destroy
+    end
+
+    context 'find' do
+      it 'should find the crated record' do
+        post = Post.where(id: @post.id).first
+        post.id.should eq(@post.id)
+      end
+    end
+
+    context 'update' do
+      it 'should update the record' do
+        @post.update_attributes(title: 'Crate Dope')
+        @post.reload.title.should eq('Crate Dope')
+      end
+
+    end
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'activerecord-crate-adapter'
+require 'logger'
+#require 'debugger'
+
+require 'dummy/app/models/address'
+require 'dummy/app/models/post'
+require 'dummy/app/models/user'
+
+RSpec.configure do |config|
+
+  config.before(:each) do
+  end
+  config.after(:each) do
+  end
+  config.before(:suite) do
+    connect
+  end
+  config.after(:all) do
+  end
+end
+
+def connect
+  ActiveRecord::Base.logger = Logger.new("log/debug.log")
+  ActiveRecord::Base.logger.level = Logger::DEBUG
+  ActiveRecord::Base.configurations = {
+      'arunit' => {
+          adapter: 'crate',
+          min_messages: 'warning',
+          port: 4209,
+          host: '127.0.0.1'
+      }
+  }
+  ActiveRecord::Base.establish_connection :arunit
+end
+
+# Crate is eventually consistent therefore we need
+# to refresh the table when doing queries, except we
+# query for the primary key
+def refresh_posts
+  Post.connection.raw_connection.refresh_table('posts')
+end

data/spec/test_server.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+class TestServer
+  CRATE_PATH = "~/crate"
+  TEST_PORT = 4209
+  NAME = "TestCluster"
+
+
+  def initialize(crate_home = nil, port = nil, host = "127.0.0.1")
+    @crate_home = crate_home || CRATE_PATH
+    @port = port || TEST_PORT
+    @host = host
+  end
+
+  def start
+    cmd = "sh #{CRATE_PATH}/bin/crate #{start_params}"
+    @pid = spawn(cmd, :out => "/tmp/crate_test_server.out", :err => "/tmp/crate_test_server.err")
+    Process.detach(@pid)
+    puts 'starting'
+    time_slept = 0
+    while true
+      puts "Crate not yet fully available. Waiting since #{time_slept} seconds..." unless alive?
+      sleep(2)
+      time_slept += 2
+    end
+  end
+
+  def stop
+    Process.kill("HUP", @pid)
+  end
+
+  private
+
+
+  def crate_exec
+  end
+
+  def crate_config
+  end
+
+  def start_params
+    "-Des.index.storage.type=memory " +
+        "-Des.node.name=#{NAME} " +
+        "-Des.cluster.name=Testing#{@port} " +
+        "-Des.http.port=#{@port}-#{@port} " +
+        "-Des.network.host=localhost " +
+        "-Des.discovery.type=zen " +
+        "-Des.discovery.zen.ping.multicast.enabled=false"
+  end
+
+  def alive?
+    req = Net::HTTP::Get.new('/')
+    resp = Net::HTTP.new(@host, @port)
+    begin
+      response = resp.start { |http| http.request(req) }
+      response.code == "200" ? true : false
+    rescue Errno::ECONNREFUSED
+      false
+    end
+  end
+
+end
+
+server = TestServer.new.start *ARGV
+
+trap("INT") do
+  puts "Script terminated by user."
+  server.stop
+  puts "Server stopped"
+  exit
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-crate-adapter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Christoph Klocker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: crate_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+description: ActiveRecord adapter for Crate, a shared-nothing, fully searchable, document-oriented
+  cluster data store.
+email:
+- christoph@vedanova.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-crate-adapter.gemspec
+- history.txt
+- lib/active_record/attribute_methods/crate_object.rb
+- lib/active_record/connection_adapters/crate/database_statements.rb
+- lib/active_record/connection_adapters/crate/quoting.rb
+- lib/active_record/connection_adapters/crate/schema_statements.rb
+- lib/active_record/connection_adapters/crate_adapter.rb
+- lib/activerecord-crate-adapter.rb
+- lib/activerecord-crate-adapter/version.rb
+- lib/arel/arel_crate.rb
+- lib/arel/visitors/crate.rb
+- log/.keep
+- spec/activerecord/connection_adapters/crate/crate_adapter_spec.rb
+- spec/activerecord/connection_adapters/crate/table_definition_spec.rb
+- spec/data_types/array_spec.rb
+- spec/data_types/object_spec.rb
+- spec/dummy/app/models/address.rb
+- spec/dummy/app/models/post.rb
+- spec/dummy/app/models/user.rb
+- spec/models/post_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb
+homepage: https://crate.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: ActiveRecord Crate Data Adapter
+test_files:
+- spec/activerecord/connection_adapters/crate/crate_adapter_spec.rb
+- spec/activerecord/connection_adapters/crate/table_definition_spec.rb
+- spec/data_types/array_spec.rb
+- spec/data_types/object_spec.rb
+- spec/dummy/app/models/address.rb
+- spec/dummy/app/models/post.rb
+- spec/dummy/app/models/user.rb
+- spec/models/post_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb
+has_rdoc: