ead 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6e07db51d8953566d048da05fc0fd512a411027c4294b1bb344342e7a24b5a3
-  data.tar.gz: 10db1021f0792bb270ac5c27f258a47b9e2124e5b41d95acb24a574bbb2f0c68
+  metadata.gz: d3b8b4dac74bd298fe1030da9c00bd04c1badb639de8ae1777f2ca8b98895381
+  data.tar.gz: bad574c55817b25d32b11307a7d867e3c503a7b768bf02e8f75ec5d4ec2a15b7
 SHA512:
-  metadata.gz: e984c6bebd41d5833ce30b06c89e24168f4d519ef48d5b92bd257b0a6617a377a723c2f8f8be9fa4cfaf614b7bdfd1d46a18ac5b5baac99cec939fe2a69f67da
-  data.tar.gz: f37f5d29d7007ee72c80fef287bc5d2a144d9a73179d925d6cf1a7011a97fe5f003e5258464387726b394cf41680cbd0ee034c2754453997000aad2d09c8c771
+  metadata.gz: a9cbd8d53a5fef880146af795e76efae5505b26649d7138cd846f169f6f4cdfbac6542f053335f87cbeb5bc67e443b859b783f4b7accf9f2d876b7267955bd07
+  data.tar.gz: 3156c9c4990b013217e9d365d8f65bc80c6da3923bbab06c345bebcbd6dde5f2afd2841e050be3d6f82caa996ff002aec425e7f3670101a69ba24e6f8787770b

data/bin/ead

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require 'ead'
 
-EAD.new.start(ARGV)
+EAD.new.start(ARGV)

data/lib/association.rb

@@ -5,13 +5,20 @@ class Association
 
   def initialize(first_item, association_block)
     @first_item = first_item
-    @second_items = add_second_items(association_block)
+    @second_items = []
+    add_second_items(association_block)
     @name = association_block.content
   end
 
   def add_second_items(block)
-    block.sub_blocks.map do |sub_block|
-      Item.new(sub_block, first_item, self)
+    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)
+      end
     end
   end
 
@@ -23,6 +30,10 @@ class Association
     name == 'has_one'
   end
 
+  def has_any?
+    has_one? || has_many?
+  end
+
   def through?
     name == ':through'
   end

data/lib/block.rb

@@ -1,5 +1,6 @@
 class Block
-  attr_accessor :id, :content, :category, :attribute_container, :attribute, :type, :association, :sub_blocks
+  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]
@@ -7,9 +8,15 @@ class Block
     @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
@@ -22,6 +29,6 @@ class Block
   end
 
   def self.find(id)
-    all.each { |block| return block if block.id == id }
+    all.find { |block| block.id == id }
   end
 end

data/lib/ead.rb

@@ -1,27 +1,56 @@
 require 'json'
-require 'fileutils'
 require 'item'
+require 'item_clone'
 require 'block'
-require 'byebug'
 
 class EAD
   def import_JSON(user_arguments)
     file = File.read(user_arguments[0] || './EAD.json')
     items = JSON.parse(file)
-    ead_id = '8'
+    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
+    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
+        create_items(sub_block)
+      end
+    end
   end
 
   def check_implement_items
-    ead_id = '8'
+    ead_id = '9'
     block = Block.find(ead_id)
-    block.sub_blocks.each do |sub_block|
-      Item.new(sub_block)
+    create_items(block)
+
+    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
     end
 
     Item.all.reverse.each do |item|
       item.create_migration
-      item.add_associations_to_model
+    end
+
+    Item.all.reverse.each do |item|
+      item.add_associations
+    end
+
+    ItemClone.all.reverse.each do |item_clone|
+      item_clone.add_associations
     end
   end
 

data/lib/item.rb

@@ -1,166 +1,70 @@
+require 'item_base'
 require 'attribute'
 require 'association'
-require 'fileutils'
 require 'active_support/core_ext/string'
 
-class Item
-  attr_accessor :name, :parent, :parent_association, :associations, :attributes
+class Item < ItemBase
+  attr_accessor :clones, :polymorphic, :polymorphic_names
 
   def initialize(block, parent = nil, parent_association = nil)
-    @name = block.content.downcase.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 grand_parent
-    parent.parent
-  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)
+    super(block, parent, parent_association)
+    @clones = []
+    @polymorphic = false
+    @polymorphic_names = []
   end
 
-  def grand_parent_association
-    parent.parent_association
-  end
-
-  def grand_parent_has_many?
-    grand_parent_association&.has_many?
-  end
-
-  def grand_parent_has_one?
-    grand_parent_association&.has_one?
+  def model_name
+    name.camelize
   end
 
-  def parent_through?
-    parent_association&.through?
-  end
+  def add_references(command, item)
+    return if command.include? " #{item.name}:references"
 
-  def parent_has_many?
-    parent_association&.has_many?
+    command << " #{item.name}:references"
   end
 
-  def parent_has_one?
-    parent_association&.has_one?
+  def add_polymorphic(command, poly_name)
+    command << " #{poly_name}:references{polymorphic}"
   end
 
-  def self.all
-    ObjectSpace.each_object(self).to_a
+  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 through_association
-    associations.find { |association| association.through? }
-  end
+  def check_polymorphic(command)
+    update_polymorphic_names
+    @polymorphic_names.each do |poly_name|
+      add_polymorphic(command, poly_name)
+    end
 
-  def through_child
-    through_association.second_items.first
-  end
-
-  def model_name
-    name.capitalize
+    @polymorphic = true if @polymorphic_names.size.positive?
   end
 
   def create_migration
-    def add_references(command, item)
-      command << " #{item.name}:references"
-    end
-
     return if File.exist?("./app/models/#{name}.rb")
 
     command = 'bundle exec rails generate model '
     command << model_name
     attributes.each { |attribute| attribute.add_to(command) }
 
-    if parent_has_many? || parent_has_one?
-      add_references(command, parent)
-    elsif parent_through? && grand_parent_has_one?
-      add_references(command, parent)
-    end
-
-    if parent_has_many? && through_association
-      through_child.create_migration
-      add_references(command, through_child)
-    end
-
-    system(command)
-  end
-
-  def add_associations_to_model
-    def through?(item)
-      item.present?
-    end
-
-    def update_model(start_item, end_item, association, intermediate_item = nil)
-      return unless association.has_one? || association.has_many?
-
-      start_model = start_item.name
-      end_model = end_item.name
-      intermediate_model = intermediate_item.name if intermediate_item
-
-      if association.has_many?
-        end_model = end_model.pluralize
-        intermediate_model = intermediate_model.pluralize if intermediate_model
-      end
+    check_polymorphic(command)
 
-      tempfile = File.open('./app/models/model_update.rb', 'w')
-      f = File.new("./app/models/#{start_model}.rb")
-      f.each do |line|
-        if line.include? 'end'
-          line_association = "  #{association.name} :#{end_model}"
-          line_association << ", through: :#{intermediate_model}" if through?(intermediate_item)
-          line_association << "\n"
-          tempfile << line_association
-        end
-        tempfile << line
+    [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
-      f.close
-      tempfile.close
 
-      FileUtils.mv(
-        './app/models/model_update.rb',
-        "./app/models/#{start_model}.rb"
+      next unless item.parent && !item.one_polymorphic_names?(item.parent) && (
+        item.parent_has_any? || item.parent_through_has_one?
       )
-    end
-
-    if parent_through?
-      if grand_parent_has_many?
-        update_model(self, parent, grand_parent_association)
-        update_model(grand_parent, self, grand_parent_association, parent)
-        update_model(self, grand_parent, grand_parent_association, parent)
 
-      elsif grand_parent_has_one?
-        update_model(parent, self, grand_parent_association)
-        update_model(grand_parent, self, grand_parent_association, parent)
-      end
-    end
-    associations.each do |association|
-      next unless association.has_many? || association.has_one?
-
-      association.second_items.each do |second_item|
-        update_model(self, second_item, association)
-      end
+      add_references(command, item.parent)
     end
+    system(command)
   end
 end

data/lib/item_base.rb

@@ -0,0 +1,239 @@
+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

@@ -0,0 +1,14 @@
+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

data/lib/project_file.rb

@@ -0,0 +1,68 @@
+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"
+    end
+
+    tempfile = File.open(tempfile_name, 'w')
+    file = File.new(file_name)
+
+    block.call(file, tempfile)
+
+    file.close
+    tempfile.close
+
+    FileUtils.mv(
+      tempfile_name,
+      file_name
+    )
+  end
+
+  def self.update_line(name, type, keywords, line_content)
+    open_close(name, type) do |file, tempfile|
+      file.each do |line|
+        if line.match(keywords)
+          line.gsub!("\n", ' ')
+          line_content.each do |key, value|
+            if line.include? key
+              line.gsub!(/#{key}: .*([, ])/, "#{key}: #{value}#{Regexp.last_match(1)}")
+            else
+              line << ", #{key}: #{value}"
+            end
+          end
+          line << "\n"
+
+        end
+        tempfile << line
+      end
+    end
+  end
+
+  def self.add_line(name, end_model, line_content)
+    open_close(name, 'model') do |file, tempfile|
+      line_found = false
+      file.each do |line|
+        if (line.include?('end') || line.include?("through: :#{end_model}")) && !line_found
+          line_found = true
+          line_association = ''
+          line_content.each do |key, value|
+            line_association << if %w[has_many has_one].include?(key)
+                                  "  #{key} #{value}"
+                                else
+                                  ", #{key}: #{value}"
+                                end
+          end
+
+          line_association << "\n"
+          tempfile << line_association
+        end
+        tempfile << line
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ead
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Hasan Ozovali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-09 00:00:00.000000000 Z
+date: 2021-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,6 +80,9 @@ files:
 - lib/block.rb
 - lib/ead.rb
 - lib/item.rb
+- lib/item_base.rb
+- lib/item_clone.rb
+- lib/project_file.rb
 homepage: https://rubygems.org/gems/ead
 licenses:
 - MIT
@@ -92,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.1
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="