yml_merger 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53bab445865ad2f7414909d6d5d06c94b077de30
+  data.tar.gz: bbde43c5fe4e037f2711e18c652a2b27823fa4dc
+SHA512:
+  metadata.gz: b9177063653202da7147bf8068f19ff1b3d6f063de2e0392bba467b1e3abe9796047d643abff33c1f9cea7b9d56cb2c34494d9013e7d602fa1bc88dbb3238d9a
+  data.tar.gz: 7e8936d1301086d2cb9b0396a79a4a60e8036f2ba66e6ee8b056f9f2a11b9c3decdf7b75cb0e024996d9d05cd96b1a1bf1236eafb940c6aa8431fad7c18837da

data/lib/yml_merger.rb

@@ -0,0 +1,310 @@
+require 'rubygems'
+require "yaml"
+require "deep_merge"
+require 'fileutils'
+require 'open-uri'
+require 'uri'
+
+
+# implement of deep merge for nested hash and array of hash
+class YML_Merger
+    attr_accessor :filestructure, :filestack, :ENTRY_YML, :search_paths
+
+    # initialize YML merge
+    # Params:
+    # - filepath: the entry file name
+    # - seatch_paths: rootpath to search all the needed YML files 
+    def initialize(filename, search_paths)
+        @ENTRY_YML           = search_paths + '/' + filename
+        @search_paths       = search_paths
+        @filestructure = Hash.new()
+        @filestack = Array.new()
+        @KEY_LIST = ['__remove__','__load__', '__common__', '__hierarchy__', '__replace__', '__add__']
+    end
+
+    # process the YMLs
+    def process
+       @filestructure = process_file(@ENTRY_YML)
+       merge_by_add(@filestructure)
+       merge_by_common(@filestructure)
+       delete_node(@filestructure,'__common__')
+       delete_node(@filestructure,'__load__')
+       #delete_node(@filestructure,'__add__')
+       post_process(@filestructure)
+    end
+
+  private
+
+    # post process nodes with strong condition
+    # execute post-process-lib and post-process-app
+    # clean the pre-process-merge node
+    # Params:
+    # - struct: the hash to be processed
+    def post_process(struct)
+      return if struct.class != Hash
+      merge_by_replace!(struct)
+      merge_by_remove!(struct)
+      struct.each_key do |key|
+        if Hash == struct[key].class
+          if struct.key?("mode") and struct["mode"] == "post-process-lib"
+            if struct[key].has_key?("attribute")
+              if struct[key]["attribute"] == "required"
+                 #puts "keep #{key}"
+              else
+                 struct.delete(key)
+                 #puts "deletes #{key}"
+                 next
+              end
+            else
+              #puts "delete #{key}"
+              struct.delete(key)
+              next
+            end
+          end
+          if struct[key].key?("mode") and struct[key]["mode"] == "post-process-app"
+            if struct[key].has_key?("attribute")
+              if struct[key]["attribute"] == "required"
+                #puts "keep #{key}"
+              else
+                struct.delete(key)
+                #puts "deletes #{key}"
+                next
+              end
+            else
+              #puts "delete #{key}"
+              struct.delete(key)
+              next
+            end
+          end
+          if struct[key].key?("mode") and struct[key]["mode"] == "pre-process-merge"
+              struct.delete(key)
+              #puts "deletes #{key}"
+              next
+          end
+          post_process(struct[key])
+        end
+      end
+    end
+
+
+    # load and process yml files
+    # recursive load and process all files in '__load__' section
+    # Params:
+    # - file: the path to the yml file
+    def process_file(file)
+        #check if file is loaded yet
+        return if @filestack.include?(file)
+        #if not loaded,push to stack
+        @filestack.push(file)
+        #add globals.yml before load file
+        #puts file
+        content = open(file.gsub("\\","/")){|f| f.read}
+        content = YAML::load(content)
+        return if  content.class == FalseClass
+        #if has file dependence load it
+        if content['__load__'] != nil
+            #load file in reversed sequence
+            content['__load__'].reverse_each do |loadfile|
+              if loadfile =~ URI::regexp
+                structure = process_file(loadfile)
+              else
+                structure = process_file(@search_paths + loadfile.gsub("\\","/"))
+              end
+              content = content.deep_merge(deep_copy(structure))
+              pre_process(content)
+              merge_by_hierarchy(content)
+              #content = content.deep_merge(structure)
+            end
+        end
+        pre_process(content)
+        merge_by_hierarchy(content)
+        delete_node(content, '__hierarchy__')
+        return content
+    end
+
+    # load and process yml files
+    # recursive load and process all files in '__load__' section
+    # Params:
+    # - file: the path to the yml file
+    def pre_process(struct)
+        return if struct.class != Hash
+        struct.each_key do |key|
+          next if struct[key].class != Hash
+          if struct[key].has_key?('mode') and struct[key]['mode'] == "pre-process-merge"
+             if struct[key]['attribute'] == "required"
+                struct[key].each_key do |subkey|
+                    if struct.has_key?(subkey) and struct[subkey].class == Hash
+                        #puts "pre process #{key} -> #{subkey}"
+                        struct[subkey] = struct[subkey].deep_merge(deep_copy(struct[key][subkey]))
+                       #struct[subkey] = struct[subkey].deep_merge(struct[key][subkey])
+                       #puts struct[subkey].to_yaml
+                    end
+                end
+             end
+          end
+          pre_process(struct[key])
+        end
+    end
+
+
+    # delete all node/subnode which key name is 'key' in 'hash'
+    # Params:
+    # - struct: the hash
+    # - type: the key to delete
+    def delete_node(struct, key)
+        struct.each_key do |subnode|
+            next if struct[subnode] == nil
+            struct.delete(key)
+            delete_node(struct[subnode],key) if Hash == struct[subnode].class
+        end
+    end
+
+    # perform merge by "__hierarchy__" struct
+    # Params:
+    # - struct: the hash
+    def merge_by_hierarchy(struct)
+        return if Hash != struct.class
+        if struct['__hierarchy__'] != nil
+            struct.each_key do |subnode|
+                next if subnode =~ /^__/ or @KEY_LIST.include?(subnode)
+                next if struct[subnode].class != Hash or struct['__hierarchy__'].class != Hash
+                struct[subnode] = struct[subnode].deep_merge(deep_copy(struct['__hierarchy__']))
+                #struct[subnode] = struct[subnode].deep_merge(struct["__hierarchy__"])
+            end
+            #struct.delete('__hierarchy__')
+        end
+        struct.each_key do |subnode|
+            merge_by_hierarchy(struct[subnode])
+        end
+    end
+
+    # perform merge by "__common__" node
+    # Params:
+    # - struct: the hash
+    def merge_by_common(struct)
+        return if Hash != struct.class
+        if struct['__common__'] != nil
+            struct.each_key do |subnode|
+                next if @KEY_LIST.include?(subnode)
+                next if struct[subnode].class != Hash or struct['__common__'].class != Hash
+                struct[subnode] = struct[subnode].deep_merge(deep_copy(struct['__common__']))
+                #struct[subnode] = struct[subnode].deep_merge(struct['__common__'])
+            end
+            struct.delete('__common__')
+        end
+        struct.each_key do |subnode|
+            merge_by_common(struct[subnode])
+        end
+    end
+
+    # hash deep merge with __add__ recursively
+    # Params:
+    # - struct: the hash
+    # - subnode: the subnode key to be add
+    # - addon: the key that idetify the addon module
+    def deep_add_merge(struct, subnode, addon)
+      return if Hash != struct.class
+      if struct[addon]['__add__'].nil?
+        #we do not want the addon module to change the status
+        struct[addon]['attribute'] = ""
+        #struct[subnode] = struct[subnode].deep_merge(deep_copy(struct[addon]))
+        struct[addon]['attribute'] = 'required'
+        return
+      end
+      #if has more addon
+      if struct[addon]['__add__'].count != 0
+         struct[addon]['__add__'].each do |submodule|
+           deep_add_merge(struct, addon, submodule)
+         end
+      else
+        #puts "add #{addon}"
+        struct[addon]['attribute'] = ""
+        #struct[subnode] = struct[subnode].deep_merge(deep_copy(struct[addon]))
+        struct[addon]['attribute'] = 'required'     
+      end
+    end
+
+    # perform merge by "__add__" node only applys to application type
+    # Params:
+    # - struct: the hash to be processed
+    def merge_by_add(struct)
+        #only scan the top level
+        return if Hash != struct.class
+        struct.each_key do |subnode|
+          next if @KEY_LIST.include?(subnode)
+          if struct[subnode]['__add__'] != nil
+            struct[subnode]['__add__'].each do |addon|
+              next if struct[addon].class != Hash
+            begin
+              next if struct[subnode]['configuration']['section-type'] != "application"
+              if struct[addon]['configuration']['section-type'] != "component"
+                puts "WARNING #{addon} is required as component but has not a component attribute"
+              end
+            rescue
+              puts "error with the merge_by_add with #{subnode} add #{addon}"
+            end
+              deep_add_merge(struct, subnode, addon)
+            end
+            #struct[subnode].delete('__add__')
+          end
+        end
+    end
+
+    # prepare merge by "__replace__" node
+    # Params:
+    # - struct: the hash to be processed    
+    def merge_by_replace!(struct)
+        return if Hash != struct.class
+        #get the replace hash
+        return if ! struct.has_key?("__replace__")
+        temp = Hash.new
+        temp = temp.deep_merge(deep_copy(struct["__replace__"]))
+        temp.each_key do |key|
+           next if ! struct.has_key?(key)
+           delete_node(struct, key)
+           struct[key] = temp[key]
+        end
+        struct.delete('__replace__')
+    end
+
+    # perform merge by "__remove__" node
+    # Params:
+    # - struct: the hash to be processed
+    def merge_by_remove!(struct)
+        return if Hash != struct.class
+        #get the replace hash
+        return if ! struct.has_key?("__remove__")
+        temp = Hash.new
+        temp = temp.deep_merge(deep_copy(struct["__remove__"]))
+        temp.each_key do |key|
+          next if ! struct.has_key?(key)
+          if struct["__remove__"][key] == nil
+            delete_node(struct, key)
+          else
+            if struct["__remove__"][key].class == Array
+              arr = Array.new
+              arr = deep_copy(struct["__remove__"][key])
+              arr.each do |item|
+                next if ! struct[key].include?(item)
+                struct[key].delete(item)
+              end
+            elsif struct["__remove__"][key].class == Hash
+              hash = Hash.new
+              hash = hash.deep_merge(deep_copy(struct["__remove__"][key]))
+              hash.each_key do |subkey|
+                next if ! struct[key].has_key?(subkey)
+                delete_node(struct[key], subkey)
+              end
+            end
+          end
+        end
+        struct.delete('__remove__')
+    end
+
+    # deep copy the hash in compare the shallow copy
+    # Params:
+    # -o: the hash to be copied 
+    def deep_copy(o)
+      Marshal.load(Marshal.dump(o))
+    end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: yml_merger
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Hake Huang
+- Marian Cingel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-18 00:00:00.000000000 Z
+dependencies: []
+description: yaml extension for heiarchy merge
+email: hakehuang@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yml_merger.rb
+homepage: http://rubygems.org/gems/yml_merger
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: yaml_merger
+test_files: []