jungle_path 0.0.0

data/lib/jungle_path/gen/schema_tree.rb

@@ -0,0 +1,105 @@
+module JunglePath
+  module Gen
+    module SchemaTree
+      require 'jungle_path/gen/schema_tree/filter'
+      require 'jungle_path/gen/schema_tree/match_columns'
+      require 'jungle_path/gen/schema_tree/match_table_data'
+      require 'jungle_path/gen/schema_tree/match_tables'
+      require 'jungle_path/gen/schema_tree/node'
+      #  configatron.schema.filters = {
+      #    allow: [
+      #      {table: "zztop"},
+      #      {table: /./, columns: nil},
+      #      {table: :contact, columns: []},
+      #      {table: :user, columns: /./},
+      #      {table: :opportunity, columns: :name}
+      #    ]
+      #    deny: [
+      #      {table: :xyz, columns: :zzz}
+      #    ]
+      #  }
+
+      def self.test_node_filter()
+        JunglePath::Gen::SchemaTree::Filter.new(#{
+          #allow: [{table: /./}],
+          #deny: [{table: /^siebel_/}]
+        #}
+        )
+      end
+
+      def self.gen_node_tree(tables_hash, node_filter=nil)
+        # test node filter:
+        ###node_filter = Gen.test_node_filter
+        # create tree structure based on pk/fk releationships of tables.
+        tables = tables_hash.values.sort {|a, b| a.table_name <=> b.table_name}
+        root = JunglePath::Gen::SchemaTree::Node.new "root"
+        root.tables_hash = {}
+
+        tables.each do |v|
+          #puts v.table_name.class
+          #puts v.table_name
+          next unless node_filter.allow?(v.table_name)
+
+          # build tables hash:
+          root.tables_hash[v.table_name] = v
+
+          #puts v.table_name
+          #puts "v.table_name: #{v.table_name}."
+          table_node = JunglePath::Gen::SchemaTree::Node.new(v.table_name)
+          root.nodes[v.table_name] = table_node
+
+          # make sub nodes for each column
+          columns = v.columns_sequence_order
+          columns.each do |column|
+            next unless node_filter.allow?(v.table_name, column.name)
+            if column.foreign_key?
+              name = column.name.to_s[0..-4].to_sym # cut off "..._id" from column name and use as node name.
+              symbol = "->"
+              child_table_name = column.foreign_key_table_name
+              child_table_join_column_name = tables_hash[column.foreign_key_table_name].primary_key_columns.first[0]
+              parent_table_join_column_name = column.name
+            else
+              name = column.name
+              symbol = nil
+              child_table_name = nil
+              child_table_join_column_name = nil
+              parent_table_join_column_name = nil
+            end
+            #puts "  #{name}, symbol: #{symbol}."
+            table_node.nodes[name] = JunglePath::Gen::SchemaTree::Node.new(name, symbol, child_table_name, child_table_join_column_name, parent_table_join_column_name)
+          end
+
+          # make sub nodes for each table having a fk reference to this (the parent) table -- exclude self.
+          tables.each do |child_table|
+            next unless node_filter.allow?(child_table.table_name)
+            if v.table_name != child_table.table_name #nor own table
+              fk_columns = child_table.foreign_key_columns_by_table_name[v.table_name]
+              if fk_columns
+                #puts "  #{child_table.table_name}. count: #{fk_columns.count}."
+                name = child_table.table_name
+                table_node.nodes[name] = []
+                fk_columns.each do |key, fk_column|
+                  #puts "    fk_column: #{fk_column.name}."
+                  #puts "      name: #{name}, #{name.class}."
+                  #puts "      class: #{table_node.nodes[name].class}."
+                  #puts "      count: #{table_node.nodes[name].count}."
+                  if fk_column.primary_key? and child_table.primary_key_columns.count == 1
+                    symbol = "<-"
+                  else
+                    symbol = "<="
+                  end
+                  child_table_name = child_table.table_name
+                  child_table_join_column_name = fk_column.name
+                  parent_table_join_column_name = v.primary_key_columns.first[0]
+                  table_node.nodes[name] << JunglePath::Gen::SchemaTree::Node.new(name, symbol, child_table_name, child_table_join_column_name, parent_table_join_column_name)
+                  #puts "    nodes[name].count: #{table_node.nodes[name].count}."
+                end
+              end
+            end
+          end
+        end
+        root
+      end
+    end
+  end
+end

data/lib/jungle_path/gen.rb

@@ -0,0 +1,9 @@
+module JunglePath
+	module Gen
+		require 'jungle_path/api'
+		require 'jungle_path/controller'
+		require 'jungle_path/db'
+		require 'jungle_path/schema'
+		require 'jungle_path/schema_tree'
+	end
+end

data/lib/jungle_path/json/base.rb

@@ -0,0 +1,29 @@
+require 'oj'
+require 'jungle_path/json'
+
+Oj.default_options = {:mode => :compat, :symbol_keys => true, :indent=>2 }
+module JunglePath
+  module Json
+    def self.default_options=(option_hash)
+      Oj.default_options = option_hash
+    end
+
+    #returns a json string
+    def self.dump(object, options={})
+      Oj.dump object, options
+    end
+
+    #returns a Ruby hash
+    def self.load(json_string, options={})
+      Oj.load(json_string, options)
+    end
+
+    def self.parse(json_string, options={})
+      load(json_string, options)
+    end
+
+    def self.hi
+      puts "hi from jungle_path/json! :)"
+    end
+  end
+end

data/lib/jungle_path/json/time.rb

@@ -0,0 +1,8 @@
+class ::Time
+  def to_json(*a)
+    strftime "\"%Y-%m-%dT%H:%M:%S%z\""
+  end
+  def as_json(*a)
+    strftime "\"%Y-%m-%dT%H:%M:%S%z\""
+  end
+end

data/lib/jungle_path/json.rb

@@ -0,0 +1,6 @@
+module JunglePath
+  module Json
+    require 'jungle_path/json/time'
+    require 'jungle_path/json/base'
+  end
+end

data/lib/jungle_path/logging.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+module Logging
+  def self.make_logger(root_dir, log_file_name, log_dir_name: 'logs', log_level: Logger::INFO, rotation_count: 10, size_in_bytes: 10240000, reset: false)
+    # pass in root_dir = ::File.dirname(__FILE__)
+    #puts "root_dir.class: #{root_dir.class}: #{root_dir}."
+    #puts "log_file_name.class: #{log_file_name.class}: #{log_file_name}."
+    #puts "log_dir_name.class: #{log_dir_name.class}: #{log_dir_name}."
+    logs_dir = ::File.join(root_dir, log_dir_name)
+
+    ::Dir.mkdir(logs_dir) unless File.exists? logs_dir
+
+    ::Logger.class_eval do
+      alias_method :write, :<<
+    end
+
+    filename = ::File.join(logs_dir, log_file_name)
+    File.delete(filename) if reset and File.exists?(filename)
+    logger = Logger.new(filename, rotation_count, size_in_bytes)
+    logger.level = log_level
+    logger
+  end
+end

data/lib/jungle_path/query/alias_info.rb

@@ -0,0 +1,16 @@
+module JunglePath
+  module Query
+    class AliasInfo
+      attr_reader :name, :alias_, :parent_alias, :primary_key_columns_count
+      def initialize(name, alias_, parent_alias, primary_key_columns_count)
+        @name = name
+        @name = @name.to_sym if @name
+        @alias_ = alias_
+        @alias_ = @alias_.to_sym if @alias_
+        @parent_alias = parent_alias
+        @parent_alias = @parent_alias.to_sym if @parent_alias
+        @primary_key_columns_count = primary_key_columns_count
+      end
+    end
+  end
+end