mongify 0.0.4

data/features/support/env.rb

@@ -0,0 +1,28 @@
+$:.unshift 'lib'
+
+require 'rubygems'
+require 'tempfile'
+require 'fileutils'
+require 'mongify/cli/application'
+require 'mongify'
+require 'spec/support/generate_database'
+require 'spec/support/config_reader'
+
+::CONNECTION_CONFIG = ConfigReader.new(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))) + '/spec/support/database.yml')
+::DATABASE_PRINT = File.read(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))) + '/spec/support/database_output.txt')
+
+module MongifyWorld
+  def run(cmd)
+    stderr_file = Tempfile.new('mongify-world')
+    stderr_file.close
+    @last_stdout = `#{cmd} 2> #{stderr_file.path}`
+    @last_exit_status = $?.exitstatus
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def mongify(args)
+    run("ruby -Ilib -rubygems bin/mongify #{args}")
+  end
+end
+
+World(MongifyWorld)

data/lib/mongify.rb

@@ -0,0 +1,22 @@
+#
+# Mongify's core functionality
+#
+require 'active_support/core_ext'
+
+require 'mongify/ui'
+require 'mongify/exceptions'
+require 'mongify/translation'
+require 'mongify/configuration'
+require 'mongify/database'
+
+module Mongify
+  class << self
+    def root=(value)
+      @root = value
+    end
+    def root
+      raise RootMissing, "Root not configured" if @root.nil?
+      @root
+    end
+  end
+end

data/lib/mongify/cli.rb

@@ -0,0 +1,8 @@
+require 'mongify'
+
+require 'mongify/cli/options'
+require 'mongify/cli/report'
+require 'mongify/cli/version_command'
+require 'mongify/cli/help_command'
+require 'mongify/cli/worker_command'
+require 'mongify/cli/application'

data/lib/mongify/cli/application.rb

@@ -0,0 +1,43 @@
+module Mongify
+  module CLI
+    #
+    # Represents an instance of a Mongify application.
+    # This is the entry point for all invocations of Mongify from the
+    # command line.
+    #
+    class Application
+      
+      STATUS_SUCCESS = 0
+      STATUS_ERROR   = 1
+      
+      def initialize(arguments=["--help"], stdin=$stdin, stdout=$stdout)
+        @options = Options.new(arguments)
+        @status = STATUS_SUCCESS
+        Mongify::Configuration.in_stream = stdin
+        Mongify::Configuration.out_stream = stdout
+      end
+      
+      def execute!
+        begin
+          cmd = @options.parse
+          cmd.execute(self)
+        rescue Exception => error
+          $stderr.puts "Error: #{error}"
+          report_error
+        end
+        return @status
+      end
+      
+      def output(message)
+        UI.puts(message)
+      end
+      
+      def report_success
+        @status = STATUS_SUCCESS
+      end
+      def report_error
+        @status = STATUS_ERROR
+      end
+    end
+  end
+end

data/lib/mongify/cli/help_command.rb

@@ -0,0 +1,16 @@
+module Mongify
+  module CLI
+    #
+    # A command to display usage information for this application.
+    #
+    class HelpCommand
+      def initialize(parser)
+        @parser = parser
+      end
+      def execute(view)
+        view.output(@parser.to_s)
+        view.report_success
+      end
+    end
+  end
+end

data/lib/mongify/cli/options.rb

@@ -0,0 +1,94 @@
+require 'optparse'
+module Mongify
+  module CLI
+    #
+    # Used to parse the options for an application
+    #
+    class Options
+      def initialize(argv)
+        @parsed = false
+        @argv = argv
+        @parser = OptionParser.new
+        @report_class = VerboseReport
+        #@command_class = ReekCommand
+        set_options
+        
+      end
+      
+      def banner
+        progname = @parser.program_name
+        return <<EOB
+Usage: #{progname} command [database_translation.rb] [-c database.config]
+
+Commands:
+#{Mongify::CLI::WorkerCommand.list_commands.join("\n")}
+
+Examples:
+
+#{progname} translate -c datbase.config
+#{progname} tr -c database.config
+#{progname} check -c database.config
+#{progname} process database_translation.rb -c database.config
+
+See http://github.com/anlek/mongify for more details
+
+EOB
+      end
+      
+      
+      def set_options
+        @parser.banner = banner
+        @parser.separator "Common options:"
+        @parser.on("-h", "--help", "Show this message") do
+          @command_class = HelpCommand
+        end
+        @parser.on("-v", "--version", "Show version") do
+          @command_class = VersionCommand
+        end
+        @parser.on('-c', '--config FILE', "Configuration File to use") do |file|
+          @config_file = file
+        end
+
+        @parser.separator "\nReport formatting:"
+        @parser.on("-q", "--[no-]quiet", "Suppress extra output") do |opt|
+          @report_class = opt ? QuietReport : VerboseReport
+        end
+      end
+
+      def parse
+        parse_options
+        
+        if @command_class == HelpCommand
+          HelpCommand.new(@parser)
+        elsif @command_class == VersionCommand
+          VersionCommand.new(@parser.program_name)
+        else
+          raise ConfigurationFileNotFound unless @config_file
+          #TODO: In the future, request sql_connection and nosql_connection from user input
+          config = Configuration.parse(@config_file)
+          
+          WorkerCommand.new(action, config, translation_file, @parser)
+        end
+      end
+      
+      private
+      
+      def translation_file(argv=@argv)
+        parse_options
+        return nil if argv.length < 2
+        argv[1]
+      end
+      
+      def action(argv=@argv)
+        parse_options
+        @argv.try(:[],0) || ''
+      end
+            
+      def parse_options
+        @parsed = true && @parser.parse!(@argv) unless @parsed
+      end      
+      
+      
+    end
+  end
+end

data/lib/mongify/cli/report.rb

@@ -0,0 +1,11 @@
+module Mongify
+  module CLI
+    class QuietReport
+      
+    end
+    
+    class VerboseReport
+      
+    end
+  end  
+end

data/lib/mongify/cli/version_command.rb

@@ -0,0 +1,18 @@
+require 'mongify/version'
+module Mongify
+  module CLI
+
+    #
+    # A command to report the application's current version number.
+    #
+    class VersionCommand
+      def initialize(progname)
+        @progname = progname
+      end
+      def execute(view)
+        view.output("#{@progname} #{Mongify::VERSION}\n")
+        view.report_success
+      end
+    end
+  end
+end

data/lib/mongify/cli/worker_command.rb

@@ -0,0 +1,93 @@
+module Mongify
+  module CLI
+
+    #
+    # A command to run the different commands in the application (related to Mongifying).
+    #
+    class WorkerCommand
+      attr_accessor :view
+      
+      AVAILABLE_COMMANDS = {
+                                :check => {:commands => ['check', 'ck'], :description => "Checks connection for sql and no_sql databases", :required => [:configuration_file]},
+                                :translate => {:commands => ['translate', 'tr'], :description => "Spits out translation from a sql connection", :required => [:configuration_file]},
+                                :process => {:commands => ['process', 'pr'], :description => "Takes a translation and process it to mongodb", :required => [:configuration_file, :translation_file]}
+                              }
+      def self.list_commands
+        [].tap do |commands|
+          AVAILABLE_COMMANDS.each do |key, obj|
+            commands << "#{obj[:commands].map{|w| %["#{w}"]}.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ').ljust(25)} >> #{obj[:description]}#{ " [#{obj[:required].join(', ')}]" if obj[:required]}"
+          end
+        end.sort
+      end
+                              
+      def self.find_command(command)
+        AVAILABLE_COMMANDS.each do |key, options|
+          return [key, options] if(options[:commands].include?(command.to_s.downcase))
+        end
+        'unknown'
+      end
+      
+      def initialize(command, config=nil, translation_file=nil, parser="")
+        @command = command.to_s.downcase
+        @config = config
+        @translation_file = translation_file
+        @parser = parser
+      end
+      
+      def execute(view)
+        self.view = view
+        
+        current_command, command_options = find_command
+        
+        if command_options
+          #FIXME: Should parse configuration file in this action, (when I know it's required)
+          raise ConfigurationFileNotFound, "Configuration file is required" if command_options[:required] && command_options[:required].include?(:configuration_file) && @config.nil?
+          if command_options[:required] && command_options[:required].include?(:translation_file)
+            raise TranslationFileNotFound, "Translation file is required for command '#{current_command}'" unless @translation_file
+            raise TranslationFileNotFound, "Unable to find Translation File at #{@translation_file}" unless File.exists?(@translation_file)
+            @translation = Translation.parse(@translation_file)
+          end
+        end
+        
+        case current_command
+        when :translate
+          check_connections
+          view.output(Mongify::Translation.load(@config.sql_connection).print)
+        when :check
+          view.output("SQL connection works") if check_sql_connection
+          view.output("NoSQL connection works") if check_nosql_connection
+        when :process
+          check_connections
+          @translation.process(@config.sql_connection, @config.no_sql_connection)
+        else
+          view.output("Unknown action #{@command}\n\n#{@parser}")
+          view.report_error
+          return
+        end
+        view.report_success
+      end
+      
+      def find_command(command=@command)
+        self.class.find_command(command)
+      end
+      
+      #######
+      private
+      #######
+
+      def check_connections(sql_only = false)
+        check_sql_connection && (sql_only || check_nosql_connection)
+      end
+      
+      def check_sql_connection
+        @config.sql_connection.valid? && @config.sql_connection.has_connection?
+      end
+      
+      def check_nosql_connection
+        @config.no_sql_connection.valid? && @config.no_sql_connection.has_connection?        
+      end
+      
+      
+    end
+  end
+end

data/lib/mongify/configuration.rb

@@ -0,0 +1,46 @@
+module Mongify
+  #
+  #  This extracts the configuration for sql and no sql
+  #
+  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
+      
+      def parse(file_name)
+        config = self.new
+        config.instance_eval(File.read(file_name))
+        config
+      end
+
+    end #self
+    
+    def mongodb_connection(options={}, &block)
+      options.stringify_keys!
+      options['adapter'] ||= 'mongodb'
+      no_sql_connection(options, &block)
+    end
+    
+    def sql_connection(options={}, &block)
+      @sql_connection ||= Mongify::Database::SqlConnection.new(options)
+      @sql_connection.instance_exec(&block) if block_given?
+      @sql_connection
+    end
+    
+    def no_sql_connection(options={}, &block)
+      @no_sql_connection ||= Mongify::Database::NoSqlConnection.new(options)
+      @no_sql_connection.instance_exec(&block) if block_given?
+      @no_sql_connection
+    end
+    
+  end
+end

data/lib/mongify/database.rb

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

data/lib/mongify/database/base_connection.rb

@@ -0,0 +1,78 @@
+require 'active_record'
+
+module Mongify
+  module Database
+    #
+    # Basic configuration for any sql or non sql database
+    #
+    class BaseConnection
+
+      REQUIRED_FIELDS = %w{host}
+      AVAILABLE_FIELDS = %w{adapter host username password database socket port}
+
+      def initialize(options=nil)
+        if options
+          options.stringify_keys!
+          options.each do |key, value|
+             instance_variable_set "@#{key}", value
+          end
+        end
+      end
+
+      def to_hash
+        hash = {}
+        instance_variables.each do |variable|
+          value = self.instance_variable_get variable
+          hash[variable.gsub('@','').to_sym] = value unless value.nil?
+        end
+        hash
+      end
+
+      def valid?
+        REQUIRED_FIELDS.each do |require_field|
+          return false unless instance_variables.include?("@#{require_field}") and
+                              !instance_variable_get("@#{require_field}").to_s.empty?
+        end
+        true
+      end
+
+
+      def setup_connection_adapter
+        raise NotImplementedError
+      end
+
+      def has_connection?
+        raise NotImplementedError
+      end
+
+      def adapter(value=nil)
+        @adapter = value.to_s unless value.nil?
+        @adapter
+      end
+
+
+      def respond_to?(method, *args)
+        return true if AVAILABLE_FIELDS.include?(method.to_s)
+        super(method)
+      end
+
+      def method_missing(method, *args)
+        method_name = method.to_s #.gsub("=", '')
+        if AVAILABLE_FIELDS.include?(method_name.to_s)
+          class_eval <<-EOF
+                          def #{method_name}(value=nil)
+                            @#{method_name} = value unless value.nil?
+                            @#{method_name}
+                          end
+                        EOF
+          value = args.first if args.size > 0
+          send(method,value)
+        else
+          super(method, args)
+        end
+
+      end
+
+    end
+  end
+end