mongify 0.0.4

data/lib/mongify/database/column.rb

@@ -0,0 +1,81 @@
+module Mongify
+  module Database
+    #
+    # A column in the sql table
+    #
+    class Column
+      attr_reader :name, :type, :options
+      
+      AVAILABLE_OPTIONS = ['references', 'default']
+
+      def initialize(name, type=:string, *args)
+        @name = name
+        type = :string if type.nil?
+        @type = type.is_a?(Symbol) ? type : type.to_sym
+        @options = args.extract_options!.stringify_keys
+        
+        auto_detect!
+        
+        self
+      end
+      
+      def translate(value)
+        case type
+        when :key
+          {"pre_mongified_#{name}" => value}
+        when :datetime
+          {"#{name}" => value.to_time}
+        else
+          {"#{self.name}" => value}
+        end
+      end
+      
+      def to_print
+        "column \"#{name}\", :#{type}".tap do |output|
+          output_options = options.map{|k, v| (v == nil) ? nil : ":#{k} => \"#{v}\""}.compact
+          output << ", #{output_options.join(', ')}" unless output_options.blank?
+        end
+      end
+      
+      def method_missing(meth, *args, &blk)
+        method_name = meth.to_s.gsub("=", '')
+        if AVAILABLE_OPTIONS.include?(method_name)
+          class_eval <<-EOF
+                          def #{method_name}=(value)
+                            options['#{method_name}'] = value
+                          end
+                          def #{method_name}
+                            options['#{method_name}']
+                          end
+                        EOF
+          send(meth, *args, &blk)
+        else
+          super(meth, *args, &blk)
+        end
+      end
+      
+      def reference?
+        !self.options['references'].nil?
+      end
+      
+      #######
+      private
+      #######
+      
+      def key?
+        self.type == :key
+      end
+
+      def auto_detect!
+        case name.downcase
+        when 'id'
+          @type = :key if self.type == :integer
+        when /(.*)_id/
+          self.references = $1.to_s.pluralize unless self.references
+        end
+      end
+      
+      
+    end
+  end
+end

data/lib/mongify/database/no_sql_connection.rb

@@ -0,0 +1,62 @@
+require 'mongo'
+module Mongify
+  module Database
+    #
+    # No sql connection configuration
+    #
+    class NoSqlConnection < Mongify::Database::BaseConnection
+      include Mongo
+      REQUIRED_FIELDS = %w{host database}  
+      
+      def initialize(options=nil)
+        super options
+        adapter 'mongodb' if adapter.nil? || adapter == 'mongo'
+      end
+      
+      def connection_string
+        "#{@adapter}://#{@host}#{":#{@port}" if @port}"
+      end
+      
+      def valid?
+        @database.present? && @host.present?
+      end
+      
+      def connection
+        return @connection if @connection
+        @connection = Connection.new(host, port)
+        @connection.add_auth(database, username, password) if username && password
+        @connection
+      end
+      
+      def has_connection?
+        connection.connected?
+      end
+      
+      def db
+        @db ||= connection[database]
+      end
+      
+      def select_rows(collection)
+        db[collection].find
+      end
+      
+      def insert_into(colleciton_name, row)
+        db[colleciton_name].insert(row, :safe => true)
+      end
+      
+      def update(colleciton_name, id, attributes)
+        db[colleciton_name].update({"_id" => id}, attributes)
+      end
+      
+      def get_id_using_pre_mongified_id(colleciton_name, pre_mongified_id)
+        db[colleciton_name].find_one('pre_mongified_id' => pre_mongified_id).try(:[], '_id')
+      end
+      
+      
+      def reset!
+        @connection = nil
+        @db = nil
+      end
+    end
+  end
+end

data/lib/mongify/database/sql_connection.rb

@@ -0,0 +1,61 @@
+module Mongify
+  module Database
+    #
+    # Sql connection configuration
+    #
+    class SqlConnection < Mongify::Database::BaseConnection
+
+      REQUIRED_FIELDS = %w{host adapter database}
+      
+      def initialize(options=nil)
+        @prefixed_db = false
+        super(options)
+      end
+
+      def setup_connection_adapter
+        ActiveRecord::Base.establish_connection(self.to_hash)
+      end
+
+      def valid?
+        return false unless @adapter
+        if sqlite_adapter?
+          return true if @database
+        else
+          return super
+        end
+        false
+      end
+
+      def has_connection?
+        setup_connection_adapter
+        connection.send(:connect) if ActiveRecord::Base.connection.respond_to?(:connect)
+        true
+      end
+      
+      def connection
+        return nil unless has_connection?
+        ActiveRecord::Base.connection
+      end
+      
+      def tables
+        return nil unless has_connection?
+        self.connection.tables
+      end
+
+      def columns_for(table_name)
+        self.connection.columns(table_name)
+      end
+      
+      def select_rows(table_name)
+        self.connection.select_all("SELECT * FROM #{table_name}")
+      end
+
+      #######
+      private
+      #######
+      def sqlite_adapter?
+        @adapter && (@adapter.downcase == 'sqlite' || @adapter.downcase == 'sqlite3')
+      end
+    end
+  end
+end

data/lib/mongify/database/table.rb

@@ -0,0 +1,74 @@
+module Mongify
+  module Database
+    #
+    #  A representation of a sql table and how it should map to a no_sql system 
+    #
+    class Table
+      
+      attr_accessor :name
+      attr_reader :options, :columns
+      
+      def initialize(name, *args, &block)
+        @columns = []
+        @column_lookup = {}
+        @options = args.extract_options!.stringify_keys
+        self.name = name
+        
+        self.instance_exec(&block) if block_given?
+        
+        import_columns
+        
+        self
+      end
+      
+      #Add a Database Column
+      def add_column(column)
+        raise Mongify::DatabaseColumnExpected, "Expected a Mongify::Database::Column" unless column.is_a?(Mongify::Database::Column)
+        add_column_index(column.name, @columns.size)
+        @columns << column
+      end
+      
+      
+      def column(name, type=nil, options={})
+        options = type and type = nil if type.is_a?(Hash)
+        type = type.to_sym if type
+        add_column_index(name.to_s.downcase, @columns.size)
+        @columns << (col = Mongify::Database::Column.new(name, type, options))
+        col
+      end
+      
+      def find_column(name)
+        return nil unless (index = @column_lookup[name.to_s.downcase])
+        @columns[index]
+      end
+      
+      
+      def reference_columns
+        @columns.reject{ |c| !c.reference? } 
+      end
+      
+      def translate(row)
+        new_row = {}
+        row.each do |key, value|
+          c = find_column(key)
+          new_row.merge!(c.present? ? c.translate(value) : {"#{key}" => value})
+        end
+        new_row
+      end
+            
+      #######
+      private
+      #######
+      
+      def add_column_index(name, index)
+        @column_lookup[name] = index
+      end
+
+      def import_columns
+        return unless import_columns = @options.delete('columns')
+        import_columns.each { |c| add_column(c) }
+      end
+      
+    end
+  end
+end

data/lib/mongify/exceptions.rb

@@ -0,0 +1,13 @@
+module Mongify
+  # File Not Found Exception
+  class FileNotFound < RuntimeError; end
+  class ConfigurationFileNotFound < FileNotFound; end
+  class TranslationFileNotFound < FileNotFound; end
+  
+  class ConfigurationError < RuntimeError; end
+  class SqlConnectionRequired < ConfigurationError; end
+  class NoSqlConnectionRequired < ConfigurationError; end
+  class DatabaseColumnExpected < ConfigurationError; end
+  
+  class RootMissing < RuntimeError; end
+end

data/lib/mongify/translation.rb

@@ -0,0 +1,55 @@
+require 'mongify/translation/printer'
+require 'mongify/translation/process'
+module Mongify
+  #
+  # Actually runs the translation from sql to no sql
+  #
+  class Translation
+    attr_reader :tables, :sql_connection, :no_sql_connection
+    
+    include Printer
+    include Process
+    class << self
+      def parse(file_name)
+        translation = self.new
+        translation.instance_eval(File.read(file_name))
+        translation
+      end
+      
+      def load(connection)
+        raise Mongify::SqlConnectionRequired, "Can only read from Mongify::Database::SqlConnection" unless connection.is_a?(Mongify::Database::SqlConnection)
+        return unless connection.has_connection?
+        translation = self.new
+        connection.tables.each do |t|
+          columns = []
+          connection.columns_for(t).each do |ar_col|
+            columns << Mongify::Database::Column.new(ar_col.name, ar_col.type, :default => ar_col.default)
+          end
+          translation.table(t, :columns => columns)
+        end
+        translation
+      end
+    end
+    
+    
+    def initialize
+      @tables = []
+    end
+    
+    def table(table_name, options={}, &block)
+      table = Mongify::Database::Table.new(table_name, options, &block)
+      @tables << table
+    end
+    
+    def add_table(table)
+      @tables << table
+    end
+    
+    #######
+    private
+    #######
+
+    
+    
+  end
+end

data/lib/mongify/translation/printer.rb

@@ -0,0 +1,20 @@
+module Mongify
+  #
+  # Actually runs the translation from sql to no sql
+  #
+  class Translation
+    module Printer
+      def print
+        ''.tap do |output|
+          @tables.each do |t|
+            output << %Q[table "#{t.name}" do\n]
+              t.columns.each do |c|
+                output << "\t#{c.to_print}\n"
+              end
+            output << "end\n\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongify/translation/process.rb

@@ -0,0 +1,61 @@
+module Mongify
+  #
+  # This will take the Translation and do the processing on it
+  #
+  class Translation
+    module Process
+      def sql_connection=(value)
+        @sql_connection=value
+      end
+      def no_sql_connection=(value)
+        @no_sql_connection=value
+      end
+      def process(sql_connection, no_sql_connection)
+        raise Mongify::SqlConnectionRequired, "Can only read from Mongify::Database::SqlConnection" unless sql_connection.is_a?(Mongify::Database::SqlConnection)
+        raise Mongify::NoSqlConnectionRequired, "Can only write to Mongify::Database::NoSqlConnection" unless no_sql_connection.is_a?(Mongify::Database::NoSqlConnection)
+        
+        self.sql_connection = sql_connection
+        raise "SQL Connection is not valid" unless self.sql_connection.valid?
+        self.no_sql_connection = no_sql_connection
+        raise "noSql Connection is not valid" unless self.no_sql_connection.valid?
+        
+        copy
+        update_reference_ids
+        nil
+      end
+      
+      #######
+      private
+      #######
+      
+      def copy
+        self.tables.each do |t|
+          sql_connection.select_rows(t.name).each do |row|
+            no_sql_connection.insert_into(t.name, t.translate(row))
+          end
+        end
+      end
+      
+      def update_reference_ids
+        self.tables.each do |t|
+          no_sql_connection.select_rows(t.name).each do |row|
+            id = row["_id"]
+            attributes = {}
+            t.reference_columns.each do |c|
+              new_id = no_sql_connection.get_id_using_pre_mongified_id(c.references.to_s, row[c.name])
+              attributes.merge!(c.name => new_id) unless new_id.nil?
+            end
+            no_sql_connection.update(t.name, id, {"$set" => attributes}) unless attributes.blank?
+          end
+        end
+      end
+      
+    end
+  end
+end
+
+
+# Process that needs to take place
+#   import the data (moving the id to premongified_id)   
+#   fix all the references to the new ids
+#   

data/lib/mongify/ui.rb

@@ -0,0 +1,45 @@
+module Mongify
+  #
+  #  Used to output messages to the UI
+  #
+  class UI
+    class << self
+      def puts(msg)
+        out_stream.puts(msg) if out_stream
+      end
+    
+      def print(msg)
+        out_stream.print(msg) if out_stream
+      end
+    
+      def gets
+        in_stream ? in_stream.gets : ''
+      end
+    
+      def request(msg)
+        print(msg)
+        gets.chomp
+      end
+    
+      def ask(msg)
+        request("#{msg} [yn] ") == 'y'
+      end
+      
+      def warn(msg)
+        puts "WARNING: #{msg}"
+      end
+      
+      def abort(message)
+        UI.puts "PROGRAM HALT: #{message}"
+        Kernel.abort message
+      end
+      
+      def in_stream
+        Configuration.in_stream
+      end
+      def out_stream
+        Configuration.out_stream
+      end
+    end
+  end
+end