pg_space_cadet 0.7.2

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+*.gem
+doc/
+tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pg_space_cadet.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Bardi Einarsson
+
+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,100 @@
+pg\_space\_cadet
+================
+
+## Summary
+
+for space cadet augmented ActiveRecord::Base's, ruby ObjectSpace like object\_id's as default ActiveRecord id's based on UUID's
+
+## Description
+
+pg\_space\_cadet is a simple hack for postgreSQL and ActiveRecord which provides a uuids table of distributable identities of space cadets -- ActiveRecord::Base instances which use the SpaceCadetWrapper. Each space cadet has a default ActiveRecord id unique in the set of all local space cadets; a space cadet's id is derived from its uuid - UUID's are by design universally distributable.
+
+## Usage
+
+Note that the version 0.7.2 gem is tested but experimental -- a proof of concept. (It does not use the postgres native uuid type yet. It has not been established whether or not the dependence on the postgreSQL setval function is practical for a production database.)
+
+    require 'space_cadet_wrapper'
+
+    class ChessGame < ActiveRecord::Base
+    
+      before_create SpaceCadetWrapper.new
+      before_destroy SpaceCadetWrapper.new # optional
+      ...
+
+    end # ChessGame
+
+    class MySpaceCadet < ActiveRecord::Base
+    
+      before_create SpaceCadetWrapper.new
+      before_destroy SpaceCadetWrapper.new # optional
+      ...
+    
+    end # MySpaceCadet
+
+ChessGame instances are space cadets.
+
+Before ActiveRecord creates a ChessGame space cadet, it uses postgreSQL's uuid\_generate\_v4 to create a UUID. The lowest 31 bits of the UUID are used to make a shared ActiveRecord default id.
+
+The uuids table gains a chess\_games row as in:
+    id           source_name        uuid
+    746042992    my_space_cadets    7770a54c-7f08-4817-877e-43e1ac77b670
+    569967860    chess_games        274ead56-7c8f-4c8d-ad21-35d4a1f904f4
+The chess\_games table gains a row like:
+    id           moves    ambiguities    move_number    ...
+    569967860    e2e4                    1              ...
+
+    569967860 == 0x21f904f4 # the 31 low order bits of the UUID
+
+The (setval) hack, used to force the id's to be the same, uses postgreSQL's setval on the uuids\_id\_seq and the chess\_games\_id\_seq sequences so that ActiveRecord uses (is tricked into using) the 569967860 value as the next id in both tables.
+
+The result is that id 569967860 is guaranteed to be unique for all space cadets i.e. ChessGame instances, MySpaceCadet instances and other space cadets. Note in the rare event that there is a duplicate id conflict in uuids, a new UUID is tried.
+
+    my_space_cadet = ... # created MySpaceCadet instance
+    uuid = SpaceCadet::Uuid.find(my_space_cadet.id) # my_space_cadet's uuid
+
+    space_cadet_ref = SpaceCadet::Uuid.find_by_uuid(
+      '274ead56-7c8f-4c8d-ad21-35d4a1f904f4')
+    space_cadet_id = space_cadet_ref.id # 569967860
+    space_cadet_source_name = space_cadet_ref.source_name # 'chess_games'
+    chess_game_class = <some function> space_cadet_source_name
+    chess_game = chess_game_class.find(space_cadet_id) 
+    'e2e4' == chess_game.moves # true
+
+## Requirements
+
+Most likely any recent version of 1.9 ruby works.
+
+Most likely any version of the pg gem that understands setval for sequences and uuid\_generate\_v4 (after create extension "uuid-ossp") works.
+
+Most likely any version of the activerecord gem which can use the given pg gem and can be used with require "active\_record" works.
+
+TODO: JRuby postgreSQL space\_cadets - should be simple 
+
+## Test with rspec ~> 2.11, rspec -fd
+
+The specs assume that the connection url in spec/support/space\_cadet.rb works.
+
+The specs assume that the uuids table exists in the postgreSQL database.
+
+The specs assume that the chess\_games table exists in the postgreSQL database.
+
+The specs do not update the database (transactions with rollback).
+
+Note, to prepare the database for testing:
+    irb prompt> load 'spec/support/space_cadet.rb'
+    irb prompt> up
+    irb prompt> exit
+
+The author uses DbVisualizer 9.0.5 and irb to try out the space cadets.
+
+Note, to find the gem installation directory:
+    irb prompt> require 'space_cadet_wrapper'
+    irb prompt> $".grep(/pg_space_cadet/)[0]
+    irb prompt> exit
+
+## License
+
+Copyright (c) 2013 Bardi Einarsson. Released under the MIT License.  See the [LICENSE][license] file for further details.
+
+[license]: https://github.com/bardibardi/pg_space_cadet/blob/master/LICENSE.md
+

data/lib/space_cadet_active_record_uuid.rb

@@ -0,0 +1,46 @@
+# needs
+# set_auto_increment conn, source_name, id
+# uuid = new_uuid conn
+# id = id_from_uuid uuid, id_bit_count
+
+require 'active_record'
+
+module SpaceCadetActiveRecordUuid
+
+  def add_uuid uuid_class, source_name, id, uuid
+    conn = uuid_class.connection
+    table_name = uuid_class.table_name
+    set_auto_increment conn, table_name, id
+    uuid_class.create! do |u|
+      u.source_name = source_name
+      u.uuid = uuid
+    end
+  end
+
+  def id_add_uuid uuid_class, source_name, id_bit_count
+    conn = uuid_class.connection
+    uuid = new_uuid conn
+    id = id_from_uuid uuid, id_bit_count
+    record = nil
+    begin
+      record = add_uuid uuid_class, source_name, id, uuid
+    rescue
+      record = nil
+    end
+    record
+  end
+
+  ID_RETRY_COUNT = 10
+
+  def prepare_create uuid_class, source_name, id_bit_count
+    record = nil
+    retry_count = 0
+    while !record && retry_count < ID_RETRY_COUNT do
+      record = id_add_uuid uuid_class, source_name, id_bit_count
+    end
+    conn = record.class.connection
+    set_auto_increment conn, source_name, record.id
+  end
+
+end # SpaceCadetActiveRecordUuid
+

data/lib/space_cadet_postgresql_hack.rb

@@ -0,0 +1,18 @@
+# require 'securerandom'
+require 'active_record'
+
+module SpaceCadetPostgresqlHack
+
+  def set_auto_increment conn, table_name, id
+    primary_id_seq = table_name + '_id_seq'
+    conn.execute("select setval('#{primary_id_seq}', #{id - 1});")
+  end
+
+# create extension "uuid-ossp"
+  def new_uuid conn
+    conn.execute("select uuid_generate_v4() as u")[0]['u']
+    # SecureRandom.uuid
+  end
+
+end
+

data/lib/space_cadet_postgresql_uuid.rb

@@ -0,0 +1,13 @@
+require_relative 'space_cadet_uuid'
+require_relative 'space_cadet_uuid_id'
+require_relative 'space_cadet_postgresql_hack'
+require_relative 'space_cadet_active_record_uuid'
+
+module SpaceCadetUuid
+
+  include SpaceCadetUuidId
+  include SpaceCadetPostgresqlHack
+  include SpaceCadetActiveRecordUuid
+
+end
+

data/lib/space_cadet_uuid.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+module SpaceCadet
+
+  class UuidCore < ActiveRecord::Migration
+
+    def self.up
+      create_table :uuids do |t|
+        t.string :source_name
+        t.string :uuid
+      end
+
+      add_index :uuids, :uuid, unique: true
+    end
+
+    def self.down
+      drop_table :uuids
+    end
+
+  end # UuidCore
+
+  class Uuid < ActiveRecord::Base
+  end # Uuid
+
+end # SpaceCadet
+

data/lib/space_cadet_uuid_id.rb

@@ -0,0 +1,30 @@
+module SpaceCadetUuidId
+
+  HEX_DIGIT ||= Hash[
+    '0', 0, '1', 1, '2', 2, '3', 3,
+    '4', 4, '5', 5, '6', 6, '7', 7,
+    '8', 8, '9', 9, 'a', 10, 'b', 11,
+    'c', 12, 'd', 13, 'e', 14, 'f', 15
+  ].reduce({}, &->(h,p){h[p[0].getbyte(0)] = p[1];h})
+  def num_from_hex_string hex_string
+    hex_string.bytes.reduce(0, &->(num,b){num <<= 4;num += HEX_DIGIT[b]})
+  end
+
+  def high_order_bits_from_hex_string hex_string, bit_count
+    total_bit_count = hex_string.length << 2
+    num = num_from_hex_string hex_string
+    num >> (total_bit_count - bit_count)
+  end
+
+  def low_order_bits_from_hex_string hex_string, bit_count
+    num = num_from_hex_string hex_string
+    num & ((1 << bit_count) - 1)
+  end
+
+  def id_from_uuid uuid, id_bit_count
+    hex_string = uuid[24..-1]
+    low_order_bits_from_hex_string hex_string, id_bit_count
+  end
+
+end # SpaceCadetUuidId
+

data/lib/space_cadet_wrapper.rb

@@ -0,0 +1,19 @@
+require_relative 'space_cadet_postgresql_uuid'
+
+class SpaceCadetWrapper
+
+  include SpaceCadetUuid
+
+  ID_BIT_COUNT = 31
+
+  def before_create record
+    source_name = record.class.table_name
+    prepare_create SpaceCadet::Uuid, source_name, ID_BIT_COUNT
+  end
+
+  def before_destroy record
+    SpaceCadet::Uuid.delete record.id
+  end
+
+end # SpaceCadetWrapper
+

data/pg_space_cadet.gemspec

@@ -0,0 +1,37 @@
+Gem::Specification.new do |s|
+  s.name = 'pg_space_cadet'
+  s.version = '0.7.2'
+  s.date = '2013-03-21'
+  s.summary = "for space cadet augmented ActiveRecord::Base's, ruby ObjectSpace like object_id's as default ActiveRecord id's based on UUID's"
+  s.description = "pg_space_cadet is a simple hack for postgreSQL and ActiveRecord which provides a uuids table of distributable identities of space cadets -- ActiveRecord::Base instances which use the SpaceCadetWrapper. Each space cadet has a default ActiveRecord id unique in the set of all local space cadets; a space cadet's id is derived from its uuid - UUID's are by design universally distributable."
+
+  s.authors = ['Bardi Einarsson']
+  s.email = ['bardi@hotmail.com']
+  s.homepage = 'https://github.com/bardibardi/pg_space_cadet'
+  s.required_ruby_version = '>= 1.9.2'
+  s.add_dependency('pg')
+  s.add_dependency('activerecord', '>= 3.0')
+  s.add_development_dependency('rspec', '~> 2.11')
+  s.requirements << 'most likely any version of the pg gem that understands setval for sequences and uuid_generate_v4 (after create extension "uuid-ossp")'
+  s.requirements << 'most likely any version of the activerecord gem which can use the given pg gem and can be used with require "active_record"'
+
+  s.files = %w(
+.gitignore
+Gemfile
+LICENSE.md
+README.md
+pg_space_cadet.gemspec
+lib/space_cadet_active_record_uuid.rb
+lib/space_cadet_postgresql_hack.rb
+lib/space_cadet_postgresql_uuid.rb
+lib/space_cadet_uuid.rb
+lib/space_cadet_uuid_id.rb
+lib/space_cadet_wrapper.rb
+spec/space_cadet_spec.rb
+spec/space_cadet_uuid_id_spec.rb
+spec/support/ar_rspec.rb
+spec/support/no_should_rspec.rb
+spec/support/space_cadet.rb
+)
+end
+

data/spec/space_cadet_spec.rb

@@ -0,0 +1,42 @@
+require_relative 'support/ar_rspec'
+require_relative 'support/space_cadet'
+require 'securerandom'
+
+describe SpaceCadet::Uuid do
+
+  it "should be created" do
+    id, _ = add_chess_game 'e2e4', ''
+    u = SpaceCadet::Uuid.find(id)
+    expect(id).to eq(u.id)
+  end
+
+  it "should be unique" do
+    duplicate_id, chess_game = add_chess_game 'e2e4', ''
+    u = SpaceCadet::Uuid.find(duplicate_id)
+    duplicate_uuid = u.uuid
+    exception_thrown = nil
+    begin
+      chess_game.add_uuid(SpaceCadet::Uuid.class,
+        'chess_games', duplicate_id, duplicate_uuid)
+    rescue
+      exception_thrown = true
+    end
+    expect(exception_thrown).to eq(true)
+  end
+
+  it "should be deleted when parent is destroyed" do
+    id, chess_game = add_chess_game 'e2e4', ''
+    u = SpaceCadet::Uuid.find(id)
+    expect(id).to eq(u.id)
+    chess_game.class.destroy(id)
+    exception_thrown = nil
+    begin
+      u = SpaceCadet::Uuid.find(id)
+    rescue
+      exception_thrown = true
+    end
+    expect(exception_thrown).to eq(true)
+  end
+
+end
+

data/spec/space_cadet_uuid_id_spec.rb

@@ -0,0 +1,33 @@
+require 'support/no_should_rspec'
+require 'space_cadet_uuid_id'
+
+$idcalc = Object.new.extend SpaceCadetUuidId
+
+describe SpaceCadetUuidId do
+
+  it "should convert hex chars to digits" do
+    digits = "abcef" * 10
+    eval_value = eval("0x" + digits)
+    value = $idcalc.num_from_hex_string digits
+    expect(value).to eq(eval_value)
+  end
+
+  it "should get high order bits" do
+    digits = "abcef" * 10
+    value = $idcalc.high_order_bits_from_hex_string digits, 3
+    expect(value).to eq(5)
+  end
+
+  it "should get low order bits" do
+    digits = "abcef" * 10
+    value = $idcalc.low_order_bits_from_hex_string digits, 3
+    expect(value).to eq(7)
+  end
+
+  it "should get uuid low order bits" do
+    uuid = "ef53c3f1-9c4f-46db-9f6c-02c7402ef24a"
+    value = $idcalc.id_from_uuid uuid, 3
+    expect(value).to eq(2)
+  end
+
+end

data/spec/support/ar_rspec.rb

@@ -0,0 +1,36 @@
+# NB: http://iain.nl/testing-activerecord-in-isolation
+# NB: require 'support/ar_rspec'
+require_relative 'no_should_rspec'
+require 'active_record'
+
+module ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object.
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end
+
+RSpec.configure do |config|
+
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+
+end
+

data/spec/support/no_should_rspec.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+
+  # rspec 2.11 turn off should monkey patching
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+end
+

data/spec/support/space_cadet.rb

@@ -0,0 +1,68 @@
+def l
+  me = File.expand_path File.basename(__FILE__), File.dirname(__FILE__)
+  result = load me
+  [result, me]
+end
+
+require_relative '../../lib/space_cadet_wrapper'
+
+POSTGRESQL_URL ||= "postgres://postgres:postgres@localhost/postgres"
+
+CONNECTION_POOL ||= ActiveRecord::Base.establish_connection POSTGRESQL_URL
+
+END { CONNECTION_POOL.disconnect! }
+
+class ChessGameCore < ActiveRecord::Migration
+
+  def self.up
+    create_table :chess_games do |t|
+      t.string :moves
+      t.string :ambiguities
+      t.integer :move_number
+      t.integer :is_whites_move
+      t.string :position
+    end
+  end
+
+  def self.down
+    drop_table :chess_games
+  end
+
+end # ChessGameCore
+
+class ChessGame < ActiveRecord::Base
+
+  before_create SpaceCadetWrapper.new
+  before_destroy SpaceCadetWrapper.new
+
+end # ChessGame
+
+START_POSITION ||=
+  "a8brb8bnc8bbd8bqe8bkf8bbg8bnh8br" +
+  "a7bpb7bpc7bpd7bpe7bpf7bpg7bph7bp" +
+  "a2wpb2wpc2wpd2wpe2wpf2wpg2wph2wp" +
+  "a1wrb1wnc1wbd1wqe1wkf1wbg1wnh1wr"
+
+def add_chess_game moves, ambiguities
+  record = nil
+  ChessGame.create! do |g|
+    g.moves = moves
+    g.ambiguities = ambiguities
+    g.move_number = 1
+    g.is_whites_move = 1
+    g.position = START_POSITION
+    record = g
+  end
+  [record.id, record]
+end
+
+def up
+  SpaceCadet::UuidCore.up
+  ChessGameCore.up
+end
+
+def down
+  ChessGameCore.down
+  SpaceCadet::UuidCore.down
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: pg_space_cadet
+version: !ruby/object:Gem::Version
+  version: 0.7.2
+  prerelease: 
+platform: ruby
+authors:
+- Bardi Einarsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: pg_space_cadet is a simple hack for postgreSQL and ActiveRecord which
+  provides a uuids table of distributable identities of space cadets -- ActiveRecord::Base
+  instances which use the SpaceCadetWrapper. Each space cadet has a default ActiveRecord
+  id unique in the set of all local space cadets; a space cadet's id is derived from
+  its uuid - UUID's are by design universally distributable.
+email:
+- bardi@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.md
+- README.md
+- pg_space_cadet.gemspec
+- lib/space_cadet_active_record_uuid.rb
+- lib/space_cadet_postgresql_hack.rb
+- lib/space_cadet_postgresql_uuid.rb
+- lib/space_cadet_uuid.rb
+- lib/space_cadet_uuid_id.rb
+- lib/space_cadet_wrapper.rb
+- spec/space_cadet_spec.rb
+- spec/space_cadet_uuid_id_spec.rb
+- spec/support/ar_rspec.rb
+- spec/support/no_should_rspec.rb
+- spec/support/space_cadet.rb
+homepage: https://github.com/bardibardi/pg_space_cadet
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- most likely any version of the pg gem that understands setval for sequences and
+  uuid_generate_v4 (after create extension "uuid-ossp")
+- most likely any version of the activerecord gem which can use the given pg gem and
+  can be used with require "active_record"
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: for space cadet augmented ActiveRecord::Base's, ruby ObjectSpace like object_id's
+  as default ActiveRecord id's based on UUID's
+test_files: []