ead 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 521bf231cf8fd799589f9a95abb7c12d30fab37ea1cc4829b81f2f516a49ed0f
-  data.tar.gz: e855abd1586c963eaf182e89f4fac8af6f7a4ef30dccc5b692afea3261320173
+  metadata.gz: 450bcaedd5e7c5a27baac86e7bd92f2ad9d9b8b7b2d7b7b2b7acccf25eb53d67
+  data.tar.gz: 7024d256fa407c6f5301bc9566a9a932eadebabd12c0e1eb16d87d1f322366aa
 SHA512:
-  metadata.gz: 02530f8d06d43e5e55b10acb4d92a2ff3b9931aabc45f468805b798366f35dd87a60722c9b5e8d788e3862b53196a4b747bdb8d90b8396e7c89fb9cdcf05c4a5
-  data.tar.gz: b37b8c574101446d2bdb997d80c67d4da0ffa9aef271f6ef26ea7e34550000138d8105f88051a623793c4c158fd6a21e87f27572b685fdac4cc5c4a6f57b2ca8
+  metadata.gz: 238c5a8c1c5c4d5252b4d5d2736c5f035ec6fe317a2f44d118bbb275c6e6c7903f4f45a2522ead87d25ace953ed26100ad55873047807609f0e2d538408183e8
+  data.tar.gz: 34f6a6ffeaa60fe7e7f500941006efb5a4e5e37cbec2f0b25b79a39952e4b1097c9bb33fe21e21145d58931d5c7c56b240ee93e0399965c3f296ffc05e90b769

data/lib/association.rb

@@ -48,6 +48,8 @@ class Association
   end
 
   def set_middle_entity
+    return unless through?
+
     source = first_entity
     target = second_entity
 
@@ -72,8 +74,8 @@ class Association
            target.children_has_one +
            target.children_has_one_through
          ).include?(through_entity) || (
-           through_entity.parents_has_many.map(&:clone_parent).include?(target.clone_parent) ||
-           through_entity.parents_has_one.map(&:clone_parent).include?(target.clone_parent)
+           through_entity.parents_has_many.map(&:table).include?(target.table) ||
+           through_entity.parents_has_one.map(&:table).include?(target.table)
          )
        )
 
@@ -103,10 +105,8 @@ class Association
     end
   end
 
-  def self.set_middle_entities
-    associations = all.select(&:through?)
-
-    associations.each(&:set_middle_entity)
+  def update_model_from_entity
+    first_entity.update_model(second_entity, self)
   end
 
   def has_many?

data/lib/ead.rb

@@ -7,7 +7,7 @@ class EAD
   def import_JSON(user_arguments)
     file = File.read(user_arguments[0] || './EAD.json')
 
-    unless ['0.4.0', '0.4.1', '0.4.2', '0.4.2', '0.4.3', '0.4.4'].include? JSON.parse(file)['version']
+    unless ['0.4.0', '0.4.1', '0.4.2', '0.4.3', '0.4.4', '0.4.5'].include? JSON.parse(file)['version']
       puts "\n\n----------------"
       puts "\e[31m#{
         'Versions of your EAD file and the gem are not compatible.'\
@@ -27,45 +27,43 @@ class EAD
   end
 
   def create_objects(file)
-    @nodes = JSON.parse(file)['nodes']
-    @edges = JSON.parse(file)['edges']
-    @tables = JSON.parse(file)['tables']
+    parsed_file = JSON.parse(file)
 
-    @tables = @tables.map do |(id)|
-      Table.new(id, @tables)
+    parsed_tables = parsed_file['tables']
+    parsed_nodes = parsed_file['nodes']
+    parsed_edges = parsed_file['edges']
+
+    @tables = parsed_tables.map do |id, parsed_table|
+      Table.new(id, parsed_table)
     end
 
-    @nodes.map! do |node|
+    Table.update_superclasses(parsed_tables)
+
+    @nodes = parsed_nodes.map do |node|
       Entity.new(node)
     end
 
-    @edges.map! do |edge|
+    @edges = parsed_edges.map do |edge|
       Association.new(edge)
     end
   end
 
-  def check_implement_objects(file)
-    create_objects(file)
-
-    Entity.all.each do |entity|
-      entity.clone_parent.entities << entity
-    end
-
+  def check_implement_objects
     Table.all.each(&:create_model)
 
+    Table.all.each(&:add_polymorphic_reference_migration_for_sti)
+
     Table.all.each(&:add_reference_migration)
 
-    Association.set_middle_entities
+    Association.all.each(&:set_middle_entity)
 
-    Association.all.each do |association|
-      association.first_entity.update_model(association.second_entity, association)
-    end
+    Association.all.each(&:update_model_from_entity)
   end
 
   def check_latest_version
     response = JSON.parse RestClient.get 'https://api.github.com/repos/ozovalihasan/ead/tags'
 
-    unless response.first['name'] == 'v0.4.4'
+    unless response.first['name'] == 'v0.4.5'
       puts "\n\n----------------"
       puts "\n\e[33m#{
         'A new version of this gem has been released.'\
@@ -87,6 +85,7 @@ class EAD
   def start(user_arguments)
     check_latest_version
     file = import_JSON(user_arguments)
-    check_implement_objects(file)
+    create_objects(file)
+    check_implement_objects
   end
 end

data/lib/entity.rb

@@ -3,15 +3,15 @@ require 'association'
 require 'project_file'
 
 class Entity < TableEntityBase
-  attr_accessor(:name, :id, :twin_name, :clone_parent, :parent, :parent_association, :associations, :parent_associations,
+  attr_accessor(:name, :id, :table, :parent, :parent_association, :associations, :parent_associations,
                 :parents_has_one, :parents_has_many, :parents_through, :children_has_one, :children_has_many, :children_through,
                 :children_has_one_through, :children_has_many_through, :parents_has_one_through, :parents_has_many_through)
 
   def initialize(node)
     @id = node['id']
-    @name = node['data']['name'].split(' || ')[0].underscore.singularize
-    @twin_name = node['data']['name'].split(' || ')[1]&.underscore&.singularize
-    @clone_parent = Table.find(node['data']['tableId'])
+    @name = node['data']['name'].underscore.singularize
+    @table = Table.find(node['data']['tableId'])
+    @table.entities << self
 
     @parent_associations = []
     @associations = []
@@ -29,61 +29,106 @@ class Entity < TableEntityBase
     @children_through = []
   end
 
+  def self.find_by_name(name)
+    all.find { |entity| entity.name == name }
+  end
+
   def model_name
-    clone_parent.name.camelize
+    table.name.camelize
   end
 
-  def tables_same?(entity)
-    table == entity.table
+  def root_classes_same?(entity)
+    table.root_class == entity.table.root_class
   end
 
-  def self.find_by_name(name)
-    all.find { |entity| entity.name == name }
+  def table_name_different?
+    table.name != name
   end
 
-  def clone_name_different?
-    clone_parent.name != name
+  def root_class_name_different?
+    table.root_class.name != name
   end
 
   def one_polymorphic_names?(entity)
     table.polymorphic && table.polymorphic_names.include?(entity.name)
   end
 
-  def table
-    clone_parent
-  end
-
   def update_end_model_migration_files(start_entity, association)
-    polymorphic_end = one_polymorphic_names?(start_entity)
-
-    return if polymorphic_end
+    return unless association.has_any?
 
     end_model_line = {}
     end_migration_line = {}
 
-    if association.has_any?
-      end_model_line['belongs_to'] = ":#{start_entity.name}"
+    end_model_line['belongs_to'] = ":#{start_entity.name}"
+
+    if root_classes_same?(start_entity)
+      end_model_line['optional'] = 'true'
+      end_migration_line['null'] = 'true'
+    else
+      end_migration_line['null'] = 'false'
+    end
+
+    end_migration_line['null'] = 'true' unless table.root_class?
+
+    polymorphic_end = one_polymorphic_names?(start_entity)
+
+    unless polymorphic_end
+      end_model_line['class_name'] = "\"#{start_entity.table.name.camelize}\"" if start_entity.table_name_different?
 
-      if tables_same?(start_entity)
-        end_model_line['optional'] = 'true'
-        end_migration_line['null'] = 'true'
-      else
-        end_migration_line['null'] = 'false'
+      if start_entity.root_class_name_different?
+        end_migration_line['foreign_key'] = "{ to_table: :#{start_entity.table.root_class.name.pluralize} }"
       end
 
-      if !polymorphic_end && start_entity.clone_name_different?
-        end_model_line['class_name'] = "\"#{start_entity.clone_parent.name.camelize}\""
-        end_migration_line['foreign_key'] = "{ to_table: :#{start_entity.clone_parent.name.pluralize} }"
+      if start_entity.table.superclass && start_entity.root_class_name_different?
+        end_migration_line['column'] = ":#{start_entity.name}_id"
       end
+
+    end
+
+    update_project_files(start_entity, end_model_line, end_migration_line)
+  end
+
+  def update_project_files(start_entity, end_model_line, end_migration_line)
+    update_model_files(start_entity, end_model_line)
+    update_migration_files(start_entity, end_migration_line)
+  end
+
+  def update_model_files(start_entity, end_model_line)
+    return if end_model_line.empty?
+
+    polymorphic_end = one_polymorphic_names?(start_entity)
+
+    if polymorphic_end
+      ProjectFile.update_line(table.name, 'model', /belongs_to :#{start_entity.name}/, end_model_line)
+    else
+      ProjectFile.add_belong_line(table.name, end_model_line)
     end
+  end
 
-    ProjectFile.add_belong_line(clone_parent.name, end_model_line) unless end_model_line.empty?
+  def update_migration_files(start_entity, end_migration_line)
+    return if end_migration_line.empty?
 
-    unless end_migration_line.empty?
-      migration_name = "Add#{start_entity.name.camelize}RefTo#{clone_parent.name.camelize}".underscore
+    polymorphic_end = one_polymorphic_names?(start_entity)
 
-      ProjectFile.update_line(migration_name, 'reference_migration', /add_reference :#{clone_parent.name.pluralize}/,
-                              end_migration_line)
+    if table.root_class? && polymorphic_end
+      migration_name = "Create#{table.name.camelize.pluralize}".underscore
+
+      ProjectFile.update_line(
+        migration_name,
+        'migration',
+        /t.references :#{start_entity.name}/,
+        end_migration_line
+      )
+
+    else
+      migration_name = "Add#{start_entity.name.camelize}RefTo#{table.root_class.name.camelize}".underscore
+
+      ProjectFile.update_line(
+        migration_name,
+        'reference_migration',
+        /add_reference :#{table.root_class.name.pluralize}/,
+        end_migration_line
+      )
     end
   end
 
@@ -103,7 +148,7 @@ class Entity < TableEntityBase
     line_content = {}
 
     if association.has_many? || (children_has_many_through.include? end_entity)
-      line_content['has_many'] = if intermediate_entity&.one_polymorphic_names?(end_entity) && (association.has_many? || (children_has_many_through.include? end_entity))
+      line_content['has_many'] = if intermediate_entity&.one_polymorphic_names?(end_entity) && (children_has_many_through.include? end_entity)
                                    ":#{end_entity.table.name.pluralize}"
                                  else
                                    ":#{end_model}"
@@ -111,7 +156,7 @@ class Entity < TableEntityBase
     end
 
     if association.has_one? || (children_has_one_through.include? end_entity)
-      line_content['has_one'] = if intermediate_entity&.one_polymorphic_names?(end_entity) && (association.has_one? || (children_has_one_through.include? end_entity))
+      line_content['has_one'] = if intermediate_entity&.one_polymorphic_names?(end_entity) && (children_has_one_through.include? end_entity)
                                   ":#{end_entity.table.name}"
                                 else
                                   ":#{end_model}"
@@ -125,11 +170,11 @@ class Entity < TableEntityBase
         line_content['source_type'] = "\"#{end_entity.table.name.camelize}\" "
       end
     elsif !intermediate_entity
-      line_content['class_name'] = "\"#{end_entity.table.name.camelize}\"" if end_entity.clone_name_different?
+      line_content['class_name'] = "\"#{end_entity.table.name.camelize}\"" if end_entity.table_name_different?
 
       if end_entity.one_polymorphic_names?(self)
         line_content['as'] = ":#{name}"
-      elsif clone_name_different?
+      elsif table_name_different?
         line_content['foreign_key'] = "\"#{name.singularize}_id\""
       end
     end

data/lib/project_file.rb

@@ -3,15 +3,15 @@ require 'fileutils'
 class ProjectFile
   def self.open_close(name, type, &block)
     case type
-    when 'migration'
-      tempfile_name = './db/migrate/migration_update.rb'
-      file_name = Dir.glob("./db/migrate/*_#{name.pluralize}.rb").first
     when 'model'
       tempfile_name = './app/models/model_update.rb'
       file_name = "./app/models/#{name}.rb"
-    when 'reference_migration'
+    when 'migration'
       tempfile_name = './db/migrate/migration_update.rb'
       file_name = Dir.glob("./db/migrate/*_#{name}.rb").first
+    when 'reference_migration'
+      tempfile_name = './db/migrate/reference_migration_update.rb'
+      file_name = Dir.glob("./db/migrate/*_#{name}.rb").first
     end
     tempfile = File.open(tempfile_name, 'w')
     file = File.new(file_name)
@@ -34,7 +34,7 @@ class ProjectFile
           line.gsub!(/ *\n/, '')
           line_content.each do |key, value|
             if line.include? key
-              line.gsub!(/#{key}: [^(\s,)]*/, "#{key}: #{value}#{Regexp.last_match(1)}")
+              line.gsub!(/#{key}: [^(,)]*/, "#{key}: #{value}")
             else
               line << ", #{key}: #{value}"
             end

data/lib/table.rb

@@ -4,30 +4,68 @@ require 'association'
 require 'active_support/core_ext/string'
 
 class Table < TableEntityBase
-  attr_accessor :name, :id, :twin_name, :attributes, :entities, :polymorphic, :polymorphic_names
+  attr_accessor :name, :id, :attributes, :entities, :polymorphic, :polymorphic_names, :superclass, :subclasses
 
-  def initialize(table_id, tables)
+  def initialize(table_id, table)
     @id = table_id
-    @name = tables[table_id]['name'].split(' || ')[0].underscore.singularize
+    @name = table['name'].underscore.singularize
     @entities = []
     @polymorphic = false
     @polymorphic_names = []
     @attributes = []
-    tables[table_id]['attributes'].each do |(_attribute_id, attribute)|
+    table['attributes'].each do |(_attribute_id, attribute)|
       @attributes << Attribute.new(attribute)
     end
+    @superclass = nil
+    @subclasses = []
+  end
+
+  def self.update_superclasses(parsed_tables)
+    all.each do |table|
+      superclass_id = parsed_tables[table.id]['superclassId']
+
+      next if superclass_id == ''
+
+      super_class = Table.find superclass_id
+      table.superclass = super_class
+      super_class.subclasses << table
+    end
   end
 
   def model_name
     name.camelize
   end
 
-  def add_references(entity)
-    command = "bundle exec rails generate migration Add#{entity.name.camelize}RefTo#{name.camelize} #{entity.name}:references"
+  def root_class
+    nil unless @superclass
+
+    root = self
+
+    root = root.superclass while root.superclass
+
+    root
+  end
+
+  def root_class?
+    !superclass
+  end
+
+  def generate_reference_migration(name, polymorphic = false)
+    command = "bundle exec rails generate migration Add#{name.camelize}RefTo#{root_class.name.camelize} #{name}:references"
+
+    command << '{polymorphic}' if polymorphic
 
     system(command)
   end
 
+  def add_polymorphic_reference_migration_for_sti
+    if superclass && polymorphic
+      polymorphic_names.each do |name|
+        generate_reference_migration(name, true)
+      end
+    end
+  end
+
   def add_polymorphic_reference(command, poly_name)
     command << " #{poly_name}:references{polymorphic}"
   end
@@ -48,31 +86,35 @@ class Table < TableEntityBase
       belong_parent_names.count(parent_name) > 1
     end.uniq
 
-    @polymorphic_names = filtered_parent_names.find_all do |parent_name|
+    self.polymorphic_names = filtered_parent_names.find_all do |parent_name|
       belong_parents.find_all do |entity|
         entity.name == parent_name
-      end.map(&:clone_parent).map(&:name).uniq.size > 1
+      end.map(&:table).map(&:name).uniq.size > 1
     end
+
+    self.polymorphic = true if polymorphic_names.size.positive?
   end
 
   def check_polymorphic(command)
     update_polymorphic_names
-    @polymorphic_names.each do |poly_name|
+    polymorphic_names.each do |poly_name|
       add_polymorphic_reference(command, poly_name)
     end
-
-    @polymorphic = true if @polymorphic_names.size.positive?
   end
 
   def create_model
     return if File.exist?("./app/models/#{name}.rb")
 
-    command = 'bundle exec rails generate model '
-    command << model_name
-    attributes.each { |attribute| attribute.add_to(command) }
+    command = "bundle exec rails generate model #{model_name}"
+
+    command << ' type' if subclasses.any? && root_class?
+
+    attributes.each { |attribute| attribute.add_to(command) } unless superclass
 
     check_polymorphic(command)
 
+    command << " --parent=#{superclass.name.classify}" if superclass
+
     system(command)
   end
 
@@ -81,7 +123,7 @@ class Table < TableEntityBase
       (entity.parents_has_many + entity.parents_has_one).each do |parent|
         next if entity.one_polymorphic_names?(parent)
 
-        add_references(parent)
+        generate_reference_migration(parent.name)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ead
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Hasan Ozovali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-08 00:00:00.000000000 Z
+date: 2022-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -100,6 +100,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
 description: The compiler updates/creates models and associations, used in a Ruby
   on Rails project, defined by EAD automatically.
 email: ozovalihasan@gmail.com
@@ -116,10 +130,12 @@ files:
 - lib/project_file.rb
 - lib/table.rb
 - lib/table_entity_base.rb
-homepage: https://rubygems.org/gems/ead
+homepage: https://github.com/ozovalihasan/ead-g
 licenses:
 - MIT
 metadata:
+  homepage_uri: https://github.com/ozovalihasan/ead-g
+  source_code_uri: https://github.com/ozovalihasan/ead-g
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []