mongify 0.0.9 → 0.1.0

data/lib/mongify/configuration.rb

@@ -1,22 +1,15 @@
 module Mongify
   #
-  #  This extracts the configuration for sql and no sql
+  # Handles all tasks regarding the connection to sql and no-sql database
+  # It also handles the parsing of the data
   #
   class Configuration
     class << self
       attr_accessor :in_stream, :out_stream
       
-      def parse_translation(file_name)
-        raise Mongify::TranslationFileNotFound, "File #{file_name} is missing" unless File.exists?(file_name)
-        Mongify::Translation.parse(file_name)
-      end
-      
-      def parse_configuration(file_name)
-        raise Mongify::ConfigurationFileNotFound, "File #{file_name} is missing" unless File.exists?(file_name)
-        Mongify::Configuration.parse(file_name)
-      end
-      
+      # Parses a external configuration file and evaluates it and returns a instence of a configuration class
       def parse(file_name)
+        raise Mongify::ConfigurationFileNotFound, "File #{file_name} is missing" unless File.exists?(file_name)
         config = self.new
         config.instance_eval(File.read(file_name))
         config
@@ -24,18 +17,27 @@ module Mongify
 
     end #self
     
+    # Returns a no_sql_connection which is bound to a mongodb adapter
+    # or builds a new no_sql_connection if block is given
     def mongodb_connection(options={}, &block)
+      return @mongodb_conncetion if @mongodb_connection and !block_given?
       options.stringify_keys!
       options['adapter'] ||= 'mongodb'
-      no_sql_connection(options, &block)
+      @mongodb_connection = no_sql_connection(options, &block)
     end
     
+    # Returns a sql_connection
+    # If a block is given, it will be executed on the connection
+    # For more information, see {Mongify::Database::SqlConnection}
     def sql_connection(options={}, &block)
       @sql_connection ||= Mongify::Database::SqlConnection.new(options)
       @sql_connection.instance_exec(&block) if block_given?
       @sql_connection
     end
     
+    # Returns a sql_connection
+    # If a block is given, it will be executed on the connection
+    # For more information, see {Mongify::Database::NoSqlConnection}
     def no_sql_connection(options={}, &block)
       @no_sql_connection ||= Mongify::Database::NoSqlConnection.new(options)
       @no_sql_connection.instance_exec(&block) if block_given?

data/lib/mongify/database.rb

@@ -1,5 +1,6 @@
 require 'mongify/database/base_connection'
 require 'mongify/database/no_sql_connection'
 require 'mongify/database/sql_connection'
+require 'mongify/database/data_row'
 require 'mongify/database/table'
-require 'mongify/database/column'
+require 'mongify/database/column'

data/lib/mongify/database/base_connection.rb

@@ -1,22 +1,25 @@
 module Mongify
+  # Module that deals with all database related items
   module Database
     #
-    # Basic configuration for any sql or non sql database
+    # This is a Basic configuration for any sql or non sql database
     #
     class BaseConnection
-
+      # List of required fields to make a valid base connection
       REQUIRED_FIELDS = %w{host}
+      # List of all the available fields to make up a connection
       AVAILABLE_FIELDS = %w{adapter host username password database socket port encoding}
-
+      
       def initialize(options=nil)
         if options
           options.stringify_keys!
           options.each do |key, value|
-             instance_variable_set "@#{key}", value
+             instance_variable_set "@#{key.downcase}", value if AVAILABLE_FIELDS.include?(key.downcase)
           end
         end
       end
-
+      
+      # Returns all settings as a hash, this is used mainly in building ActiveRecord::Base.establish_connection
       def to_hash
         hash = {}
         instance_variables.each do |variable|
@@ -26,7 +29,9 @@ module Mongify
         hash
       end
 
+      # Ensures the required fields are filled
       def valid?
+        #TODO: Improve this to create an errors array with detailed errors (or maybe just use activemodel)
         REQUIRED_FIELDS.each do |require_field|
           return false unless instance_variables.include?("@#{require_field}") and
                               !instance_variable_get("@#{require_field}").to_s.empty?
@@ -34,32 +39,37 @@ module Mongify
         true
       end
 
-
+      # Used to setup connection, Raises NotImplementedError because it needs to be setup in BaseConnection's children
       def setup_connection_adapter
         raise NotImplementedError
       end
 
+      # Used to test connection, Raises NotImplementedError because it needs to be setup in BaseConnection's children
       def has_connection?
         raise NotImplementedError
       end
 
-      def adapter(value=nil)
-        @adapter = value.to_s unless value.nil?
-        @adapter
-      end
-
 
-      def respond_to?(method, *args)
+      # Returns true if we are trying to respond_to AVAILABLE_FIELDS functions
+      def respond_to?(method, *args) 
         return true if AVAILABLE_FIELDS.include?(method.to_s)
         super(method)
       end
-
+      
+      # Building set and/or return functions for AVAILABLE_FIELDS
+      # Example:
+      # 
+      #   def host(value=nil)
+      #     @host = value.to_s unless value.nil?
+      #     @host
+      #   end
+      #
       def method_missing(method, *args)
-        method_name = method.to_s #.gsub("=", '')
+        method_name = method.to_s
         if AVAILABLE_FIELDS.include?(method_name.to_s)
           class_eval <<-EOF
                           def #{method_name}(value=nil)
-                            @#{method_name} = value unless value.nil?
+                            @#{method_name} = value.to_s unless value.nil?
                             @#{method_name}
                           end
                         EOF

data/lib/mongify/database/column.rb

@@ -2,28 +2,88 @@ require 'active_record/connection_adapters/abstract/schema_definitions'
 module Mongify
   module Database
     #
-    # A column in the sql table
+    # A column that is used to access sql data and transform it into the no sql database
     #
+    # 
+    # ==== Structure
+    # 
+    # Structure for defining a column is as follows:
+    #   column "name", :type, {options}
+    # <em>Columns with no type given will be set to <tt>:string</tt></em>
+    # 
+    # ==== Notes
+    # Leaving a column out when defining a table will result in a copy of the information (as a string).
+    # ==== Types
+    # 
+    # Types of columns are supported:
+    #   :key                  # Columns that are primary keys need to be marked as :key type
+    #   :integer              # Will be converted to a integer
+    #   :float                # Will be converted to a float
+    #   :decimal              # Will be converted to a BigDecimal
+    #   :string               # Will be converted to a string
+    #   :text                 # Will be converted to a string
+    #   :datetime             # Will be converted to a Time format (DateTime is not currently supported in the Mongo ruby driver)
+    #   :date                 # Will be converted to a Time format (Date is not currently supported in the Mongo ruby driver)
+    #   :timestamps           # Will be converted to a Time format
+    #   :time                 # Will be converted to a Time format (the date portion of the Time object will be 2000-01-01)
+    #   :binary               # Will be converted to a string
+    #   :boolean              # Will be converted to a true or false values
+    # 
+    # ==== Options
+    # 
+    #   column "post_id", :integer, :referneces => :posts   # Referenced columns need to be marked as such, this will mean that they will be updated
+    #                                                       # with the new BSON::ObjectID.
+    # <b>NOTE: if you rename the table 'posts', you should set the :references to the new name</b>
+    # 
+    #   column "name", :string, :ignore => true             # Ignoring a column will make the column NOT copy over to the new database
+    # 
+    #   column "surname", :string, :rename_to => 'last_name'# Rename_to allows you to rename the column
+    #
+    #   column "post_id", :integer, :auto_detect => true    # Will run auto detect and make this column a :references => 'posts', :on => 'post_id' for you
+    #                                                       # More used when reading a sql database, NOT recommended for use during processing of translation
+    #   
     class Column
       attr_reader :sql_name, :type, :options
       
+      #List of available options for a column
       AVAILABLE_OPTIONS = ['references', 'ignore', 'rename_to']
-
+      
+      # Auto detects if a column is an :key column or is a reference column
+      def self.auto_detect(column)
+        case column.sql_name.downcase
+        when 'id'
+          column.type = :key if column.type == :integer
+        when /(.*)_id/
+          column.references = $1.to_s.pluralize unless column.referenced? || column.type != :integer
+        end
+      end
+      
       def initialize(sql_name, type=:string, options={})
         @sql_name = sql_name
-        type = :string if type.nil?
-        @type = type.is_a?(Symbol) ? type : type.to_sym
+        options, type = type, nil if type.is_a?(Hash)
+        self.type = type
         @options = options.stringify_keys
-        
-        auto_detect!
+        @auto_detect = @options.delete('auto_detect')
+        run_auto_detect!
         
         self
       end
       
+      # Allows you to set a type
+      def type=(value=:string)
+        value = :string if value.nil?
+        @type = value.is_a?(Symbol) ? value : value.to_sym
+      end
+      
+      # Returns the no_sql record name
       def name
         @name ||= rename_to || sql_name
       end
       
+      # Returns a translated hash from a given value
+      # Example:
+      #   @column = Column.new("surname", :string, :rename_to => 'last_name')
+      #   @column.translate("Smith") # => {"last_name" => "Smith"}
       def translate(value)
         return {} if ignored?
         case type
@@ -34,13 +94,24 @@ module Mongify
         end
       end
       
+      # Returns a string representation of the column as it would show in a translation file.
+      # Mainly used during print out of translation file
       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
+      alias :to_s :to_print
       
+      # Sets up a accessor method for an option
+      #
+      #   def rename_to=(value)
+      #     options['rename_to'] = value
+      #   end
+      #   def rename_to
+      #     options['rename_to']
+      #   end
       def method_missing(meth, *args, &blk)
         method_name = meth.to_s.gsub("=", '')
         if AVAILABLE_OPTIONS.include?(method_name)
@@ -58,18 +129,36 @@ module Mongify
         end
       end
       
+      # Returns true if the column is a reference column
       def referenced?
         !self.options['references'].nil?
       end
       
+      # Returns true if column is being renamed
       def renamed?
         self.name != self.sql_name
       end
       
+      # Returns true if column is a :key type column
+      def key?
+        self.type == :key
+      end
+      
+      # Returns true if column should be auto_detected (passed via options)
+      def auto_detect?
+        !!@auto_detect
+      end
+      
+      # Returns true if column is ignored
+      def ignored?
+        !!self.ignore
+      end
+      
       #######
       private
       #######
       
+      # Casts the value to a given type
       def type_cast(value)
         return nil if value.nil?
         case type
@@ -81,28 +170,17 @@ module Mongify
           when :datetime  then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
           when :timestamp then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
           when :time      then ActiveRecord::ConnectionAdapters::Column.string_to_dummy_time(value)
-          when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_date(value)
+          when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
           when :binary    then ActiveRecord::ConnectionAdapters::Column.binary_to_string(value)
           when :boolean   then ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
           else value
         end
       end
       
-      def key?
-        self.type == :key
-      end
-      
-      def ignored?
-        !!self.ignore
-      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
+      # runs auto detect (see {Mongify::Database::Column.auto_detect})
+      def run_auto_detect!
+        self.class.auto_detect(self) if auto_detect?
       end
       
       

data/lib/mongify/database/data_row.rb

@@ -0,0 +1,67 @@
+module Mongify
+  module Database
+    # Class that will be used to allow user to modify data for the given row
+    class DataRow
+      def initialize(hash={})
+        @hash = hash.dup.stringify_keys!
+      end
+      
+      # See if a given key is included
+      def include?(key)
+        @hash.has_key?(key)
+      end
+      
+      # Deletes a given key from the object
+      def delete(key)
+        @hash.delete(key)
+      end
+      
+      # Returns a list of available keys
+      def keys
+        @hash.keys
+      end
+      
+      # Outputs an hash
+      # This is used to write into the no sql database
+      def to_hash
+        @hash
+      end
+      
+      # Used to manually read an attribute
+      def read_attribute(key)
+        @hash[key.to_s]
+      end
+      # Used to manually write an attribute
+      def write_attribute(key, value)
+        @hash[key.to_s] = value
+      end
+      
+      # Passes Inspect onto the internal hash
+      def inspect
+        @hash.inspect
+      end
+      
+      # Updated respond_to to return true if it's a key the hash
+      def respond_to?(method)
+        return true if @hash.has_key?(method.gsub('=', ''))
+        super(method)
+      end
+      
+      # Added the ability to read and write attributes in the hash
+      def method_missing(meth, *args, &blk)
+        match = meth.to_s.match(/^([a-zA-Z\_]+)(=|$)$/)
+        if match
+          attribute, setter = match[1], !match[2].blank?
+          if setter
+            write_attribute(attribute, args.first)
+          else
+            read_attribute(attribute)
+          end
+        else
+          super(meth, *args, &blk)
+        end
+      end
+      
+    end
+  end
+end

data/lib/mongify/database/no_sql_connection.rb

@@ -2,10 +2,28 @@ require 'mongo'
 module Mongify
   module Database
     #
-    # No sql connection configuration
+    # No Sql Connection configuration
+    # 
+    # Basic format should look something like this:
+    # 
+    #   no_sql_connection do
+    #     adapter   "mongodb"
+    #     host      "localhost"
+    #     database  "my_database"
+    #   end
+    # 
+    # Possible attributes:
+    #   adapter
+    #   host
+    #   database
+    #   username
+    #   password
+    #   port
     #
     class NoSqlConnection < Mongify::Database::BaseConnection
       include Mongo
+      
+      #Required fields for a no sql connection
       REQUIRED_FIELDS = %w{host database}  
       
       def initialize(options=nil)
@@ -13,57 +31,77 @@ module Mongify
         adapter 'mongodb' if adapter.nil? || adapter == 'mongo'
       end
       
+      # Sets and/or returns a adapter
+      # It takes care of renaming adapter('mongo') to 'mongodb'
+      def adapter(name=nil)
+        name = 'mongodb' if name && name.to_s.downcase == 'mongo'
+        super(name)
+      end
+      
+      # Returns a connection string that can be used to build a Mongo Connection
+      # (Currently this isn't used due to some issue early on in development)
       def connection_string
         "#{@adapter}://#{@host}#{":#{@port}" if @port}"
       end
       
+      # Returns true or false depending if the given attributes are present and valid to make up a 
+      # connection to a mongo server
       def valid?
-        @database.present? && @host.present?
+        super && @database.present?
       end
       
+      # Sets up a connection to the database
+      def setup_connection_adapter
+        connection = Connection.new(host, port)
+        connection.add_auth(database, username, password) if username && password
+        connection
+      end
+      
+      # Returns a mongo connection
       def connection
-        return @connection if @connection
-        @connection = Connection.new(host, port)
-        @connection.add_auth(database, username, password) if username && password
-        @connection
+        @connection ||= setup_connection_adapter
       end
       
+      # Returns true or false depending if we have a connection to a mongo server
       def has_connection?
         connection.connected?
       end
       
+      # Returns the database from the connection
       def db
         @db ||= connection[database]
       end
       
+      # Returns a hash of all the rows from the database of a given collection
       def select_rows(collection)
         db[collection].find
       end
       
+      # Inserts into the collection a given row
       def insert_into(colleciton_name, row)
         db[colleciton_name].insert(row, :safe => true)
       end
       
+      # Updates a collection item with a given ID with the given attributes
       def update(colleciton_name, id, attributes)
         db[colleciton_name].update({"_id" => id}, attributes)
       end
       
+      # Finds one item from a collection with the given query
       def find_one(collection_name, query)
         db[collection_name].find_one(query)
       end
       
+      # Returns a row of a item from a given collection with a given pre_mongified_id
       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
       
+      # Removes pre_mongified_id from all records in a given collection
       def remove_pre_mongified_ids(collection_name)
         db[collection_name].update({}, { '$unset' => { 'pre_mongified_id' => 1} }, :multi => true)
       end
       
-      def reset!
-        @connection = nil
-        @db = nil
-      end
     end
   end
 end