meta-record 1.0.1

data/lib/metarecord/generators/rails/data_generator.rb

@@ -0,0 +1,143 @@
+require 'metarecord/model'
+require 'metarecord/generator_base'
+
+class RailsDataGenerator < GeneratorBase
+  class << self
+    def is_file_based? ; false ; end
+  end
+
+  def model_base_class
+    if defined? RAILS_RECORD_BASE
+      RAILS_RECORD_BASE
+    else
+      "ActiveRecord::Base"
+    end
+  end
+  
+  def reset
+    super
+    @default_authorized_properties = []
+  end
+
+  def generate_for object
+    reset
+    indent do
+      _append "class #{object[:name]} < #{model_base_class}"
+      indent do
+        _append "self.abstract_class = true"
+        _append ""
+        self.instance_eval &object[:block]
+        _append ""
+        generate_default_authorized_properties
+      end
+      _append "end"
+    end
+    @src
+  end
+
+  def generate_default_authorized_properties
+    _append "class << self"
+    indent do
+      _append "def permitted_attributes"
+      indent do
+        symbols = @default_authorized_properties.collect do |v| v.to_sym.inspect end
+        _append "[#{symbols.join ','}]"
+      end
+      _append "end"
+    end
+    _append "end"
+  end
+
+  def validation type, name, data
+    src = "validates #{name.to_s.inspect}"
+    src += ", presence: true"     if data[:required] == true
+    src += ", allow_blank: false" if data[:required] && type == "std::string"
+    src += ", uniqueness: true"   if data[:uniqueness] == true
+    if !data[:min].nil? || !data[:max].nil?
+      src += validation_numericality name, data
+    end
+    _append src
+  end
+
+  def validation_numericality name, data
+    src = ", numericality: { "
+    if !data[:min].nil?
+      src += "greater_than_or_equal_to: #{data[:min]}"
+    end
+    if !data[:max].nil?
+      src += ", " if !data[:min].nil?
+      src += "less_than_or_equal_to: #{data[:max]}"
+    end
+    src += " }"
+    src
+  end
+
+  def visibility value
+  end
+
+  def resource_name name
+    _append "RESOURCE_NAME = #{name.to_s.inspect}"
+  end
+
+  def order_by name, flow = nil
+    src = if flow.nil?
+      name.to_s.inspect
+    else
+      "#{name}: :#{flow}"
+    end
+    _append "scope :default_order, -> { order(#{src}) }"
+  end
+
+  def property type, name, options = {}
+    has_custom_column_name = !options[:column].nil?
+    rails_name = (options[:column] || name).to_s
+    if type == 'DataTree'
+      _append "store #{rails_name.inspect}, coder: JSON"
+      _append "def #{name} ; self.#{rails_name} ; end" if has_custom_column_name
+    elsif has_custom_column_name
+      _append "def #{name}"
+      indent do _append "self.#{options[:column]}" end
+      _append "end"
+      _append "def #{name}=(value)"
+      indent do _append "self.#{options[:column]} = value"end
+      _append "end"
+    end
+    validation type, rails_name, options[:validate] unless options[:validate].nil?
+    @default_authorized_properties << name unless options[:read_only]
+  end
+
+  def has_one type, name, options = {}
+    db_options  = options[:db] || {}
+    foreign_key = db_options[:column] || "#{name}_id"
+    _append "belongs_to #{name.to_sym.inspect},"
+    indent do
+      optional = if db_options[:null].nil? then true else db_options[:null] end
+      _append "class_name: #{type.to_s.inspect},"
+      _append "foreign_key: #{foreign_key.to_s.inspect},"
+      _append "optional: #{optional}"
+    end
+  end
+
+  def has_many type, name, options = {}
+    db_options = options[:db] || {}
+    if options[:joined] != false
+      suffix = []
+      suffix << "class_name: #{type.to_s.inspect}"
+      suffix << "dependent: #{options[:dependent].to_sym.inspect}" if options[:dependent] && options[:dependent].to_sym != :unlink
+      _append "has_many #{name.to_sym.inspect}, #{suffix.join ','}"
+    else
+      throw "id based has_many is not supported by the rails generator"
+    end
+  end
+
+  class << self
+    def extension ; ".rb" ; end
+
+    def make_file filename, data
+      <<RUBY
+module #{METARECORD_NAMESPACE}
+#{data[:bodies].join "\n"}end
+RUBY
+    end
+  end
+end

data/lib/metarecord/generators/rails/migration_generator.rb

@@ -0,0 +1,89 @@
+require 'metarecord/generator_base'
+require 'metarecord/generators/rails/migrations/table_helpers'
+
+class RailsMigrationGenerator < GeneratorBase
+  include RailsTableHelpers
+
+  def should_generate_for object
+    false
+  end
+
+  def should_generate_from_manifest
+    true
+  end
+
+  def generate_manifest old_manifest, new_manifest
+    reset
+    @indent = 2
+    probe_additions old_manifest, new_manifest
+    probe_deletions old_manifest, new_manifest
+    @indent = 0
+    if @src.length > 0
+      make_migration
+    else
+      puts "[metarecord][rails/migration] no migrations to generate"
+    end
+  end
+
+private
+  def have_column_changed? old_column, new_column
+    old_column["type"] != new_column["type"] || old_column["options"] != new_column["options"]
+  end
+
+  def probe_additions old_manifest, new_manifest
+    new_manifest.keys.each do |model_name|
+      old_table = old_manifest[model_name]
+      new_table = new_manifest[model_name]
+
+      # If table does not exist, create it
+      if old_table.nil?
+        create_table model_name, new_table
+      # If table exists, check if some of its columns have been modified
+      else
+        new_table.keys.each do |column_name|
+          old_column = old_table[column_name]
+          new_column = new_table[column_name]
+          # If column does not exist, create it
+          if old_column.nil?
+            create_column model_name, column_name, new_column
+          # If column exists, ensure none of its options have been changed
+          elsif have_column_changed? old_column, new_column
+            update_column model_name, column_name, new_column
+          end
+        end
+      end
+    end
+  end
+
+  def probe_deletions old_manifest, new_manifest
+    old_manifest.keys.each do |model_name|
+      new_table = new_manifest[model_name]
+      old_table = old_manifest[model_name]
+
+      if new_table.nil?
+        drop_table model_name
+      else
+        old_table.keys.each do |column_name|
+          new_column = new_table[column_name]
+          drop_column model_name, column_name if new_column.nil?
+        end
+      end
+    end
+  end
+
+  def make_migration
+    now = DateTime.now
+    timestamp = DateTime.now.strftime "%Y%m%d%H%M%S"
+    filepath = "db/migrate/#{timestamp}_metarecord_generator_#{timestamp}.rb"
+    src = <<RUBY
+class MetarecordGenerator#{timestamp} < ActiveRecord::Migration[6.0]
+  def change
+#{@src}  end
+end
+RUBY
+    File.open filepath, 'w' do |f|
+      f.write src
+    end
+    puts "[metarecord][rails/migration] Generated migration file #{filepath}"
+  end
+end

data/lib/metarecord/generators/rails/migrations/table_helpers.rb

@@ -0,0 +1,67 @@
+require 'metarecord/generators/rails/migrations/type_helpers'
+
+module RailsTableHelpers
+  include RailsTypeHelpers
+
+  def create_table model_name, columns
+    _append "create_table :#{get_table_name model_name} do |t|"
+    indent do
+      columns.each do |name, options|
+        record_type = get_record_type options["type"]
+        if record_type.nil?
+          on_unsupported_type model_name, name, options["type"]
+          next
+        end
+        src = "t."
+        src += rails_type_name record_type
+        src += " :#{name}"
+        src += type_options_string record_type
+        src += database_options_string options
+        _append src
+      end
+    end
+    _append "end"
+  end
+
+  def create_column model_name, column_name, data
+    column_operation 'add', model_name, column_name, data
+  end
+
+  def update_column model_name, column_name, data
+    column_operation 'change', model_name, column_name, data
+  end
+
+  def drop_table model_name
+    _append "drop_table :#{get_table_name model_name}"
+  end
+
+  def drop_column model_name, column_name
+    _append "remove_column :#{get_table_name model_name}, :#{column_name}"
+  end
+
+private
+  def get_table_name model_name
+    get_pluralized_name model_name.underscore
+  end
+
+  def database_options_string data
+    str = ""
+    data["options"].each do |key, value|
+      str += ", #{key}: #{value.to_json}"
+    end
+    str
+  end
+
+  def column_operation operation, model_name, column_name, data
+    record_type = get_record_type data["type"]
+    if record_type.nil?
+      on_unsupported_type model_name, column_name, data["type"]
+      return
+    end
+    src  = "#{operation}_column :#{get_table_name model_name}, :#{column_name}"
+    src += ", :#{rails_type_name record_type}"
+    src += type_options_string record_type
+    src += database_options_string data
+    _append src
+  end
+end

data/lib/metarecord/generators/rails/migrations/type_helpers.rb

@@ -0,0 +1,45 @@
+module RailsTypeHelpers
+  def get_record_type type
+    case type
+    when "ODB::id_type"       then :bigint
+    when "char"               then :tinyint
+    when "unsigned char"      then :smallint
+    when "short"              then :smallint
+    when "unsigned short"     then :mediumint
+    when "int"                then :integer
+    when "unsigned int"       then :integer
+    when "long"               then :bigint
+    when "long long"          then :bigint
+    when "unsigned long"      then :bigint
+    when "unsigned long long" then :bigint
+    when "double"             then :float
+    when "long double"        then :float
+    when "float"              then :float
+    when "bool"               then :boolean
+    when "std::string"        then :string
+    when "std::time_t"        then :timestamp
+    else nil
+    end
+  end
+
+  def on_unsupported_type model_name, column_name, type_name
+    puts "[metarecord][rails-migration] unsupported type #{type_name} for column `#{column_name}` in table `#{model_name}`"
+  end
+
+  def is_integer_type? type
+    [:tinyint, :smallint, :mediumint, :bigint, :integer].include? type
+  end
+
+  def rails_type_name type
+    if is_integer_type? type then "integer" else type.to_s end
+  end
+
+  def type_options_string type
+    if is_integer_type? type
+      table = { tinyint: 1, smallint: 2, mediumint: 3, integer: 4, bigint: 8 }
+      ", limit: #{table[type]}"
+    else
+      ""
+    end
+  end
+end

data/lib/metarecord/manifest_generator.rb

@@ -0,0 +1,42 @@
+require 'metarecord/generator_base'
+require 'metarecord/model'
+require 'json'
+
+class ManifestGenerator < GeneratorBase
+  def initialize
+    @manifest_data = {}
+  end
+
+  def generate output
+    Model.list.each do |model|
+      @manifest_data[model[:name]] = @current_manifest_item = Hash.new
+      self.instance_eval &model[:block]
+    end
+    File.open output, 'w' do |f|
+      f.write JSON.pretty_generate(@manifest_data)
+    end
+  end
+
+  def property type, name, options = {}
+    db_options  = options[:db] || Hash.new
+    column_name = db_options[:column] || name
+    db_options.delete :column
+    @current_manifest_item[column_name] = { type: type, options: db_options }
+  end
+
+  def has_one type, name, options = {}
+    db_options  = options[:db] || Hash.new
+    column_name = db_options[:column] || "#{name}_id"
+    db_options.delete :column
+    @current_manifest_item[column_name] = { type: "ODB::id_type", options: db_options }
+  end
+
+  def has_many type, name, options = {}
+    if options[:joined] == false
+      db_options  = options[:db] || Hash.new
+      column_name = db_options[:column] || "#{get_singular_name name}_id"
+      db_options.delete :column
+      @current_manifest_item[column_name] = { type: "INTEGER[]", options: db_options }
+    end
+  end
+end

data/lib/metarecord/model.rb

@@ -0,0 +1,66 @@
+METARECORD_NAMESPACE = "MetaRecord"
+
+class Model
+  class << self
+    attr_accessor :current_file
+
+    def add name, definition = {}, &block
+      @list ||= []
+      if definition.kind_of?(Array)
+        definition = { classname: definition.first, hpp: definition.last }
+      end
+      definition[:classname] ||= "::#{name}"
+      @list << { name: name, filename: current_file, block: block,
+                 classname: definition[:classname], header: definition[:hpp] }
+    end
+
+    def list
+      @list || []
+    end
+
+    def reset
+      @list = nil
+    end
+  end
+end
+
+class Includes
+  class << self
+    attr_accessor :list
+    attr_accessor :headers
+
+    def reset
+      list = headers = nil
+    end
+  end
+end
+
+def add_include path, options = {}
+  options = { include_in_header: true } if options.kind_of? TrueClass
+  if options[:include_in_header]
+    Includes.headers ||= {}
+    Includes.headers[Model.current_file] ||= []
+    Includes.headers[Model.current_file] << path
+  else
+    Includes.list ||= {}
+    Includes.list[Model.current_file] ||= []
+    Includes.list[Model.current_file] << path
+  end
+end
+
+def collect_includes_for filename, is_header = false
+  base = if is_header then Includes.headers else Includes.list end
+  return [] if base.nil?
+  pre  = "#include"
+  pre  = "# include" if is_header
+  base = base[filename]
+  ((base || []).collect {|a| "#{pre} \"#{a}\""}).uniq
+end
+
+def load_all_models input_dir
+  Dir["#{input_dir}/*.rb"].each do |file|
+    Model.current_file = file
+    load file
+  end
+  Model.list
+end

data/lib/metarecord/runner.rb

@@ -0,0 +1,56 @@
+require 'metarecord/generator_base'
+require 'metarecord/manifest_generator'
+
+module MetaRecordRunner
+  def manifest_path
+    ".metarecord-manifest.json"
+  end
+
+  def run_all
+    @generators.each do |generator|
+      require "metarecord/generators/#{generator.to_s}_generator"
+    end
+    `rm -Rf #{@tmpdir} && mkdir -p #{@tmpdir}`
+    GeneratorBase.prepare @input, @tmpdir, @base_path
+    GeneratorBase.odb_connection = @odb_connection || { object: "Crails::Odb::Connection", include: "crails/odb/connection.hpp" }
+    ManifestGenerator.new.generate "#{@tmpdir}/#{manifest_path}"
+    @old_manifest = JSON.parse File.read(manifest_path) rescue {}
+    @new_manifest = JSON.parse File.read("#{@tmpdir}/#{manifest_path}")
+    @generators.each do |generator|
+      const_name = generator.to_s.camelcase + "Generator"
+      klass      = Kernel.const_get const_name
+      GeneratorBase.use klass
+      if klass.new.should_generate_from_manifest
+        klass.new.generate_manifest @old_manifest, @new_manifest
+      end
+    end
+    update_files
+  end
+
+  def update_files
+    `cp "#{@tmpdir}/#{manifest_path}" "#{manifest_path}"`
+
+    Dir["#{@tmpdir}/**/*"].each do |tmp_file|
+      next if File.directory? tmp_file
+      new_path = "#{@output}/#{tmp_file[@tmpdir.size + 1..tmp_file.size]}"
+      if (not File.exists?(new_path)) || File.read(new_path) != File.read(tmp_file)
+        puts "[metarecord] generated #{new_path}"
+        `mkdir -p '#{File.dirname new_path}'`
+        `cp '#{tmp_file}' '#{new_path}'`
+      else
+        puts "[metarecord] no updates required for #{new_path}"
+      end
+    end
+
+    @input.each do |input|
+      Dir["#{@output}/#{input}/**/*"].each do |actual_file|
+        next if File.directory? actual_file
+        tmp_path = "#{@tmpdir}/#{@output[@output.size + 1..@output.size]}"
+        if not File.exists?(tmp_path)
+          puts "[metarecord] removed #{actual_file}"
+          `rm '#{actual_file}'`
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: meta-record
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Michael Martin Moro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-03-23 00:00:00.000000000 Z
+dependencies: []
+description: |2
+    MetaRecord is a code generator that allows you to define your application
+    models using a Ruby-powered DSL, and generates various implementation for
+    them, for your web server, client, or mobile application.
+    It can generates code for the following targests: Crails, ActiveRecord,
+    Comet.cpp, and Aurelia.js.
+email: michael@unetresgrossebite.com
+executables:
+- metarecord-make
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/metarecord-make
+- lib/guard/metarecord.rb
+- lib/metarecord/generator_base.rb
+- lib/metarecord/generators/aurelia_generator.rb
+- lib/metarecord/generators/comet/archive_generator.rb
+- lib/metarecord/generators/comet/data_generator.rb
+- lib/metarecord/generators/comet/edit_generator.rb
+- lib/metarecord/generators/crails/data_generator.rb
+- lib/metarecord/generators/crails/destroy_generator.rb
+- lib/metarecord/generators/crails/edit_generator.rb
+- lib/metarecord/generators/crails/helpers/validations.rb
+- lib/metarecord/generators/crails/query_generator.rb
+- lib/metarecord/generators/crails/view_generator.rb
+- lib/metarecord/generators/rails/data_generator.rb
+- lib/metarecord/generators/rails/migration_generator.rb
+- lib/metarecord/generators/rails/migrations/table_helpers.rb
+- lib/metarecord/generators/rails/migrations/type_helpers.rb
+- lib/metarecord/manifest_generator.rb
+- lib/metarecord/model.rb
+- lib/metarecord/runner.rb
+homepage: https://github.com/crails-framework/meta-record
+licenses:
+- BSD
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: MetaRecord is a database code generator from Crails Framework
+test_files: []