ead 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3b8b4dac74bd298fe1030da9c00bd04c1badb639de8ae1777f2ca8b98895381
-  data.tar.gz: bad574c55817b25d32b11307a7d867e3c503a7b768bf02e8f75ec5d4ec2a15b7
+  metadata.gz: b0246f506ee0396b4da7f7dfd2cd58b856893a05148b593f999b7f0a704cb0f5
+  data.tar.gz: dd5e95c1b53959a0762c667d66913a60c3b222ec237d9a40c1931371a13e65bf
 SHA512:
-  metadata.gz: a9cbd8d53a5fef880146af795e76efae5505b26649d7138cd846f169f6f4cdfbac6542f053335f87cbeb5bc67e443b859b783f4b7accf9f2d876b7267955bd07
-  data.tar.gz: 3156c9c4990b013217e9d365d8f65bc80c6da3923bbab06c345bebcbd6dde5f2afd2841e050be3d6f82caa996ff002aec425e7f3670101a69ba24e6f8787770b
+  metadata.gz: fa2bb67008c2de407ce152432cfee9a0ea5f8cdb222d2e89a8f28ca79d690970ca4200d9ae52f6150a5f7df7ec14ae7b2169abd83d8a6e6388058862c0bb3b6d
+  data.tar.gz: e269830ca88205dc5f2fe681574d7fe9b634c1fb76519651a6344083ca48003dd1ae79384b2e06d4313c77762d14e5e52ed52954aef8871f47e665c594bdc115

data/lib/association.rb

@@ -1,27 +1,114 @@
-require 'item'
+require 'table'
 
 class Association
-  attr_accessor :first_item, :second_items, :name
-
-  def initialize(first_item, association_block)
-    @first_item = first_item
-    @second_items = []
-    add_second_items(association_block)
-    @name = association_block.content
-  end
-
-  def add_second_items(block)
-    block.sub_blocks.each do |sub_block|
-      if sub_block.entity
-        second_items << Item.new(sub_block, first_item, self)
-      elsif sub_block.entity_clone
-        second_items << ItemClone.new(sub_block, first_item, self)
-      elsif sub_block.entity_container
-        add_second_items(sub_block)
+  attr_accessor :first_entity, :second_entity, :name, :middle_entities_has_one, :middle_entities_has_many,
+                :through_entity
+
+  # 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 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,61 +1,92 @@
 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')
-    items = JSON.parse(file)
-    ead_id = '9'
-    Block.new(ead_id, items)
-    Block.all.each do |block|
-      next unless block.cloneable
-
-      block.clone_blocks.map! do |id|
-        Block.find(id.to_s)
-      end
+
+    unless ['0.4.0'].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'
+      }\e[0m"
+
+      puts "\e[31m#{
+        "\ngem install ead -v #{JSON.parse(file)['version']}"
+      }\e[0m"
+      puts "----------------\n\n"
+
+      raise StandardError, msg = 'Incompatible version'
     end
+
+    file
   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
-        create_items(sub_block)
-      end
+  def create_objects(file)
+    @nodes = JSON.parse(file)['nodes']
+    @edges = JSON.parse(file)['edges']
+    @tables = JSON.parse(file)['tables']
+
+    @tables = @tables.map do |(id)|
+      Table.new(id, @tables)
     end
-  end
 
-  def check_implement_items
-    ead_id = '9'
-    block = Block.find(ead_id)
-    create_items(block)
+    @nodes.map! do |node|
+      Entity.new(node)
+    end
 
-    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
+    @edges.map! do |edge|
+      Association.new(edge)
     end
+  end
 
-    Item.all.reverse.each do |item|
-      item.create_migration
+  def check_implement_objects(file)
+    create_objects(file)
+
+    Entity.all.each do |entity|
+      entity.clone_parent.entities << entity
     end
 
-    Item.all.reverse.each do |item|
-      item.add_associations
+    Table.all.each(&:create_model)
+
+    Table.all.each(&:add_reference_migration)
+
+    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 = JSON.parse RestClient.get 'https://api.github.com/repos/ozovalihasan/ead/tags'
 
-    ItemClone.all.reverse.each do |item_clone|
-      item_clone.add_associations
+    unless response.first['name'] == 'v0.4.0'
+      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'
+      }\e[0m"
+
+      puts "\n----------------\n\n"
     end
+  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.'
+    }\e[0m"
+
+    puts "\n----------------\n\n"
   end
 
   def start(user_arguments)
-    import_JSON(user_arguments)
-    check_implement_items
+    check_latest_version
+    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

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 class ProjectFile
   def self.open_close(name, type, &block)
     case type
@@ -7,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)
 
@@ -27,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
@@ -65,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,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: ead
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Hasan Ozovali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-25 00:00:00.000000000 Z
+date: 2022-09-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -38,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
@@ -77,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:
@@ -102,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+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_container, :attribute, :type, :association, :sub_blocks,
-                :clone_blocks, :cloneable, :entity, :entity_clone, :clone_parent, :entity_container
-
-  def initialize(id, items)
-    item = items[id]
-    @id = id
-    @content = item['content']
-    @category = item['category']
-    @attribute_container = item['attributeContainer']
-    @entity = item['entity']
-    @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,70 +0,0 @@
-require 'item_base'
-require 'attribute'
-require 'association'
-require 'active_support/core_ext/string'
-
-class Item < ItemBase
-  attr_accessor :clones, :polymorphic, :polymorphic_names
-
-  def initialize(block, parent = nil, parent_association = nil)
-    super(block, parent, parent_association)
-    @clones = []
-    @polymorphic = false
-    @polymorphic_names = []
-  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
-    all_parents_name = [self, *clones].map do |item|
-      [item.parent&.name, item.through_association && item.through_child.name]
-    end
-    all_parents_name.flatten!.compact!
-    @polymorphic_names = all_parents_name.find_all { |name| all_parents_name.count(name) > 1 }.uniq
-  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)
-
-    [self, *clones].each do |item|
-      if item.parent_has_many? && item.through_association
-        item.through_child.create_migration if item.through_child.not_clone?
-        add_references(command, item.through_child)
-      end
-
-      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,239 +0,0 @@
-require 'project_file'
-
-class ItemBase
-  attr_accessor :name, :parent, :parent_association, :associations, :attributes, :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
-    @parent = parent
-    @parent_association = parent_association
-    @attributes = []
-    @associations = []
-    block.sub_blocks.each do |sub_block|
-      if sub_block.attribute
-        add_to_attributes(sub_block)
-      elsif sub_block.attribute_container
-        add_attribute_container(sub_block)
-      elsif sub_block.association
-        add_to_associations(sub_block)
-      end
-    end
-  end
-
-  def add_attribute_container(block)
-    block.sub_blocks.each do |attribute|
-      add_to_attributes(attribute)
-    end
-  end
-
-  def add_to_attributes(block)
-    @attributes << Attribute.new(block.content, block.type)
-  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? && (clone_parent.name != name)
-  end
-
-  def one_polymorphic_names?(item)
-    real_item.polymorphic && real_item.polymorphic_names.include?(item.name)
-  end
-
-  def clone?
-    instance_of?(ItemClone)
-  end
-
-  def not_clone?
-    !clone?
-  end
-
-  def real_item
-    clone? ? clone_parent : self
-  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 start_item.clone? && !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
-
-  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,14 +0,0 @@
-require 'item_base'
-
-class ItemClone < ItemBase
-  attr_accessor :clone_parent
-
-  def initialize(block, parent = nil, parent_association = nil)
-    super(block, parent, parent_association)
-    @clone_parent = block.clone_parent
-  end
-
-  def model_name
-    clone_parent.name.camelize
-  end
-end