mongify-mongoid 1.0.0

data/lib/mongify/mongoid/templates/mongoid.rb.erb

@@ -0,0 +1,33 @@
+class <%= class_name %>
+  include Mongoid::Document
+  <%- if has_timestamps? -%>
+  include Mongoid::Timestamps<%= "::#{has_created_at_timestamp? ? "Created" : "Updated"}" unless has_both_timestamps?-%>
+  <%- end %>
+
+  <%- fields.each do |key, field| -%>
+    <%- unless key == "id" -%>
+  field :<%= field.name %>, type: <%= field.type %>
+    <%- end -%>
+  <%- end -%>
+  
+  <%- if polymorphic? -%>
+  ### POLYMORPHIC RELATIONS ###
+  #
+  # This model is polymorphic, please uncomment one of the following options:
+  #
+  # belongs_to :<%= polymorphic_as %>, polymorphic: true
+  # embedded_in :<%= polymorphic_as %>, polymorphic: true
+  #
+  # ALSO: Make sure to add the otherside of the polymorphic relationship into your other models,
+  # below are some examples:
+  #  has_many :address, as: :<%= polymorphic_as %>
+  #  embeds_many :notes, as: :<%= polymorphic_as %>
+  #
+  ###
+
+  <%- end -%>
+  <%- relations.sort{|a,b | a.name <=> b.name}.each do |relation| -%>
+  <%= relation.name %> :<%= relation.association %>
+  <%- end -%>
+
+end

data/lib/mongify/mongoid/ui.rb

@@ -0,0 +1,64 @@
+module Mongify
+  module Mongoid
+    #
+    #  Used to output messages to the UI
+    #
+    class UI
+      class << self
+        # Outputs to stream using puts method
+        def puts(msg)
+          out_stream.puts(msg) if out_stream
+        end
+        
+        # Outputs to stream using print method
+        def print(msg)
+          out_stream.print(msg) if out_stream
+        end
+      
+        # Gets input from user
+        def gets
+          in_stream ? in_stream.gets : ''
+        end
+      
+        # Outputs a question and gets input
+        def request(msg)
+          print(msg)
+          gets.chomp
+        end
+      
+        # Asks a yes or no question and waits for reply
+        def ask(msg)
+          request("#{msg} [yn] ") == 'y'
+        end
+        
+        # Outputs a Warning (using puts command)
+        def warn(msg)
+          puts "WARNING: #{msg}"
+        end
+        
+        # Outputs a message and aborts execution of app
+        def abort(message)
+          UI.puts "PROGRAM HALT: #{message}"
+          Kernel.abort message
+        end
+        
+        # Incoming stream
+        def in_stream
+          $stdin
+        end
+        # Output stream
+        def out_stream
+          $stdout
+        end
+        
+        # Creates an instance of HighLine
+        # which lets us figure out width of console
+        # plus a whole lot more
+        # @return [HighLine] instance 
+        def terminal_helper
+          @terminal_helper ||= HighLine.new
+        end
+      end
+    end
+  end
+end

data/lib/mongify/mongoid/version.rb

@@ -0,0 +1,6 @@
+module Mongify
+  module Mongoid
+    #Version number for Mongify-Mongoid
+    VERSION = "1.0.0"
+  end
+end

data/mongify-mongoid.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongify/mongoid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongify-mongoid"
+  spec.version       = Mongify::Mongoid::VERSION
+  spec.authors       = ["Andrew Kalek", "Afolabi Badmos"]
+  spec.email         = ["andrew.kalek@anlek.com", "afolabi@badmos.com"]
+  spec.description   = %q{Generates Mongoid Models from the Mongify translation file}
+  spec.summary       = %q{Generates Mongoid Models from the Mongify translation file}
+  spec.homepage      = "https://github.com/anlek/mongify-mongoid"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = [
+    "CHANGELOG.md",
+    "README.md"
+  ]
+
+  spec.add_dependency "mongify"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet'
+end

data/spec/files/translation.rb

@@ -0,0 +1,44 @@
+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", :rename_to => 'user_id'
+  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, :references => "posts"
+  column "user_id", :integer, :references => "users"
+  column "created_at", :datetime
+  column "updated_at", :datetime
+end
+
+table "preferences", :embed_in => 'users', :as => 'object' do
+  column "id", :key
+  column "user_id", :integer, :references => "users"
+  column "notify_by_email", :boolean
+  column "created_at", :datetime, :ignore => true
+  column "updated_at", :datetime, :ignore => true
+end
+
+table "notes", :polymorphic => 'notable', :embed_in => true do
+  column "id", :key
+  column "user_id", :integer, :references => "users"
+  column "notable_id", :integer, :references => "notables"
+  column "notable_type", :string
+  column "body", :text
+  column "created_at", :datetime
+  column "updated_at", :datetime
+end

data/spec/lib/mongify/mongoid/cli/command/worker_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Mongify::Mongoid::CLI::Command::Worker do
+  let(:translation_file){ "spec/files/translation.rb" }
+  let(:output_folder) { "spec/files/tmp" }
+  subject(:worker) { Mongify::Mongoid::CLI::Command::Worker.new(translation_file) }
+  
+  before(:each) do
+    Mongify::Mongoid::Printer.any_instance.stub(:write)
+  end
+
+  let(:view) do
+    view = stub("View")
+    view.stub(:output)
+    view.stub(:report_success)
+    view
+  end
+
+  context "default output file" do
+    it "should be called path + models" do
+      FileUtils.stub(:mkdir_p)
+      Mongify::Mongoid::Generator.any_instance.stub(:process)
+      worker.output_folder.should == File.join(Dir.pwd, "models")    
+    end
+  end
+
+  context "translation file" do
+    it "raises an error if not passed" do
+      lambda { Mongify::Mongoid::CLI::Command::Worker.new().execute(view) }.should raise_error(Mongify::Mongoid::TranslationFileNotFound)
+    end
+    it "raises an error if file doesn't exist" do
+      lambda { Mongify::Mongoid::CLI::Command::Worker.new("missing/translation.rb").execute(view) }.should raise_error(Mongify::Mongoid::TranslationFileNotFound)
+    end
+  end
+  
+  context "output folder" do
+    it "raises an error if folder exist" do
+      lambda { Mongify::Mongoid::CLI::Command::Worker.new(translation_file, output_folder).execute(view) }.should raise_error(Mongify::Mongoid::OverwritingFolder)
+    end
+    it "doesn't raise error if overwrite is true" do
+      lambda { Mongify::Mongoid::CLI::Command::Worker.new(translation_file, output_folder, :overwrite => true).execute(view) }.should_not raise_error(Mongify::Mongoid::OverwritingFolder)
+    end
+  end
+  
+end

data/spec/lib/mongify/mongoid/generator_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Mongify::Mongoid::Generator do
+  context "Instance Methods" do
+    context "process" do
+
+      let(:translation_file) { "spec/files/translation.rb" }
+      let(:output_dir){File.expand_path('../../../files/tmp', File.dirname(__FILE__))}
+      subject(:generator) { Mongify::Mongoid::Generator.new(translation_file, output_dir) }
+
+      it "is successful" do
+        subject.should_receive(:generate_models)
+        subject.should_receive(:process_fields)
+        subject.should_receive(:generate_embedded_relations)
+        subject.should_receive(:write_models_to_file)
+
+        subject.process
+      end
+
+      context "file doesnt exists" do
+        subject { Mongify::Mongoid::Generator.new("/my/awesome/file.ext", output_dir) }
+
+        it "should raise FileNotFound exception" do
+          expect { subject.process }.to raise_error(Mongify::Mongoid::FileNotFound)
+        end
+      end
+
+      context "generate_models" do
+        let(:table) { stub(name: 'users', columns: [], polymorphic?: false) }
+        it "should build model" do
+          subject.models.should be_empty
+          subject.send("build_model", table)
+          subject.should have(1).model
+          model = subject.models[table.name.to_sym]
+          model.table_name.should == table.name
+        end
+      end
+      context "process_fields" do
+        let(:table) { stub(name: 'users', columns: [], ignored?: false, polymorphic?: false) }
+        before(:each) do
+          table.stub(:columns).and_return([stub(name: "first_name", type: "string", options: {}), stub(name: "last_name", type: "string", options:{})])  
+          subject.translation.stub(:all_tables).and_return([table])
+          subject.generate_models
+        end
+        it "works" do
+          subject.send(:translation).should_receive(:find).with(table.name).and_return(table)
+          subject.process_fields
+          model = subject.find_model(table.name)
+          model.should have(2).fields
+        end
+      end
+
+      context "embedded_relations" do
+        let(:table) { stub(name: 'preferences', columns: [stub(name: "Email", type:"string")], polymorphic?: false) }
+        let(:parent_model){ Mongify::Mongoid::Model.new(:table_name => "users", :class_name => "User")}
+        before(:each) do
+          table.stub(:embed_in).and_return('users')
+          table.stub(:embedded_as_object?).and_return(true)
+          subject.generate_models
+          generator.models[parent_model.table_name.to_sym] = parent_model
+          @model = subject.send("extract_embedded_relations", table)
+        end
+
+        context "model relations" do
+          it "should add embedded_in relations" do
+            @model.should have_relation(Mongify::Mongoid::Model::Relation::EMBEDDED_IN).for_association(parent_model.table_name)
+          end
+        end
+        context "parent model relations" do
+          it "should add embeds_one " do
+            parent_model.should have_relation(Mongify::Mongoid::Model::Relation::EMBEDS_ONE).for_association(@model.table_name)
+          end
+        end
+      end
+
+      context "polymorphic tables" do
+        let(:table) { stub(name: 'users', columns: [], ignored?: false, polymorphic?: false) }
+        let(:polymorphic_table){ stub(name: 'notes', columns: [], ignored?: false, polymorphic?: true, polymorphic_as: "notable") }
+        before(:each) do
+          table.stub(:columns).and_return([stub(name: "first_name", type: "string", options: {}), stub(name: "last_name", type: "string", options:{})])
+          tables = [table, polymorphic_table]
+          tables.each do |_table|
+            subject.translation.stub(:find).with(_table.name).and_return(_table)
+          end
+          
+          subject.translation.stub(:all_tables).and_return(tables)
+          subject.generate_models
+        end
+        it "should have model" do
+          model = subject.find_model(polymorphic_table.name)
+          model.should_not be_nil
+          model.should be_polymorphic
+        end
+
+        it "should not add polymorphic fields" do
+          subject.process_fields
+          model = subject.find_model(polymorphic_table.name)
+          model.should_not have_relation(:belongs_to)
+        end
+      end
+
+      context "generate_fields_for" do
+        let(:model) {generator.send(:build_model, stub(name: "users", polymorphic?: false))}
+        let(:parent_model) {generator.send(:build_model, stub(name: "accounts", polymorphic?: false))}
+        let(:table) {stub(name: "users", columns: [stub(name: "account_id", type: "id", options: {'references' => "accounts"})], polymorphic?: false)}
+        before(:each) do
+          model #generate via rspec
+          parent_model #generate via rspec
+          generator.translation.stub(:find).with(model.table_name).and_return(table)
+        end
+        it "adds correctly" do
+          generator.send(:generate_fields_for, model, table)
+          model.should have_relation(Mongify::Mongoid::Model::Relation::BELONGS_TO).for_association("account")
+          parent_model.should have_relation(Mongify::Mongoid::Model::Relation::HAS_MANY).for_association("users")
+        end
+      end
+
+      after(:all) do
+        FileUtils.rm  Dir["#{output_dir}/*.rb"]
+      end
+    end
+  end
+end

data/spec/lib/mongify/mongoid/model/field_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Mongify::Mongoid::Model::Field do
+  subject(:field){ Mongify::Mongoid::Model::Field.new("first_name", "String") }
+  context "types" do
+    context "validation" do
+      it "doesn't raise error when valid value" do
+        expect { Mongify::Mongoid::Model::Field.new("first_name", "String") }.to_not raise_error  
+      end
+      it "does raise error on invalid value" do
+        expect { Mongify::Mongoid::Model::Field.new("first_name", "Limb") }.to raise_error(Mongify::Mongoid::InvalidField)
+      end
+    end
+
+    context "translation" do
+      [:array, :bigdecimal, :boolean, :date, :datetime, :float, :hash, :integer, :objectid, :binary, :range, :regexp, :string, :symbol, :time, :timewithzone].each do |type|  
+        it "for #{type} works" do
+          field.send(:translate_type, type).should == Mongify::Mongoid::Model::Field::TRANSLATION_TYPES[type]
+        end
+      end
+      it "for Text is String" do
+        field.send(:translate_type, 'Text').should == "String"
+      end
+      it "uses original name if no translation was found" do
+        type = "Limb"
+        field.send(:translate_type, type).should == type
+      end
+    end
+    
+  end
+end

data/spec/lib/mongify/mongoid/model/relation_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Mongify::Mongoid::Model::Relation do
+  describe "VALID_RELATIONS" do
+    subject { Mongify::Mongoid::Model::Relation::VALID_RELATIONS }
+
+    it { should =~ %w(embeds_one embeds_many embedded_in has_one has_many has_and_belongs_to_many belongs_to) }
+  end
+
+  context "singularize" do
+    [Mongify::Mongoid::Model::Relation::BELONGS_TO, 
+     Mongify::Mongoid::Model::Relation::EMBEDDED_IN,
+     Mongify::Mongoid::Model::Relation::EMBEDS_ONE].each do |relation|
+      it "#{relation}" do
+        r = Mongify::Mongoid::Model::Relation.new(relation, "posts")
+        r.association.should == "post"
+      end  
+    end
+    
+  end
+
+  describe "initialize" do
+    context "invalid relation name" do
+      it "should raise InvalidRelation error" do
+        expect {
+          @relation = Mongify::Mongoid::Model::Relation.new(:brother, "user", {})
+        }.to raise_error Mongify::Mongoid::InvalidRelation
+      end
+    end
+
+    context "valid relation name" do
+      before do
+        @relation = Mongify::Mongoid::Model::Relation.new(:embeds_one, "user", {})
+      end
+
+      subject { @relation }
+      its(:name) { should == "embeds_one" }
+      its(:association) { should == "user" }
+      its(:options) { should == {} }
+    end
+  end
+end

data/spec/lib/mongify/mongoid/model_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Mongify::Mongoid::Model do
+  subject(:model) { Mongify::Mongoid::Model.new(:table_name => "users", :class_name => "User") }
+  
+  describe "initialize" do
+    its(:class_name) { should == "User" }
+    its(:table_name) { should == "users" }
+  end
+
+  describe "add_field" do
+    before(:each) { model.add_field("name", "String") }
+    it { should have_field("name").of_type("String") }
+    it "doesn't add the id column" do
+      model.add_field("id", "integer")
+      model.should_not have_field("id")
+    end
+    it "doesn't add ignored columns" do
+      model.add_field("first_name", "String", {ignore: true})
+      model.should_not have_field("first_name")
+    end
+    it "renames fields" do
+      model.add_field("sur_name", "String", {rename_to: "last_name"})
+      model.should_not have_field("sur_name")
+      model.should have_field("last_name")
+    end
+    it "doesn't add a reference columns" do
+      model.add_field("user_id", "integer", {references: 'users'})
+      model.should_not have_field("user_id")
+    end
+    it "raises error if field is unkown" do
+      expect { model.add_field("user_id", 'limb') }.to raise_error(
+                  Mongify::Mongoid::InvalidField, 
+                  "Unkown field type limb for user_id in #{model.class_name}")
+    end
+  end
+
+  it "should find relation" do
+    model.add_relation(Mongify::Mongoid::Model::Relation::BELONGS_TO, "accounts")
+    model.add_relation(Mongify::Mongoid::Model::Relation::HAS_MANY, "posts")
+    r = model.send(:find_relation_by, "accounts")
+    r.association.should == "account"
+    r.name.should == Mongify::Mongoid::Model::Relation::BELONGS_TO
+  end
+
+  it "should delete relation" do
+    model.add_relation(Mongify::Mongoid::Model::Relation::BELONGS_TO, "accounts")
+    model.add_relation(Mongify::Mongoid::Model::Relation::HAS_MANY, "posts")
+    model.send(:delete_relation_for, "accounts")
+    model.should have(1).relation
+  end
+
+  describe "Timestamps" do
+    it "doesn't at created_at field" do
+      model.add_field("created_at", "Datetime")
+      model.should have(0).fields
+    end
+    it "doesn't at updated_at field" do
+      model.add_field("updated_at", "Datetime")
+      model.should have(0).fields
+    end
+
+    it "has a created_at timestamp" do
+      model.should_not have_created_at_timestamp
+      model.add_field("created_at", "Datetime")
+      model.should have_created_at_timestamp
+    end
+
+    it "has a updated_at timestamp" do
+      model.should_not have_updated_at_timestamp
+      model.add_field("updated_at", "Datetime")
+      model.should have_updated_at_timestamp
+    end
+
+    it "has timestamps" do
+      model.should_not have_timestamps
+      model.add_field("updated_at", "Datetime")
+      model.should have_timestamps
+    end
+
+    it "has both timestamps" do
+      model.should_not have_both_timestamps
+      model.add_field("created_at", "Datetime")
+      model.add_field("updated_at", "Datetime")
+      model.should have_both_timestamps
+    end
+
+    it "doesn't add ignored timestamps" do
+      model.add_field("created_at", "Datetime", ignore: true)
+      model.should_not have_timestamps
+    end
+  end
+
+  context "polymorphic name" do
+    before(:each) do
+      model.polymorphic_as = "userable"
+    end
+    it "should match" do
+      model.send("polymorphic_field?", "userable_id").should be_true
+      model.send("polymorphic_field?", "userable_type").should be_true
+    end
+    it "doesn't match" do
+      model.send("polymorphic_field?", "user_name").should be_false
+      model.send("polymorphic_field?", "userable_other").should be_false
+    end
+
+  end
+
+  describe "add_relation" do
+    let(:associated) { "preferences" }
+    Mongify::Mongoid::Model::Relation::VALID_RELATIONS.each do |relation|
+      context relation do
+        before { model.add_relation(relation, associated) }
+        it { should have_relation(relation).for_association(associated) }
+      end
+    end
+
+    context "embedded relations overpower relational relations" do
+      let(:association){"comments"}
+      it "works" do
+        model.add_relation(Mongify::Mongoid::Model::Relation::HAS_MANY, association)
+        model.add_relation(Mongify::Mongoid::Model::Relation::EMBEDS_MANY, association)
+        model.relations.should have(1).relation
+        relation = model.relations.first
+        relation.name.should == Mongify::Mongoid::Model::Relation::EMBEDS_MANY
+        relation.association = association
+      end
+
+      it "works with belongs_to as well" do
+        model.add_relation(Mongify::Mongoid::Model::Relation::BELONGS_TO, association.singularize)
+        model.add_relation(Mongify::Mongoid::Model::Relation::EMBEDDED_IN, association)
+        model.relations.should have(1).relation
+        relation = model.relations.first
+        relation.name.should == Mongify::Mongoid::Model::Relation::EMBEDDED_IN
+        relation.association = association
+      end
+
+      it "doesn't delete embedded" do
+        model.add_relation(Mongify::Mongoid::Model::Relation::EMBEDS_MANY, association)
+        model.add_relation(Mongify::Mongoid::Model::Relation::HAS_MANY, association)
+        model.relations.should have(1).relation
+      end
+      
+    end
+  end
+end