jungle_path 0.0.0

data/lib/jungle_path/db_access/io/insert.rb

@@ -0,0 +1,24 @@
+module JunglePath
+	module DBAccess
+		module IO
+			require 'jungle_path/db_access/io/init_db'
+
+			class Insert
+				include JunglePath::DBAccess::IO::InitDB
+
+				def _model(model)
+					insert = handle_json_columns(model, model._has_value_hash)
+					puts "inserting: #{insert}."
+					#@db[model._table_name] << insert
+					result = @db[model._table_name].insert(insert)
+					if model._primary_key_columns.count == 1
+						model._values[model._primary_key_columns.keys.first] = result
+					end
+					model._secure = false #allow 'secure' columns to be included in hash.
+					model = model.class.new(model.to_hash, false) # create a new model instance with all values marked as unmodified.
+					model
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/db_access/io/schema.rb

@@ -0,0 +1,21 @@
+module JunglePath
+	require 'jungle_path/db_model/schema'
+
+	module DBAccess
+		module IO
+			require 'jungle_path/db_access/io/init_db'
+
+			class Schema
+				include JunglePath::DBAccess::IO::InitDB
+
+				def drop_table(table_class)
+					JunglePath::DBModel::Schema.new(@db).drop_table table_class
+				end
+
+				def create_table(table_class)
+					JunglePath::DBModel::Schema.new(@db).create_table table_class
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/db_access/io/select.rb

@@ -0,0 +1,44 @@
+module JunglePath
+	module DBAccess
+		module IO
+			require 'jungle_path/db_access/io/init_db'
+
+			class Select
+				include JunglePath::DBAccess::IO::InitDB
+
+				def _model(model)
+					# select based on a model's primary key.
+					ds = @db[model._table_name].where(model._primary_key)
+					#puts ds.sql
+					hash = ds.first
+					return nil unless hash
+					new_model = model.class.new(hash, false) # false since row (initial values) from db is considered unmodified.
+				end
+
+				def _model_by_any(model)
+					ds = @db[model._table_name].where(handle_json_columns(model, model._modified_hash))
+					#puts ds.sql
+					hash = ds.first
+					#puts "hash: #{hash}. Nil? #{hash == nil}."
+					return nil unless hash
+					new_model = model.class.new(hash, false) # false since row (initial values) from db is considered unmodified.
+				end
+
+				def _models(model, *order_by)
+					# select all of a given model.
+					ds = @db[model._table_name]
+					ds = ds.where(handle_json_columns(model, model._has_value_hash)) if model._has_value_hash.length > 0
+					ds = ds.order(*order_by) if order_by.length > 0
+					ds = ds.order(model._primary_key_columns.keys) unless order_by.length > 0
+					#puts ds.sql
+					rows = ds.all
+					models = []
+					rows.each do |row|
+						models << model.class.new(row, false)
+					end
+					models
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/db_access/io/update.rb

@@ -0,0 +1,36 @@
+module JunglePath
+	module DBAccess
+		module IO
+			require 'jungle_path/db_access/io/init_db'
+
+			class Update
+				include JunglePath::DBAccess::IO::InitDB
+
+				def _model(model)
+					update = handle_json_columns(model, model._modified_hash)
+					count = update_by_primary_key model, update
+					return {update_count: count}
+				end
+
+				def _models(model_filter, model_values, confirm=false)
+					ds = @db[model_filter._table_name].where(handle_json_columns(model_filter, model_filter._has_value_hash))
+					#puts ds.sql
+					#puts "set values: #{model_values._has_value_hash}."
+					count = 0
+					count = ds.update(handle_json_columns(model_values, model_values._has_value_hash)) if confirm
+					return {update_count: count}
+				end
+
+				private
+
+				def update_by_primary_key model, update
+					@db.transaction do
+						ds = @db[model._table_name].where(model._primary_key).for_update
+						#puts ds.sql
+						ds.update update
+					end
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/db_access/io.rb

@@ -0,0 +1,104 @@
+require 'sequel'
+
+module JunglePath
+	module DBAccess
+		module IO
+			require 'jungle_path/db_access/io/chunked_file_reader'
+			require 'jungle_path/db_access/io/config'
+			require 'jungle_path/db_access/io/copy'
+			require 'jungle_path/db_access/io/db'
+			require 'jungle_path/db_access/io/delete'
+			require 'jungle_path/db_access/io/init_db'
+			require 'jungle_path/db_access/io/insert'
+			require 'jungle_path/db_access/io/schema'
+			require 'jungle_path/db_access/io/select'
+			require 'jungle_path/db_access/io/update'
+
+			def self.connection_from_config(config)
+				connection(
+					database_type: config.type,
+					user_name: config.user_name,
+					database_name: config.name,
+					host: config.host,
+					extensions: config.extensions,
+					password: config.password,
+					port: config.port,
+					options: config.options
+				)
+			end
+
+			def self.connection_from_config_unknown_database(config)
+				if config.type == 'postgres'
+					connection_from_config_use_postgres_db(config)
+				elsif config.type == 'tinytds'
+					connection_from_config_use_ms_sql_server_db(config)
+				else
+					throw "Unknown database type: #{config.type}."
+				end
+			end
+
+			def self.connection_from_config_use_ms_sql_server_db(config)
+				db = connection(
+					database_type: config.type,
+					user_name: config.user_name,
+					database_name: 'master',
+					host: config.host,
+					extensions: config.extensions,
+					password: config.password,
+					port: config.port,
+					options: config.options
+				)
+			end
+
+			def self.connection_from_config_use_postgres_db(config)
+				db = connection(
+					database_type: config.type,
+					user_name: config.user_name,
+					database_name: 'postgres',
+					host: config.host,
+					extensions: config.extensions,
+					password: config.password,
+					port: config.port,
+					options: config.options
+				)
+			end
+
+			def self.clone_config(config)
+				JunglePath::DBAccess::IO::Config.new(
+					name: config.name,
+					type: config.type,
+					user_name: config.user_name,
+					password: config.password,
+					host: config.host,
+					extensions: config.extensions,
+					port: config.port,
+					options: config.options
+				)
+			end
+
+			def self.connection(database_type:, user_name:, database_name:, host: "localhost", extensions: [], password: nil, port: nil, options: nil)
+				Sequel.default_timezone = :utc
+				colon_port = ":#{port}" if port
+				options = {} unless options
+				if password
+					puts "Using db connection with explicit password!"
+					connection_string = "#{database_type}://#{user_name}:#{password}@#{host}#{colon_port}/#{database_name}"
+					puts "connection_string: #{connection_string}."
+					db = Sequel.connect(connection_string, options)
+					puts "connected."
+				else
+					puts "no explicit pw."
+					connection_string = "#{database_type}://#{user_name}@#{host}#{colon_port}/#{database_name}"
+					puts "connection_string: #{connection_string}."
+					db = Sequel.connect(connection_string, options)
+					puts "connected."
+				end
+				extensions.each do |extension|
+					puts "Adding Sequel extension: #{extension}."
+					db.extension extension
+				end
+				db
+			end
+		end
+	end
+end

data/lib/jungle_path/db_model/column.rb

@@ -0,0 +1,186 @@
+require 'set'
+
+module JunglePath
+  module DBModel
+    class Column
+      attr_reader :name, :type, :base_type, :foreign_key_table_name, :sequence, :tags, :override_type
+      def initialize(sequence, name, type, primary_key=false, foreign_key=false, foreign_key_table_name=nil, not_null=false, unique=false, secure=false, alternate_key=false, calculated=false, desc=nil, index=nil, unique_index=nil, default_value=nil, tags=nil, override_type=nil)
+        @sequence = sequence
+        @name = name
+        @type = type
+        @override_type = override_type
+        @base_type = get_base_type(@type)
+        @primary_key = primary_key
+        @foreign_key = foreign_key
+        @foreign_key_table_name = foreign_key_table_name
+        @not_null = not_null
+        @unique = unique
+        @secure = secure
+        @alternate_key = alternate_key
+        @calculated = calculated
+        @desc = desc
+        @index = index
+        @unique_index = unique_index
+        @default_value = default_value
+        @tags = tags
+        @is_audit_column = audit_column_names.include? name
+      end
+
+      def primary_key?
+        @primary_key
+      end
+
+      def alternate_key?
+        @alternate_key
+      end
+
+      def foreign_key?
+        @foreign_key
+      end
+
+      def not_null?
+        @not_null
+      end
+
+      def calculated?
+        @calculated
+      end
+
+      def calculated=(value)
+        @calculated = value
+      end
+
+      def unique?
+        @unique
+      end
+
+      def secure?
+        @secure
+      end
+
+      def audit_column_names
+         [:created_at, :updated_at, :created_by_key_id, :created_by_user_id, :updated_by_key_id, :updated_by_user_id].to_set
+      end
+
+      def is_audit_column?
+        @is_audit_column
+      end
+
+      def ruby_type
+        return Integer if @type == :foreign_key
+        return Integer if @type == :primary_key
+        return String if @type == :string
+        return Integer if @type == :integer
+        return DateTime if @type == :timestamp
+        return DateTime if @type == :timestamp_local
+        return TrueClass if @type == :boolean
+        return Date if @type == :date
+        return String if @type == :json
+        return String if @type == :jsonb
+        return Float if @type == :float
+        nil
+      end
+
+      def desc
+        @desc
+      end
+
+      def index
+        @index
+      end
+
+      def unique_index
+        @unique_index
+      end
+
+      def default_value
+        @default_value
+      end
+
+      def self.get_column_def_columns(column_definition, sequence)
+        return audit_key(sequence) if column_definition.length == 1 and column_definition[0] == :audit_key
+        return audit_user(sequence) if column_definition.length == 1 and column_definition[0] == :audit_user
+        return killable(sequence) if column_definition.length == 1 and column_definition[0] == :killable
+        return verification(sequence) if column_definition.length == 1 and column_definition[0] == :verification
+        return audit_data(sequence) if column_definition.length == 1 and column_definition[0] == :audit_data
+        normal(column_definition, (sequence))
+      end
+
+      private
+
+      def get_base_type(type)
+        base_type = type
+        if type == :primary_key or type == :foreign_key
+          base_type = :integer
+        end
+        base_type = override_type if override_type
+        base_type
+      end
+
+      def self.normal(array, sequence)
+        name = array[0]
+        type = array[1]
+        #type = :integer if array.include? :primary_key
+        #type = :integer if array.include? :foreign_key
+        primary_key = array.include? :primary_key
+        foreign_key = array.include? :foreign_key
+        foreign_key_table_name = array[array.index(:foreign_key) + 1] if foreign_key
+        not_null = ((array.include? :not_null) or primary_key)
+        unique = array.include? :unique
+
+        contains_unique_index = array.include? :unique_index
+        unique_index = array[array.index(:unique_index) + 1] if contains_unique_index
+
+        contains_index = array.include? :index
+        index = array[array.index(:index) + 1] if contains_index
+
+        secure = array.include? :secure
+        alternate_key = array.include? :alternate_key
+        calculated = array.include? :calculated
+        desc = array[array.index(:desc) + 1] if array.include? :desc
+        override_type = array[array.index(:override_type) + 1] if array.include? :override_type
+        default_index = array.index(:default)
+        default_value = array[default_index + 1] if default_index and default_index > 0
+        tags = array[array.index(:tags) + 1] if array.include? :tags
+
+        columns = [Column.new(sequence, name, type, primary_key, foreign_key, foreign_key_table_name, not_null, unique, secure, alternate_key, calculated, desc, index, unique_index, default_value, tags, override_type)]
+      end
+
+      def self.audit_key(sequence)
+        columns = [
+          normal([:created_at, :timestamp], sequence)[0],
+          normal([:created_by_key_id, :foreign_key, :key], sequence+1)[0],
+          normal([:updated_at, :timestamp], sequence+2)[0],
+          normal([:updated_by_key_id, :foreign_key, :key], sequence+3)[0]]
+      end
+
+      def self.audit_user(sequence)
+        columns = [
+          normal([:created_at, :timestamp], sequence)[0],
+          normal([:created_by_user_id, :foreign_key, :user], sequence+1)[0],
+          normal([:updated_at, :timestamp], sequence+2)[0],
+          normal([:updated_by_user_id, :foreign_key, :user], sequence+3)[0]]
+      end
+
+      def self.killable(sequence)
+        columns = [
+          normal([:active, :boolean], sequence)[0],
+          normal([:effective_date, :date], sequence+1)[0],
+          normal([:kill_date, :date], sequence+2)[0],
+          normal([:kill_by_key_id, :foreign_key, :key], sequence+3)[0],
+          normal([:kill_reason, :string], sequence+4)[0]]
+      end
+
+      def self.verification(sequence)
+        columns = [
+          normal([:verification, :json, :tags, [:verification, :approval]], sequence)[0]]
+      end
+
+      def self.audit_data(sequence)
+        columns = [
+          normal([:audit_data, :json], sequence)[0]]
+      end
+
+    end
+	end
+end

data/lib/jungle_path/db_model/params.rb

@@ -0,0 +1,60 @@
+module JunglePath
+	module DBModel
+		module Params
+			def self.transform(params, columns)
+				# sinatra params come as string keys with string values.
+				# Convert values to various types based on Schema column definitions.
+				# Convert keys to symbols.
+				p = params.to_hash
+				p = symbolize(p)
+				p = convert_to_type(p, columns)
+				p
+			end
+
+			def self.symbolize(params)
+				p = params.to_hash
+				Hash[p.map {|k, v| [k.to_sym, v] }]
+			end
+
+			def self.convert_to_type(params, columns)
+				#params must be hash of symbols (as keys) and values
+				p = {}
+				params = params.to_hash
+				params.each do |k, v|
+					column = columns[k]
+					if column and v
+						#puts "column, type: #{k} #{column.type}."
+						if column.type == :integer or column.base_type == :integer
+							p[k] = v.to_i
+						elsif column.type == :timestamp and v.class == String
+							p[k] = Time.parse(v).utc
+						elsif column.type == :timestamp_local and v.class == String # experimental, probably won't use...
+							p[k] = Time.parse(v)
+						elsif column.type == :date and v.class == String
+							p[k] = Date.parse(v).to_time
+						elsif column.type == :date and v.class == Date
+							p[k] = v.to_time
+						elsif column.type == :boolean
+							p[k] = to_bool(v)
+						elsif (column.type == :string or column.base_type == :string) and v.class == String and v.strip.empty?
+							# treat empty/whitespace only strings as nil.
+							p[k] = nil
+						else
+							p[k] = v
+						end
+					else
+						p[k] = v
+					end
+				end
+				p
+			end
+
+			def self.to_bool(value)
+				return false if value == nil
+				return true  if value == true   || value =~ (/(true|t|yes|y|on|1)$/i)
+				return false if value == false  || value.empty? || value =~ (/(false|f|no|n|off|0)$/i)
+				raise ArgumentError.new("invalid value for Boolean: \"#{value}\"")
+			end
+		end
+	end
+end

data/lib/jungle_path/db_model/schema.rb

@@ -0,0 +1,100 @@
+module JunglePath
+	module DBModel
+		class Schema
+			def initialize db
+				# db should be a "Sequel" db object that is connected to some database.
+				@db = db
+			end
+
+			def get_sequel_method type
+				return 'foreign_key' if type == :foreign_key
+				return 'primary_key' if type == :primary_key
+				return 'String' if type == :string
+				return 'Integer' if type == :integer
+				return 'DateTime' if type == :timestamp
+				return 'DateTime' if type == :timestamp_local
+				return 'TrueClass' if type == :boolean
+				return 'Date' if type == :date
+				return 'json' if type == :json
+				return 'jsonb' if type == :jsonb
+				return 'Float' if type == :float
+				return type
+			end
+
+			def get_postgresql_override_type type
+				return 'text' if type == :string
+				return 'integer' if type == :integer
+				return 'bigint' if type == :bigint
+				return 'timestamp' if type == :timestamp
+				return 'timestamp' if type == :timestamp_local
+				return 'boolean' if type == :boolean
+				return 'date' if type == :date
+				return 'json' if type == :json
+				return 'jsonb' if type == :jsonb
+				return 'double' if type == :float
+				return type.to_s
+			end
+
+			def create_table table_class
+				# translate column type keys into Sequel methods used by Sequel (DB.create_table).
+
+				# call the Sequel DB.create_table method with a block:
+				#puts "\ttable_name: #{table_class.table_name}"
+				schema = self
+				@db.create_table? table_class.table_name do
+					made_pk = false
+					table_class.columns.each_value do |column|
+						puts "\tcolumn: #{column.name} #{schema.get_sequel_method(column.type)} #{column.foreign_key_table_name}."
+						method = schema.get_sequel_method(column.type)
+						args_hash = {}
+						if column.foreign_key? and column.not_null?
+							#args = [column.name, column.foreign_key_table_name, :null=>false]
+							args = [column.name, column.foreign_key_table_name]
+							args_hash[:null] = false
+						elsif column.foreign_key?
+							args = [column.name, column.foreign_key_table_name]
+						elsif column.primary_key?
+							args = [column.name]
+							#made_pk = true
+						else
+							args = [column.name]
+						end
+						args_hash[:unique] = true if column.unique?
+						args_hash[:null] = false if column.not_null?
+						args_hash[:type] = schema.get_postgresql_override_type(column.override_type) unless column.override_type == nil
+						args_hash[:default] = column.default_value unless column.default_value == nil
+						args << args_hash
+						#puts "\t\tmethod: #{method}. args:#{args}.\n"
+						made_pk = true if column.type == :primary_key # only happens when pk is single column.
+						puts "column: #{column.name}, override_type: #{column.override_type}, override_type.class: #{column.override_type.class}, method: #{method}, args: #{args}."
+						send(method, *args)
+
+						#index:
+						if column.index
+							send('index', column.index)
+						end
+
+						#unique index:
+						if column.unique_index
+							send('unique', column.unique_index)
+						end
+					end
+
+					if not made_pk
+						#puts "creating primary_key for table #{table_class.name}. keys: #{table_class.primary_key_columns.keys}."
+						send('primary_key', table_class.primary_key_columns.keys, :name=>"#{table_class.table_name}_pk".to_sym)
+					end
+					#puts "end of block"
+				end
+			end
+
+			def create_table! table_class
+				nil
+			end
+
+			def drop_table table_class
+				@db.drop_table? table_class.table_name
+			end
+		end
+	end
+end

data/lib/jungle_path/db_model/string.rb

@@ -0,0 +1,9 @@
+class ::String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end