mongify 0.0.4

data/lib/mongify/version.rb

@@ -0,0 +1,3 @@
+module Mongify
+  VERSION = "0.0.4"
+end

data/mongify.gemspec

@@ -0,0 +1,42 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "mongify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongify"
+  s.version     = Mongify::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Kalek"]
+  s.email       = ["andrew.kalek@anlek.com"]
+  s.homepage    = "http://github.com/anlek/mongify"
+  s.summary     = %q{Translate your SQL data to MongoDB}
+  s.description = %q{Mongify allows you to map your data from a sql database and into a mongodb document database.}
+
+  s.default_executable = "mongify"
+
+  s.add_dependency('activerecord', ">= 2.3.10")
+  s.add_dependency('activesupport', ">= 2.3.10")
+  s.add_dependency('mongo', ">= 1.1.5")
+  s.add_dependency('bson_ext', ">= 1.1.5")
+  s.add_dependency('net-ssh', ">= 2.0")
+
+  s.add_development_dependency('rspec', '>= 2.0')
+  s.add_development_dependency('rcov', '>= 0.9.9')
+  s.add_development_dependency('cucumber', '>= 0.10')
+  s.add_development_dependency('mocha', '>= 0.9.8')
+  s.add_development_dependency('yard', '>= 0.5.3')
+  s.add_development_dependency('watchr', '>= 0.6')
+  s.add_development_dependency('sqlite3-ruby', '>= 1.3')
+  s.add_development_dependency('mysql', '>= 2.8.1')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.extra_rdoc_files = [
+    "CHANGELOG.rdoc",
+    "README.rdoc"
+  ]
+  s.rdoc_options = ["--title", "Mongify -- SQL db to Mongo db converter", "--main", "README", "--line-numbers", "--inline-source"]
+end

data/spec/default.watch

@@ -0,0 +1,199 @@
+# Run me with:
+#
+#   $ watchr specs.watchr
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+
+
+def clear_console
+  puts "\e[H\e[2J"
+end
+
+def banner(*messages)
+  messages = messages.to_a unless messages.is_a?(Array)
+  spacing = 100
+  char = "*"
+  puts "\n",char * spacing
+  messages.each do |message|
+    puts "#{char}#{message.to_s.center(spacing-2)}#{char}"
+  end
+  puts char * spacing, "\n\n"
+end
+
+def strip_colors(message='')
+  message.gsub(/\e\[(\d+)m/, '')
+end
+
+# --------------------------------------------------
+# Rspec Methods
+# --------------------------------------------------
+
+
+def all_spec_files
+  Dir['spec/**/*_spec.rb']
+end
+
+def run_spec_matching(thing_to_match)
+  matches = all_spec_files.grep(/#{thing_to_match}/i)
+  if matches.empty?
+    puts "Sorry, but there were no matches for #{thing_to_match}."
+  else
+    run_spec matches.join(' ')
+  end
+end
+
+def run_spec(files_to_run)
+  clear_console
+  puts("Running spec(s): #{files_to_run}")
+  result = %x(bundle exec rspec -c -b #{files_to_run})
+  rspec_to_growl(result)
+  no_int_for_you
+end
+
+def run_all_specs
+  run_spec(all_spec_files.join(' '))
+end
+
+# --------------------------------------------------
+# Cuucmber Methods
+# --------------------------------------------------
+
+def run_cucumber_scenario (scenario_path='features', options={})
+  #options[:tag] ||= nil
+  run_cucumber(scenario_path, options)
+end
+
+def run_wip_scenarios
+  run_cucumber('features', :tags => "@wip")
+end
+
+def run_cucumber files_to_run, options={}
+  return puts "** Not running cucumber (#{files_to_run}) due to rspec failure **" unless rspec_passed?
+  clear_console
+  tags = (options[:tags].nil?) ? nil : "--tags #{options[:tags]}"
+  puts "Running Feature: #{files_to_run} #{ "with a #{options[:tags]} tag(s)" if tags }"
+
+  result = %x(bundle exec cucumber -c #{tags} #{files_to_run})
+  features_to_growl(result)
+  result
+end
+
+# --------------------------------------------------
+# Growl Messages
+# --------------------------------------------------
+def growl(message, title="Unknown", image="~/.watchr/failed.png", priority=0)
+  return if message.empty?
+  begin
+    message = strip_colors(message)
+    banner(title.upcase, message)
+    growlnotify = `which growlnotify`.chomp
+    options = "--name Watchr --image '#{File.expand_path(image)}' -m '#{message}' -p #{priority || 0} -t #{title}"
+    system %(#{growlnotify} #{options} &)
+  rescue Exception => e
+    puts "ERROR: #{e}"
+  end
+end
+
+def rspec_to_growl(message)
+  result = message.split("\n").find{|l| l =~ /(\d+) examples?/}
+  @status = if !result || !result.include?('0 failures')
+               image = "~/.watchr/failed.png"
+               priority = 2
+               puts message.to_s
+               rspec_failed
+               "failed"
+             elsif result.include?("pending")
+               image = "~/.watchr/pending.png"
+               priority = 1
+               puts message.to_s
+               rspec_passed
+               "pending"
+             else
+               image = "~/.watchr/passed.png"
+               priority = -2
+               rspec_passed
+               "passed"
+             end
+  begin
+    growl(result, "RSpec - #{@status}", image, priority)
+  rescue
+    banner("Failed to growl notifiy for specs")
+    puts message
+  end
+end
+
+def features_to_growl(messages)
+  begin
+    messages = messages.split("\n") unless messages.is_a? Array
+    scenario_idx = messages.rindex(messages.find{|line| line =~ /^(\d) scenario/})
+    scenario, step, timing = messages[scenario_idx..(scenario_idx + 2)]
+    if scenario.include?('failed')
+      image = "~/.watchr/failed.png"
+      priority = 2
+      puts messages.join("\n")
+    elsif scenario.include?("undefined") || scenario.include?('pending')
+      image = "~/.watchr/pending.png"
+      priority = 1
+      puts messages.join("\n") #messages[(scenario_idx+3)..-1].join("\n")
+    else
+      image = "~/.watchr/passed.png"
+      priority = -2
+    end
+    growl("#{scenario}, #{step}", "Features", image, priority) rescue banner("Failed to growl notifiy for features".upcase)
+  rescue Exception => e
+    puts "ERROR in features growl: #{e}"
+  end
+end
+
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch('^spec/(.*)_spec\.rb')                      { |m| run_spec_matching(m[1]) }
+watch('^lib/(.*)\.rb')                            { |m| run_spec_matching(m[1]); run_wip_scenarios }
+watch('^app/(models|controllers)/(.*).rb')        { |m| run_spec_matching("#{m[1]}/#{m[2]}"); run_wip_scenarios }
+watch('^app/views/([^/]*)/(.*).(haml|erb)')       { run_wip_scenarios }
+watch('^spec/spec_helper\.rb')                    { run_all_specs }
+watch('^spec/support/.*\.rb')                     { run_all_specs }
+watch('^spec/factories/.*\.rb')                   { run_all_specs }
+watch('^config/(.*)\.rb')                         { run_all_specs; run_cucumber_scenario }
+watch('^features/(.*)\.feature')                  { |m| run_cucumber_scenario(m[0], :tags => "@wip") }
+watch('^features/(.*)\.rb')                       { run_wip_scenarios }
+
+
+# --------------------------------------------------
+#  Fail logging
+# --------------------------------------------------
+def rspec_failed
+  @rspec_failed = true
+end
+def rspec_passed
+  @rspec_failed = false
+end
+def rspec_passed?
+  !@rspec_failed
+end
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+
+def no_int_for_you
+  @sent_an_int = nil
+end
+
+Signal.trap 'INT' do
+  if @sent_an_int then
+    clear_console
+    puts "   Stopped watching."
+    exit
+  else
+    puts "   Resetting tests... if you want to quit, press control-c again."
+    @sent_an_int = true
+    Kernel.sleep 1.5
+    run_all_specs
+    run_cucumber_scenario
+  end
+end

data/spec/files/base_configuration.rb

@@ -0,0 +1,9 @@
+sql_connection do
+  adapter     'sqlite3'
+  database    'spec/tmp/test.sqlite'
+end
+
+mongodb_connection do
+  host          '127.0.0.1'
+  database      'mongify_test'
+end

data/spec/files/simple_translation.rb

@@ -0,0 +1,26 @@
+table "users" do
+	column "id", :key
+	column "first_name", :string
+	column "last_name", :string
+	column "created_at", :datetime
+	column "updated_at", :datetime
+end
+
+table "posts" do
+	column "id", :key
+	column "title", :string
+	column "owner_id", :integer, :references => :users
+	column "body", :text
+	column "published_at", :datetime
+	column "created_at", :datetime
+	column "updated_at", :datetime
+end
+
+table "comments", :embed_in => :posts, :on => :post_id do
+	column "id", :key
+	column "body", :text
+	column "post_id", :integer, :referneces => :posts
+	column "user_id", :integer, :references => :users
+	column "created_at", :datetime
+	column "updated_at", :datetime
+end

data/spec/mongify/cli/application_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Mongify::CLI::Application do
+  before(:each) do
+    @application = Mongify::CLI::Application.new()
+  end
+
+  context "execute!" do
+    it "should return a 0" do
+      @application.execute!.should == 0
+    end
+    
+    it "should return a 1 on error" do
+      @application = Mongify::CLI::Application.new(["door"])
+      @application.execute!.should == 1
+    end
+  end
+
+end

data/spec/mongify/cli/help_command_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe Mongify::CLI::HelpCommand do
+  before :each do
+    @text = 'Piece of interesting text'
+    @cmd = Mongify::CLI::HelpCommand.new(@text)
+    @view = mock('view').as_null_object
+  end
+
+  it 'displays the correct text on the view' do
+    @view.should_receive(:output).with(@text)
+    @cmd.execute(@view)
+  end
+
+  it 'tells the view it succeeded' do
+    @view.should_receive(:report_success)
+    @cmd.execute(@view)
+  end
+end

data/spec/mongify/cli/options_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Mongify::CLI::Options do
+  before(:each) do
+    @config_file = File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'files', 'base_configuration.rb')
+  end
+  it "should run help command when passed an -h" do
+    @options = Mongify::CLI::Options.new(['-h'])
+    @options.parse
+    @options.instance_variable_get(:@command_class).should == Mongify::CLI::HelpCommand
+  end
+  
+  it "should run version command when passed an -h" do
+    @options = Mongify::CLI::Options.new(['-v'])
+    @options.parse
+    @options.instance_variable_get(:@command_class).should == Mongify::CLI::VersionCommand  
+  end
+  
+  context "action" do
+    it "should get action command" do
+      @options = Mongify::CLI::Options.new(['check'])
+      @options.send(:action).should == 'check'
+    end
+    
+    it "should return blank if no action is sent" do
+      @options = Mongify::CLI::Options.new(['-v'])
+      @options.send(:action).should == ''
+    end
+  end
+  
+  context "translation" do
+    it "should return path" do
+      @options = Mongify::CLI::Options.new(['check', '-c', 'some/config', 'some/folder/translation'])
+      @options.send(:translation_file).should == 'some/folder/translation'
+    end
+    
+    it "should return nil if no path specified" do
+      @options = Mongify::CLI::Options.new(['check', '-c', 'some/config'])
+      @options.send(:translation_file).should be_nil
+    end
+  end
+  
+  
+  context "Configuration file" do
+    it "should take option (-c) with a file" do
+      @options = Mongify::CLI::Options.new(['-c', @config_file])
+      @options.parse
+      @options.instance_variable_get(:@config_file).should == @config_file
+    end
+  
+    it "should be require" do
+      @options = Mongify::CLI::Options.new(["database_translation.rb"])
+      lambda {@options.parse}.should raise_error(Mongify::ConfigurationFileNotFound)
+    end
+    
+    it "should call Configuration.parse" do
+      Mongify::Configuration.should_receive(:parse)
+      @options = Mongify::CLI::Options.new(['-c', @config_file])
+      @options.parse
+    end
+  end
+end

data/spec/mongify/cli/version_command_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Mongify::CLI::VersionCommand do
+  before :each do
+    @text = 'Piece of interesting text'
+    @cmd = Mongify::CLI::VersionCommand.new(@text)
+    @view = mock('view').as_null_object
+  end
+
+  it 'displays the text on the view' do
+    @view.expects(:output).with(/#{@text}/)
+    @cmd.execute(@view)
+  end
+
+  it 'displays the Reek version on the view' do
+    @view.should_receive(:output).with(/#{Mongify::VERSION}/)
+    @cmd.execute(@view)
+  end
+
+  it 'tells the view it succeeded' do
+    @view.should_receive(:report_success)
+    @cmd.execute(@view)
+  end
+end

data/spec/mongify/cli/worker_command_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Mongify::CLI::WorkerCommand do
+  before(:each) do
+    @config = Mongify::Configuration.new()
+    @sql_connection = Mongify::Database::SqlConnection.new()
+    @sql_connection.stub(:valid?).and_return(true)
+    @sql_connection.stub(:has_connection?).and_return(true)
+    @config.stub(:sql_connection).and_return(@sql_connection)
+    @no_sql_connection = Mongify::Database::NoSqlConnection.new
+    @no_sql_connection.stub(:valid?).and_return(true)
+    @no_sql_connection.stub(:has_connection?).and_return(true)
+    @config.stub(:no_sql_connection).and_return(@no_sql_connection)
+    
+    @translation_file = 'spec/files/simple_translation.rb'
+    
+    Mongify::Translation.stub(:load).and_return(stub(:print => 'worked'))
+    @view = mock('view').as_null_object
+  end
+  
+  context "list_commands" do
+    it "should return same number as available" do
+      Mongify::CLI::WorkerCommand.list_commands.size.should == Mongify::CLI::WorkerCommand::AVAILABLE_COMMANDS.size
+    end
+  end
+  
+  context "check command" do
+    before(:each) do
+      @command = Mongify::CLI::WorkerCommand.new('check', @config)
+      @command.stub(:check_sql_connection).and_return(true)
+      @command.stub(:check_nosql_connection).and_return(true)
+    end
+    it "should ensure sql_connection is correct" do
+      @command.should_receive(:check_sql_connection).and_return(true)
+      @command.execute(@view)
+    end
+    it "should ensure noSql connection is correct" do
+      @command.should_receive(:check_nosql_connection).and_return(true)
+      @command.execute(@view)
+    end
+    it "should require config file" do
+      lambda { @command = Mongify::CLI::WorkerCommand.new('check').execute(@view) }.should raise_error(Mongify::ConfigurationFileNotFound)
+    end
+  end
+  
+  context "non-existing command" do
+     before(:each) do
+      @command = Mongify::CLI::WorkerCommand.new('unknown')
+    end
+    
+    it "should report error" do
+      @view.should_receive(:report_error)
+      @command.execute(@view)
+    end
+    
+    it "should output an error" do
+      @view.should_receive(:output).with("Unknown action unknown\n\n")
+      @command.execute(@view)
+    end
+  end
+
+  context "translate command" do
+    before(:each) do
+      @command = Mongify::CLI::WorkerCommand.new('translate', @config)
+      Mongify::Translation.stub(:load).with(@sql_connection).and_return(stub(:print => 'worked'))
+    end
+    
+    it "should require configuration file" do
+      lambda { Mongify::CLI::WorkerCommand.new('translate').execute(@view) }.should raise_error(Mongify::ConfigurationFileNotFound)
+    end
+    
+    it "should check sql connection" do
+      @command.should_receive(:check_sql_connection).and_return(true)
+      @command.execute(@view)
+    end
+    
+    it "should call load on Translation" do
+      Mongify::Translation.should_receive(:load).with(@sql_connection).and_return(stub(:print => 'worked'))
+      @command.execute(@view)
+    end
+  end
+  
+  context "process command" do
+    before(:each) do
+      @command = Mongify::CLI::WorkerCommand.new('process', @config, 'spec/files/simple_translation.rb')
+      Mongify::Translation.stub(:parse).and_return(mock(:process => true))
+    end
+    it "should report success" do
+      @view.should_receive(:report_error).never
+      @view.should_receive(:report_success)
+      @command.execute(@view)
+    end
+    
+    it "should require config file" do
+      lambda { @command = Mongify::CLI::WorkerCommand.new('process').execute(@view) }.should raise_error(Mongify::ConfigurationFileNotFound)
+    end
+    
+    it "should require transaction file" do
+      lambda { @command = Mongify::CLI::WorkerCommand.new('process', @config).execute(@view) }.should raise_error(Mongify::TranslationFileNotFound)
+    end
+    
+    it "should check_connection" do
+      @command.should_receive(:check_connections).and_return(true)
+      @command.execute(@view)
+    end
+    
+    it "should call process on translation" do
+      puts @config.no_sql_connection.inspect
+      Mongify::Translation.should_receive(:parse).and_return(mock(:process => true))
+      @command.execute(@view)
+    end
+    
+    
+  end
+end