jungle_path 0.0.0

data/lib/jungle_path/db_model/table.rb

@@ -0,0 +1,307 @@
+require 'set'
+require 'jungle_path/json'
+require 'jungle_path/db_model'
+
+module JunglePath
+  module DBModel
+		class Table
+			@models = {}
+			def self.set_columns
+				@columns = {}
+				@non_audit_columns = {}
+				@primary_key_columns = {}
+				@alternate_key_columns = {}
+				@foreign_key_columns = {}
+				@foreign_key_columns_by_table_name = {}
+				@references = Set.new
+				@secure_columns = {}
+				@unique_indexes = []
+				@indexes = []
+				@table_name = self.name.split('::').last.underscore.to_sym
+				@tagged_columns = {}
+				@sequence = 0
+			end
+
+			def self.columns
+				@columns
+			end
+
+			def self.columns_alphabetical_order
+				@columns.values.clone.sort { |a,b| a.name <=> b.name }
+			end
+
+			def self.columns_sequence_order
+				@columns.values.clone.sort { |a,b| a.sequence <=> b.sequence }
+			end
+
+			def self.non_audit_columns
+				@non_audit_columns
+			end
+
+			def self.primary_key_columns
+				@primary_key_columns
+			end
+
+			def self.alternate_key_columns
+				@alternate_key_columns
+			end
+
+			def self.foreign_key_columns
+				@foreign_key_columns
+			end
+
+			def self.foreign_key_columns_by_table_name
+				@foreign_key_columns_by_table_name
+			end
+
+			def self.tagged_columns
+				#call like: TableClass.tagged_columns[:my_tag] to return set of columns having given tag.
+				@tagged_columns
+			end
+
+			def self.references
+				@references
+			end
+
+			def self.has_reference_to?(table)
+				@references.member?(table.table_name)
+			end
+
+			def self.has_references?
+				!@references.empty?
+			end
+
+			def self.has_no_references?
+				!self.has_references?
+			end
+
+			def self.secure_columns
+				@secure_columns
+			end
+
+			def self.table_name
+				@table_name
+			end
+
+			def self.plural_table_name
+				"#{@table_name}s"
+			end
+
+			def self.description
+				@description
+			end
+
+			def self.description=(value)
+				@description = value
+			end
+
+			def self.inherited(sub_class)
+				sub_class.set_columns #setup subclass with particular class instance vars.
+        @models = {} unless @models
+				@models[sub_class.table_name] = sub_class #keep a list of all subclasses.
+			end
+
+			def self.models
+				@models
+			end
+
+			def self.models_alphabetical_order
+				@models.values.clone.sort { |a,b| a.table_name <=> b.table_name }
+			end
+
+			def self.models_dependent_order
+				result = self.model_sort(@models.values.clone)
+				# map array of table names into an array of table (model) classes.
+				result.map {|key| @models[key]}
+			end
+
+			def self.model_sort(list, result=Set.new, level=0)
+				# return array of table names sorted in dependency order (not alphabetical order).
+				puts "level: #{level}."
+				remaining = []
+				list.each do |value|
+					puts "\tvalue: #{value.table_name}. references: #{value.references.to_a}."
+					if value.has_no_references?
+						puts "\tadding: #{value.table_name}."
+						result << value.table_name
+					elsif value.references.subset? result
+						puts "\tadding: #{value.table_name}."
+						result << value.table_name
+					else
+						remaining << value
+					end
+				end
+				puts "\tresult: #{result.length}: #{result.to_a}."
+				puts "\tremaining: #{remaining.length}: #{remaining}."
+				return [] if level > 10 #something is wrong!!!
+				result = self.model_sort(remaining, result, level + 1) if remaining.length > 0
+				result
+			end
+
+			def self.define(*column_defs)
+				set_columns
+
+				column_defs.each do |column_def|
+					# one column_def may produce multiple actual columns:
+					columns = Column.get_column_def_columns(column_def, @sequence)
+					columns.each do |column|
+						@sequence = column.sequence + 1
+						self.columns[column.name] = column
+						self.primary_key_columns[column.name] = column if column.primary_key?
+						self.alternate_key_columns[column.name] = column if column.alternate_key?
+						self.foreign_key_columns[column.name] = column if column.foreign_key?
+
+						if column.foreign_key?
+							hash = self.foreign_key_columns_by_table_name
+							sub_hash = hash[column.foreign_key_table_name]
+							sub_hash = {} unless sub_hash
+							sub_hash[column.name] = column
+							hash[column.foreign_key_table_name] = sub_hash
+						end
+
+						if column.tags
+							column.tags.each do |tag|
+								tagged_columns = @tagged_columns[tag] || Set.new
+								tagged_columns.add(column)
+								@tagged_columns[tag] = tagged_columns
+							end
+						end
+
+						self.references << column.foreign_key_table_name if column.foreign_key? and column.foreign_key_table_name != self.table_name
+						self.secure_columns[column.name] = column if column.secure?
+						self.non_audit_columns[column.name] = column unless column.is_audit_column?
+						#attr_accessor column.name
+						define_method(column.name) do
+							@values[column.name]
+						end
+						define_method("#{column.name}=") do |value|
+							if value != @values[column.name]
+								@values[column.name] = value
+								@modified.add(column.name)
+							end
+						end
+					end
+					self.primary_key_columns.values[0].calculated = true if self.primary_key_columns.length == 1
+				end
+
+				define_method("_values") do
+					@values
+				end
+
+				define_method("_modified") do
+					@modified
+				end
+
+				define_method("_modified_hash") do
+					hash = {}
+					@modified.each do |key|
+						hash[key] = @values[key]
+					end
+					hash
+				end
+
+				define_method("_has_value_hash") do
+					hash = {}
+					@values.each do |key, value|
+						hash[key] = value unless value == nil
+					end
+					hash
+				end
+
+				define_method("_primary_key") do
+					primary_key = {}
+					_primary_key_columns.keys.each do |key|
+						primary_key[key] = @values[key]
+					end
+					primary_key
+				end
+
+				define_method("_alternate_key") do
+					alternate_key = {}
+					_alternate_key_columns.keys.each do |key|
+						alternate_key[key] = @values[key]
+					end
+					alternate_key
+				end
+
+				define_method("_consume_hash") do |hash, mark_as_modified_if_changed=true|
+					@values.each do |key, value|
+						if hash.has_key?(key) and @values[key] != hash[key]
+							@values[key] = hash[key]
+							@modified.add(key) if mark_as_modified_if_changed
+						end
+					end
+				end
+
+				define_method("_columns") do
+					self.class.columns
+				end
+
+				define_method("_primary_key_columns") do
+					self.class.primary_key_columns
+				end
+
+				define_method("_alternate_key_columns") do
+					self.class.alternate_key_columns
+				end
+
+				define_method("_foreign_key_columns") do
+					self.class.foreign_key_columns
+				end
+
+				define_method("_secure_columns") do
+					self.class.secure_columns
+				end
+
+				define_method("_tagged_columns") do
+					self.class.tagged_columns
+				end
+
+				define_method("_table_name") do
+					self.class.table_name
+				end
+
+				define_method("_secure?") do
+					@secure
+				end
+
+				define_method("_secure=") do |value|
+					@secure = value
+				end
+
+				define_method("to_hash") do
+					#puts "#{_table_name} to_hash."
+					return @values.clone if _secure_columns.length == 0 or !_secure?
+					hash = {}
+					puts "stripping secure columns!"
+					@values.each do |key, value|
+						hash[key] = value unless _secure_columns.has_key?(key)
+					end
+					hash
+				end
+
+				define_method("to_h") do
+					# ruby way :)
+					to_hash
+				end
+
+				define_method("to_json") do |arg=nil|
+					#puts "#{_table_name} to_json."
+					#puts "to_json - arg: #{arg.class}" if arg
+					json = JsonWrap.dump self
+					#puts json
+					json
+				end
+			end
+
+			def initialize(hash=nil, mark_as_modified_if_changed=true, transform_params=false)
+				@values = {}
+				@secure = true
+				_columns.keys.each do |key| @values[key] = nil end
+				@modified = Set.new # holds hash keys of modified values.
+				hash = DBModel::Params.transform(hash, _columns) if transform_params
+				_consume_hash(hash, mark_as_modified_if_changed) if hash
+			end
+		end
+	end
+end

data/lib/jungle_path/db_model.rb

@@ -0,0 +1,34 @@
+# db_model.rb
+# db_model
+# Create ruby classes (models) based on database table definitions.
+# Schema class (using the Sequel gem) can generate database tables from your models.
+#
+# Example from gbwho app's schema.rb file:
+#
+#        require_relative '../lib/db_model'
+#
+#        module Schema
+#          class User < DBModel::Table
+#            define(
+#              [:id, :primary_key],
+#              [:user_name, :string, :unique, :not_null, :alternate_key],
+#              [:hash, :string, :not_null, :secure, :calculated, :desc, "See password_hash.rb for details."],
+#              [:name, :string, :not_null, :desc, "Your human name! :)"],
+#              [:email, :string, :not_null],
+#              [:audit])
+#          end
+#        end
+
+require 'set'
+#require_relative 'json_wrap'
+require 'jungle_path/json'
+
+module JunglePath
+  module DBModel
+    require 'jungle_path/db_model/string'
+    require 'jungle_path/db_model/column'
+    require 'jungle_path/db_model/table'
+    require 'jungle_path/db_model/schema'
+    require 'jungle_path/db_model/params'
+  end
+end

data/lib/jungle_path/exceptions.rb

@@ -0,0 +1,10 @@
+module JunglePath
+  module Exceptions
+  	# Exception classes:
+    class InvalidAPIKeyException < RuntimeError; end
+    class InvalidPassword < RuntimeError; end
+    class MissingRequiredFields < RuntimeError; end
+    class NotFoundException < RuntimeError; end
+    class TestException < RuntimeError; end
+  end
+end

data/lib/jungle_path/gen/api.rb

@@ -0,0 +1,52 @@
+require 'erb'
+require 'jungle_path/db_model/table'
+
+module JunglePath
+	module DBModel
+	  class Table
+	    # Adds useful methods to Table class for use when generating API and Model code:
+
+	    def self.template_new
+	      "#{self.name}.new"
+	    end
+
+	    def self.template_pk_url
+	      pk = self.primary_key_columns.keys.map {|key| "/:#{key}"}
+	      pk.join
+	    end
+
+	    def self.template_model_name
+	      "Model::#{self.name.split('::').last}"
+	    end
+
+	    def self.template_params_pk_hash
+	      #{id: p[:id]}
+	      array = []
+	      self.primary_key_columns.keys.each do |key|
+	        array << "#{key}: p[:#{key}]"
+	      end
+	      "{#{array.join(',')}}"
+	    end
+	  end
+	end
+end
+
+module JunglePath
+	module Gen
+	  def self.api(app_root_path, tables, output_file='./api/api_gen.rb', name_space='ServerAPI', controller_name_space='Controller', template_file=nil)
+	    if template_file
+	      template_file = ::File.expand_path(template_file, app_root_path)
+	    else
+	      template_file = ::File.expand_path('./api_template.erb', ::File.dirname(__FILE__))
+	    end
+
+	    # template uses name_space and controller_name_space vars:``
+	    template = ERB.new(File.read(template_file))
+
+	    output_file = ::File.expand_path(output_file, app_root_path)
+	    result = template.result(binding)
+	    #puts result
+	    File.write(output_file, result)
+	  end
+	end
+end

data/lib/jungle_path/gen/schema.rb

@@ -0,0 +1,47 @@
+# gen_schema.rb -- creates a database schema from a set of DBModel::Table (sub)classes.
+require 'logger'
+require 'sequel'
+require 'jungle_path/db_model'
+require 'jungle_path/db_access'
+
+# todo: fix ! vs "" vs ? method calls...
+module JunglePath
+	module Gen
+	  module Schema
+	    def self.create(table_subclasses, db_config, logger=$stdout)
+	      puts "Gen::Schema.create..."
+	      db = JunglePath::DBAccess.connection_from_config(db_config)
+	      db.loggers << Logger.new(logger)
+	      schema = JunglePath::DBModel::Schema.new(db)
+	      table_subclasses.each do |table|
+	        puts "create table: #{table.table_name}"
+	        schema.create_table table
+	      end
+	    end
+
+	    def self.set_version schema_info_class, db_config, schema_initial_version
+	      # set starting version numnber
+	      db = JunglePath::DBAccess::DB.new(db_config)
+	      db.schema.create_table schema_info_class
+	      if schema_initial_version
+	        schema_info = schema_info_class.new({version: schema_initial_version})
+	        db.insert._model(schema_info)
+	      end
+	    end
+
+	    def self.set_version_to_latest schema_info_class, db_config, migrations_path
+	      version = 0
+	      migration_files = Dir.glob(File.join(migrations_path, "*.rb"))
+	      migration_files.each do |file_name|
+	        puts file_name
+	        parts = File.basename(file_name).split('_')
+	        if parts.length > 0
+	          value = parts[0].to_i
+	          version = value if value > version
+	        end
+	      end
+	      set_version schema_info_class, db_config, version
+	    end
+	  end
+	end
+end

data/lib/jungle_path/gen/schema_tree/filter.rb

@@ -0,0 +1,33 @@
+module JunglePath
+	module Gen
+		module SchemaTree
+			class Filter
+				def initialize hash=nil
+					throw "Invalid data parameter: expected a hash, but got this: #{hash}" unless hash.class == Hash or hash == nil
+					allow = hash[:allow] if hash
+					deny = hash[:deny] if hash
+					@match_tables_allow = MatchTables.new allow
+					@match_tables_deny = MatchTables.new deny
+				end
+				def allow? table_name, column_name=nil
+					if @match_tables_allow.matched?(table_name, column_name)
+						if column_name and @match_tables_deny.matched?(table_name, column_name)
+							return false
+						end
+						if column_name and !@match_tables_deny.matched?(table_name, column_name)
+							return true
+						end
+						if !column_name and @match_tables_deny.matched?(table_name) and !@match_tables_deny.includes_columns?(table_name)
+							return false
+						end
+						if !column_name and @match_tables_deny.includes_columns?(table_name)
+							return true
+						end
+						return true
+					end
+					false
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/gen/schema_tree/match_columns.rb

@@ -0,0 +1,54 @@
+module JunglePath
+	module Gen
+		module SchemaTree
+			class MatchColumns
+				attr_reader :is_nil
+				def initialize columns
+					@is_nil = false
+					@hash = {}
+					@regexes = []
+					if columns
+						if columns.class == Symbol
+							@hash[columns] = true
+						elsif columns.class == String
+							@hash[columns.to_sym] = true
+						elsif columns.class == Regexp
+							@regexes << columns
+						elsif columns.class == Array and columns.length > 0
+							columns.each do |col|
+								if col.class == Symbol
+									@hash[col] = true
+								elsif columns.class == String
+									@hash[col.to_sym] = true
+								elsif col.class == Regexp
+									@regexes << col
+								else
+									throw "Invalid type for col array item: #{col.class}, value: #{col}."
+								end
+							end
+						elsif columns.class == Array
+							@is_nil = true
+						else
+							throw "Invalid type for columns parameter: #{columns.class}, value: #{columns}."
+						end
+					else
+						@is_nil = true
+					end
+				end
+
+				def matched? column_name
+					return true if @is_nil
+					return true if @hash[column_name.to_sym]
+					@regexes.each do |regx|
+						return true if regx =~ column_name.to_s
+					end
+					false
+				end
+
+				def to_s
+					"is_nil: #{@is_nil}, hash: #{@hash}, regexes: #{@regexes}."
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/gen/schema_tree/match_table_data.rb

@@ -0,0 +1,22 @@
+module JunglePath
+	module Gen
+		module SchemaTree
+			class MatchTableData
+				attr_reader :name, :columns, :regexp
+				def initialize name, columns
+					@name = name
+					@columns = MatchColumns.new(columns)
+					@regexp = @name if @name and @name.class == Regexp
+				end
+
+				def nil_columns?
+					@columns.is_nil
+				end
+
+				def to_s
+					"name: #{@name}, columns: #{@columns}, regexp: #{@regexp}."
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/gen/schema_tree/match_tables.rb

@@ -0,0 +1,70 @@
+module JunglePath
+	module Gen
+		module SchemaTree
+			class MatchTables
+				def initialize data
+					@hash = {}
+					@match_data = []
+					throw "Invalid data parameter: expected an array, but got this: #{data}" unless data.class == Array or data == nil
+					if data
+						data.each do |h|
+							if h.class == Hash
+								table = h[:table]
+								puts "table: #{table}."
+								columns = h[:columns]
+								puts "columns: #{columns}."
+								if table
+									mtd = MatchTableData.new(table, columns)
+									puts "mtd: #{mtd}."
+									@hash[mtd.name] = mtd
+									@match_data << mtd if mtd.regexp
+								else
+									throw "Invalid hash -- missing key :table. Got this: #{h}."
+								end
+							else
+								throw "Invalid data item. Expected hash got this: #{h}."
+							end
+						end
+					end
+				end
+
+				def matched? table_name, column_name=nil
+					if table_name
+						match_table_data = get_match_table_data(table_name)
+						if match_table_data
+							if column_name
+								return match_table_data.columns.matched?(column_name)
+							else
+								return true
+							end
+						end
+					end
+					false
+				end
+
+				def includes_columns? table_name
+					if table_name
+						match_table_data = get_match_table_data(table_name)
+						return !match_table_data.nil_columns? if match_table_data
+					end
+					false
+				end
+
+				def to_s
+					"@hash: #{@hash}\n@match_data: #{@match_data}."
+				end
+
+				private
+
+				def get_match_table_data table_name
+					match_table_data = @hash[table_name.to_sym]
+					return match_table_data if match_table_data
+					@match_data.each do |mtd|
+						return mtd if mtd.regexp =~ table_name.to_s
+					end
+					nil
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/gen/schema_tree/node.rb

@@ -0,0 +1,39 @@
+module JunglePath
+	module Gen
+		module SchemaTree
+			class Node
+	      attr_accessor :name, :symbol, :child_table_name, :child_table_join_column_name, :parent_table_join_column_name, :nodes, :tables_hash
+
+	      def initialize(name, symbol=nil, child_table_name=nil, child_table_join_column_name=nil, parent_table_join_column_name=nil)
+	        @name = name
+	        @symbol = symbol
+	        @child_table_name = child_table_name
+	        @child_table_join_column_name = child_table_join_column_name
+	        @parent_table_join_column_name = parent_table_join_column_name
+	        @nodes = {}
+	      end
+
+	      def str_name
+	        return "#{name} #{symbol} #{child_table_name}.#{child_table_join_column_name.to_s[0..-4]}" if (child_table_join_column_name and (symbol == "<=" or symbol == "<-"))
+	        return "#{name} #{symbol} #{child_table_name}" if symbol
+	        "#{name}"
+	      end
+
+	      def to_str(level=0)
+	        indent = "  " * level
+	        result = ["#{indent}#{str_name}"]
+	        nodes.each do |k, v|
+	          if v.class == ::Array
+	            v.each do |item|
+	              result << item.to_str(level + 1)
+	            end
+	          else
+	            result << v.to_str(level + 1)
+	          end
+	        end
+	        result.join("\n")
+	      end
+	    end
+		end
+	end
+end