sqlite2dbf 0.1.8 → 0.2

data/lib/logging.rb

@@ -54,140 +54,140 @@ class TClass
 end
 =end
 module Logging
-	include File_Checking
-
-	@@have_log = false
-	@@LOG_CONF = File.dirname(File.absolute_path(__FILE__)) << File::Separator << 'log.conf'
-
-	# Call this method in an instance-method (e.g. initialize() ) to define the
-	# object-level logger; i.e. an object-specific member @log.
-	# Call this method within the class-definition for a class-level logger; i.e.
-	# a member @log for class-level acces.
-	# The method returns the logger, so you can actually do what you want with it.
-	def init_logger(target = STDOUT, level = Logger::INFO)
-		# Prepare for a class-level logger. This is actually quite cool.
-		
-		# ---> Ingeniuous code starts here
-		cn = (self.class == Class ? name : self.class.name)
-		# <--- Ingeniuous code ends here
-		
-		# allow to override the set log-levels with an
-		# external configuration (log.conf).
-		log_conf(cn)
-		# Or use the defaults as set here or elsewhere...
-
-		@level ||= level 
-		@target ||= target
-
-		@log = Logger.new(@target)
-		@log.level = @level
-
-		@log.formatter = proc do |severity, datetime, progname, msg|
-			t = Time.now
-			"#{cn}: #{severity} #{t.hour}-#{t.min}-#{t.sec}: #{msg}\n"
-		end
-		if ! @@have_log
-			@log.debug cn.dup << ' reading logging-configuration from ' << @@LOG_CONF	
-			@@have_log = true
-			@log.debug('level is ' << level.to_s)
-		end
-		return @log
-	end
-
-	# Set the log-target to an IO object.
-	def log_target=(target)
-		@target = target
-		@log = Logger.new(@@target)
-		@log.level = @level
-	end
-
-	# set the log-level
-	def log_level=(level)
-		@level = level
-		@log.level = @level
-	end
-
-	private
-
-	# Override or set the log-level and target-device, as set in a file 'log.conf'.
-	# I do not like the look of this, but it works just the way I want it to.
-	# "HEAVANS! Isn't there a standard way to do this in Ruby, for Christ's sake?", you say.
-	# Heck, I don't care. <= Read that again, I say.
-	def log_conf(cn = nil)
-		config = level = target = nil
-		# puts 'log-config is in ' << @@LOG_CONF
-		if(File::exist?(@@LOG_CONF) )
-			begin
-				conf = File.read(@@LOG_CONF)
-				config = instance_eval(conf)
-			rescue Exception => ex
-				STDERR.puts "WARNING! Cannot evaluate the logger-configuration!" << ' ' << ex.message
-				STDERR.puts "Default log-levels apply."
-			end
-		else
-			puts "Default log-levels apply."
-		end
-
-		if(config && config.respond_to?(:to_hash) )
-			config.default = nil
-			if cn
-				config = config[cn.to_sym]
-			else
-				config = config[self.class.name.to_sym]
-			end
-
-			if(config )
-				if(config.respond_to?(:to_ary) && config.size == 2)
-					@level, @target = config
-					@target.downcase!
-					logdir = File.dirname(@target)
-					msg = file_check(logdir, :exist?, :directory?, :writable?)
-					if(msg) 
-						STDERR.puts "WARNING! A logfile for '%s' cannot be written to %s (%s)!" %[self.class.name, logdir, msg] 
-						@target = nil
-					end
-				else
-					@level = config
-				end	
-			end
-		end
-	end
+  include File_Checking
+
+  @@have_log = false
+  @@LOG_CONF = File.dirname(File.absolute_path(__FILE__)) << File::Separator << 'log.conf'
+
+  # Call this method in an instance-method (e.g. initialize() ) to define the
+  # object-level logger; i.e. an object-specific member @log.
+  # Call this method within the class-definition for a class-level logger; i.e.
+  # a member @log for class-level acces.
+  # The method returns the logger, so you can actually do what you want with it.
+  def init_logger(target = STDOUT, level = Logger::INFO)
+    # Prepare for a class-level logger. This is actually quite cool.
+
+    # ---> Ingeniuous code starts here
+    cn = (self.class == Class ? name : self.class.name)
+    # <--- Ingeniuous code ends here
+
+    # allow to override the set log-levels with an
+    # external configuration (log.conf).
+    log_conf(cn)
+    # Or use the defaults as set here or elsewhere...
+
+    @level ||= level 
+    @target ||= target
+
+    @log = Logger.new(@target)
+    @log.level = @level
+
+    @log.formatter = proc do |severity, datetime, progname, msg|
+      t = Time.now
+      "#{cn}: #{severity} #{t.hour}-#{t.min}-#{t.sec}: #{msg}\n"
+    end
+    if ! @@have_log
+      @log.debug cn.dup << ' reading logging-configuration from ' << @@LOG_CONF	
+      @@have_log = true
+      @log.debug('level is ' << level.to_s)
+    end
+    return @log
+  end
+
+  # Set the log-target to an IO object.
+  def log_target=(target)
+    @target = target
+    @log = Logger.new(@@target)
+    @log.level = @level
+  end
+
+  # set the log-level
+  def log_level=(level)
+    @level = level
+    @log.level = @level
+  end
+
+  private
+
+  # Override or set the log-level and target-device, as set in a file 'log.conf'.
+  # I do not like the look of this, but it works just the way I want it to.
+  # "HEAVANS! Isn't there a standard way to do this in Ruby, for Christ's sake?", you say.
+  # Heck, I don't care. <= Read that again, I say.
+  def log_conf(cn = nil)
+    config = level = target = nil
+    # puts 'log-config is in ' << @@LOG_CONF
+    if(File::exist?(@@LOG_CONF) )
+      begin
+	conf = File.read(@@LOG_CONF)
+	config = instance_eval(conf)
+      rescue Exception => ex
+	STDERR.puts "WARNING! Cannot evaluate the logger-configuration!" << ' ' << ex.message
+	STDERR.puts "Default log-levels apply."
+      end
+    else
+      puts "Default log-levels apply."
+    end
+
+    if(config && config.respond_to?(:to_hash) )
+      config.default = nil
+      if cn
+	config = config[cn.to_sym]
+      else
+	config = config[self.class.name.to_sym]
+      end
+
+      if(config )
+	if(config.respond_to?(:to_ary) && config.size == 2)
+	  @level, @target = config
+	  @target.downcase!
+	  logdir = File.dirname(@target)
+	  msg = file_check(logdir, :exist?, :directory?, :writable?)
+	  if(msg) 
+	    STDERR.puts "WARNING! A logfile for '%s' cannot be written to %s (%s)!" %[self.class.name, logdir, msg] 
+	    @target = nil
+	  end
+	else
+	  @level = config
+	end	
+      end
+    end
+  end
 end
 
 ######### test
 if __FILE__ == $0
-	class TClass
-		# class level ---->
-		self.extend(Logging)
-		@@log = init_logger(STDOUT, Logger::INFO)
-		# <------
-		# object-level ---->
-		include Logging
-		# <---------
-
-		def test_log
-			@@log.info('class-level logger called from instance: ' << @@log.to_s)
-			#@log = @@log # works too
-			@log = TClass.class_eval{@log}
-			@log.info('AGAIN: class-level logger called from instance: ' << @log.to_s)
-			@log.debug("you won't see this on log-level INFO")
-
-			# object-level ---->
-			init_logger
-			# <-----------
-			@log.info("That's a different thing: " << @log.to_s << " - object-level logger!")
-
-		end
-		def self::test_log
-			@log.info('class-level logger called from class: ' << @log.to_s)
-			@@log.info('AGAIN: class-level logger called from class: ' << @log.to_s)
-		end
-	end
-
-	TClass.new.test_log # class-logger + 1st object-logger
-	TClass.new.test_log # same class-logger + 2nd object-logger
-
-	TClass::test_log # same class-logger
-	puts 'And just say it once clearly: THIS IS COOOL!!'
+  class TClass
+    # class level ---->
+    self.extend(Logging)
+    @@log = init_logger(STDOUT, Logger::INFO)
+    # <------
+    # object-level ---->
+    include Logging
+    # <---------
+
+    def test_log
+      @@log.info('class-level logger called from instance: ' << @@log.to_s)
+      #@log = @@log # works too
+      @log = TClass.class_eval{@log}
+      @log.info('AGAIN: class-level logger called from instance: ' << @log.to_s)
+      @log.debug("you won't see this on log-level INFO")
+
+      # object-level ---->
+      init_logger
+      # <-----------
+      @log.info("That's a different thing: " << @log.to_s << " - object-level logger!")
+
+    end
+    def self::test_log
+      @log.info('class-level logger called from class: ' << @log.to_s)
+      @@log.info('AGAIN: class-level logger called from class: ' << @log.to_s)
+    end
+  end
+
+  TClass.new.test_log # class-logger + 1st object-logger
+  TClass.new.test_log # same class-logger + 2nd object-logger
+
+  TClass::test_log # same class-logger
+  puts 'And just say it once clearly: THIS IS COOOL!!'
 end
 #EOF

data/lib/mapping.rb

@@ -0,0 +1,94 @@
+#encoding: UTF-8 
+=begin
+/***************************************************************************
+ *   ©2016 Michael Uplawski <michael.uplawski@uplawski.eu>            *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 3 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+=end
+
+# This is not a module.
+# TODO get rid of the ambivalence.
+# This class represents the mapping between SQLite data-types and those in
+# dBase. It is basically a decorator for an Array of OpenStruct objects.
+# Mapping-objects have access to the configuration.
+# TODO: Decide if this needs to be a singleton (one table only) or if it might,
+# in the future, make sense to preview several mapping-objects for the
+# transformation of several tables in a row.
+class Mapping
+
+  include Logging
+
+  @@TMap = {
+    'INT' => 1, 
+    'TINYINT' => 1, 
+    'SMALLINT' => 1, 
+    'MEDIUMINT' => 1, 
+    'BIGINT' => 1, 
+    'UNSIGNED BIGINT' => 1, 
+    'VARCHAR' => 0, 
+    'CHARACTER' => 0, 
+    'VARYING CHARACTER' => 0, 
+    'LONGVARCHAR' => 0, 
+    'TEXT' => 0, 
+    'BLOB' => 0, 
+    'INTEGER' => 1, 
+    'FLOAT' => 2, 
+    'REAL' => 2, 
+    'DOUBLE' => 2
+  } 
+
+  # Constructor
+  # Creates a mapping for the table of name 'table'
+  # and basedon the table_info.
+  def initialize config, table_info, content
+    init_logger()
+
+    @table_name = config.name
+    @mapping = []
+    @content = content
+    @date_fields = config.date ? config.date : [] 
+    @time_fields = config.time ? config.time : []
+
+    table_info.each_with_index do |field, i|
+      @log.debug('field is ' << (field ? field.to_s : ' N I L ') )
+      field_name = field['name']
+
+      ftype = nil 
+
+      # Enforce Text field for dates and times.
+      ftype = 0 if  @date_fields.include?(field_name)
+      ftype = 0 if @time_fields.include?(field_name) 
+
+      # Do as you must for the remainder
+      ftype ||= @@TMap.detect{|key, value| field['type'].upcase.start_with?(key) }[1]
+
+      @mapping << OpenStruct.new(:name => field_name, :type => ftype, :index => i)
+    end
+  end
+  def [](*args)
+    @mapping.detect do |field|
+      field.index == args[0]
+    end
+  end
+
+  def each(&b)
+    @mapping.each do |field|
+      yield(field)
+    end
+  end
+
+end