declare_schema 0.1.0 → 0.2.0

data/lib/generators/declare_schema/migration/migrator.rb

@@ -96,6 +96,20 @@ module Generators
           def connection
             ActiveRecord::Base.connection
           end
+
+          def fix_native_types(types)
+            case connection.class.name
+            when /mysql/i
+              types[:integer][:limit] ||= 11
+              types[:text][:limit]    ||= 0xffff
+              types[:binary][:limit]  ||= 0xffff
+            end
+            types
+          end
+
+          def native_types
+            @native_types ||= fix_native_types(connection.native_database_types)
+          end
         end
 
         def initialize(ambiguity_resolver = {})
@@ -106,37 +120,29 @@ module Generators
 
         attr_accessor :renames
 
+        # TODO: Add an application callback (maybe an initializer in a special group?) that
+        # the application can use to load other models that live in the database, to support DeclareSchema migrations
+        # for them.
         def load_rails_models
+          ActiveRecord::Migration.verbose = false
+
           Rails.application.eager_load!
+          Rails::Engine.subclasses.each(&:eager_load!)
         end
 
         # Returns an array of model classes that *directly* extend
         # ActiveRecord::Base, excluding anything in the CGI module
         def table_model_classes
           load_rails_models
-          ActiveRecord::Base.send(:descendants).reject { |c| (c.base_class != c) || c.name.starts_with?("CGI::") }
+          ActiveRecord::Base.send(:descendants).select do |klass|
+            klass.base_class == klass && !klass.name.starts_with?("CGI::")
+          end
         end
 
         def connection
           self.class.connection
         end
 
-        class << self
-          def fix_native_types(types)
-            case connection.class.name
-            when /mysql/i
-              types[:integer][:limit] ||= 11
-              types[:text][:limit]    ||= 0xffff
-              types[:binary][:limit]  ||= 0xffff
-            end
-            types
-          end
-
-          def native_types
-            @native_types ||= fix_native_types(connection.native_database_types)
-          end
-        end
-
         def native_types
           self.class.native_types
         end
@@ -217,14 +223,24 @@ module Generators
           end
         end
 
-        def always_ignore_tables
-          # TODO: figure out how to do this in a sane way and be compatible with 2.2 and 2.3 - class has moved
-          if defined?(CGI::Session::ActiveRecordStore::Session) &&
-             defined?(ActionController::Base) &&
-             ActionController::Base.session_store == CGI::Session::ActiveRecordStore
-            sessions_table = CGI::Session::ActiveRecordStore::Session.table_name
-          end
-          ['schema_info', 'schema_migrations', 'simple_sesions', sessions_table].compact
+        def self.always_ignore_tables
+          sessions_table =
+            begin
+              if defined?(CGI::Session::ActiveRecordStore::Session) &&
+                 defined?(ActionController::Base) &&
+                 ActionController::Base.session_store == CGI::Session::ActiveRecordStore
+                CGI::Session::ActiveRecordStore::Session.table_name
+              end
+            rescue
+              nil
+            end
+
+          [
+            'schema_info',
+            ActiveRecord::Base.try(:schema_migrations_table_name) || 'schema_migrations',
+            ActiveRecord::Base.try(:internal_metadata_table_name) || 'ar_internal_metadata',
+            sessions_table
+          ].compact
         end
 
         def generate
@@ -246,7 +262,7 @@ module Generators
           model_table_names = models_by_table_name.keys
 
           to_create = model_table_names - db_tables
-          to_drop = db_tables - model_table_names - always_ignore_tables
+          to_drop = db_tables - model_table_names - self.class.always_ignore_tables
           to_change = model_table_names
           to_rename = extract_table_renames!(to_create, to_drop)
 
@@ -295,10 +311,6 @@ module Generators
           down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes, undo_fk_changes].flatten.reject(&:blank?) * "\n\n"
 
           [up, down]
-        rescue Exception => ex
-          puts "Caught exception: #{ex}"
-          puts ex.backtrace.join("\n")
-          raise
         end
 
         def create_table(model)
@@ -398,14 +410,13 @@ module Generators
             spec = model.field_specs[c]
             if spec.different_to?(col) # TODO: DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
               change_spec = fk_field_options(model, c)
-              change_spec[:limit]     = spec.limit     if (spec.sql_type != :text ||
+              change_spec[:limit]     ||= spec.limit   if (spec.sql_type != :text ||
                                                          ::DeclareSchema::Model::FieldSpec.mysql_text_limits?) &&
                                                           (spec.limit || col.limit)
               change_spec[:precision] = spec.precision unless spec.precision.nil?
               change_spec[:scale]     = spec.scale     unless spec.scale.nil?
               change_spec[:null]      = spec.null      unless spec.null && col.null
               change_spec[:default]   = spec.default   unless spec.default.nil? && col.default.nil?
-              change_spec[:comment]   = spec.comment   unless spec.comment.nil? && (col.comment if col.respond_to?(:comment)).nil?
 
               changes << "change_column :#{new_table_name}, :#{c}, " +
                          ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type, changing: true)).join(", ")
@@ -473,7 +484,7 @@ module Generators
           return [[], []] if Migrator.disable_indexing
 
           new_table_name = model.table_name
-          existing_fks = DeclareSchema::Model::ForeignKeySpec.for_model(model, old_table_name)
+          existing_fks = ::DeclareSchema::Model::ForeignKeySpec.for_model(model, old_table_name)
           model_fks = model.constraint_specs
           add_fks = model_fks - existing_fks
           drop_fks = existing_fks - model_fks
@@ -505,8 +516,7 @@ module Generators
               next if k == :null && v == true
             end
 
-            next if k == :limit && type == :text &&
-                    (!::DeclareSchema::Model::FieldSpec.mysql_text_limits? || v == ::DeclareSchema::Model::FieldSpec::MYSQL_LONGTEXT_LIMIT)
+            next if k == :limit && type == :text && !::DeclareSchema::Model::FieldSpec.mysql_text_limits?
 
             if k.is_a?(Symbol)
               "#{k}: #{v.inspect}"
@@ -517,10 +527,20 @@ module Generators
         end
 
         def fk_field_options(model, field_name)
-          if (foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }) && (parent_table = foreign_key.parent_table_name)
+          foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }
+          if foreign_key && (parent_table = foreign_key.parent_table_name)
             parent_columns = connection.columns(parent_table) rescue []
-            pk_column = parent_columns.find { |column| column.name == "id" } # right now foreign keys assume id is the target
-            pk_limit  = pk_column ? pk_column.cast_type.limit : 8
+            pk_limit  =
+              if (pk_column = parent_columns.find { |column| column.name.to_s == "id" }) # right now foreign keys assume id is the target
+                if Rails::VERSION::MAJOR <= 4
+                  pk_column.cast_type.limit
+                else
+                  pk_column.limit
+                end
+              else
+                8
+              end
+
             { limit: pk_limit }
           else
             {}

data/lib/generators/declare_schema/migration/templates/migration.rb.erb

@@ -1,4 +1,4 @@
-class <%= @migration_class_name %> < ActiveRecord::Migration<%= Rails::VERSION::MAJOR > 4 ? '[4.2]' : '' %>
+class <%= @migration_class_name %> < ActiveRecord::Migration<%= ('[4.2]' if Rails::VERSION::MAJOR >= 5) %>
   def self.up
     <%= @up %>
   end

data/lib/generators/declare_schema/support/eval_template.rb

@@ -9,9 +9,18 @@ module DeclareSchema
             private
 
             def eval_template(template_name)
-              source  = File.expand_path(find_in_source_paths(template_name))
-              context = instance_eval('binding')
-              ERB.new(::File.binread(source), trim_mode: '-').result(context)
+              source = File.expand_path(find_in_source_paths(template_name))
+              erb = ERB.new(::File.read(source).force_encoding(Encoding::UTF_8), trim_mode: '>')
+              erb.filename = source
+              begin
+                erb.result(binding)
+              rescue Exception => ex
+                raise ex.class, <<~EOS
+                  #{ex.message}
+                  #{erb.src}
+                    #{ex.backtrace.join("\n  ")}
+                EOS
+              end
             end
           end
         end

data/lib/generators/declare_schema/support/model.rb

@@ -4,6 +4,39 @@ require_relative './eval_template'
 
 module DeclareSchema
   module Support
+    class IndentedBuffer
+      def initialize(indent: 0)
+        @string = +""
+        @indent = indent
+        @column = 0
+        @indent_amount = 2
+      end
+
+      def to_string
+        @string
+      end
+
+      def indent!
+        @indent += @indent_amount
+        yield
+        @indent -= @indent_amount
+      end
+
+      def newline!
+        @column = 0
+        @string << "\n"
+      end
+
+      def <<(str)
+        if (difference = @indent - @column) > 0
+          @string << ' ' * difference
+        end
+        @column += difference
+        @string << str
+        newline!
+      end
+    end
+
     module Model
       class << self
         def included(base)
@@ -26,9 +59,51 @@ module DeclareSchema
 
             def inject_declare_schema_code_into_model_file
               gsub_file(model_path, /  # attr_accessible :title, :body\n/m, "")
-              inject_into_class model_path, class_name do
-                eval_template('model_injection.rb.erb')
+              inject_into_class(model_path, class_name) do
+                declare_model_fields_and_associations
+              end
+            end
+
+            private
+
+            def declare_model_fields_and_associations
+              buffer = ::DeclareSchema::Support::IndentedBuffer.new(indent: 2)
+              buffer.newline!
+              buffer << 'fields do'
+              buffer.indent! do
+                field_attributes.each do |attribute|
+                  decl = "%-#{max_attribute_length}s" % attribute.name + ' ' +
+                    attribute.type.to_sym.inspect +
+                    case attribute.type.to_s
+                    when 'string'
+                      ', limit: 255'
+                    else
+                      ''
+                    end
+                  buffer << decl
+                end
+                if options[:timestamps]
+                  buffer.newline!
+                  buffer << 'timestamps'
+                end
+              end
+              buffer << 'end'
+
+              if bts.any?
+                buffer.newline!
+                bts.each do |bt|
+                  buffer << "belongs_to #{bt.to_sym.inspect}"
+                end
               end
+              if hms.any?
+                buffer.newline
+                hms.each do |hm|
+                  buffer << "has_many #{hm.to_sym.inspect}, dependent: :destroy"
+                end
+              end
+              buffer.newline!
+
+              buffer.to_string
             end
 
             protected

data/spec/lib/declare_schema/api_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'rails/generators'
+
+RSpec.describe 'DeclareSchema API' do
+  before do
+    load File.expand_path('prepare_testapp.rb', __dir__)
+  end
+
+  describe 'example models' do
+    it 'generates a model' do
+      expect(system("bundle exec rails generate declare_schema:model advert title:string body:text")).to be_truthy
+
+      # The above will generate the test, fixture and a model file like this:
+      # model_declaration = Rails::Generators.invoke('declare_schema:model', ['advert2', 'title:string', 'body:text'])
+      # expect(model_declaration.first).to eq([["Advert"], nil, "app/models/advert.rb", nil,
+      #                                       [["AdvertTest"], "test/models/advert_test.rb", nil, "test/fixtures/adverts.yml"]])
+
+      expect(File.read("#{TESTAPP_PATH}/app/models/advert.rb")).to eq(<<~EOS)
+        class Advert < #{active_record_base_class}
+
+          fields do
+            title :string, limit: 255
+            body  :text
+          end
+
+        end
+      EOS
+      system("rm -rf #{TESTAPP_PATH}/app/models/advert2.rb #{TESTAPP_PATH}/test/models/advert2.rb #{TESTAPP_PATH}/test/fixtures/advert2.rb")
+
+      # The migration generator uses this information to create a migration.
+      # The following creates and runs the migration:
+
+      expect(system("bundle exec rails generate declare_schema:migration -n -m")).to be_truthy
+
+      # We're now ready to start demonstrating the API
+
+      Rails.application.config.autoload_paths += ["#{TESTAPP_PATH}/app/models"]
+
+      $LOAD_PATH << "#{TESTAPP_PATH}/app/models"
+
+      unless Rails::VERSION::MAJOR >= 6
+        # TODO: get this to work on Travis for Rails 6
+        Rails::Generators.invoke('declare_schema:migration', %w[-n -m])
+      end
+
+      require 'advert'
+
+      ## The Basics
+
+      # The main feature of DeclareSchema, aside from the migration generator, is the ability to declare rich types for your fields. For example, you can declare that a field is an email address, and the field will be automatically validated for correct email address syntax.
+
+      ### Field Types
+
+      # Field values are returned as the type you specify.
+
+      Advert.destroy_all
+
+      a = Advert.new(body: "This is the body", id: 1, title: "title")
+      expect(a.body).to eq("This is the body")
+
+      # This also works after a round-trip to the database
+
+      a.save!
+      expect(a.reload.body).to eq("This is the body")
+
+      ## Names vs. Classes
+
+      ## Model extensions
+
+      # DeclareSchema adds a few features to your models.
+
+      ### `Model.attr_type`
+
+      # Returns the type (i.e. class) declared for a given field or attribute
+
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      expect(Advert.attr_type(:title)).to eq(String)
+      expect(Advert.attr_type(:body)).to eq(String)
+
+      ## Field validations
+
+      # DeclareSchema gives you some shorthands for declaring some common validations right in the field declaration
+
+      ### Required fields
+
+      # The `:required` argument to a field gives a `validates_presence_of`:
+
+      class AdvertWithRequiredTitle < ActiveRecord::Base
+        self.table_name = 'adverts'
+
+        fields do
+          title :string, :required, limit: 255
+        end
+      end
+
+      a = AdvertWithRequiredTitle.new
+      expect(a.valid? || a.errors.full_messages).to eq(["Title can't be blank"])
+      a.id = 2
+      a.body = "hello"
+      a.title = "Jimbo"
+      a.save!
+
+      ### Unique fields
+
+      # The `:unique` argument in a field declaration gives `validates_uniqueness_of`:
+
+      class AdvertWithUniqueTitle < ActiveRecord::Base
+        self.table_name = 'adverts'
+
+        fields do
+          title :string, :unique, limit: 255
+        end
+      end
+
+      a = AdvertWithUniqueTitle.new :title => "Jimbo", id: 3, body: "hello"
+      expect(a.valid? || a.errors.full_messages).to eq(["Title has already been taken"])
+      a.title = "Sambo"
+      a.save!
+    end
+  end
+end

data/spec/lib/declare_schema/field_declaration_dsl_spec.rb

@@ -3,11 +3,15 @@
 require_relative '../../../lib/declare_schema/field_declaration_dsl'
 
 RSpec.describe DeclareSchema::FieldDeclarationDsl do
-  class TestModel < ActiveRecord::Base
-    fields do
-      name :string, limit: 127
+  before do
+    load File.expand_path('prepare_testapp.rb', __dir__)
 
-      timestamps
+    class TestModel < ActiveRecord::Base
+      fields do
+        name :string, limit: 127
+
+        timestamps
+      end
     end
   end
 

data/spec/lib/declare_schema/generator_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+RSpec.describe 'DeclareSchema Migration Generator' do
+  before do
+    load File.expand_path('prepare_testapp.rb', __dir__)
+  end
+
+  it "generates nested models" do
+    Rails::Generators.invoke('declare_schema:model', %w[alpha/beta one:string two:integer])
+
+    expect(File.exist?('app/models/alpha/beta.rb')).to be_truthy
+
+    expect(File.read('app/models/alpha/beta.rb')).to eq(<<~EOS)
+      class Alpha::Beta < #{active_record_base_class}
+  
+        fields do
+          one :string, limit: 255
+          two :integer
+        end
+  
+      end
+    EOS
+
+    expect(File.read('app/models/alpha.rb')).to eq(<<~EOS)
+      module Alpha
+        def self.table_name_prefix
+          'alpha_'
+        end
+      end
+    EOS
+
+    expect(File.read('test/models/alpha/beta_test.rb')).to eq(<<~EOS)
+      require 'test_helper'
+      
+      class Alpha::BetaTest < ActiveSupport::TestCase
+        # test "the truth" do
+        #   assert true
+        # end
+      end
+    EOS
+
+    expect(File.exist?('test/fixtures/alpha/beta.yml')).to be_truthy
+
+    $LOAD_PATH << "#{TESTAPP_PATH}/app/models"
+
+    expect(system("bundle exec rails generate declare_schema:migration -n -m")).to be_truthy
+
+    expect(File.exist?('db/schema.rb')).to be_truthy
+
+    expect(File.exist?("db/development.sqlite3") || File.exist?("db/test.sqlite3")).to be_truthy
+
+    module Alpha; end
+    require 'alpha/beta'
+
+    expect { Alpha::Beta }.to_not raise_exception
+  end
+end