mongify-mongoid 1.0.0

data/lib/mongify/mongoid/exceptions.rb

@@ -0,0 +1,30 @@
+module Mongify
+  module Mongoid
+    # Base Mongify Error
+    class Error < RuntimeError; end
+
+    # Not Implemented Error from Mongify
+    class NotImplementedError < Error; end
+    
+    # Would overwrite existing file
+    class OverwritingFolder < Error; end
+
+    # File Not Found Exception
+    class FileNotFound < Error; end
+
+    # Raised when Translation file is missing
+    class TranslationFileNotFound < FileNotFound; end
+    
+    # Raised when an invalid relation is created
+    class InvalidRelation < Error; end
+
+    # Raised when an invalid field is created
+    class InvalidField < Error; end
+    
+    # Raised when application has no root folder set
+    class RootMissing < Error; end
+    
+    # Raised when an invalid option is passed via CLI
+    class InvalidOption < Error; end
+  end
+end

data/lib/mongify/mongoid/generator.rb

@@ -0,0 +1,117 @@
+module Mongify
+  module Mongoid
+    #
+    # Generator - Processes translation file and generates output based on models
+    #
+    class Generator
+      attr_reader :models
+      def initialize(translation_file, output_dir)
+        @translation_file = translation_file
+        @output_dir = output_dir
+        @models = {}
+      end
+
+      # Process translation file and generate output files
+      # @return [nil]
+      def process
+        unless File.exists?(@translation_file)
+          raise Mongify::Mongoid::TranslationFileNotFound, "Unable to find Translation File at #{@translation_file}"
+        end
+
+        generate_models
+        process_fields
+        generate_embedded_relations
+        write_models_to_file
+        nil
+      end
+
+      # Generate models based on traslation tables
+      # @return [Array] List of tables that models were generated from
+      def generate_models
+        (translation.tables + translation.polymorphic_tables).each do |table|
+          build_model(table)
+        end
+      end
+
+      # Goes through all the models and adds fields based on columns in the given table
+      # @return [Array] List of models that fields were added to
+      def process_fields
+        models.each do |key, model|
+          table = translation.find(model.table_name)
+          model = generate_fields_for model, table if table
+        end
+      end
+
+      # Goes through embedded relationships
+      # @return [Array] List of tables that were used to extra embedded relations
+      def generate_embedded_relations
+        translation.embed_tables.each do |table|
+          extract_embedded_relations(table)
+        end
+      end
+
+      # Writes models to files
+      # @return [Printer] Printer class used to write output
+      def write_models_to_file
+        Printer.new(models, @output_dir).tap do |p|
+          p.write
+        end
+      end
+
+      # Returns model based on table name
+      # @param [String] name Name of table
+      # @return [Model, nil] Found model or nil
+      def find_model(name)
+        @models[name.to_s.downcase.to_sym]
+      end
+
+      # Returns Mongify translation class for given translation file
+      # @return [Mongify::Translation] Translation file
+      def translation
+        @translation ||= Mongify::Translation.parse(@translation_file)
+      end
+
+      #######
+      private
+      #######
+      
+      # Generates fields for given model and it's table
+      # @param [Model] model
+      # @param [Mongify::Database::Table] table
+      # @return [Array] List of columns from the table
+      def generate_fields_for(model, table)
+        table.columns.each do |column|
+          if column.options['references'] && parent_model = find_model(column.options['references'])
+            model.add_relation(Model::Relation::BELONGS_TO, parent_model.class_name.downcase)
+            #TODO: Look into if there is there a way to figure out a has_one relationship?
+            parent_model.add_relation(Model::Relation::HAS_MANY, model.table_name)
+          else
+            model.add_field(column.name, column.type.to_s.classify, column.options)
+          end
+        end
+      end
+
+      # Extracts embedded relationships for given table
+      # @param [Mongify::Database::Table] table
+      # @return [Model] Model for the given table
+      def extract_embedded_relations(table)
+        model = find_model(table.name)
+        parent_model = find_model(table.embed_in)
+
+        model.add_relation(Model::Relation::EMBEDDED_IN, table.embed_in)
+        parent_model.add_relation((table.embedded_as_object? ? Model::Relation::EMBEDS_ONE : Model::Relation::EMBEDS_MANY), model.table_name)
+        model
+      end
+
+      # Returns build model based on a table
+      # @param [Mongify::Database::Table] table
+      def build_model(table)
+        model = Mongify::Mongoid::Model.new(class_name: table.name.classify, table_name: table.name)
+        model.polymorphic_as = table.polymorphic_as if table.polymorphic?
+        #TODO: Might need to check that model doesn't already exist in @models
+        @models[table.name.downcase.to_sym] = model
+        model
+      end
+    end
+  end
+end

data/lib/mongify/mongoid/model.rb

@@ -0,0 +1,137 @@
+require "mongify/mongoid/model/field"
+require "mongify/mongoid/model/relation"
+
+module Mongify
+  module Mongoid
+    #
+    # Class that will be used to define a mongoid model
+    # 
+    class Model
+      #default created at field name
+      CREATED_AT_FIELD = 'created_at'
+      #default update at field name
+      UPDATED_AT_FIELD = 'updated_at'
+
+      #List of fields to exclude from the model
+      EXCLUDED_FIELDS = [
+        'id',
+        CREATED_AT_FIELD,
+        UPDATED_AT_FIELD
+      ]
+      attr_accessor :class_name, :table_name, :fields, :relations, :polymorphic_as
+
+      #Returns true if it has any timestamps
+      def has_timestamps?
+        has_created_at_timestamp? || has_updated_at_timestamp?
+      end
+
+      #Returns true both timestamps are present (created_at and updated_at)
+      def has_both_timestamps?
+        has_created_at_timestamp? && has_updated_at_timestamp?
+      end
+
+      #Returns true created_at timestamp exists
+      def has_created_at_timestamp?
+        !!@created_at
+      end
+
+      #Returns true updated_at timestamp exists
+      def has_updated_at_timestamp?
+        !!@updated_at
+      end
+
+      #Returns true it is a polymorphic model
+      def polymorphic?
+        !!@polymorphic_as
+      end
+
+      def initialize(options = {})
+        @class_name = options[:class_name].to_s
+        @table_name = options[:table_name].to_s
+        self.polymorphic_as = options[:polymorphic_as]
+
+        @fields = {}
+        @relations = []
+      end
+      alias :name :class_name
+
+      # Adds a field definition to the class, 
+      # e.g: 
+      #   add_field("field_name", "String", {rename_to: "name"})
+      def add_field(name, type, options={})
+        options.stringify_keys!
+        return if options['ignore'] || options['references'] || polymorphic_field?(name)
+        check_for_timestamp(name)
+        return if EXCLUDED_FIELDS.include?(name.to_s.downcase)
+        name = options['rename_to'] if options['rename_to'].present?
+        begin
+          @fields[name.to_sym] = Field.new(name, type, options)  
+        rescue InvalidField => e
+          raise InvalidField, "Unkown field type #{type} for #{name} in #{class_name}"
+        end      
+      end
+
+      # Adds a relationship definition to the class, 
+      # e.g: 
+      #   add_relation("embedded_in", "users")
+      #   
+      # @note Embedded relations will overpower related relations
+      # @return [Relation] New generated relation
+      def add_relation(relation_name, association, options={})
+        if existing = find_relation_by(association)
+          if relation_name =~ /^embed/
+            delete_relation_for association
+          else
+            return
+          end
+        end
+        Relation.new(relation_name.to_s, association, options).tap do |r|
+          @relations << r
+        end
+      end
+
+      # Returns binding for ERB template
+      # @return [Binding]
+      def get_binding
+        return binding()
+      end
+
+      # Returns an improved inspection output including fields and relations
+      # @return [String] String representation of the model
+      def to_s
+        "#<Mongify::Mongoid::Model::#{name} fields=#{@fields.keys} relations=#{@relations.map{|r| "#{r.name} :#{r.association}"}}>"
+      end
+
+      #######
+      private
+      #######
+      
+      # Checks if given field name is a known timestamp field
+      # @return [nil]
+      def check_for_timestamp name
+        @created_at = true if name == CREATED_AT_FIELD
+        @updated_at = true if name == UPDATED_AT_FIELD
+        nil
+      end
+
+      # Returns true if given field name follows polymorphic rules
+      # @return [Boolean]
+      def polymorphic_field? name
+        return unless polymorphic?
+        name == "#{polymorphic_as}_type" || name == "#{polymorphic_as}_id"
+      end
+
+      # Finds a relation by association
+      # @return [Relation, nil] The found relation or nil
+      def find_relation_by association
+        @relations.find{|r| r.association == association || r.association == association.singularize}
+      end
+
+      # Deletes given relations based on association name
+      # @return [nil]
+      def delete_relation_for association
+        @relations.reject!{ |r| r.association == association || r.association == association.singularize}
+      end
+    end
+  end
+end

data/lib/mongify/mongoid/model/field.rb

@@ -0,0 +1,79 @@
+module Mongify
+  module Mongoid
+    class Model
+      #
+      # Field for a Mongoid Model
+      #
+      class Field
+        #List of accepted types
+        ACCEPTED_TYPES = [
+          "Array",
+          "BigDecimal",
+          "Boolean",
+          "Date",
+          "DateTime",
+          "Float",
+          "Hash",
+          "Integer",
+          "Moped::BSON::ObjectId",
+          "Moped::BSON::Binary",
+          "Range",
+          "Regexp",
+          "String",
+          "Symbol",
+          "Time",
+          "TimeWithZone"
+        ]
+
+        #Hash of translations for different types
+        TRANSLATION_TYPES = {
+          array: "Array",
+          bigdecimal: "BigDecimal",
+          boolean: "Boolean",
+          date: "Date",
+          datetime: "DateTime",
+          float: "Float",
+          hash: "Hash",
+          integer: "Integer",
+          objectid: "Moped::BSON::ObjectId",
+          binary: "Moped::BSON::Binary",
+          range: "Range",
+          regexp: "Regexp",
+          string: "String",
+          symbol: "Symbol",
+          time: "Time",
+          text: "String",
+          timewithzone: "TimeWithZone"
+        }
+
+        attr_accessor :name, :type, :options
+
+        def initialize(name, type, options={})
+          type = translate_type(type)
+          check_field_type(type)
+          @name = name
+          @type = type
+          @options = options
+        end
+
+        #######
+        private
+        #######
+        
+        # Tries to find a translation for a SQL type to a Mongoid Type
+        # @param [String] name Name of type
+        # @return [String] Translated field name or the same name if no translation is found
+        def translate_type(name)
+          TRANSLATION_TYPES[name.to_s.downcase.to_sym] || name
+        end
+        
+        # Raises InvalidField if field type is unknown
+        # @param [String] name Name of type
+        # @raise InvalidField if name is not an accepted type
+        def check_field_type (name)
+          raise InvalidField, "Unknown field type #{name}" unless ACCEPTED_TYPES.map(&:downcase).include? name.to_s.downcase
+        end
+      end
+    end
+  end
+end

data/lib/mongify/mongoid/model/relation.rb

@@ -0,0 +1,60 @@
+module Mongify
+  module Mongoid
+    class Model
+      #
+      # This class defines a relation for an association on a mongoid model
+      # 
+      class Relation
+        # Embeds one relation name
+        EMBEDS_ONE = "embeds_one"
+        # Embeds many relation name
+        EMBEDS_MANY = "embeds_many"
+        # Embedded in relation name
+        EMBEDDED_IN = "embedded_in"
+        # Has one relation name
+        HAS_ONE = "has_one"
+        # Has many relation name
+        HAS_MANY = "has_many"
+        # Has and belongs to many relation name
+        HAS_AND_BELONGS_TO_MANY = "has_and_belongs_to_many"
+        # Belongs to relation name
+        BELONGS_TO = "belongs_to"
+
+        # Holds a list of all allowed relations
+        VALID_RELATIONS = [
+          EMBEDS_ONE,
+          EMBEDS_MANY,
+          EMBEDDED_IN,
+          HAS_ONE,
+          HAS_MANY,
+          HAS_AND_BELONGS_TO_MANY,
+          BELONGS_TO
+        ]
+
+        # List of fields that need to be singularized
+        SINGULARIZE_RELATIONS = [
+          BELONGS_TO,
+          EMBEDDED_IN,
+          EMBEDS_ONE
+        ]
+        
+        # Valid Option key values
+        # currently not used
+        OPTION_KEYS = %w(class_name inverse_of)
+
+        attr_accessor :name, :association, :options
+
+        def initialize(name, association, options = {})
+          @name, @association, @options =  name.to_s, association.to_s, options
+          unless VALID_RELATIONS.include?(@name)
+            raise Mongify::Mongoid::InvalidRelation, "Mongoid does not support the relation #{name} for model associations"
+          end
+
+          #Singularize association if belongs_to or embedded_in
+          self.association = association.singularize if SINGULARIZE_RELATIONS.include? name 
+          
+        end
+      end
+    end
+  end
+end

data/lib/mongify/mongoid/printer.rb

@@ -0,0 +1,58 @@
+require 'erb'
+
+module Mongify
+  module Mongoid
+    #
+    # Class that writes the models to individule mongoid model files
+    # 
+    class Printer
+      #Template file location
+      TEMPLATE_FILE = File.expand_path('templates/mongoid.rb.erb', File.dirname(__FILE__))
+      attr_accessor :models, :output_directory
+      def initialize(models, output_directory)
+        @models = models
+        @output_directory = output_directory
+      end
+
+      # Writes models to given output directory
+      # @return [nil]
+      def write
+        models.each do |key, model|
+          write_file(model)
+        end
+        nil
+      end
+
+      #######
+      private
+      #######
+      
+      # Returns ERB template file
+      # @return [String] Template file content
+      def template
+        @template ||= File.read(TEMPLATE_FILE)
+      end
+      
+      # Writes given model to output file
+      # @param [Model] model Model
+      # @return [String] The written output
+      def write_file model
+        output = render_file model
+        save_file output, model.name
+        output
+      end
+
+      # Renders ERB template for given model
+      # @return [String] rendered template string
+      def render_file model
+        ERB.new(template, nil, '-').result(model.get_binding)
+      end
+
+      # Saveds text output into a file (output_directory/model_name.rb)
+      # @return [File] saved file
+      def save_file output, file_name
+        File.open(File.join(output_directory, "#{file_name.downcase}.rb"), 'w') {|f| f.write(output) }
+      end
+    end
+  end
+end