declare_schema 0.1.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Tom Locke
+
+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,11 @@
+# DeclareSchema
+
+Declare your active_record model schemas and have database migrations generated for you!
+
+## Testing
+To run tests:
+```
+rake test:prepare_testapp[force]
+rake test:all < test_responses.txt
+```
+(Note: there currently are no unit tests. The above will run the `rdoctests`.)

data/Rakefile

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubygems'
+require 'tmpdir'
+require 'pry'
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'declare_schema'
+
+RUBY = 'ruby'
+RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
+GEM_ROOT = __dir__
+TESTAPP_PATH = ENV['TESTAPP_PATH'] || File.join(Dir.tmpdir, 'declare_schema_testapp')
+BIN = File.expand_path('bin/declare_schema', __dir__)
+
+task default: 'test:all'
+
+include Rake::DSL
+
+namespace "test" do
+  task all: [:doctest, :spec]
+
+  desc "Run the doctests"
+  task :doctest do |_t|
+    files = Dir['test/*.rdoctest'].sort.map { |f| File.expand_path(f) }.join(' ')
+    system("#{RUBYDOCTEST} #{files}") or exit(1)
+  end
+
+  desc "Prepare a rails application for testing"
+  task :prepare_testapp, :force do |_t, args|
+    if args.force || !File.directory?(TESTAPP_PATH)
+      FileUtils.remove_entry_secure(TESTAPP_PATH, true)
+      sh %(#{BIN} new #{TESTAPP_PATH} --skip-wizard --skip-bundle)
+      FileUtils.chdir TESTAPP_PATH
+      sh %(bundle install)
+      sh %(echo "" >> Gemfile)
+      sh %(echo "gem 'irt', :group => :development" >> Gemfile) # to make the bundler happy
+      sh %(echo "gem 'therubyracer'" >> Gemfile)
+      sh %(echo "gem 'kramdown'" >> Gemfile)
+      sh %(echo "" > app/models/.gitignore) # because git reset --hard would rm the dir
+      rm %(.gitignore) # we need to reset everything in a testapp
+      sh %(git init && git add . && git commit -m "initial commit")
+      puts %(The testapp has been created in '#{TESTAPP_PATH}')
+    else
+      FileUtils.chdir TESTAPP_PATH
+      sh %(git add .)
+      sh %(git reset --hard -q HEAD)
+    end
+  end
+end

data/bin/declare_schema

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rubygems'
+require_relative '../lib/declare_schema/command'
+require_relative '../lib/declare_schema/version'
+
+ARGV.freeze
+
+DeclareSchema::Command.run(:DeclareSchema, ARGV.dup, DeclareSchema::VERSION)

data/declare_schema.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lib/declare_schema/version'
+
+Gem::Specification.new do |s|
+  s.authors = ['Invoca Development adapted from hobo_fields by Tom Locke']
+  s.email = 'development@invoca.com'
+  s.homepage = 'https://github.com/Invoca/declare_schema'
+  s.summary = 'Database migration generator for Rails'
+  s.description = 'Declare your Rails/active_record model schemas and have database migrations generated for you!'
+  s.name = "declare_schema"
+  s.version = DeclareSchema::VERSION
+
+  s.metadata = {
+    "allowed_push_host" => "https://rubygems.org"
+  }
+
+  s.executables = ["declare_schema"]
+  s.files = `git ls-files -x declare_schema/* -z`.split("\0")
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rails', '>= 4.2'
+end

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+source "https://gem.fury.io/invoca"
+
+gem "appraisal"
+gem "pry"
+gem "pry-byebug"
+gem "rails", "~> 4.2"
+gem "responders"
+gem "rubydoctest"
+gem "sqlite3", "~> 1.3.0"
+gem "test_overrides"
+gem "yard"
+
+group :testapp do
+  gem "bootsnap", ">= 1.1.0", require: false
+  gem "kramdown"
+  gem "listen"
+  gem "RedCloth"
+end
+
+gemspec path: "../"

data/gemfiles/rails_5.gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+source "https://gem.fury.io/invoca"
+
+gem "appraisal"
+gem "pry"
+gem "pry-byebug"
+gem "rails", "~> 5.2"
+gem "responders"
+gem "rubydoctest"
+gem "sqlite3"
+gem "test_overrides"
+gem "yard"
+
+group :testapp do
+  gem "bootsnap", ">= 1.1.0", require: false
+  gem "kramdown"
+  gem "listen"
+  gem "RedCloth"
+end
+
+gemspec path: "../"

data/gemfiles/rails_6.gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+source "https://gem.fury.io/invoca"
+
+gem "appraisal"
+gem "pry"
+gem "pry-byebug"
+gem "rails", "~> 6.0"
+gem "responders"
+gem "rubydoctest"
+gem "sqlite3"
+gem "test_overrides"
+gem "yard"
+
+group :testapp do
+  gem "bootsnap", ">= 1.1.0", require: false
+  gem "kramdown"
+  gem "listen"
+  gem "RedCloth"
+end
+
+gemspec path: "../"

data/lib/declare_schema.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/all'
+require_relative 'declare_schema/version'
+
+ActiveSupport::Dependencies.autoload_paths |= [__dir__]
+
+module DeclareSchema
+  class Boolean; end
+
+  PLAIN_TYPES = {
+    boolean:  Boolean,
+    date:     Date,
+    datetime: ActiveSupport::TimeWithZone,
+    time:     Time,
+    integer:  Integer,
+    decimal:  BigDecimal,
+    float:    Float,
+    string:   String,
+    text:     String
+  }.freeze
+
+  class << self
+    def to_class(type)
+      case type
+      when Class
+        type
+      when Symbol, String
+        PLAIN_TYPES[type.to_sym]
+      else
+        raise ArgumentError, "expected Class or Symbol or String: got #{type.inspect}"
+      end
+    end
+  end
+end
+
+require 'declare_schema/extensions/active_record/fields_declaration'
+require 'declare_schema/field_declaration_dsl'
+require 'declare_schema/model'
+require 'declare_schema/model/field_spec'
+require 'declare_schema/model/index_spec'
+
+require 'declare_schema/railtie' if defined?(Rails)

data/lib/declare_schema/command.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require 'rubygems'
+
+module DeclareSchema
+  module Command
+    BANNER = <<~EOS
+      Usage:
+          declare_schema new <app_name> [rails_opt]              Creates a new declare_schema Application
+          declare_schema generate|g <generator> [ARGS] [options] Fires the declare_schema:<generator>
+          declare_schema destroy <generator> [ARGS] [options]    Tries to undo generated code
+          declare_schema --help|-h                               This help screen
+
+    EOS
+
+    class << self
+      def run(gem, args, version)
+        command = args.shift
+
+        case command
+
+        when nil
+          puts "\nThe command is missing!\n\n"
+          puts BANNER
+          exit(1)
+
+        when /^--help|-h$/
+          puts BANNER
+          exit
+
+        when 'new'
+          app_name = args.shift or begin
+            puts "\nThe application name is missing!\n\n"
+            puts BANNER
+            exit(1)
+          end
+          template_path = File.join(Dir.tmpdir, "declare_schema_app_template")
+          File.open(template_path, 'w') do |file|
+            file.puts "gem '#{gem}', '>= #{version}'"
+          end
+          puts "Generating Rails infrastructure..."
+          system("rails new #{app_name} #{args * ' '} -m #{template_path}")
+          File.delete(template_path)
+
+        when /^(g|generate|destroy)$/
+          cmd = Regexp.last_match(1)
+          if args.empty?
+            puts "\nThe generator name is missing!\n\n"
+            puts BANNER
+            exit(1)
+          else
+            system("bundle exec rails #{cmd} declare_schema:#{args * ' '}")
+          end
+
+        else
+          puts "\n  => '#{command}' is an unknown command!\n\n"
+          puts BANNER
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/declare_schema/extensions/active_record/fields_declaration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'declare_schema/model'
+require 'declare_schema/field_declaration_dsl'
+
+module DeclareSchema
+  module FieldsDsl
+    def fields(&block)
+      # Any model that calls 'fields' gets DeclareSchema::Model behavior
+      DeclareSchema::Model.mix_in(self)
+
+      # @include_in_migration = false #||= options.fetch(:include_in_migration, true); options.delete(:include_in_migration)
+      @include_in_migration = true
+
+      if block
+        dsl = DeclareSchema::FieldDeclarationDsl.new(self, null: false)
+        if block.arity == 1
+          yield dsl
+        else
+          dsl.instance_eval(&block)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.singleton_class.prepend DeclareSchema::FieldsDsl

data/lib/declare_schema/extensions/module.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Module
+
+  private
+
+  # Creates a class attribute reader that will delegate to the superclass
+  # if not defined on self. Default values can be a Proc object that takes the class as a parameter.
+  def inheriting_cattr_reader(*names)
+    receiver =
+      if self.class == Module
+        self
+      else
+        singleton_class
+      end
+
+    names_with_defaults = (names.pop if names.last.is_a?(Hash)) || {}
+
+    (names + names_with_defaults.keys).each do |name|
+      ivar_name = "@#{name}"
+      block = names_with_defaults[name]
+
+      receiver.send(:define_method, name) do
+        if instance_variable_defined? ivar_name
+          instance_variable_get(ivar_name)
+        else
+          superclass.respond_to?(name) && superclass.send(name) ||
+            block && begin
+              result = block.is_a?(Proc) ? block.call(self) : block
+              instance_variable_set(ivar_name, result) if result
+            end
+        end
+      end
+    end
+  end
+end

data/lib/declare_schema/field_declaration_dsl.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/proxy_object'
+
+module DeclareSchema
+  class FieldDeclarationDsl < BasicObject # avoid Object because that gets extended by lots of gems
+    include ::Kernel                      # but we need the basic class methods
+
+    instance_methods.each do |m|
+      unless m.to_s.starts_with?('__') || m.in?([:object_id, :instance_eval])
+        undef_method(m)
+      end
+    end
+
+    def initialize(model, options = {})
+      @model = model
+      @options = options
+    end
+
+    attr_reader :model
+
+    def timestamps
+      field(:created_at, :datetime, null: true)
+      field(:updated_at, :datetime, null: true)
+    end
+
+    def optimistic_lock
+      field(:lock_version, :integer, default: 1, null: false)
+    end
+
+    def field(name, type, *args)
+      options = args.extract_options!
+      @model.declare_field(name, type, *(args + [@options.merge(options)]))
+    end
+
+    def method_missing(name, *args)
+      field(name, args.first, *args[1..-1])
+    end
+  end
+end

data/lib/declare_schema/model.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'declare_schema/extensions/module'
+
+module DeclareSchema
+  module Model
+    class << self
+      def mix_in(base)
+        base.singleton_class.prepend ClassMethods unless base.singleton_class < ClassMethods # don't mix in if a base class already did it
+
+        base.class_eval do
+          # ignore the model in the migration until somebody sets
+          # @include_in_migration via the fields declaration
+          inheriting_cattr_reader include_in_migration: false
+
+          # attr_types holds the type class for any attribute reader (i.e. getter
+          # method) that returns rich-types
+          inheriting_cattr_reader attr_types: HashWithIndifferentAccess.new
+          inheriting_cattr_reader attr_order: []
+
+          # field_specs holds FieldSpec objects for every declared
+          # field. Note that attribute readers are created (by ActiveRecord)
+          # for all fields, so there is also an entry for the field in
+          # attr_types. This is redundant but simplifies the implementation
+          # and speeds things up a little.
+          inheriting_cattr_reader field_specs: HashWithIndifferentAccess.new
+
+          # index_specs holds IndexSpec objects for all the declared indexes.
+          inheriting_cattr_reader index_specs: []
+          inheriting_cattr_reader ignore_indexes: []
+          inheriting_cattr_reader constraint_specs: []
+
+          # eval avoids the ruby 1.9.2 "super from singleton method ..." error
+
+          eval %(
+            def self.inherited(klass)
+              unless klass.field_specs.has_key?(inheritance_column)
+                fields do |f|
+                  f.field(inheritance_column, :string, limit: 255, null: true)
+                end
+                index(inheritance_column)
+              end
+              super
+            end
+          )
+        end
+      end
+    end
+
+    module ClassMethods
+      def index(fields, options = {})
+        # don't double-index fields
+        index_fields_s = Array.wrap(fields).map(&:to_s)
+        unless index_specs.any? { |index_spec| index_spec.fields == index_fields_s }
+          index_specs << ::DeclareSchema::Model::IndexSpec.new(self, fields, options)
+        end
+      end
+
+      def primary_key_index(*fields)
+        index(fields.flatten, unique: true, name: "PRIMARY_KEY")
+      end
+
+      def constraint(fkey, options = {})
+        fkey_s = fkey.to_s
+        unless constraint_specs.any? { |constraint_spec| constraint_spec.foreign_key == fkey_s }
+          constraint_specs << DeclareSchema::Model::ForeignKeySpec.new(self, fkey, options)
+        end
+      end
+
+      # tell the migration generator to ignore the named index. Useful for existing indexes, or for indexes
+      # that can't be automatically generated (for example: an prefix index in MySQL)
+      def ignore_index(index_name)
+        ignore_indexes << index_name.to_s
+      end
+
+      # Declare named field with a type and an arbitrary set of
+      # arguments. The arguments are forwarded to the #field_added
+      # callback, allowing custom metadata to be added to field
+      # declarations.
+      def declare_field(name, type, *args)
+        options = args.extract_options!
+        field_added(name, type, args, options) if respond_to?(:field_added)
+        add_formatting_for_field(name, type, args)
+        add_validations_for_field(name, type, args, options)
+        add_index_for_field(name, args, options)
+        field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, options)
+        attr_order << name unless name.in?(attr_order)
+      end
+
+      def index_specs_with_primary_key
+        if index_specs.any?(&:primary_key?)
+          index_specs
+        else
+          index_specs + [rails_default_primary_key]
+        end
+      end
+
+      def primary_key
+        super || 'id'
+      end
+
+      private
+
+      def rails_default_primary_key
+        ::DeclareSchema::Model::IndexSpec.new(self, [primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexSpec::PRIMARY_KEY_NAME)
+      end
+
+      # Extend belongs_to so that it creates a FieldSpec for the foreign key
+      def belongs_to(name, *args, &block)
+        if args.size == 0 || (args.size == 1 && args[0].is_a?(Proc))
+          options = {}
+          args.push(options)
+        elsif args.size == 1
+          options = args[0]
+        else
+          options = args[1]
+        end
+        column_options = {}
+        column_options[:null] = options.delete(:null) || false
+        column_options[:comment] = options.delete(:comment) if options.has_key?(:comment)
+        column_options[:default] = options.delete(:default) if options.has_key?(:default)
+        column_options[:limit] = options.delete(:limit) if options.has_key?(:limit)
+
+        index_options = {}
+        index_options[:name]   = options.delete(:index) if options.has_key?(:index)
+        index_options[:unique] = options.delete(:unique) if options.has_key?(:unique)
+        index_options[:allow_equivalent] = options.delete(:allow_equivalent) if options.has_key?(:allow_equivalent)
+
+        fk_options = options.dup
+        fk_options[:constraint_name] = options.delete(:constraint) if options.has_key?(:constraint)
+        fk_options[:index_name] = index_options[:name]
+
+        fk_options[:dependent] = options.delete(:far_end_dependent) if options.has_key?(:far_end_dependent)
+        super(name, *args, &block).tap do |_bt|
+          refl = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
+          fkey = refl.foreign_key
+          declare_field(fkey.to_sym, :integer, column_options)
+          if refl.options[:polymorphic]
+            foreign_type = options[:foreign_type] || "#{name}_type"
+            declare_polymorphic_type_field(foreign_type, column_options)
+            index([foreign_type, fkey], index_options) if index_options[:name] != false
+          else
+            index(fkey, index_options) if index_options[:name] != false
+            options[:constraint_name] = options
+            constraint(fkey, fk_options) if fk_options[:constraint_name] != false
+          end
+        end
+      end
+
+      # Declares the "foo_type" field that accompanies the "foo_id"
+      # field for a polymorphic belongs_to
+      def declare_polymorphic_type_field(foreign_type, column_options)
+        declare_field(foreign_type, :string, column_options.merge(limit: 255))
+        # FIXME: Before declare_schema was extracted, this used to now do:
+        # never_show(type_col)
+        # That needs doing somewhere
+      end
+
+      # Declare a rich-type for any attribute (i.e. getter method). This
+      # does not effect the attribute in any way - it just records the
+      # metadata.
+      def declare_attr_type(name, type, options = {})
+        klass = DeclareSchema.to_class(type)
+        attr_types[name] = DeclareSchema.to_class(type)
+        klass.declared(self, name, options) if klass.respond_to?(:declared)
+      end
+
+      # Add field validations according to arguments in the
+      # field declaration
+      def add_validations_for_field(name, type, args, options)
+        validates_presence_of   name if :required.in?(args)
+        validates_uniqueness_of name, allow_nil: !:required.in?(args) if :unique.in?(args)
+
+        if (validates_options = options[:validates])
+          validates name, validates_options
+        end
+
+        # Support for custom validations
+        if (type_class = DeclareSchema.to_class(type))
+          if type_class.public_method_defined?("validate")
+            validate do |record|
+              v = record.send(name)&.validate
+              record.errors.add(name, v) if v.is_a?(String)
+            end
+          end
+        end
+      end
+
+      def add_formatting_for_field(name, type, _args)
+        if (type_class = DeclareSchema.to_class(type))
+          if "format".in?(type_class.instance_methods)
+            before_validation do |record|
+              record.send("#{name}=", record.send(name)&.format)
+            end
+          end
+        end
+      end
+
+      def add_index_for_field(name, args, options)
+        if (to_name = options.delete(:index))
+          index_opts =
+            {
+              unique: args.include?(:unique) || options.delete(:unique)
+            }
+          # support index: true declaration
+          index_opts[:name] = to_name unless to_name == true
+          index(name, index_opts)
+        end
+      end
+
+      # Returns the type (a class) for a given field or association. If
+      # the association is a collection (has_many or habtm) return the
+      # AssociationReflection instead
+      public \
+      def attr_type(name)
+        if attr_types.nil? && self != self.name.constantize
+          raise "attr_types called on a stale class object (#{self.name}). Avoid storing persistent references to classes"
+        end
+
+        attr_types[name] ||
+          if (refl = reflections[name.to_s])
+            if refl.macro.in?([:has_one, :belongs_to]) && !refl.options[:polymorphic]
+              refl.klass
+            else
+              refl
+            end
+          end ||
+          if (col = column(name.to_s))
+            DeclareSchema::PLAIN_TYPES[col.type] || col.klass
+          end
+      end
+
+      # Return the entry from #columns for the named column
+      def column(name)
+        defined?(@table_exists) or @table_exists = table_exists?
+        if @table_exists
+          columns_hash[name.to_s]
+        end
+      end
+    end
+  end
+end