ead 0.3.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d62683086a74dc4cbce34a117d063da51a137ed24e20f117c9d8f8c43dd6b1e
-  data.tar.gz: 7d3a00c9a835690badf247b55c3e5ae1c0eca161a510180a7cace92ea752feca
+  metadata.gz: d7f4093a77c77ad563d127f8e091fccbb10a4c026402f6981b5019fdb6d0efff
+  data.tar.gz: 01f1f36ba0deb5b8a963d8d853b1a9190b8f749a8338bf363766f21961b854ee
 SHA512:
-  metadata.gz: '03986509b44274befb0dbd6bdd4c0aa4f38aeafcd1e51efe42bae53c1a6870a80c27bec3f8e5d96d67bbf33dcda80d645ea913175c5d969cae7397ba05cbd808'
-  data.tar.gz: 24e308dee598b32009ea7ffc5def63325040bd428a8b645a7bc3695e9ef185a08498afdb1c2a82c7f8f19436bec16f614f6f15d20c8c70582e2579de6d28688d
+  metadata.gz: 91231d696d2a26b2fcee500756374fc48ec3c403bee73f2f3a43e05b09065d7c969453b924598bef287b7ac80ed0357fe3eafd958142650663ab8e6e6c002e6f
+  data.tar.gz: f5b2b67f1917ada516d19cb498ab580ba55bd25698dc3c019db10fc26d4d1d92018c91295950d2f61a41ba8ec965fed96d566f7e771aee0060061eb4ec01b466

data/lib/association.rb

@@ -1,21 +1,114 @@
-require 'item'
+require 'table'
 
 class Association
-  attr_accessor :first_item, :second_items, :name
+  attr_accessor :first_entity, :second_entity, :name, :middle_entities_has_one, :middle_entities_has_many,
+                :through_entity
 
-  def initialize(first_item, association_block)
-    @first_item = first_item
-    @second_items = []
-    add_second_items(association_block)
-    @name = association_block.content
+  # first_entity, association_block)
+  def initialize(edge)
+    @first_entity = Entity.find(edge['source'])
+    @second_entity = Entity.find(edge['target'])
+    @through_entity = nil
+
+    @middle_entities_has_one = []
+    @middle_entities_has_many = []
+
+    @first_entity.associations << self
+    @second_entity.parent_associations << self
+
+    @name = nil
+    case edge['type']
+    when 'hasMany'
+      @first_entity.children_has_many << @second_entity
+      @second_entity.parents_has_many << @first_entity
+
+      @name = 'has_many'
+    when 'hasOne'
+      @first_entity.children_has_one << @second_entity
+      @second_entity.parents_has_one << @first_entity
+
+      @name = 'has_one'
+    when 'through'
+      @first_entity.children_through << @second_entity
+      @second_entity.parents_through << @first_entity
+
+      @through_entity = Entity.find(edge['data']['throughNodeId'])
+
+      @name = ':through'
+    end
+  end
+
+  def self.check_middle_entities_include(entity)
+    associations = Association.all.select { |association| association.through_entity == entity }
+    associations.each do |association|
+      unless (association.middle_entities_has_many.include? entity) || (association.middle_entities_has_one.include? entity)
+        association.set_middle_entity
+      end
+    end
   end
 
-  def add_second_items(block)
-    block.sub_blocks.each do |sub_block|
-      second_items << ItemClone.new(sub_block, first_item, self)
+  def set_middle_entity
+    source = first_entity
+    target = second_entity
+
+    if (
+        source.parents_has_many +
+        source.parents_has_many_through +
+        source.parents_has_one +
+        source.parents_has_one_through +
+        source.children_has_many +
+        source.children_has_many_through +
+        source.children_has_one +
+        source.children_has_one_through
+      ).include?(through_entity) &&
+       (
+         (
+           target.parents_has_many +
+           target.parents_has_many_through +
+           target.parents_has_one +
+           target.parents_has_one_through +
+           target.children_has_many +
+           target.children_has_many_through +
+           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)
+         )
+       )
+
+      if (
+          source.children_has_many.include?(through_entity) ||
+          source.children_has_many_through.include?(through_entity)
+        ) || (
+          target.parents_has_many.include?(through_entity) ||
+          target.parents_has_many_through.include?(through_entity)
+        )
+
+        unless middle_entities_has_many.include? through_entity
+          middle_entities_has_many << through_entity
+          source.children_has_many_through << target
+          target.parents_has_many_through << source
+          Association.check_middle_entities_include(target)
+        end
+      else
+        unless middle_entities_has_one.include? through_entity
+          middle_entities_has_one << through_entity
+          source.children_has_one_through << target
+          target.parents_has_one_through << source
+          Association.check_middle_entities_include(target)
+        end
+      end
+
     end
   end
 
+  def self.set_middle_entities
+    associations = all.select(&:through?)
+
+    associations.each(&:set_middle_entity)
+  end
+
   def has_many?
     name == 'has_many'
   end

data/lib/attribute.rb

@@ -1,9 +1,9 @@
 class Attribute
   attr_accessor :name, :type
 
-  def initialize(name, type)
-    @name = name
-    @type = type
+  def initialize(attribute)
+    @name = attribute['name']
+    @type = attribute['type']
   end
 
   def add_to(command)

data/lib/ead.rb

@@ -1,19 +1,18 @@
 require 'json'
-require 'item'
-require 'item_clone'
-require 'block'
+require 'table'
+require 'entity'
 require 'rest-client'
 
 class EAD
   def import_JSON(user_arguments)
     file = File.read(user_arguments[0] || './EAD.json')
 
-    unless ['0.3.0','0.3.1'].include? JSON.parse(file)['version']
+    unless ['0.4.0', '0.4.1', '0.4.2'].include? JSON.parse(file)['version']
       puts "\n\n----------------"
       puts "\e[31m#{
         'Versions of your EAD file and the gem are not compatible.'\
-        ' So, you may have some unexpected results.'\
-        'To run your EAD file correctly, please run'
+          ' So, you may have some unexpected results.'\
+          'To run your EAD file correctly, please run'
       }\e[0m"
 
       puts "\e[31m#{
@@ -21,72 +20,65 @@ class EAD
       }\e[0m"
       puts "----------------\n\n"
 
-      raise StandardError.new(msg="Incompatible version")
+      raise StandardError, msg = 'Incompatible version'
     end
 
-    items = JSON.parse(file)['items']
-    ead_id = '9'
-    Block.new(ead_id, items)
-    Block.all.each do |block|
-      next unless block.cloneable
+    file
+  end
+
+  def create_objects(file)
+    @nodes = JSON.parse(file)['nodes']
+    @edges = JSON.parse(file)['edges']
+    @tables = JSON.parse(file)['tables']
 
-      block.clone_blocks.map! do |id|
-        Block.find(id.to_s)
-      end
+    @tables = @tables.map do |(id)|
+      Table.new(id, @tables)
+    end
+
+    @nodes.map! do |node|
+      Entity.new(node)
     end
-  end
 
-  def create_items(block)
-    block.sub_blocks.each do |sub_block|
-      if sub_block.entity
-        Item.new(sub_block)
-      elsif sub_block.entity_clone
-        ItemClone.new(sub_block)
-      elsif sub_block.entity_container || sub_block.entity_association
-        create_items(sub_block)
-      end
+    @edges.map! do |edge|
+      Association.new(edge)
     end
   end
 
-  def check_implement_items
-    ead_id = '9'
-    block = Block.find(ead_id)
-    create_items(block)
+  def check_implement_objects(file)
+    create_objects(file)
 
-    ItemClone.all.each do |item_clone|
-      parent = Item.find(item_clone.clone_parent)
-      item_clone.clone_parent = Item.find(item_clone.clone_parent)
-      parent.clones << item_clone
+    Entity.all.each do |entity|
+      entity.clone_parent.entities << entity
     end
 
-    Item.all.each do |item|
-      item.create_migration
-    end
+    Table.all.each(&:create_model)
+
+    Table.all.each(&:add_reference_migration)
 
-    ItemClone.all.each do |item_clone|
-      item_clone.add_associations
+    Association.set_middle_entities
+
+    Association.all.each do |association|
+      association.first_entity.update_model(association.second_entity, association)
     end
   end
 
   def check_latest_version
-    # response = RestClient::Request.new(:method => :get, :url => 'https://api.github.com/repos/ozovalihasan/ead/tags')
-    # response = JSON.parse response
     response = JSON.parse RestClient.get 'https://api.github.com/repos/ozovalihasan/ead/tags'
-    
-    unless response.first['name'] == "v0.3.1"
+
+    unless response.first['name'] == 'v0.4.2'
       puts "\n\n----------------"
       puts "\n\e[33m#{
         'A new version of this gem has been released.'\
-        ' Please check it. https://github.com/ozovalihasan/ead-g/releases'
+          ' Please check it. https://github.com/ozovalihasan/ead-g/releases'
       }\e[0m"
 
       puts "\n----------------\n\n"
     end
-  rescue
+  rescue StandardError
     puts "\n\n----------------"
     puts "\n\e[31m#{
       'If you want to check the latest version of this gem,'\
-      ' you need to have a stable internet connection.'
+        ' you need to have a stable internet connection.'
     }\e[0m"
 
     puts "\n----------------\n\n"
@@ -94,7 +86,7 @@ class EAD
 
   def start(user_arguments)
     check_latest_version
-    import_JSON(user_arguments)
-    check_implement_items
+    file = import_JSON(user_arguments)
+    check_implement_objects(file)
   end
 end

data/lib/entity.rb

@@ -0,0 +1,145 @@
+require 'table_entity_base'
+require 'association'
+require 'project_file'
+
+class Entity < TableEntityBase
+  attr_accessor(:name, :id, :twin_name, :clone_parent, :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'])
+
+    @parent_associations = []
+    @associations = []
+
+    @parents_has_one = []
+    @parents_has_many = []
+    @parents_has_one_through = []
+    @parents_has_many_through = []
+    @parents_through = []
+
+    @children_has_one = []
+    @children_has_many = []
+    @children_has_one_through = []
+    @children_has_many_through = []
+    @children_through = []
+  end
+
+  def model_name
+    clone_parent.name.camelize
+  end
+
+  def tables_same?(entity)
+    table == entity.table
+  end
+
+  def self.find_by_name(name)
+    all.find { |entity| entity.name == name }
+  end
+
+  def clone_name_different?
+    clone_parent.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
+
+    end_model_line = {}
+    end_migration_line = {}
+
+    if association.has_any?
+      end_model_line['belongs_to'] = ":#{start_entity.name}"
+
+      if tables_same?(start_entity)
+        end_model_line['optional'] = 'true'
+        end_migration_line['null'] = 'true'
+      else
+        end_migration_line['null'] = 'false'
+      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} }"
+      end
+    end
+
+    ProjectFile.add_belong_line(clone_parent.name, end_model_line) unless end_model_line.empty?
+
+    unless end_migration_line.empty?
+      migration_name = "Add#{start_entity.name.camelize}RefTo#{clone_parent.name.camelize}".underscore
+
+      ProjectFile.update_line(migration_name, 'reference_migration', /add_reference :#{clone_parent.name.pluralize}/,
+                              end_migration_line)
+    end
+  end
+
+  def update_start_model_file(end_entity, association)
+    start_model = table.name
+
+    end_model = end_entity.name
+    intermediate_entity = association.through_entity
+
+    intermediate_model = intermediate_entity.name if intermediate_entity
+
+    if association.has_many? || (children_has_many_through.include? end_entity)
+      end_model = end_model.pluralize
+      intermediate_model = intermediate_model.pluralize if intermediate_model
+    end
+
+    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))
+                                   ":#{end_entity.table.name.pluralize}"
+                                 else
+                                   ":#{end_model}"
+                                 end
+    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))
+                                  ":#{end_entity.table.name}"
+                                else
+                                  ":#{end_model}"
+                                end
+    end
+
+    if intermediate_entity
+      line_content['through'] = ":#{intermediate_model}"
+      if intermediate_entity.one_polymorphic_names?(end_entity)
+        line_content['source'] = ":#{end_entity.name}"
+        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?
+
+      if end_entity.one_polymorphic_names?(self)
+        line_content['as'] = ":#{name}"
+      elsif clone_name_different?
+        line_content['foreign_key'] = "\"#{name.singularize}_id\""
+      end
+    end
+
+    ProjectFile.add_line(start_model, end_model, line_content)
+  end
+
+  def update_model(end_entity, association)
+    end_entity.update_end_model_migration_files(self, association) if association.has_any?
+
+    update_start_model_file(end_entity, association)
+  end
+end

data/lib/project_file.rb

@@ -9,8 +9,10 @@ class ProjectFile
     when 'model'
       tempfile_name = './app/models/model_update.rb'
       file_name = "./app/models/#{name}.rb"
+    when 'reference_migration'
+      tempfile_name = './db/migrate/migration_update.rb'
+      file_name = Dir.glob("./db/migrate/*_#{name}.rb").first
     end
-
     tempfile = File.open(tempfile_name, 'w')
     file = File.new(file_name)
 
@@ -29,10 +31,10 @@ class ProjectFile
     open_close(name, type) do |file, tempfile|
       file.each do |line|
         if line.match(keywords)
-          line.gsub!("\n", ' ')
+          line.gsub!(/ *\n/, '')
           line_content.each do |key, value|
             if line.include? key
-              line.gsub!(/#{key}: .*([, ])/, "#{key}: #{value}#{Regexp.last_match(1)}")
+              line.gsub!(/#{key}: [^(\s,)]*/, "#{key}: #{value}#{Regexp.last_match(1)}")
             else
               line << ", #{key}: #{value}"
             end
@@ -67,4 +69,27 @@ class ProjectFile
       end
     end
   end
+
+  def self.add_belong_line(name, line_content)
+    open_close(name, 'model') do |file, tempfile|
+      line_found = false
+      file.each do |line|
+        tempfile << line
+        next unless line.include?('class') && !line_found
+
+        line_found = true
+        line_association = ''
+        line_content.each do |key, value|
+          line_association << if %w[belongs_to].include?(key)
+                                "  #{key} #{value}"
+                              else
+                                ", #{key}: #{value}"
+                              end
+        end
+
+        line_association << "\n"
+        tempfile << line_association
+      end
+    end
+  end
 end

data/lib/table.rb

@@ -0,0 +1,88 @@
+require 'table_entity_base'
+require 'attribute'
+require 'association'
+require 'active_support/core_ext/string'
+
+class Table < TableEntityBase
+  attr_accessor :name, :id, :twin_name, :attributes, :entities, :polymorphic, :polymorphic_names
+
+  def initialize(table_id, tables)
+    @id = table_id
+    @name = tables[table_id]['name'].split(' || ')[0].underscore.singularize
+    @entities = []
+    @polymorphic = false
+    @polymorphic_names = []
+    @attributes = []
+    tables[table_id]['attributes'].each do |(_attribute_id, attribute)|
+      @attributes << Attribute.new(attribute)
+    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"
+
+    system(command)
+  end
+
+  def add_polymorphic_reference(command, poly_name)
+    command << " #{poly_name}:references{polymorphic}"
+  end
+
+  def update_polymorphic_names
+    return if entities.size.zero?
+
+    belong_parents = []
+    entities.each do |entity|
+      entity.parent_associations.each do |association|
+        belong_parents << association.first_entity
+      end
+    end
+
+    belong_parent_names = belong_parents.map(&:name)
+
+    filtered_parent_names = belong_parent_names.find_all do |parent_name|
+      belong_parent_names.count(parent_name) > 1
+    end.uniq
+
+    @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
+  end
+
+  def check_polymorphic(command)
+    update_polymorphic_names
+    @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) }
+
+    check_polymorphic(command)
+
+    system(command)
+  end
+
+  def add_reference_migration
+    entities.each do |entity|
+      (entity.parents_has_many + entity.parents_has_one).each do |parent|
+        next if entity.one_polymorphic_names?(parent)
+
+        add_references(parent)
+      end
+    end
+  end
+end

data/lib/table_entity_base.rb

@@ -0,0 +1,9 @@
+class TableEntityBase
+  def self.all
+    ObjectSpace.each_object(self).to_a
+  end
+
+  def self.find(id)
+    all.find { |base| base.id == id }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ead
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Hasan Ozovali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-18 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -58,6 +58,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -97,16 +111,16 @@ files:
 - bin/ead
 - lib/association.rb
 - lib/attribute.rb
-- lib/block.rb
 - lib/ead.rb
-- lib/item.rb
-- lib/item_base.rb
-- lib/item_clone.rb
+- lib/entity.rb
 - lib/project_file.rb
+- lib/table.rb
+- lib/table_entity_base.rb
 homepage: https://rubygems.org/gems/ead
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -122,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Compiler for JSON files created by EAD

data/lib/block.rb

@@ -1,34 +0,0 @@
-class Block
-  attr_accessor :id, :content, :category, :attribute, :type, :association, :sub_blocks,
-                :clone_blocks, :cloneable, :entity, :entity_clone, :clone_parent, :entity_container, :entity_association
-
-  def initialize(id, items)
-    item = items[id]
-    @id = id
-    @content = item['content']
-    @category = item['category']
-    @entity = item['entity']
-    @entity_association = item['entityAssociation']
-    @entity_container = item['entityContainer']
-    @attribute = item['attribute']
-    @type = item['type']
-    @association = item['association']
-    @entity_clone = item['entityClone']
-    @cloneable = item['cloneable']
-    @clone_blocks = item['cloneChildren']
-    @clone_parent = item['cloneParent'].to_s
-    @sub_blocks = []
-    item['subItemIds'].each do |sub_item_id|
-      sub_item_id = sub_item_id.to_s
-      @sub_blocks << Block.new(sub_item_id, items)
-    end
-  end
-
-  def self.all
-    ObjectSpace.each_object(self).to_a
-  end
-
-  def self.find(id)
-    all.find { |block| block.id == id }
-  end
-end

data/lib/item.rb

@@ -1,92 +0,0 @@
-require 'item_base'
-require 'attribute'
-require 'association'
-require 'active_support/core_ext/string'
-
-class Item < ItemBase
-  attr_accessor :attributes, :clones, :polymorphic, :polymorphic_names
-
-  def initialize(block)
-    super(block)
-    @clones = []
-    @polymorphic = false
-    @polymorphic_names = []
-    @attributes = []
-    block.sub_blocks.each do |sub_block|
-      add_to_attributes(sub_block)
-    end
-  end
-
-  def add_to_attributes(block)
-    @attributes << Attribute.new(block.content, block.type)
-  end
-
-  def model_name
-    name.camelize
-  end
-
-  def add_references(command, item)
-    return if command.include? " #{item.name}:references"
-
-    command << " #{item.name}:references"
-  end
-
-  def add_polymorphic(command, poly_name)
-    command << " #{poly_name}:references{polymorphic}"
-  end
-
-  def update_polymorphic_names
-    return if clones.size.zero?
-
-    belong_parents = []
-    clones.each do |item|
-      if item.through_association && item.parent_has_many?
-        belong_parents << item.parent
-        belong_parents << item.through_child
-      elsif !item.parent_through_has_many? && item.parent
-        belong_parents << item.parent
-      end
-    end
-    belong_parent_names = belong_parents.map(&:name)
-
-    filtered_parent_names = belong_parent_names.find_all do |parent_name|
-      belong_parent_names.count(parent_name) > 1
-    end.uniq
-
-    @polymorphic_names = filtered_parent_names.find_all do |parent_name|
-      belong_parents.find_all do |item|
-        item.name == parent_name
-      end.map(&:clone_parent).map(&:name).uniq.size > 1
-    end
-  end
-
-  def check_polymorphic(command)
-    update_polymorphic_names
-    @polymorphic_names.each do |poly_name|
-      add_polymorphic(command, poly_name)
-    end
-
-    @polymorphic = true if @polymorphic_names.size.positive?
-  end
-
-  def create_migration
-    return if File.exist?("./app/models/#{name}.rb")
-
-    command = 'bundle exec rails generate model '
-    command << model_name
-    attributes.each { |attribute| attribute.add_to(command) }
-
-    check_polymorphic(command)
-
-    clones.each do |item|
-      add_references(command, item.through_child) if item.parent_has_many? && item.through_association
-
-      next unless item.parent && !item.one_polymorphic_names?(item.parent) && (
-        item.parent_has_any? || item.parent_through_has_one?
-      )
-
-      add_references(command, item.parent)
-    end
-    system(command)
-  end
-end

data/lib/item_base.rb

@@ -1,17 +0,0 @@
-class ItemBase
-  attr_accessor :name, :id, :twin_name
-
-  def initialize(block, _parent = nil, _parent_association = nil)
-    @id = block.id
-    @name = block.content.split(' || ')[0].underscore.singularize
-    @twin_name = block.content.split(' || ')[1]&.underscore&.singularize
-  end
-
-  def self.all
-    ObjectSpace.each_object(self).to_a
-  end
-
-  def self.find(id)
-    all.find { |item| item.id == id }
-  end
-end

data/lib/item_clone.rb

@@ -1,212 +0,0 @@
-require 'item_base'
-require 'association'
-require 'project_file'
-
-class ItemClone < ItemBase
-  attr_accessor :clone_parent, :parent, :parent_association, :associations
-
-  def initialize(block, parent = nil, parent_association = nil)
-    super(block)
-    @clone_parent = block.clone_parent
-    @parent = parent
-    @parent_association = parent_association
-
-    @associations = []
-    block.sub_blocks.each do |sub_block|
-      add_to_associations(sub_block)
-    end
-  end
-
-  def model_name
-    clone_parent.name.camelize
-  end
-
-  def add_to_associations(block)
-    @associations << Association.new(self, block)
-  end
-
-  def grand
-    parent.parent
-  end
-
-  def grand_association
-    parent.parent_association
-  end
-
-  def grand_has_many?
-    grand_association&.has_many?
-  end
-
-  def grand_has_one?
-    grand_association&.has_one?
-  end
-
-  def grand_real_self_real?
-    reals_same? grand
-  end
-
-  def reals_same?(item)
-    real_item == item.real_item
-  end
-
-  def parent_through?
-    parent_association&.through?
-  end
-
-  def parent_has_many?
-    parent_association&.has_many?
-  end
-
-  def parent_has_one?
-    parent_association&.has_one?
-  end
-
-  def parent_has_any?
-    parent_has_one? || parent_has_many?
-  end
-
-  def parent_through_has_one?
-    parent_through? && grand_has_one?
-  end
-
-  def parent_through_has_many?
-    parent_through? && grand_has_many?
-  end
-
-  def through_association
-    associations.find(&:through?)
-  end
-
-  def through_child
-    through_association&.second_items&.first
-  end
-
-  def through?(item)
-    item.present?
-  end
-
-  def clone_name_different?
-    clone_parent.name != name
-  end
-
-  def one_polymorphic_names?(item)
-    real_item.polymorphic && real_item.polymorphic_names.include?(item.name)
-  end
-
-  def real_item
-    clone_parent
-  end
-
-  def grand_many_through_reals_same?(item)
-    parent_through_has_many? && (grand == item) && reals_same?(item)
-  end
-
-  def parent_has_many_reals_same_through_child?(item)
-    item.parent_through_has_many? && (through_child == item) && item.reals_same?(parent)
-  end
-
-  def update_end_model_migration_files(start_item, association)
-    polymorphic_end = one_polymorphic_names?(start_item)
-
-    end_model_line = {}
-    end_migration_line = {}
-    if association.has_one? && start_item.parent&.reals_same?(self)
-      end_model_line['optional'] = 'true'
-      end_migration_line['null'] = 'true'
-    end
-
-    if association.has_any?
-      if reals_same?(start_item)
-        end_model_line['optional'] = 'true'
-        end_migration_line['null'] = 'true'
-      end
-
-      if !polymorphic_end && start_item.clone_name_different?
-        end_model_line['class_name'] = "\"#{start_item.clone_parent.name.camelize}\""
-        end_migration_line['foreign_key'] = "{ to_table: :#{start_item.clone_parent.name.pluralize} }"
-      end
-    end
-
-    ProjectFile.update_line(real_item.name, 'model', /belongs_to :#{start_item.name}/, end_model_line)
-
-    migration_name = real_item.name
-    ProjectFile.update_line(migration_name, 'migration', /t.references :#{start_item.name}/, end_migration_line)
-  end
-
-  def update_start_model_file(end_item, association, intermediate_item = nil)
-    start_model = real_item.name
-
-    end_model = if end_item.parent_has_many_reals_same_through_child?(self)
-                  end_item.twin_name
-                else
-                  end_item.name
-                end
-
-    intermediate_model = if grand_many_through_reals_same?(end_item)
-                           intermediate_item.twin_name
-                         elsif intermediate_item
-                           intermediate_item.name
-                         end
-
-    if association.has_many?
-      end_model = end_model.pluralize
-      intermediate_model = intermediate_model.pluralize if intermediate_model
-    end
-
-    line_content = {}
-    line_content[association.name] = if intermediate_item&.one_polymorphic_names?(end_item) && association.has_many?
-                                       ":#{end_item.real_item.name.pluralize}"
-                                     else
-                                       ":#{end_model}"
-                                     end
-
-    if intermediate_item
-      line_content['through'] = ":#{intermediate_model}"
-      if intermediate_item.one_polymorphic_names?(end_item)
-        line_content['source'] = ":#{end_item.name}"
-        line_content['source_type'] = "\"#{end_item.real_item.name.camelize}\" "
-      end
-    elsif !intermediate_item
-      line_content['class_name'] = "\"#{end_item.real_item.name.camelize}\"" if end_item.clone_name_different?
-
-      if end_item.one_polymorphic_names?(self)
-        line_content['as'] = ":#{name}"
-      elsif clone_name_different?
-        line_content['foreign_key'] = "\"#{name.singularize}_id\""
-      end
-    end
-
-    ProjectFile.add_line(start_model, end_model, line_content)
-  end
-
-  def update_model(end_item, association, intermediate_item = nil)
-    return unless association.has_one? || association.has_many?
-
-    end_item.update_end_model_migration_files(self, association) unless intermediate_item
-    update_start_model_file(end_item, association, intermediate_item)
-  end
-
-  def parent_through_add_associations
-    if parent_through_has_many?
-      update_model(parent, grand_association)
-      update_model(grand, grand_association, parent)
-
-    elsif parent_through_has_one?
-      parent.update_model(self, grand_association)
-    end
-
-    grand.update_model(self, grand_association, parent)
-  end
-
-  def add_associations
-    parent_through_add_associations if parent_through?
-
-    associations.each do |association|
-      next unless association.has_any?
-
-      association.second_items.each do |second_item|
-        update_model(second_item, association)
-      end
-    end
-  end
-end