activeschema 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d34a9132fca30741b7068eb347fd44e48bd03370
-  data.tar.gz: 8cd3965d1c97c86bd4ed705486f6f898ae134cf7
+  metadata.gz: 079547f5a035f7e3a866f1f1cfe5adc2da584a65
+  data.tar.gz: aab407a26b4bf56e80b064172375bb0631a0f58f
 SHA512:
-  metadata.gz: f29cf2886d2b5397acca430b1614f0946e5423ed0f0648d604f8a844d6abb6ec121d995052add560b7d374ded6445c0b8e95ad4084ecc125d097a07e8801674b
-  data.tar.gz: eeb27abdffb683d785f13d44e2975ccc1466e73b63d72aec62a30187c64440126b178f651772825b8c61c833938b892f86c1e74ae9e2aca468b1943daa6415cc
+  metadata.gz: bde07fdb4962b00451965f0de9706c3e5936c2deea66143d424dd12108d8e693a478a1312672b3b4b1b754ddc38c17256a5020810b57ce1ce8383fb8ce29a1c5
+  data.tar.gz: e6e72aa0d897cd7f123e27f857fc813c88ab249ac7e8b2d59edccce50e09dc98cc0fcecbe93450cdeff8abd367d0854c87d17c6858c06f6f9941ed5b18cba42e

data/.pryrc

@@ -0,0 +1,7 @@
+require 'continuation'
+require 'active_record'
+$:.unshift(File.expand_path('../lib', __FILE__))
+require 'active_schema'
+
+ActiveRecord::Base.establish_connection('postgres://dev@localhost/dev')
+connection = ActiveRecord::Base.connection

data/Rakefile

@@ -1 +1,7 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+
+task :test do
+  require './spec/run'
+end
+
+task default: :test

data/activeschema.gemspec

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-name, version = 'activeschema 0.0.0'.split
+name, version = 'activeschema 0.0.1'.split
 Gem::Specification.new do |spec|
   spec.name          = name
   spec.version       = version
@@ -14,11 +14,12 @@ Gem::Specification.new do |spec|
   spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock)\Z/}
   spec.require_paths = ['lib']
 
-  spec.executables = Dir['bin/*'].map{|f| File.basename(f)}
+  spec.required_ruby_version = '>= 2.0'
 
-  spec.required_ruby_version = '>= 1.9.2'
+  spec.add_dependency 'activerecord', '~> 3.2'
 
-  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minispec'
+  spec.add_development_dependency 'activerecord-nulldb-adapter'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
 end

data/lib/active_schema/api.rb

@@ -0,0 +1,16 @@
+module ActiveSchema
+  module API
+
+    def self.included base
+      base.extend(self)
+    end
+
+    def schema opts = {}, &schema
+      opts = Hash[opts] # somehow i do not like #dup in this context...
+      table = opts.delete(:table) || self.table_name
+      connection = opts.delete(:connection) || ActiveRecord::Base.connection
+      ActiveSchema::SCHEMAS[table.to_s] = [connection, opts, schema]
+    end
+
+  end
+end

data/lib/active_schema/column.rb

@@ -0,0 +1,65 @@
+module ActiveSchema
+  class Column
+
+    def initialize connection, table_name, column_name, column_type, column_opts
+      @connection, @table_name, @column_name, @column_type, @column_opts = \
+        connection, table_name, column_name, column_type, column_opts
+      return add_column unless column_exists?
+      update_column_type_if_needed
+      update_column_if_needed
+    end
+
+    private
+    def update_column_type_if_needed
+      update_column(@column_type) unless column_exists?(@column_type)
+    end
+
+    def update_column_if_needed
+      @connection.reset! # reconnect to get fresh columns info
+      @column_opts.each_pair do |o,v|
+        next if column_exists?(@column_type, o => v)
+        update_column(@column_type, o => v)
+      end
+    end
+
+    def update_column type, opts = {}
+      @connection.change_column(@table_name, @column_name, type, opts)
+    end
+
+    def column_exists? type = nil, opts = {}
+      @connection.column_exists?(@table_name, @column_name, type, opts)
+    end
+
+    def add_column
+      @connection.add_column(@table_name, @column_name, @column_type, @column_opts)
+    end
+
+    class Pruner
+      def initialize connection, table_name, specified_columns
+        @connection, @table_name, @specified_columns = \
+          connection, table_name, specified_columns.map(&:to_s)
+        @connection.reset!
+        prune_as_needed
+      end
+
+      private
+      def prune_as_needed
+        (existing_columns - Array(primary_key) - @specified_columns).each do |column_name|
+          remove_column(column_name)
+        end
+      end
+
+      def primary_key
+        @connection.primary_key(@table_name)
+      end
+
+      def remove_column column_name
+        @connection.remove_column(@table_name, column_name)
+      end
+
+      def existing_columns
+        @connection.columns(@table_name).map(&:name).map(&:to_s)
+      end
+    end
+  end
+end

data/lib/active_schema/index.rb

@@ -0,0 +1,49 @@
+module ActiveSchema
+  class Index
+
+    def initialize connection, table_name, columns, opts
+      @connection, @table_name, @columns, @opts = \
+        connection, table_name, columns, opts
+
+      # nothing to do if index of given columns with given opts already exists
+      return if index_exists?(@opts)
+
+      # if index of given columns exists and it has different options, remove it
+      remove_index if index_exists?
+
+      add_index
+    end
+
+    private
+
+    def index_exists? opts = {}
+      @connection.index_exists?(@table_name, @columns, opts)
+    end
+
+    def add_index
+      @connection.add_index(@table_name, @columns, @opts)
+    end
+
+    def remove_index
+      # @connection.remove_index(@table_name, column: @columns)
+    end
+
+    class Pruner
+
+      def initialize connection, table_name, indexes
+        @connection, @table_name, @indexes = \
+          connection, table_name, indexes
+
+        existing = @connection.indexes(@table_name).map(&:name)
+        specified = @indexes.map {|c| @connection.index_name(@table_name, c)}
+
+        p [existing, specified]
+
+        (existing - specified).each do |index|
+          @connection.remove_index(@table_name, index)
+        end
+
+      end
+    end
+  end
+end

data/lib/active_schema/schema.rb

@@ -0,0 +1,77 @@
+module ActiveSchema
+  class Schema
+
+    def initialize connection, table_name, table_opts, &schema
+      @connection, @table_name, @table_opts, @schema = \
+        connection, table_name, table_opts, schema
+      @strict = @table_opts.keys.map(&:to_sym).include?(:strict) ? @table_opts.delete(:strict) : true
+      @columns, @indexes = {}, {}
+      yield_schema
+      table = Table.new(@connection, @table_name, @table_opts, @columns)
+      table.exists? ? handle_columns : table.create
+      handle_indexes
+    end
+
+    # by default ActiveSchema will drop db columns that's not defined in schema.
+    # so the table will reflect the exact structure of your schema
+    # use `strict: false` option to allow columns not defined in schema.
+    #
+    # @example
+    #   # => \d users
+    #   #                Table "public.users"
+    #   #         Column        |            Type
+    #   # ----------------------+------------------------
+    #   #  id                   | integer
+    #   #  email                | character varying(255)
+    #   #  first_name           | character varying(255)
+    #   #  last_name            | character varying(255)
+    #   #  username             | character varying(255)
+    #
+    #   schema :users, strict: false do |t|
+    #     # this schema WILL KEEP username column
+    #     t.string :email
+    #     t.string :first_name
+    #     t.string :last_name
+    #   end
+    #
+    #   schema :users do |t|
+    #     # this schema WILL DROP username column
+    #     t.string :email
+    #     t.string :first_name
+    #     t.string :last_name
+    #   end
+    #
+    def strict?; @strict end
+
+    def column name, type, opts = {}
+      @columns[name.to_s] = [type, opts]
+    end
+
+    def index columns, opts = {}
+      @indexes[Array(columns).map(&:to_sym)] = opts
+    end
+
+    def method_missing type, name, opts = {}
+      column(name, type, opts)
+    end
+
+    private
+    def yield_schema
+      @schema.call(self) if @schema
+    end
+
+    def handle_columns
+      @columns.each_pair do |column, (type, opts)|
+        Column.new(@connection, @table_name, column, type, opts)
+      end
+      Column::Pruner.new(@connection, @table_name, @columns.keys) if strict?
+    end
+
+    def handle_indexes
+      @indexes.each_pair do |columns, opts|
+        Index.new(@connection, @table_name, columns, opts)
+      end
+      Index::Pruner.new(@connection, @table_name, @indexes.keys) if strict?
+    end
+  end
+end

data/lib/active_schema/table.rb

@@ -0,0 +1,21 @@
+module ActiveSchema
+  class Table
+
+    def initialize connection, table_name, table_opts, columns
+      @connection, @table_name, @table_opts, @columns =
+        connection, table_name, table_opts, columns
+    end
+
+    def create
+      @connection.create_table(@table_name, @table_opts) do |t|
+        @columns.each_pair do |name,(type,opts)|
+          t.column(name, type, opts)
+        end
+      end
+    end
+
+    def exists?
+      @connection.table_exists?(@table_name)
+    end
+  end
+end

data/lib/active_schema.rb

@@ -0,0 +1,17 @@
+module ActiveSchema
+  SCHEMAS = {}
+
+  def apply table = nil
+    schemas = table ? SCHEMAS.select {|t,_| t == table} : SCHEMAS
+    schemas.each_pair do |table, (conn, opts, schema)|
+      Schema.new(conn, table, opts, &schema)
+    end
+  end
+  module_function :apply
+end
+
+require 'active_schema/api'
+require 'active_schema/schema'
+require 'active_schema/table'
+require 'active_schema/column'
+require 'active_schema/index'

data/lib/activeschema.rb

@@ -1,5 +1 @@
-require "activeschema/version"
-
-module Activeschema
-  # Your code goes here...
-end
+require 'active_schema'

data/spec/column_spec.rb

@@ -0,0 +1,73 @@
+describe ActiveSchema::Column do
+  include_setup :*
+
+  before do
+    model.schema {|t| t.string :name}
+  end
+
+  it 'creates columns that does not exists' do
+    mock(connection, table_exists?: true)
+
+    expect(connection).
+      to_receive(:column_exists?).
+      with {|*a| a.include?('name')}.
+      and_return(false)
+
+    expect(connection).
+      to_receive(:add_column).
+      with {|t,c,*| t == model.table_name && c == 'name'}
+
+    model.apply_schema
+  end
+
+  it 'does not try to create columns that already exists' do
+    mock(connection, table_exists?: true, column_exists?: true)
+    spy(connection, :add_column)
+    model.apply_schema
+    assert(connection).did_not.received(:add_column)
+  end
+
+  it 'updates column type' do
+    model.apply_schema
+    assert(connection.columns(model.table_name).map(&:name)).include?('name')
+    model.schema {|t| t.text :name}
+
+    expect(connection).
+      to_receive(:change_column).
+      with(model.table_name, 'name', :text, {})
+
+    model.apply_schema
+  end
+
+  it 'updates column options' do
+    model.apply_schema
+    column = connection.columns(model.table_name).find {|c| c.name == 'name'}
+    assert(column.class.name) =~ /Column/
+    is(column.default).nil?
+
+    model.schema {|t| t.string :name, default: 'blah'}
+
+    expect(connection).
+      to_receive(:change_column).
+      with(model.table_name, 'name', :string, {default: 'blah'})
+
+    model.apply_schema
+  end
+
+  it 'updates both type and options' do
+    model.apply_schema
+    model.schema {|t| t.text :name, limit: 50}
+
+    # called once to update type
+    expect(connection).
+      to_receive(:change_column).
+      with(model.table_name, 'name', :text, {})
+
+    # and once to update options
+    expect(connection).
+      to_receive(:change_column).
+      with(model.table_name, 'name', :text, {limit: 50})
+
+    model.apply_schema
+  end
+end

data/spec/index_spec.rb

@@ -0,0 +1,94 @@
+describe ActiveSchema::Index do
+  include_setup :*
+
+  before do
+    model.schema do |t|
+      t.string :name
+      t.index :name
+    end
+  end
+
+  # it 'creates indexes that does not exists' do
+  #   expect(connection).
+  #     to_receive(:index_exists?).
+  #     with(model.table_name, [:name], {})
+
+  #   model.apply_schema
+  # end
+
+  # should 'remove then add an index of given columns if it has different options' do
+  #   model.apply_schema
+
+  #   expect(connection).
+  #     to_receive(:index_exists?).
+  #     with(model.table_name, [:name], {}).
+  #     and_return(true)
+
+  #   expect(connection).
+  #     to_receive(:index_exists?).
+  #     with(model.table_name, [:name], {unique: true}).
+  #     and_return(false)
+
+  #   expect(connection).
+  #     to_receive(:remove_index).
+  #     with(model.table_name, column: [:name])
+
+  #   model.schema {|t| t.index(:name, unique: true)}
+
+  #   expect do
+  #     # NullDB adapter does not really remove indexes
+  #     # so ActiveRecord raises an exception when new index with same name added
+  #     model.apply_schema
+  #   end.to_raise(ArgumentError, /Index.+already exists/)
+  # end
+
+  # should 'ignore existing indexes' do
+  #   model.apply_schema
+
+  #   expect(connection).
+  #     to_receive(:index_exists?).
+  #     with(model.table_name, [:name], {}).
+  #     and_return(true)
+
+  #   spy(connection, :remove_index)
+
+  #   model.apply_schema
+
+  #   assert(connection).did_not.received(:remove_index)
+  # end
+
+  context 'strict mode' do
+
+    before do
+      stub(connection, :indexes).
+        with(model.table_name) do
+          [Struct.new(:name).new('some_manually_added_index')]
+        end
+    end
+
+    # should 'keep unspecified indexes on unrestricted mode' do
+    #   model.schema(strict: false)
+
+    #   spy(connection, :remove_index)
+
+    #   model.apply_schema
+
+    #   assert(connection).did_not.received(:remove_index)
+    # end
+
+    should 'remove unspecified indexes on strict mode' do
+      model.schema(strict: true)
+
+      # stub(connection, :remove_index)
+
+      expect(connection).
+        to_receive(:remove_index).
+        with(model.table_name, 'some_manually_added_index').
+        with_caller {|c| puts c*"\n"}
+
+      model.apply_schema
+      # @__ms__messages.each {|b| p b.reject {|k,v| k == :object}}
+    end
+  end
+
+end

data/spec/run.rb

@@ -0,0 +1,37 @@
+require 'minispec'
+require 'active_record'
+require 'nulldb'
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'active_schema'
+
+ActiveRecord::Base.extend(ActiveSchema::API)
+NullDB.configure {|c| def c.project_root; File.expand_path('../', __FILE__) end}
+
+module ActiveSchema::API
+  # monkey-patch to easily apply schema on models
+  def apply_schema
+    ActiveSchema.apply(table_name)
+  end
+end
+
+shared_setup :* do
+  before do
+    ActiveRecord::Base.establish_connection(adapter: :nulldb)
+    stub(connection, :change_column) # needed to avoid NotImplemented exception
+  end
+
+  after do
+    ActiveRecord::Base.remove_connection
+  end
+
+  let :model do
+    Class.new(ActiveRecord::Base) do
+      self.table_name = '_%s_' % self.__id__
+    end
+  end
+
+  let(:connection) { ActiveRecord::Base.connection }
+end
+
+Minispec.pattern = 'spec/index*'
+require 'minispec/autorun'

data/spec/table_spec.rb

@@ -0,0 +1,21 @@
+describe ActiveSchema::Table do
+  include_setup :*
+
+  before do
+    model.schema
+  end
+
+  it 'creates tables that does not exists' do
+    expect(connection).
+      to_receive(:create_table).
+      with {|t,*| t == model.table_name}
+    model.apply_schema
+  end
+
+  it 'does not try to create tables that already exists' do
+    mock(connection, table_exists?: true)
+    spy(connection, :create_table)
+    model.apply_schema
+    assure(connection).did_not.received(:create_table)
+  end
+end

metadata

@@ -1,17 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: activeschema
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Lars Milton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-30 00:00:00.000000000 Z
+date: 2014-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: minispec
+  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: activerecord-nulldb-adapter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -60,13 +88,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".pryrc"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - activeschema.gemspec
+- lib/active_schema.rb
+- lib/active_schema/api.rb
+- lib/active_schema/column.rb
+- lib/active_schema/index.rb
+- lib/active_schema/schema.rb
+- lib/active_schema/table.rb
 - lib/activeschema.rb
-- lib/activeschema/version.rb
+- spec/column_spec.rb
+- spec/db/schema.rb
+- spec/index_spec.rb
+- spec/run.rb
+- spec/table_spec.rb
 homepage: https://github.com/smilton/activeschema
 licenses:
 - MIT
@@ -79,7 +118,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -90,6 +129,6 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: activeschema-0.0.0
+summary: activeschema-0.0.1
 test_files: []
 has_rdoc: 

data/lib/activeschema/version.rb

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