active_record-mti 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 556fa783caa9bcba984b0ce5773a69f4703317b6
-  data.tar.gz: 6d6c0f07e90648aae6cdcce02acde5c787c40a93
+  metadata.gz: 70e92bb458152badc92fe1d0f6aa3ac255419211
+  data.tar.gz: ec759e61c4042d9fa8119f3c5602fa674b226260
 SHA512:
-  metadata.gz: 129a447a2b60dadef04349abb786136e6d5be55090aac4f950ca86ebabd5393a4d0ab981faceca3802b73c15b071d0b7ac36a801af403bc978cee18ae70cc050
-  data.tar.gz: 99abf9b045de3a36aff4cfb450ce54cba4378de16ad8dde7406e5044890bf87ace33caa4cadcd6e382b3a8699a42d87d66a03a34a0e9df954d46b6082a18dd2f
+  metadata.gz: 8156561ef762ff46a270d9907f1df24e74824fd4314a96ca365d30d03700cf92bc8e6a96c8f68f598680b98185fbbc2642900b2b32302303e81ceda50b596ba0
+  data.tar.gz: 4d453baef7016ff52e81c366bb54bc8a095f35fce78186847ee605a2c2252810b258fb7e6f4e0e8bfc3be93d2623069802421cf4d0757e6f1267bf6a52002761

data/.gitignore

@@ -0,0 +1,74 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Database config and secrets
+/config/database.yml
+/config/secrets.yml
+
+# Ignore bundler config
+/.bundle
+
+# Ignore client credentials
+/config/client_api_credentials.yml
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp
+/db/structure.sql
+/doc/app/*
+/vendor/cldr/*
+/public/uploads/*
+/public/photo/*
+/public/test/*
+/test/assets/*
+/spec/assets/*
+/public/assets/**
+.powenv
+.rvmrc
+.env
+.ruby-version
+
+# Compiled source #
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+Icon?
+ehthumbs.db
+Thumbs.db

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Dale Stevens
+
+MIT License
+
+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,88 @@
+# ActiveRecord::MTI
+
+Allows for true native inheritance of tables in PostgreSQL
+
+Currently requires Rails 4.2
+
+## Usage
+
+Add this line to your application's Gemfile:
+
+    gem 'active_record-mti'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record-mti
+
+### Migrations
+
+In your migrations define a table to inherit from another table:
+
+```ruby
+class CreateAccounts < ActiveRecord::Migration
+  def change
+    # Things is the head of or inheritance tree representing all things
+    # both tangible and intangible.  Can be considered the vertices in
+    # the graph.
+    create_table :accounts do |t|
+      t.jsonb       :settings
+      t.timestamps
+    end
+
+    create_table :users, inherits: :accounts do |t|
+      t.string      :firstname
+      t.string      :lastname
+    end
+
+    create_table :developers, inherits: :users do |t|
+      t.string      :url
+      t.string      :api_key
+    end
+  end
+end
+
+```
+
+### Schema.rb
+
+A schema will be created that reflects the inheritance chain so that rake:db:schema:load will work
+
+```ruby
+ctiveRecord::Schema.define(version: 20160910024954) do
+
+  create_table "accounts", force: :cascade do |t|
+    t.jsonb    "settings"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "users", inherits: "accounts" do |t|
+    t.string "firstname"
+    t.string "lastname"
+  end
+
+  create_table "developers", inherits: "users" do |t|
+    t.string "url"
+    t.string "api_key"
+  end
+
+end
+```
+
+### In your application code
+
+ActiveRecord queries work as usual with the following differences:
+
+* The default query of "*" is changed to include the OID of each row for subclass discrimination. The default select will be `SELECT cast("accounts"."tableoid"::regclass AS text), "accounts".*`
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_record-mti/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/active_record-mti.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/mti/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record-mti"
+  spec.version       = ActiveRecord::MTI::VERSION
+  spec.authors       = ["Dale Stevens"]
+  spec.email         = ["dale@twilightcoders.net"]
+  spec.summary       = %q{Multi Table Inheritance for PostgreSQL in Rails}
+  spec.description   = %q{Allows use of native inherited tables in PostgreSQL}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency 'rake', '~> 0'
+  spec.add_runtime_dependency 'rails', '~> 4.1', '> 4.1'
+  spec.add_runtime_dependency 'pg', '~> 0'
+
+end

data/lib/active_record/mti.rb

@@ -0,0 +1,8 @@
+require "active_record/mti/version"
+require 'active_record/mti/railtie' if defined?(Rails)
+
+module ActiveRecord
+  module MTI
+    # Your code goes here...
+  end
+end

data/lib/active_record/mti/calculations.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module MTI
+    module Calculations
+
+      private
+
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        # Postgresql doesn't like ORDER BY when there are no GROUP BY
+        relation = unscope(:order)
+
+        column_alias = column_name
+
+        bind_values = nil
+
+        if operation == "count" && (relation.limit_value || relation.offset_value)
+          # Shortcut when limit is zero.
+          return 0 if relation.limit_value == 0
+
+          query_builder = build_count_subquery(relation, column_name, distinct)
+          bind_values = query_builder.bind_values + relation.bind_values
+        else
+          column = aggregate_column(column_name)
+
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+
+          column_alias = select_value.alias
+          column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
+          relation.select_values = [select_value]
+
+          # Only use the last projection (probably the COUNT(*)) all others don't matter
+          # relation.arel.projections = [relation.arel.projections.last].compact if @klass.using_multi_table_inheritance?
+          relation.arel.projections.shift if @klass.using_multi_table_inheritance?
+
+          query_builder = relation.arel
+          bind_values = query_builder.bind_values + relation.bind_values
+        end
+
+        result = @klass.connection.select_all(query_builder, nil, bind_values)
+        row    = result.first
+        value  = row && row.values.first
+        column = result.column_types.fetch(column_alias) do
+          type_for(column_name)
+        end
+
+        type_cast_calculated_value(value, column, operation)
+      end
+
+    end
+  end
+end

data/lib/active_record/mti/connection_adapters/postgresql/schema_statements.rb

@@ -0,0 +1,96 @@
+module ActiveRecord
+  module MTI
+    module ConnectionAdapters
+      module PostgreSQL
+        module SchemaStatements
+          # Creates a new table with the name +table_name+. +table_name+ may either
+          # be a String or a Symbol.
+          #
+          # Add :inherits options for Postgres table inheritance.  If a table is inherited then
+          # the primary key column is also inherited.  Therefore the :primary_key options is set to false
+          # so we don't duplicate that colume.
+          #
+          # However the primary key column from the parent is not inherited as primary key so
+          # we manually add it.  Lastly we also create indexes on the child table to match those
+          # on the parent table since indexes are also not inherited.
+          def create_table(table_name, options = {})
+            if options[:inherits]
+              options[:id] = false
+              options.delete(:primary_key)
+            end
+
+            if schema = options.delete(:schema)
+              # If we specify a schema then we only create it if it doesn't exist
+              # and we only force create it if only the specific schema is in the search path
+              table_name = "#{schema}.#{table_name}"
+            end
+
+            if parent_table = options.delete(:inherits)
+              options[:options] = ["INHERITS (#{parent_table})", options[:options]].compact.join
+            end
+
+            td = create_table_definition table_name, options[:temporary], options[:options], options[:as]
+
+            if options[:id] != false && !options[:as]
+              pk = options.fetch(:primary_key) do
+                Base.get_primary_key table_name.to_s.singularize
+              end
+
+              if pk.is_a?(Array)
+                td.primary_keys pk
+              else
+                td.primary_key pk, options.fetch(:id, :primary_key), options
+              end
+            end
+
+            yield td if block_given?
+
+            if options[:force] && data_source_exists?(table_name)
+              drop_table(table_name, options)
+            end
+
+            # Rails 5 wont create an empty column list which we might have if we're
+            # working with inherited tables.  So we need to do that manually
+            sql = schema_creation.accept(td)
+            # sql = sql.sub("INHERITS", "() INHERITS") if td.columns.empty?
+
+            result = execute sql
+
+            if parent_table
+              parent_table_primary_key = primary_key(parent_table)
+              execute "ALTER TABLE #{table_name} ADD PRIMARY KEY (#{parent_table_primary_key})"
+              indexes(parent_table).each do |index|
+                add_index table_name, index.columns, :unique => index.unique
+              end
+              # triggers_for_table(parent_table).each do |trigger|
+              #   name = trigger.first
+              #   definition = trigger.second.merge(on: table_name)
+              #   create_trigger name, definition
+              # end
+            end
+
+            td.indexes.each_pair { |c,o| add_index table_name, c, o }
+          end
+
+          # Parent of inherited table
+          def parent_tables(table_name)
+            sql = <<-SQL
+              SELECT pg_namespace.nspname, pg_class.relname
+              FROM pg_catalog.pg_inherits
+                INNER JOIN pg_catalog.pg_class ON (pg_inherits.inhparent = pg_class.oid)
+                INNER JOIN pg_catalog.pg_namespace ON (pg_class.relnamespace = pg_namespace.oid)
+              WHERE inhrelid = '#{table_name}'::regclass
+            SQL
+            result = exec_query(sql, "SCHEMA")
+            result.map{|a| a['relname']}
+          end
+
+          def parent_table(table_name)
+            parents = parent_tables(table_name)
+            parents.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mti/inheritance.rb

@@ -0,0 +1,79 @@
+module ActiveRecord
+  # == Multi table inheritance
+  #
+  # PostgreSQL allows for table inheritance. To enable this in ActiveRecord, ensure that the
+  # inheritance_column is named "tableoid" (can be changed by setting <tt>Base.inheritance_column</tt>).
+  # This means that an inheritance looking like this:
+  #
+  #   class Company < ActiveRecord::Base;
+  #     self.inheritance_column = 'tableoid'
+  #   end
+  #   class Firm < Company; end
+  #   class Client < Company; end
+  #   class PriorityClient < Client; end
+  #
+  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
+  # the firms table which inherits from companies. You can then fetch this row again using
+  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
+  #
+  # Note, all the attributes for all the cases are kept in the same table. Read more:
+  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  #
+  module MTI
+    module Inheritance
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # We know we're using multi-table inheritance if the inheritance_column is not actually
+        # present in the DB structure. Thereby implying the inheritance_column is inferred.
+        # To further isolate usage of multi-table inheritance, the inheritance column must be set
+        # to 'tableoid'
+        def using_multi_table_inheritance?(klass = self)
+          @using_multi_table_inheritance ||= if klass.columns_hash.include?(klass.inheritance_column)
+            false
+          elsif klass.inheritance_column == 'tableoid' && (klass.descendants.select{ |d| d.table_name != klass.table_name }.any?)
+            true
+          else
+            false
+          end
+        end
+
+        private
+
+        # Called by +instantiate+ to decide which class to use for a new
+        # record instance. For single-table inheritance, we check the record
+        # for a +type+ column and return the corresponding class.
+        def discriminate_class_for_record(record)
+          if using_single_table_inheritance?(record)
+            find_sti_class(record[inheritance_column])
+          elsif using_multi_table_inheritance?(base_class)
+            find_mti_class(record)
+          else
+            super
+          end
+        end
+
+        # Search descendants for one who's table_name is equal to the returned tableoid.
+        # This indicates the class of the record
+        def find_mti_class(record)
+          descendants.find(Proc.new{ self }) { |d| d.table_name == record['tableoid'] }
+        end
+
+        # Type condition only applies if it's STI, otherwise it's
+        # done for free by querying the inherited table in MTI
+        def type_condition(table = arel_table)
+          if using_multi_table_inheritance?
+            nil
+          else
+            sti_column = table[inheritance_column]
+            sti_names  = ([self] + descendants).map { |model| model.sti_name }
+
+            sti_column.in(sti_names)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/mti/query_methods.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  module MTI
+    module QueryMethods
+
+      private
+
+      # Retrieve the OID as well on a default select
+      def build_select(arel)
+        arel.project("cast(\"#{klass.table_name}\".\"tableoid\"::regclass as text)") if @klass.using_multi_table_inheritance?
+        # arel.project("\"#{klass.table_name}\".\"tableoid\"::regclass as \"#{klass.inheritance_column}\"") if @klass.using_multi_table_inheritance?
+        if select_values.any?
+          arel.project(*arel_columns(select_values.uniq))
+        else
+          arel.project(@klass.arel_table[Arel.star])
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/mti/railtie.rb

@@ -0,0 +1,21 @@
+require 'active_record/mti/schema_dumper'
+require 'active_record/mti/inheritance'
+require 'active_record/mti/query_methods'
+require 'active_record/mti/calculations'
+require 'active_record/mti/connection_adapters/postgresql/schema_statements'
+
+module ActiveRecord
+  module MTI
+    class Railtie < Rails::Railtie
+      initializer 'active_record-mti.inheritance.initialization' do |_app|
+        ::ActiveRecord::Base.send :include, Inheritance
+        ::ActiveRecord::Relation.send :include, QueryMethods
+        ::ActiveRecord::Relation.send :include, ActiveRecord::MTI::Calculations
+
+        ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :include, ConnectionAdapters::PostgreSQL::SchemaStatements
+        ::ActiveRecord::SchemaDumper.send :include, ActiveRecord::MTI::SchemaDumper
+      end
+    end
+  end
+end
+

data/lib/active_record/mti/schema_dumper.rb

@@ -0,0 +1,177 @@
+# Modified SchemaDumper that knows how to dump
+# inherited tables. Key is that we have to dump parent
+# tables before we dump child tables (of course).
+# In addition we have to make sure we don't dump columns
+# that are inherited.
+module ActiveRecord
+  # = Active Record Schema Dumper
+  #
+  # This class is used to dump the database schema for some connection to some
+  # output format (i.e., ActiveRecord::Schema).
+  module MTI
+    module SchemaDumper #:nodoc:
+      extend ActiveSupport::Concern
+
+
+      included do
+
+        private
+
+        def dumped_tables
+          @dumped_tables ||= []
+        end
+
+        # Output table and columns - but don't output columns that are inherited from
+        # a parent table.
+        #
+        # TODO: Qualify with the schema name IF the table is in a schema other than the first
+        # schema in the search path (not including the $user schema)
+        def table(table, stream)
+          return if already_dumped?(table)
+          if parent_table = @connection.parent_table(table)
+            table(parent_table, stream)
+            parent_column_names = @connection.columns(parent_table).map(&:name)
+          end
+
+          columns = @connection.columns(table)
+          begin
+            tbl = StringIO.new
+
+            # first dump primary key column
+            pk = @connection.primary_key(table)
+
+            tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+            if parent_table
+              tbl.print %Q(, inherits: "#{parent_table}")
+            else
+              pkcol = columns.detect { |c| c.name == pk }
+              if pkcol
+                if pk != 'id'
+                  tbl.print %Q(, primary_key: "#{pk}")
+                elsif pkcol.sql_type == 'bigint'
+                  tbl.print ", id: :bigserial"
+                elsif pkcol.sql_type == 'uuid'
+                  tbl.print ", id: :uuid"
+                  tbl.print %Q(, default: #{pkcol.default_function.inspect})
+                end
+              else
+                tbl.print ", id: false"
+              end
+              tbl.print ", force: :cascade"
+            end
+            tbl.puts " do |t|"
+
+            # then dump all non-primary key columns
+            column_specs = columns.map do |column|
+              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+              next if column.name == pk
+
+              # Except columns in parent table
+              next if parent_column_names && parent_column_names.include?(column.name)
+
+              @connection.column_spec(column, @types)
+            end.compact
+
+            # find all migration keys used in this table
+            keys = @connection.migration_keys
+
+            # figure out the lengths for each column based on above keys
+            lengths = keys.map { |key|
+              column_specs.map { |spec|
+                spec[key] ? spec[key].length + 2 : 0
+              }.max
+            }
+
+            # the string we're going to sprintf our values against, with standardized column widths
+            format_string = lengths.map{ |len| "%-#{len}s" }
+
+            # find the max length for the 'type' column, which is special
+            type_length = column_specs.map{ |column| column[:type].length }.max
+
+            # add column type definition to our format string
+            format_string.unshift "    t.%-#{type_length}s "
+
+            format_string *= ''
+
+            column_specs.each do |colspec|
+              values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+              values.unshift colspec[:type]
+              tbl.print((format_string % values).gsub(/,\s*$/, ''))
+              tbl.puts
+            end
+
+            tbl.puts "  end"
+            tbl.puts
+
+            indexes(table, tbl)
+
+            tbl.rewind
+            stream.print tbl.read
+          rescue => e
+            stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
+
+          dumped_tables << table
+          stream
+        end
+
+        # Output indexes but don't output indexes that are inherited from parent tables
+        # since those will be created by create_table.
+        def indexes(table, stream)
+          if (indexes = @connection.indexes(table)).any?
+            if parent_table = @connection.parent_table(table)
+              parent_indexes = @connection.indexes(parent_table)
+            end
+
+            indexes.delete_if {|i| is_parent_index?(i, parent_indexes) } if parent_indexes
+            return if indexes.empty?
+
+            add_index_statements = indexes.map do |index|
+              statement_parts = [
+                ('add_index ' + remove_prefix_and_suffix(index.table).inspect),
+                index.columns.inspect,
+                ('name: ' + index.name.inspect),
+              ]
+              statement_parts << 'unique: true' if index.unique
+
+              index_lengths = (index.lengths || []).compact
+              statement_parts << ('length: ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+
+              index_orders = (index.orders || {})
+              statement_parts << ('order: ' + index.orders.inspect) unless index_orders.empty?
+
+              statement_parts << ('where: ' + index.where.inspect) if index.where
+
+              statement_parts << ('using: ' + index.using.inspect) if index.using
+
+              statement_parts << ('type: ' + index.type.inspect) if index.type
+
+              '  ' + statement_parts.join(', ')
+            end
+
+            stream.puts add_index_statements.sort.join("\n")
+            stream.puts
+          end
+        end
+
+
+        def remove_prefix_and_suffix(table)
+          table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+        end
+
+        def already_dumped?(table)
+          dumped_tables.include? table
+        end
+
+        def is_parent_index?(index, parent_indexes)
+          parent_indexes.each do |pindex|
+            return true if pindex.columns == index.columns
+          end
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mti/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module MTI
+    VERSION = "0.0.2"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-mti
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-10 00:00:00.000000000 Z
+date: 2016-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,7 +78,20 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record-mti.gemspec
+- lib/active_record/mti.rb
+- lib/active_record/mti/calculations.rb
+- lib/active_record/mti/connection_adapters/postgresql/schema_statements.rb
+- lib/active_record/mti/inheritance.rb
+- lib/active_record/mti/query_methods.rb
+- lib/active_record/mti/railtie.rb
+- lib/active_record/mti/schema_dumper.rb
+- lib/active_record/mti/version.rb
 homepage: ''
 licenses:
 - MIT