dialect_lookup 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c21001861f311995fb7349aa86d892adf16d9efe46997b91dcde3353eff38e85
+  data.tar.gz: 21bfee114f954b4566f4786e793dee6b7d5164663b4024d85bab53ce23190219
+SHA512:
+  metadata.gz: 7dfa96e3f85d0a76e95b6ae1fa68222467fa800c7afd480efe04b318e16bf8df5a32bd1e35beed25e5e9f921f2f62ab1c592425b7603b3db705bbc5b2b826d3b
+  data.tar.gz: c682c0dec5e7871473a6197cb86a890770c70e803f59ff5bd3cb7c849c1099aabc18f3f765429e5adbff72dacb3ca3c58fc445415c433563f6f0a19a6f943820

data/dialect_lookup.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name    = 'dialect_lookup'.freeze
+  s.version = '0.0.1'
+  s.authors = ['Eugene Istomin'.freeze]
+  s.email   = ['info@innosense.org'.freeze]
+  
+  s.homepage    = 'https://github.com/ArchDelivery/Dialog'.freeze
+  s.description = 'Dialect lookup'.freeze
+  s.summary     = 'Dialect lookup'.freeze
+  
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }  
+  s.require_paths = ['lib'.freeze]
+  
+  s.add_runtime_dependency 'sqlite3',   '~> 0'
+  s.add_runtime_dependency 'oj',        '~> 0'
+end

data/lib/dialect_lookup.rb

@@ -0,0 +1,111 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+
+#Gems
+require 'sqlite3'
+
+#Files
+require 'sql'
+require 'lookup'
+Dir[File.join(__dir__, 'lookup/**', '*.rb')].each { |file| require_relative file }
+    
+    def run(state)
+        
+      args = {views: {}, con_views: {}, exec: {}, stages: {} }
+      state.has_key?(:sqlite) ? db = state[:sqlite] : db = "/tmp/dialect.sqlite"
+      state[:dbhandler] = SQLite3::Database.new db
+      
+      ###functional views
+      folderMain = state[:dbhandler].execute("select id from folders where name in ('#{state[:dialectFolder]}')")[0][0]
+      folderId = state[:dbhandler].execute("select folder_id from folders_in_model where parent_folder_id in ('#{folderMain}') and model_version = (select max(model_version) from folders_in_model where parent_folder_id in ('#{folderMain}')) and folder_version = (select max(folder_version) from folders_in_model where parent_folder_id in ('#{folderMain}'))").each do |conFolder|
+        folderDialog = state[:dbhandler].execute("select id from folders where name in ('Dialog') and id in ('#{conFolder[0]}')")[0]
+        if folderDialog.is_a?(Array)
+          state[:dbhandler].execute("select view_id as view_id2, view_version, model_version from views_in_model where parent_folder_id in ('#{folderDialog[0]}') and model_version = (select max(model_version) from views_in_model where view_id in (view_id2))") do |row|
+            viewAtr = state[:dbhandler].execute("select name, version from views where id in ('#{row[0]}') and version = (select max(version) from views where id in ('#{row[0]}'))")
+            if row[1] == viewAtr[0][1]
+              id = row[0].tr("-", "_")
+
+              args[:views][id] ||= {}
+              args[:views][id][:version] = row[1]
+              args[:views][id][:name] = state[:dialectFolder]
+              Dialog.logger.info "Dialect functional view '#{viewAtr[0][0]}' (id #{id}, view ver.#{row[1]}, model ver.#{row[2]}) of folder '#{Dialog.config.dialect.folder}' for bot '#{Dialog.config.naming.instance}' suits for me!"
+            end
+          end           
+        end
+      end
+      
+
+      
+      ###_constructors views
+      folderId = state[:dbhandler].execute("select id from folders where name in ('_constructors')")[0][0]       
+      constructorFolders = state[:dbhandler].execute("select folder_id, folder_version, model_version from folders_in_model where parent_folder_id in ('#{folderId}') and model_version = (select max(model_version) from folders_in_model where parent_folder_id in ('#{folderId}')) and folder_version = (select max(folder_version) from folders_in_model where parent_folder_id in ('#{folderId}'))").each do |conFolder|
+        
+      state[:dbhandler].execute("select view_id as view_id2, view_version, model_version from views_in_model where parent_folder_id in ('#{conFolder[0]}') and model_version = (select max(model_version) from views_in_model where view_id in (view_id2))") do |row|
+        viewAtr = state[:dbhandler].execute("select name, version from views where id in ('#{row[0]}') and version = (select max(version) from views where id in ('#{row[0]}'))")
+          id = row[0].tr("-", "_")
+
+          args[:con_views][id] ||= {}
+          args[:con_views][id][:version] = row[1]
+          args[:con_views][id][:name] = state[:dialectFolder]
+          Dialog.logger.info "Dialect constructor view '#{viewAtr[0][0]}' (id #{id}, view ver.#{row[1]}, model ver.#{row[2]}) suits for me!"     
+        end        
+      end
+       
+      
+      args[:stages][state[:dialectFolder]] = {}
+      args[:stages][state[:dialectFolder]] = {codegenGlobal: {}, codegenPerView: {}, x: {}, panView: {lookup: {}}, perView: {}, constructor: {}}
+      
+      getObjects(args, state)
+
+
+      args[:con_views].each do |viewId, viewProps|
+        viewType = :constructors
+        lookup_constructors_DockedGroupings2AppFunctions(args, state, viewId, viewType)  
+        lookup_constructors_Element2ModSend(args, state, viewId, viewType)        
+        lookup_constructors_ElementsInElements(args, state, viewId, viewType)
+      end
+      
+      args[:views].each do |viewId, viewProps|
+        viewType = :perView
+        fullName = "#{state[:dialectFolder]}_#{viewId}"
+        fullNameSym = fullName.to_sym
+        Dialog.logger.debug "#Dialect_lookup RUN instance #{state[:dialectFolder]}"
+        ###functional
+        lookupStruct = {'functional' => [
+          'Expect2Events',     'Events2AppEvent',   'Events2ModReceive', 'ModReceive2AppEvent',
+          'Appevent2EventBus', 'AppEvent2Elements', 'Elements2AppEvent', 'Element2ModElements',
+          'Element2ModSend',   'ModElementsSpecs',  'ElementChains']}
+        #1
+        lookup_run(args, lookupStruct, state, viewId, viewType)
+        
+        ###data
+        lookupStruct = {'data' => [
+          'ModReceive2GetData',     'GetData2Elements',   'GenData2Dest', 'Results2GenData']}
+        #1
+        lookup_run(args, lookupStruct, state, viewId, viewType)        
+        ###
+      end
+        
+        
+        state[:dbhandler].close
+        json = Oj.dump(args)
+#         File.delete(db)
+        FileUtils.mkdir_p("#{state[:jsonFolder]}")
+        FileUtils.rm_rf(Dir.glob("#{state[:jsonFolder]}/*.json"))        
+        jsonDump = "#{state[:jsonFolder]}/#{state[:dialectFolder]}_#{state[:myAppName]}.json"
+        File.open(jsonDump, 'w') { |file| file.write(json) }
+    end
+
+  end
+end

data/lib/lookup/constructors/DockedGroupings2AppFunctions.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_constructors_DockedGroupings2AppFunctions(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'CompositionRelationship', fPropKey: :docked, fPropValue: "true",
+                        fClass: 'Grouping',      fFqn: "#{state[:myAppName]}Element*", 
+                        tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Element*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+#       dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/constructors/Element2ModSend.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_constructors_Element2ModSend(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModSend*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/constructors/ElementsInElements.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_constructors_ElementsInElements(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'SpecializationRelationship',
+                        fClass: 'ApplicationFunction',      fFqn: "#{state[:myAppName]}Element*", 
+                        tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Element*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+#       dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/data/1.ModReceive2GetData.rb

@@ -0,0 +1,28 @@
+  ########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_data_ModReceive2GetData(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
+
+      args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'AccessRelationship', 
+                             fClass: 'ApplicationService',      fFqn: "#{state[:myAppName]}ArchiGetdata*", 
+                             tClass: 'DataObject',              tFqn: "#{state[:myAppName]}ModReceiveData*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/data/2.GetData2Elements.rb

@@ -0,0 +1,28 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_data_GetData2Elements(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
+      
+      args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'TriggeringRelationship', 
+                             fClass: 'ApplicationService',      fFqn: "#{state[:myAppName]}ArchiGetdata*", 
+                             tClass: 'ApplicationFunction',     tFqn: "#{state[:myAppName]}Element*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/data/3.GenData2Dest.rb

@@ -0,0 +1,28 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_data_GenData2Dest(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
+      
+      args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'ServingRelationship', 
+                             fClass: 'ApplicationFunction',     fFqn: "#{state[:myAppName]}Element*",                                 
+                             tClass: 'ApplicationService',      tFqn: "#{state[:myAppName]}ArchiGendata*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/data/4.Results2GenData.rb

@@ -0,0 +1,28 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_data_Results2GenData(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
+      
+      args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'RealizationRelationship', 
+                             fClass: 'ApplicationFunction',     fFqn: "#{state[:myAppName]}Element*",                                 
+                             tClass: 'ApplicationService',      tFqn: "#{state[:myAppName]}ArchiGendata*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/1.Expect2Events.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Expect2Events(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AggregationRelationship', 
+                        fClass: 'ApplicationFunction',      fFqn: "#{state[:myAppName]}ArchiEventExpect", 
+                        tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Event*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/2.1.Events2AppEvent.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Events2AppEvent(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'FlowRelationship',
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Event*", 
+                             tClass: 'ApplicationEvent',    tFqn: "#{state[:myAppName]}ArchiAppevent*" }
+      
+      dialectLookup(args, state, viewId, viewType) 
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/functional/2.2.1.Events2ModReceive.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Events2ModReceive(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Event*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModReceiveData*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/functional/2.2.2.ModReceive2AppEvent.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_ModReceive2AppEvent(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship',
+                             fClass: 'ApplicationEvent',    fFqn: "#{state[:myAppName]}ArchiAppevent*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModReceiveData*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup/functional/3.Appevent2EventBus.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Appevent2EventBus(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,   cClass: 'ServingRelationship', 
+                             fClass: 'ApplicationService', fFqn: "#{state[:myAppName]}ArchiEventBus",
+                             tClass: 'ApplicationEvent',   tFqn: "#{state[:myAppName]}ArchiAppevent*"  }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/4.1.AppEvent2Elements.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_AppEvent2Elements(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'TriggeringRelationship', 
+                             fClass: 'ApplicationEvent',    fFqn: "#{state[:myAppName]}ArchiAppevent*", 
+                             tClass: 'ApplicationFunction', tFqn: "#{state[:myAppName]}Element*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/4.2.Elements2AppEvent.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Elements2AppEvent(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'ServingRelationship', 
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*",                                   
+                             tClass: 'ApplicationEvent',    tFqn: "#{state[:myAppName]}ArchiAppevent*"}
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/5.1.Element2ModElements.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Element2ModElements(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModElement*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/5.2.Element2ModSend.rb

@@ -0,0 +1,26 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_Element2ModSend(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
+                             fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModSend*" }
+      
+      dialectLookup(args, state, viewId, viewType)  
+    end
+    
+  end
+end

data/lib/lookup/functional/6.ModElementsSpecs.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_ModElementsSpecs(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'SpecializationRelationship', 
+                             fClass: 'DataObject',          fFqn: "#{state[:myAppName]}ModSend*", 
+                             tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModElement*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)            
+    end
+    
+  end
+end

data/lib/lookup/functional/7.ElementChains.rb

@@ -0,0 +1,27 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup
+    
+    
+    def lookup_functional_ElementChains(args, state, viewId, viewType)
+      queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
+      args[:dialectLookupQuery] = {queryName: queryName,      cClass: 'TriggeringRelationship', 
+                            fClass: 'ApplicationFunction',    fFqn: "#{state[:myAppName]}ElementSend*", 
+                            tClass: 'ApplicationFunction',    tFqn: "#{state[:myAppName]}ElementSend*" }
+      
+      dialectLookup(args, state, viewId, viewType)
+      dialectRepack(args, state, viewId, viewType, queryName)      
+    end
+    
+  end
+end

data/lib/lookup.rb

@@ -0,0 +1,149 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup    
+  
+    
+    def dialectLookup(args,state,viewId,viewType)            
+      queryName = args[:dialectLookupQuery][:queryName]
+      if args[:objects][viewId][:links][args[:dialectLookupQuery][:cClass]].is_a?(Hash)
+        args[:objects][viewId][:links][args[:dialectLookupQuery][:cClass]].each do |conPairId, conProp|
+         
+          
+         if   conProp[:viewID] == viewId and
+              conProp[:fClass] =~ /^#{args[:dialectLookupQuery][:fClass]}/ and 
+              conProp[:fFqn] =~ /^#{args[:dialectLookupQuery][:fFqn]}/ and
+              conProp[:tClass] =~ /^#{args[:dialectLookupQuery][:tClass]}/ and
+              conProp[:tFqn] =~ /^#{args[:dialectLookupQuery][:tFqn]}/
+           
+              
+
+              conProp[:cClass] = args[:dialectLookupQuery][:cClass]
+              prop = getProp(args,state,conProp,'from')
+              conProp[:fProp] = prop if not prop.nil?
+              prop = getProp(args,state,conProp,'to')
+              conProp[:tProp] = prop if not prop.nil?
+              
+              if args[:dialectLookupQuery].has_key?(:fPropKey)
+                conProp[:fProp][args[:dialectLookupQuery][:fPropKey]] == args[:dialectLookupQuery][:fPropValue] ? store = true : store = false
+              else
+                store = true
+              end
+              
+              if store == true    
+#                 Dialog.logger.debug "In view #{viewId} by query '#{queryName}' we have a #{args[:dialectLookupQuery][:cClass]} connection: CONNPARID #{conPairId} FROM fClass = #{conProp[:fClass]} fqn = #{conProp[:fFqn]}  fId = #{conProp[:fId]}  NAME #{conProp[:fName]} FPROP #{conProp[:fProp]} [[ TO ]] tClass = #{conProp[:tClass]} fqn = #{conProp[:tFqn]}  tId = #{conProp[:tId]} NAME #{conProp[:tName]} TPROP #{conProp[:tProp]}\n"         
+                
+                hash_fName = Digest::SHA256.hexdigest("#{conProp[:fName]}")[0..20]
+                hash_tName = Digest::SHA256.hexdigest("#{conProp[:tName]}")[0..20]
+                hash_fName_fId_tId = Digest::SHA256.hexdigest("#{conProp[:fName]}#{conProp[:fOID]}#{conProp[:tOID]}")[0..20]              
+  #               puts conProp
+                args[:stages][state[:dialectFolder]][viewType] ||= {}
+                args[:stages][state[:dialectFolder]][viewType][state[:myAppName]] ||= {}
+                case viewType
+                when :perView
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName] ||= {}              
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup][hash_tName] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup][hash_tName][hash_fName_fId_tId] = conProp                   
+                when :constructors
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName] ||= {}              
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup][hash_tName] ||= {}
+                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup][hash_tName][hash_fName_fId_tId] = conProp                  
+                end
+              end
+                
+          end
+        end
+      end
+    end
+    
+    
+    
+    def getProp(args,state,conProp,direction)
+      rows = {}
+      
+      case direction
+      when 'from'
+        eID  = conProp[:fEID]
+        eVer = conProp[:fEVer]        
+      when 'to'
+        eID  = conProp[:tEID]
+        eVer = conProp[:tEVer]        
+      end
+      
+      state[:dbhandler].execute( "
+        select name, value                  
+        from properties 
+        where parent_id like '#{eID}' AND
+        parent_version = '#{eVer}' AND
+        name NOT LIKE 'fqn'
+      ")  do |row|
+#             Bot.logger.debug "### ROW #{eID} #: #{row}"  
+#             rows[eID] ||= {}
+            rows[row[0].to_sym] = row[1]             
+      end  
+      return rows if not rows.empty?
+    end
+
+    
+    def dialectRepack(args, state, viewId, viewType, queryName)
+      
+      case viewType
+      when :perView
+        base = args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName]          
+      when :constructors
+        base = args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName]          
+      end
+      if base.is_a?(Hash)
+        repackNames = [:fFqn, :tFqn, :fOID, :tOID, :fEID, :tEID]              
+        base[:repack] = {}      
+        repackNames.each do |repackName|
+          res = {}                     
+          base[:repack][repackName] ||= {}      
+          base[:lookup].each do |tName, hash_tNameProp|
+            hash_tNameProp.each do |fName, hash_fNameProp|
+              res[hash_fNameProp[repackName]] = hash_fNameProp
+            end 
+          end  
+          case viewType          
+          when :perView
+            args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:repack][repackName] = res      
+          when :constructors
+            args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:repack][repackName] = res
+          end          
+        end      
+      end
+    end
+    
+    
+    def lookupDebug(name, prop)
+      Bot.logger.debug "### #{name} :: F:: '#{prop[:fName]}' fqn:#{prop[:fFqn]} o:#{prop[:fOID]} e:#{prop[:fEID]} p '#{prop[:fProp]}' :: T :: '#{prop[:tName]}' fqn:#{prop[:tFqn]} o:#{prop[:tOID]} e:#{prop[:tEID]} p '#{prop[:tProp]}'"
+    end
+    
+    
+    def lookup_run(args, lookupStruct, state, viewId, viewType)
+      lookupStruct.each do |type,lookups|
+        lookups.each do |lookup|
+        run = "lookup_#{type}_#{lookup}"
+#           Dialog.logger.debug "### Dialect_lookup call - #{run}"        
+          send(run, args, state, viewId, viewType)
+        end
+      end
+    end
+    
+  
+    
+  end
+end

data/lib/sql.rb

@@ -0,0 +1,138 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module Dialect
+  class Lookup 
+    
+    
+    def getObjects(args, state)
+      args[:views].each do |viewId, viewProps|
+        getObjectsFromSQL(args, state, viewId, viewProps)
+      end
+      args[:con_views].each do |viewId, viewProps|
+        getObjectsFromSQL(args, state, viewId, viewProps)
+      end      
+      return args
+    end
+    
+    def getObjectsFromSQL(args, state, viewId, viewProps)
+      
+      args[:x] = {}
+      viewIdOrig = viewId.to_s.tr("_", "-")
+      args[:objects] ||= {}
+      args[:objects][viewId] = {}
+      rows={}
+      links = {}
+      i = 1
+
+#  (views_objects.id in ('views_connections'.`source_object_id`) AND views_objects.id not in ('views_connections'.`target_object_id`)) 
+      
+      state[:dbhandler].execute( "
+        select 
+        views_objects.id, 
+        elements.id, 
+        elements.class,
+        relationships.class, 
+        elements.name, 
+        views_connections.source_object_id, 
+        views_connections.target_object_id,
+        elements.documentation,
+        relationships.version,
+        elements.version,
+        views_objects.element_version,
+        properties.value
+                                      
+        from views_connections_in_view
+        INNER JOIN views_connections ON views_connections_in_view.connection_id = views_connections.id
+                                AND views_connections.version = (select max(views_connections.version) from views_connections where views_connections.id = views_connections_in_view.connection_id )
+        INNER JOIN relationships ON relationships.id = views_connections.relationship_id 
+
+        INNER JOIN views_objects ON (views_objects.id = views_connections.source_object_id OR  
+                                  views_objects.id = views_connections.target_object_id) AND  
+
+                                  views_objects.version = (select max(views_objects.version) from views_objects where (
+                                  (views_objects.id in ('views_connections'.`target_object_id`) AND views_objects.id not in ('views_connections'.`source_object_id`))
+                                  ))
+                               
+        INNER JOIN elements ON elements.id = views_objects.element_id AND elements.version = (select max(elements.version) from elements where elements.id in ('views_objects'.`element_id`))
+        LEFT JOIN properties ON properties.parent_id = elements.id AND  
+                                    properties.parent_version = (select max(properties.parent_version) from properties where properties.parent_id in ('elements'.`id`)) AND
+                                    properties.name LIKE 'fqn'
+                                      
+      
+          where views_connections_in_view.view_id like '#{viewIdOrig}' 
+          and views_connections_in_view.view_version = (select max(views_connections_in_view.view_version) from views_connections_in_view where views_connections_in_view.view_id like '#{viewIdOrig}')
+          and relationships.class in ('AggregationRelationship', 'TriggeringRelationship', 'FlowRelationship', 'AccessRelationship', 'SpecializationRelationship', 'CompositionRelationship', 'ServingRelationship', 'RealizationRelationship') 
+          and (elements.class LIKE 'Application%' OR elements.class in ('DataObject', 'Grouping'))
+                                      and elements.version = (select max(elements.version) from elements where elements.id in ('views_objects'.`element_id`))
+
+      ")  do |row|
+#                 Bot.logger.debug "### ROW ##{i}: #{row}" 
+
+#             hash_tName_fId_tId = Digest::SHA256.hexdigest("#{row[0]}_#{row[4]}_#{row[5]}")[0..20]  
+            hash_tName_fId_tId = Digest::SHA256.hexdigest("#{row[4]}_#{row[5]}")[0..20]                    
+            rows[row[0]] ||= {}
+            rows[row[0]][:e_id] = row[1]            
+            rows[row[0]][:e_class] = row[2]
+            rows[row[0]][:o_name]  = row[4]
+            rows[row[0]][:e_doc] = row[7]
+            rows[row[0]][:e_ver] = row[9]            
+            rows[row[0]][:p_fqn]  = row[11]                        
+
+            
+            rows[row[0]][row[3]] ||= {}            
+            rows[row[0]][row[3]][hash_tName_fId_tId] ||= {}  
+            rows[row[0]][row[3]][hash_tName_fId_tId] = {from: row[5], to: row[6] }
+            i = i + 1
+      end
+                    
+      i = 1
+        rows.each do |objId, objProps|            
+          objProps.each do |objProp, objVal|
+            if objProp.to_s =~ /Relationship/
+              links[objProp] ||= {}                
+              objVal.each do |conPairId, conProps| 
+                
+                if ! rows[conProps[:from]].nil? and ! rows[conProps[:to]].nil?
+                  links[objProp][conPairId] ||= {}
+  #                 Bot.logger.debug "### AAA #{i}: #{rows[conProps[:from]] }"                    
+                  links[objProp][conPairId][:connUUID]  = "#{conProps[:from]}#{conProps[:to]}".unpack("H8H4H4H4H12").join('-') 
+                  links[objProp][conPairId][:viewID]    = viewId                   
+                  links[objProp][conPairId][:fOID]      = conProps[:from].tr("-", "_")
+                  links[objProp][conPairId][:fEID]      = rows[conProps[:from]][:e_id].tr("-", "_")
+                  links[objProp][conPairId][:fEVer]     = rows[conProps[:from]][:e_ver]
+                  links[objProp][conPairId][:fDoc]      = rows[conProps[:from]][:e_doc] == "" ? 0 : rows[conProps[:from]][:e_doc]
+                  links[objProp][conPairId][:fName]     = rows[conProps[:from]][:o_name]                
+                  links[objProp][conPairId][:fClass]    = rows[conProps[:from]][:e_class]
+                  links[objProp][conPairId][:fFqn]      = rows[conProps[:from]][:p_fqn]                
+                  
+                  
+                  links[objProp][conPairId][:tOID]       = conProps[:to].tr("-", "_")
+                  links[objProp][conPairId][:tEID]      = rows[conProps[:to]][:e_id].tr("-", "_")                               
+                  links[objProp][conPairId][:tEVer]     = rows[conProps[:to]][:e_ver]
+                  links[objProp][conPairId][:tDoc]      = rows[conProps[:to]][:e_doc] == "" ? 0 : rows[conProps[:to]][:e_doc]
+                  links[objProp][conPairId][:tName]     = rows[conProps[:to]][:o_name]                
+                  links[objProp][conPairId][:tClass]    = rows[conProps[:to]][:e_class]
+                  links[objProp][conPairId][:tFqn]      = rows[conProps[:to]][:p_fqn] 
+#                     Bot.logger.debug "### AAA #{i}: #{links[objProp][conPairId]}"
+                  i = i + 1
+                end
+              end
+            end
+          end
+        end
+      
+      args[:objects][viewId][:objects] = rows 
+      args[:objects][viewId][:links] = links
+    end
+  end
+    
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: dialect_lookup
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eugene Istomin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Dialect lookup
+email:
+- info@innosense.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dialect_lookup.gemspec
+- lib/dialect_lookup.rb
+- lib/lookup.rb
+- lib/lookup/constructors/DockedGroupings2AppFunctions.rb
+- lib/lookup/constructors/Element2ModSend.rb
+- lib/lookup/constructors/ElementsInElements.rb
+- lib/lookup/data/1.ModReceive2GetData.rb
+- lib/lookup/data/2.GetData2Elements.rb
+- lib/lookup/data/3.GenData2Dest.rb
+- lib/lookup/data/4.Results2GenData.rb
+- lib/lookup/functional/1.Expect2Events.rb
+- lib/lookup/functional/2.1.Events2AppEvent.rb
+- lib/lookup/functional/2.2.1.Events2ModReceive.rb
+- lib/lookup/functional/2.2.2.ModReceive2AppEvent.rb
+- lib/lookup/functional/3.Appevent2EventBus.rb
+- lib/lookup/functional/4.1.AppEvent2Elements.rb
+- lib/lookup/functional/4.2.Elements2AppEvent.rb
+- lib/lookup/functional/5.1.Element2ModElements.rb
+- lib/lookup/functional/5.2.Element2ModSend.rb
+- lib/lookup/functional/6.ModElementsSpecs.rb
+- lib/lookup/functional/7.ElementChains.rb
+- lib/sql.rb
+homepage: https://github.com/ArchDelivery/Dialog
+licenses: []
+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.7.3
+signing_key: 
+specification_version: 4
+summary: Dialect lookup
+test_files: []