leifcr-activeuuid 0.6.1

data/lib/activeuuid/uuid.rb

@@ -0,0 +1,166 @@
+require "uuidtools"
+
+# monkey-patch Friendly::UUID to serialize UUIDs
+module UUIDTools
+  class UUID
+    alias_method :id, :raw
+
+    # duck typing activerecord 3.1 dirty hack )
+    def gsub(*); self; end
+
+    def ==(another_uuid)
+      to_s == another_uuid.to_s
+    end
+
+    def next
+      self.class.random_create
+    end
+
+    def quoted_id
+      s = raw.unpack("H*")[0]
+      "x'#{s}'"
+    end
+
+    def as_json(_options = nil)
+      to_s
+    end
+
+    def to_param
+      to_s
+    end
+
+    def self.serialize(value)
+      case value
+      when self
+        value
+      when String
+        parse_string value
+      end
+    end
+
+    def bytesize
+      16
+    end
+
+    private
+
+    def self.parse_string(str)
+      return nil if str.empty?
+      if str.length == 36
+        parse str
+      elsif str.length == 32
+        parse_hexdigest str
+      else
+        parse_raw str
+      end
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    class DepthFirst < Arel::Visitors::Visitor
+      def visit_UUIDTools_UUID(o, _a = nil)
+        o.quoted_id
+      end
+    end
+
+    class MySQL < Arel::Visitors::ToSql
+      def visit_UUIDTools_UUID(o, _a = nil)
+        o.quoted_id
+      end
+    end
+
+    class WhereSql < Arel::Visitors::ToSql
+      def visit_UUIDTools_UUID(o)
+        o.quoted_id
+      end
+    end
+
+    class SQLite < Arel::Visitors::ToSql
+      def visit_UUIDTools_UUID(o, _a = nil)
+        o.quoted_id
+      end
+    end
+
+    class PostgreSQL < Arel::Visitors::ToSql
+      def visit_UUIDTools_UUID(o, _a = nil)
+        "'#{o}'"
+      end
+    end
+  end
+end
+
+module ActiveUUID
+  module UUID
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_natural_key, instance_writer: false
+      class_attribute :_uuid_namespace, instance_writer: false
+      class_attribute :_uuid_generator, instance_writer: false
+      self._uuid_generator = :random
+
+      singleton_class.prepend Instantiation
+      before_create :generate_uuids_if_needed
+    end
+
+    module ClassMethods
+      def natural_key(*attributes)
+        self._natural_key = attributes
+      end
+
+      def uuid_namespace(namespace)
+        namespace = UUIDTools::UUID.parse_string(namespace) unless namespace.is_a? UUIDTools::UUID
+        self._uuid_namespace = namespace
+      end
+
+      def uuid_generator(generator_name)
+        self._uuid_generator = generator_name
+      end
+
+      def uuids(*_attributes)
+        ActiveSupport::Deprecation.warn <<-EOS
+          ActiveUUID detects uuid columns independently.
+          There is no more need to use uuid method.
+        EOS
+      end
+
+      def uuid_columns
+        @uuid_columns ||= columns.select { |c| c.type == :uuid }.map(&:name)
+      end
+    end
+
+    module Instantiation
+      def instantiate(record, _record_models = nil)
+        uuid_columns.each do |uuid_column|
+          record[uuid_column] = UUIDTools::UUID.serialize(record[uuid_column]).to_s if record[uuid_column]
+        end
+
+        super(record)
+      end
+    end
+
+    def create_uuid
+      if _natural_key
+        # TODO if all the attributes return nil you might want to warn about this
+        chained = _natural_key.map { |attribute| send(attribute) }.join("-")
+        UUIDTools::UUID.sha1_create(_uuid_namespace || UUIDTools::UUID_OID_NAMESPACE, chained)
+      else
+        case _uuid_generator
+        when :random
+          UUIDTools::UUID.random_create
+        when :time
+          UUIDTools::UUID.timestamp_create
+        end
+      end
+    end
+
+    def generate_uuids_if_needed
+      primary_key = self.class.primary_key
+      if self.class.columns_hash[primary_key].type == :uuid
+        send("#{primary_key}=", create_uuid) unless send("#{primary_key}?")
+      end
+    end
+  end
+end

data/lib/activeuuid/version.rb

@@ -0,0 +1,3 @@
+module Activeuuid
+  VERSION = "0.6.1".freeze
+end

data/lib/activeuuid.rb

@@ -0,0 +1,10 @@
+require "activeuuid/version"
+require "activeuuid/patches"
+require "activeuuid/uuid"
+require "activeuuid/railtie" if defined?(Rails::Railtie)
+require "pp"
+
+module ActiveUUID
+end
+
+ActiveUUID::Patches.apply!

data/spec/fabricators/article_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:article) do
+  title { Forgery::LoremIpsum.word }
+  body { Forgery::LoremIpsum.sentence }
+end

data/spec/fabricators/uuid_article_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:uuid_article) do
+  title { Forgery::LoremIpsum.word }
+  body { Forgery::LoremIpsum.sentence }
+end

data/spec/fabricators/uuid_article_with_namespace_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:uuid_article_with_namespace) do
+  title { Forgery::LoremIpsum.word }
+  body { Forgery::LoremIpsum.sentence }
+end

data/spec/fabricators/uuid_article_with_natural_key_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:uuid_article_with_natural_key) do
+  title { Forgery::LoremIpsum.word }
+  body { Forgery::LoremIpsum.sentence }
+end

data/spec/lib/activerecord_spec.rb

@@ -0,0 +1,224 @@
+require "spec_helper"
+
+describe ActiveRecord::Base do
+  context ".connection" do
+    def table_exists?(connection, table_name)
+      connection.respond_to?(:data_source_exists?) ?
+        connection.data_source_exists?(table_name) :
+        connection.table_exists?(table_name)
+    end
+
+    let!(:connection) { ActiveRecord::Base.connection }
+    let(:table_name) { :test_uuid_field_creation }
+
+    before do
+      connection.drop_table(table_name) if table_exists?(connection, table_name)
+      connection.create_table(table_name)
+    end
+
+    after do
+      connection.drop_table table_name
+    end
+
+    specify { expect(table_exists?(connection, table_name)).to be_truthy }
+
+    context "#add_column" do
+      let(:column_name) { :uuid_column }
+      let(:column) { connection.columns(table_name).detect { |c| c.name.to_sym == column_name } }
+
+      before { connection.add_column table_name, column_name, :uuid }
+
+      specify { expect(connection.column_exists?(table_name, column_name)).to be_truthy }
+      specify { expect(column).not_to be_nil }
+
+      it "should have proper sql type" do
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { expect(column.sql_type).to eq("binary(16)") }
+          adapters.mysql2 { expect(column.sql_type).to eq("binary(16)") }
+          adapters.postgresql { expect(column.sql_type).to eq("uuid") }
+        end
+      end
+    end
+
+    context "#change_column" do
+      let(:column_name) { :string_col }
+      let(:column) { connection.columns(table_name).detect { |c| c.name.to_sym == column_name } }
+
+      before do
+        connection.add_column table_name, column_name, :string
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { connection.change_column table_name, column_name, :uuid }
+          adapters.mysql2 { connection.change_column table_name, column_name, :uuid }
+        end
+      end
+
+      it "support changing type from string to uuid" do
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { expect(column.sql_type).to eq("binary(16)") }
+          adapters.mysql2 { expect(column.sql_type).to eq("binary(16)") }
+          adapters.postgresql { skip("postgresql can`t change column type to uuid") }
+        end
+      end
+    end
+  end
+end
+
+describe Article do
+  let!(:article) { Fabricate :article }
+  let(:id) { article.id }
+  let(:model) { Article }
+  subject { model }
+
+  context "model" do
+    its(:all) { should == [article] }
+    its(:first) { should == article }
+  end
+
+  context "existance" do
+    subject { article }
+    its(:id) { should be_a Integer }
+  end
+
+  context ".find" do
+    specify { expect(model.find(id)).to eq(article) }
+  end
+
+  context ".where" do
+    specify { expect(model.where(id: id).first).to eq(article) }
+  end
+
+  context "#destroy" do
+    subject { article }
+    its(:delete) { should be_truthy }
+    its(:destroy) { should be_truthy }
+  end
+
+  context "#save" do
+    subject { article }
+    let(:array) { [1, 2, 3] }
+
+    its(:save) { should be_truthy }
+
+    context "when change array field" do
+      before { article.some_array = array }
+      its(:save) { should be_truthy }
+    end
+  end
+end
+
+describe UuidArticle do
+  let!(:article) { Fabricate :uuid_article }
+  let!(:id) { article.id }
+  let(:model) { UuidArticle }
+  subject { model }
+
+  context "model" do
+    its(:primary_key) { should == "id" }
+    its(:all) { should == [article] }
+    its(:first) { should == article }
+  end
+
+  context "existance" do
+    subject { article }
+    its(:id) { should be_a UUIDTools::UUID }
+  end
+
+  context "interpolation" do
+    specify { model.where("id = :id", id: article.id) }
+  end
+
+  context "batch interpolation" do
+    before { model.update_all(["title = CASE WHEN id = :id THEN 'Passed' ELSE 'Nothing' END", id: article.id]) }
+    specify { expect(article.reload.title).to eq("Passed") }
+  end
+
+  context ".find" do
+    specify { expect(model.find(article.id)).to eq(article) }
+    specify { expect(model.find(id)).to eq(article) }
+    specify { expect(model.find(id.to_s)).to eq(article) }
+    specify { expect(model.find(id.raw)).to eq(article) }
+  end
+
+  context ".where" do
+    specify { expect(model.where(id: article).first).to eq(article) }
+    specify { expect(model.where(id: id).first).to eq(article) }
+    specify { expect(model.where(id: id.to_s).first).to eq(article) }
+    specify { expect(model.where(id: id.raw).first).to eq(article) }
+  end
+
+  context "#destroy" do
+    subject { article }
+    its(:delete) { should be_truthy }
+    its(:destroy) { should be_truthy }
+  end
+
+  context "#reload" do
+    subject { article }
+    its(:'reload.id') { should == id }
+    specify { expect(subject.reload(select: :another_uuid).id).to eq(id) }
+  end
+
+  context "columns" do
+    %i[id another_uuid].each do |column|
+      context column do
+        subject { model.columns_hash[column.to_s] }
+        its(:type) { should == :uuid }
+      end
+    end
+  end
+
+  context "typecasting" do
+    let(:uuid) { UUIDTools::UUID.random_create }
+    let(:string) { uuid.to_s }
+    context "primary" do
+      before { article.id = string }
+      specify do
+        expect(article.id).to eq(uuid)
+        expect(article.id_before_type_cast).to eq(string)
+      end
+      specify do
+        expect(article.id_before_type_cast).to eq(string)
+        expect(article.id).to eq(uuid)
+      end
+    end
+
+    context "non-primary" do
+      before { article.another_uuid = string }
+      specify do
+        expect(article.another_uuid).to eq(uuid)
+        expect(article.another_uuid_before_type_cast).to eq(string)
+      end
+      specify do
+        expect(article.another_uuid_before_type_cast).to eq(string)
+        expect(article.another_uuid).to eq(uuid)
+      end
+      specify do
+        article.save
+        article.reload
+        expect(article.another_uuid_before_type_cast).to eq(string)
+        expect(article.another_uuid).to eq(uuid)
+      end
+    end
+  end
+end
+
+describe UuidArticleWithNaturalKey do
+  let!(:article) { Fabricate :uuid_article_with_natural_key }
+  let!(:id) { article.id }
+  let!(:uuid) { UUIDTools::UUID.sha1_create(UUIDTools::UUID_OID_NAMESPACE, article.title) }
+  subject { article }
+  context "natural_key" do
+    its(:id) { should == uuid }
+  end
+end
+
+describe UuidArticleWithNamespace do
+  let!(:article) { Fabricate :uuid_article_with_namespace }
+  let!(:id) { article.id }
+  let!(:namespace) { UuidArticleWithNamespace._uuid_namespace }
+  let!(:uuid) { UUIDTools::UUID.sha1_create(namespace, article.title) }
+  subject { article }
+  context "natural_key_with_namespace" do
+    its(:id) { should == uuid }
+  end
+end

data/spec/lib/uuid_mokeypatch_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe UUIDTools::UUID do
+  let(:input) { "e4618518-cb9f-11e1-aa7c-14dae903e06a" }
+  let(:hex) { "E4618518CB9F11E1AA7C14DAE903E06A" }
+  let(:uuid) { described_class.parse input }
+
+  context "instance methods" do
+    subject { uuid }
+    let(:sql_out) { "x'e4618518cb9f11e1aa7c14dae903e06a'" }
+
+    its(:quoted_id) { should == sql_out }
+    its(:as_json) { should == uuid.to_s }
+    its(:to_param) { should == uuid.to_s }
+    its(:next) { should be_a(described_class) }
+  end
+
+  describe ".serialize" do
+    subject { described_class }
+    let(:raw) { uuid.raw }
+
+    specify { expect(subject.serialize(uuid)).to eq(uuid) }
+    specify { expect(subject.serialize(input)).to eq(uuid) }
+    specify { expect(subject.serialize(hex)).to eq(uuid) }
+    specify { expect(subject.serialize(raw)).to eq(uuid) }
+    specify { expect(subject.serialize(nil)).to be_nil }
+    specify { expect(subject.serialize("")).to be_nil }
+    specify { expect(subject.serialize(5)).to be_nil }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+require "rubygems"
+require "bundler/setup"
+
+Bundler.require :development
+
+require "active_record"
+require "active_support/all"
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.configurations = YAML::safe_load(File.read(File.dirname(__FILE__) + "/support/database.yml"))
+
+require "activeuuid"
+
+ActiveRecord::Base.establish_connection((ENV["DB"] || "sqlite3").to_sym)
+
+if ENV["DB"] == "mysql"
+  if ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR <= 1
+    class ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
+      NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
+    end
+  elsif ActiveRecord::VERSION::MAJOR == 3
+    class ActiveRecord::ConnectionAdapters::Mysql2Adapter
+      NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
+    end
+  end
+end
+
+ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + "/support/migrate")
+ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, STDOUT)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/fabricators/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  # Remove this line if you don't want RSpec's should and should_not
+  # methods or matchers
+  require "rspec/expectations"
+  config.include RSpec::Matchers
+
+  # == Mock Framework
+  config.mock_with :rspec
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  def spec_for_adapter
+    switcher = ActiveUUID::SpecSupport::SpecForAdapter.new
+    yield switcher
+    switcher.run(connection)
+  end
+end

data/spec/support/database.yml

@@ -0,0 +1,12 @@
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"
+postgresql:
+  adapter: postgresql
+  host: localhost
+  database: activeuuid_test
+mysql:
+  adapter: mysql2
+  username: root
+  database: activeuuid_test
+  encoding: utf8

data/spec/support/migrate/20111117081813_create_articles.rb

@@ -0,0 +1,13 @@
+parent_class = ActiveRecord::Migration.respond_to?(:[]) ?
+               ActiveRecord::Migration[4.2] :
+               ActiveRecord::Migration
+class CreateArticles < parent_class
+  def change
+    create_table :articles do |t|
+      t.string :title
+      t.text :body
+
+      t.timestamps
+    end
+  end
+end

data/spec/support/migrate/20120817081813_create_uuid_articles.rb

@@ -0,0 +1,15 @@
+parent_class = ActiveRecord::Migration.respond_to?(:[]) ?
+               ActiveRecord::Migration[4.2] :
+               ActiveRecord::Migration
+class CreateUuidArticles < parent_class
+  def change
+    create_table :uuid_articles, id: false do |t|
+      t.uuid :id, primary_key: true
+      t.string :title
+      t.text :body
+      t.uuid :another_uuid
+
+      t.timestamps
+    end
+  end
+end

data/spec/support/migrate/20141017204945_add_array_to_articles.rb

@@ -0,0 +1,8 @@
+parent_class = ActiveRecord::Migration.respond_to?(:[]) ?
+               ActiveRecord::Migration[4.2] :
+               ActiveRecord::Migration
+class AddArrayToArticles < parent_class
+  def change
+    add_column :articles, :some_array, :integer, array: true
+  end
+end

data/spec/support/models/article.rb

@@ -0,0 +1,3 @@
+class Article < ActiveRecord::Base
+
+end

data/spec/support/models/uuid_article.rb

@@ -0,0 +1,3 @@
+class UuidArticle < ActiveRecord::Base
+  include ActiveUUID::UUID
+end

data/spec/support/models/uuid_article_with_namespace.rb

@@ -0,0 +1,6 @@
+class UuidArticleWithNamespace < ActiveRecord::Base
+  include ActiveUUID::UUID
+  self.table_name = "uuid_articles"
+  natural_key :title
+  uuid_namespace "45e676ea-8a43-4ffe-98ca-c142b0062a83" # a random UUID
+end

data/spec/support/models/uuid_article_with_natural_key.rb

@@ -0,0 +1,5 @@
+class UuidArticleWithNaturalKey < ActiveRecord::Base
+  include ActiveUUID::UUID
+  self.table_name = "uuid_articles"
+  natural_key :title
+end

data/spec/support/spec_for_adapter.rb

@@ -0,0 +1,20 @@
+require "activeuuid"
+
+module ActiveUUID::SpecSupport
+  class SpecForAdapter
+    def initialize
+      @specs = {}
+    end
+
+    %i[sqlite3 mysql2 postgresql].each do |name|
+      send :define_method, name do |&block|
+        @specs[name] = block
+      end
+    end
+
+    def run(connection)
+      name = connection.adapter_name.downcase.to_sym
+      @specs[name].call if @specs.include? name
+    end
+  end
+end