Now default tags can be removed from module

lib/orbit_tag/taggable.rb

@@ -74,31 +74,86 @@ module OrbitTag
     end
 
     def get_default_tags
-      Tag.where(default: true)
+      Tag.where(is_default: true)
     end
   end
 
   module Merging
     protected
 
-    def create_default_tag(name, taggings, module_app_ids)
-      create_tag(@module_app, name, taggings, module_app_ids, true)
-    end
-
-    def create_tag(module_app, name, taggings, module_app_ids=[module_app.id], default=false)
-      new_tag = module_app.module_tags.create(name_translations: name, module_app_ids: module_app_ids - [module_app.id], is_default: default)
+    def create_tag(name, taggings, module_app, default=false)
+      new_tag = module_app.module_tags.create(name_translations: name, module_app_id: module_app.id, is_default: default)
       taggings.each do |tagging|
         tagging.taggable.taggings.create(tag_id: new_tag.tag.id) unless tagging.taggable.taggings.detect{|t| t.tag_id.eql?(new_tag.tag.id)}
       end
+      new_tag
     end
 
-    def merge_default_tags(name, taggings, module_app_ids)
-      create_default_tag(name, taggings, module_app_ids)
+    def merge_default_tags(name, tag_leases)
+      parent = @module_app.module_tags.create(name_translations: name, is_default: true)
+      lease_by_module_app_id = tag_leases.inject({}) do |sorted, parent|
+        sorted = parent.children.inject(sorted) do |children, lease|
+          module_app_id = lease.module_app_id.to_s
+          if children[module_app_id]
+            children[module_app_id] += [lease]
+          else
+            children[module_app_id] = [lease]
+          end
+          children
+        end
+        sorted
+      end
+      merge_duplicates_in_module(parent, lease_by_module_app_id)
+      tag_leases.each(&:destroy)
+      parent
     end
 
-    def merge_tags(name, taggings, module_app_id)
+    def merge_duplicates_in_module(parent, lease_by_module_app_id)
+      lease_by_module_app_id.each do |module_app_id, leases|
+        if leases.count > 0
+          taggings = leases.map { |l| l.tag.taggings }.flatten
+          module_tag =  merge_tags(parent.name_translations, taggings, module_app_id, true)
+          module_tag.update_attribute(:parent_id, parent.id)
+          leases.each(&:destroy)
+        else
+          leases[0].update_attributes(name_translations: parent.name_translations, is_default: true, parent_id: parent.id) unless leases[0].is_default
+        end
+      end
+    end
+
+    def merge_tags(name, taggings, module_app_id, default=nil)
       module_app = ModuleApp.find(module_app_id)
-      create_tag(module_app, name, taggings)
+      new_tag = create_tag(name, taggings, module_app, default)
+      new_tag
+    end
+
+    def merge_with_default_tags(name, tag_leases)
+      lease_by_module_app_id = tag_leases.inject({}) do |sorted, lease|
+        module_app_id = lease.is_default ? 'default' : lease.module_app_id.to_s
+        if sorted[module_app_id]
+          sorted[module_app_id] += [lease]
+        else
+          sorted[module_app_id] = [lease]
+        end
+        sorted
+      end
+      if lease_by_module_app_id['default'].count > 1
+        parent = merge_default_tags(name, lease_by_module_app_id['default'])
+      else
+        parent = lease_by_module_app_id['default'][0]
+        parent.update_attributes(name_translations: name)
+      end
+      lease_by_module_app_id.delete('default')
+      lease_by_module_app_id = parent.children.inject(lease_by_module_app_id) do |sorted, lease|
+        module_app_id = lease.module_app_id.to_s
+        if sorted[module_app_id]
+          sorted[module_app_id] += [lease]
+        else
+          sorted[module_app_id] = [lease]
+        end
+        sorted
+      end
+      merge_duplicates_in_module(parent, lease_by_module_app_id)
     end
   end
 end