rare_map 2.1.1 → 2.2.0

data/lib/rare_map/options.rb

@@ -0,0 +1,78 @@
+require 'active_support/core_ext/hash'
+
+module RareMap
+  # RareMap::Options defines all available options of RareMap.
+  # @author Wei-Ming Wu
+  # @!attribute [r] opts
+  #   @return [Hash] the details of options
+  class Options
+    # A default group name
+    DEFAULT_GROUP = 'default'
+    attr_reader :opts
+    
+    # Creates a Options.
+    #
+    # @param raw_opts [Hash] the details of options
+    # @return [Options] a Options object
+    def initialize(raw_opts = {})
+      raw_opts ||= {}
+      raw_opts = raw_opts.with_indifferent_access
+      @opts = { group: DEFAULT_GROUP,
+                primary_key: {},
+                foreign_key: { suffix: nil, alias: {} } }.with_indifferent_access
+                
+      if raw_opts.kind_of? Hash
+        if raw_opts[:group]
+          @opts[:group] = raw_opts[:group]
+        end
+        if raw_opts[:primary_key].kind_of? Hash
+          @opts[:primary_key] = raw_opts[:primary_key].select { |k, v| k.kind_of? String and v.kind_of? String }
+        end
+        if raw_opts[:foreign_key].kind_of? Hash and raw_opts[:foreign_key][:suffix].kind_of? String
+           @opts[:foreign_key][:suffix] = raw_opts[:foreign_key][:suffix]
+        end
+        if raw_opts[:foreign_key].kind_of? Hash and raw_opts[:foreign_key][:alias].kind_of? Hash
+           @opts[:foreign_key][:alias] = raw_opts[:foreign_key][:alias].select { |k, v| k.kind_of? String and v.kind_of? String }
+        end
+        if raw_opts[:group].kind_of? String
+          @opts[:group] = raw_opts[:group]
+        end
+      end
+    end
+    
+    # Checks if this Options belongs to a group.
+    #
+    # @return [true, false] true if this Options contains a group, false otherwise
+    def group?
+      @opts[:group] != DEFAULT_GROUP
+    end
+    
+    # Returns the name of this Options' group
+    #
+    # @return [String] the name of this Options' group
+    def group
+      @opts[:group] || DEFAULT_GROUP
+    end
+    
+    # Returns the primary key of a table specified by this Options
+    #
+    # @return [String, nil] the primary key of a table specified by this Options
+    def find_primary_key_by_table(table_name)
+      @opts[:primary_key].values_at(table_name).first
+    end
+    
+    # Returns the table of a foreign key specified by this Options
+    #
+    # @return [String, nil] the table of a foreign key specified by this Options
+    def find_table_by_foreign_key(column_name)
+      @opts[:foreign_key][:alias].values_at(column_name).first
+    end
+    
+    # Returns the suffix of a foreign key should have
+    #
+    # @return [String, nil] the suffix of a foreign key should have
+    def fk_suffix
+      @opts[:foreign_key][:suffix]
+    end
+  end
+end

data/lib/rare_map/rails_locator.rb

@@ -1,19 +1,27 @@
 module RareMap
+  # RareMap::RailsLocator locates the root of a rails application from any
+  # where inside it.
+  # @author Wei-Ming Wu
   module RailsLocator
-   def locate_rails_root(depth = 5)
-      rails_dirs = ['app', 'config', 'db', 'lib', 'log', 'public']
+   # Finds the root of a rails application.
+   #
+   # @param [String] path the location where start to search
+   # @param [Integer] depth the max levels of folders to search
+   # @return [String, nil] the root of a rails application
+   def locate_rails_root(path = '.', depth = 5)
+      rails_dirs = %w(app config db lib log public)
       
       depth.times do |level|
         found = true
-        path = ''
+        paths = [path]
         
-        level.times { path << '../' }
+        level.times { paths << '..' }
         
         rails_dirs.each do |dir|
-          found = false unless Dir.exist?(path + dir)
+          found = false unless Dir.exist? File.join(*(paths + [dir]))
         end
         
-        return path if found
+        return File.absolute_path(File.join(*paths)) if found
       end
       
       nil

data/lib/rare_map/relation.rb

@@ -0,0 +1,41 @@
+require 'rare_map/errors'
+
+module RareMap
+  # RareMap::Relation defines one of has_one, has_many and has_many_through
+  # relations of a database table.
+  # @author Wei-Ming Wu
+  # @!attribute [r] type
+  #   @return [Symbol] the type of relation, `:has_one` or `:has_many` or `:has_many_through`
+  # @!attribute [r] foreign_key
+  #   @return [String] the foreign key of this Relation based on
+  # @!attribute [r] table
+  #   @return [String] the table of this Relation refers to
+  # @!attribute [r] through
+  #   @return [String, nil] the table of this Relation goes through
+  class Relation
+    # The :has_one association.
+    HAS_ONE = :has_one
+    # The :belongs_to association.
+    BELONGS_TO = :belongs_to
+    # The :has_many association.
+    HAS_MANY = :has_many
+    # The :has_many_through association.
+    HAS_MANY_THROUGH = :has_many_through
+    # All three kinds of relations
+    RELATIONS = [HAS_ONE, BELONGS_TO, HAS_MANY, HAS_MANY_THROUGH]
+    include Errors
+    attr_reader :type, :foreign_key, :table, :through
+    
+    # Creates a Relation.
+    #
+    # @param type [Symbol] the type, `:has_one` or `:has_many` or `:has_many_through`
+    # @param foreign_key [String] the foreign key of this Relation based on
+    # @param table [String] the table of this Relation refers to
+    # @param through [String, nil] the table of this Relation goes through
+    # @return [Relation] the Relation object
+    def initialize(type, foreign_key, table, through = nil)
+      raise RelationNotDefinedError, 'Relation type not defined.' unless RELATIONS.include? type
+      @type, @foreign_key, @table, @through = type, foreign_key, table, through
+    end
+  end
+end

data/lib/rare_map/schema_parser.rb

@@ -1,7 +1,13 @@
-require 'active_support/inflector'
+require 'rare_map/table'
+require 'rare_map/column'
 
 module RareMap
+  # RareMap::SchemaParser parses schema.rb into Table.
+  # @author Wei-Ming Wu
   module SchemaParser
+    # Parses schema.rb into an Array of Table.
+    #
+    # @return [Array] an Array of Table
     def parse_schema(schema)
       tables = []
       
@@ -27,74 +33,4 @@ module RareMap
       tables
     end
   end
-  
-  class Table
-    attr_reader :name, :id, :columns
-    attr_writer :primary_key
-    attr_accessor :fk_suffix
-    
-    def initialize(name, opts = { :id => true, :primary_key => nil })
-      @name = name
-      @id = opts[:id]
-      @primary_key = opts[:primary_key]
-      @columns = []
-      @fk_suffix = 'id'
-    end
-    
-    def primary_key
-      return @primary_key if @primary_key
-      return 'id' if @id
-      
-      candidates = @columns.find_all { |col| col.unique }.map { |col| col.name }
-      # return @primary_key if candidates.include? @primary_key
-      return 'id' if candidates.include? 'id'
-      candidates.find { |c| c =~ eval("/^#{@name}.*id$/") } ||
-      candidates.find { |c| c =~ eval("/^#{singularize}.*id$/") } ||
-      candidates.find { |c| c =~ eval("/^#{pluralize}.*id$/") } ||
-      candidates.first
-    end
-    
-    def singularize
-      @name.pluralize.singularize
-    end
-    
-    def pluralize
-      @name.pluralize
-    end
-    
-    def match_foreign_key(column)
-      if column.references == @name || foreign_keys.include?(column.name)
-        @name if primary_key
-      end
-    end
-    
-    def match_foreign_key_by_primary_key(pk)
-      @name if foreign_keys.include?(pk) && primary_key
-    end
-    
-    private
-    def foreign_keys
-      ["#{@name}_#{fk_suffix}",      "#{@name}#{fk_suffix}",      "#{singularize}_#{fk_suffix}",
-       "#{singularize}#{fk_suffix}", "#{pluralize}_#{fk_suffix}", "#{pluralize}#{fk_suffix}"]
-    end
-  end
-  
-  class Column
-    attr_reader :name, :type
-    attr_accessor :unique, :references
-    
-    def initialize(name, type)
-      @name = name
-      @type = type
-      @unique = false
-    end
-    
-    def unique?
-      @unique
-    end
-    
-    def foreign_key?
-      @references ? true : false
-    end
-  end
 end

data/lib/rare_map/schema_reader.rb

@@ -2,7 +2,12 @@ require 'active_record'
 require 'activerecord-jdbc-adapter' if RUBY_PLATFORM == 'java'
 
 module RareMap
+  # RareMap::SchemaReader dumps database schema by using ActiveRecord::SchemaDumper.
+  # @author Wei-Ming Wu
   module SchemaReader
+    # Returns the content of schema.rb which is created by ActiveRecord::SchemaDumper.
+    #
+    # @return [String] the content of schema.rb which is created by ActiveRecord::SchemaDumper
     def read_schema(db_profile)
       conn = db_profile.connection.map { |k, v| v.kind_of?(Integer) ? "'#{k}'=>#{v}" : "'#{k}'=>'#{v}'" }.join(', ')
       schema = if RUBY_PLATFORM == 'java'
@@ -21,6 +26,8 @@ module RareMap
 =end
     end
     
+    private
+    
     def detect_errors(schema)
       if $? != 0
         puts schema

data/lib/rare_map/table.rb

@@ -0,0 +1,89 @@
+require 'active_support/inflector'
+
+module RareMap
+  # RareMap::Table defines a table of a database.
+  # @author Wei-Ming Wu
+  # @!attribute [r] name
+  #   @return [String] the name of this Table
+  # @!attribute [r] id 
+  #   @return [true, false] true if this Table has id, false otherwise
+  # @!attribute primary_key
+  #   @return [String] the primary key of this Table
+  # @!attribute fk_suffix
+  #   @return [String] the foreign key suffix of this Table
+  # @!attribute columns
+  #   @return [Array] an Array of Column of this Table
+  class Table
+    attr_reader :name, :id
+    attr_writer :primary_key
+    attr_accessor :fk_suffix, :columns
+    
+    # Creates a Table.
+    #
+    # @param name [String] the name of this Table
+    # @param opts [Hash] the options of this Table
+    # @option opts [true, false] :id the id existence of this Table
+    # @option opts [String] :primary_key the primary key of this Table
+    # @option opts [String] :fk_suffix the foreign key suffix of this Table
+    # @return [Table] a Table object
+    def initialize(name, opts = {})
+      @name = name
+      @id = opts[:id] != false
+      @primary_key = opts[:primary_key]
+      @columns = []
+      @fk_suffix = opts[:fk_suffix] || 'id'
+    end
+    
+    # Returns the primary key of this Table.
+    #
+    # @return [String, nil] the primary key of this Table
+    def primary_key
+      return @primary_key if @primary_key
+      return 'id' if @id
+      
+      candidates = @columns.find_all { |col| col.unique }.map { |col| col.name }
+      return 'id' if candidates.include? 'id'
+      candidates.find { |c| c =~ eval("/^#{@name}.*id$/") } ||
+      candidates.find { |c| c =~ eval("/^#{singularize}.*id$/") } ||
+      candidates.find { |c| c =~ eval("/^#{pluralize}.*id$/") } ||
+      candidates.first
+    end
+    
+    # Returns the singular name of this Table.
+    #
+    # @return [String] the singular name of this Table
+    def singularize
+      @name.pluralize.singularize
+    end
+    
+    # Returns the plural name of this Table.
+    #
+    # @return [String] the plural name of this Table
+    def pluralize
+      @name.pluralize
+    end
+    
+    # Returns the name of this Table if given Column matched.
+    #
+    # @return [String, nil] the name of this Table if given Column matched, nil otherwise
+    def match_foreign_key(column)
+      if column.ref_table == @name || foreign_keys.include?(column.name)
+        @name if primary_key
+      end
+    end
+    
+    # Returns the name of this Table if given primary key matched.
+    #
+    # @return [String, nil] the name of this Table if given primary key matched, nil otherwise
+    def match_foreign_key_by_primary_key(pk)
+      @name if foreign_keys.include?(pk) && primary_key
+    end
+    
+    private
+    
+    def foreign_keys
+      ["#{@name}_#{fk_suffix}",      "#{@name}#{fk_suffix}",      "#{singularize}_#{fk_suffix}",
+       "#{singularize}#{fk_suffix}", "#{pluralize}_#{fk_suffix}", "#{pluralize}#{fk_suffix}"]
+    end
+  end
+end

data/lib/rare_map/version.rb

@@ -1,7 +1,11 @@
 module RareMap
+  # The major version of RareMap
   MAJOR = 2
-  MINOR = 1
-  PATCH = 1
-
+  # The minor version of RareMap
+  MINOR = 2
+  # The patch version of RareMap
+  PATCH = 0
+  
+  # The version of RareMap
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')
 end

data/test/column_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'rare_map/column'
+
+class ColumnTest < Test::Unit::TestCase
+  def setup
+    @column = RareMap::Column.new 'col1', 'integer'
+  end
+  
+  def test_constructor
+    assert @column.kind_of? RareMap::Column
+  end
+  
+  def test_properties
+    assert_equal 'col1', @column.name
+    assert_equal 'integer', @column.type
+  end
+  
+  def test_unique?
+    assert_equal false, @column.unique?
+    @column.unique = true
+    assert @column.unique?
+  end
+  
+  def test_foreign_key?
+    assert_equal false, @column.foreign_key?
+    @column.ref_table = 'table1'
+    assert @column.foreign_key?
+  end
+end

data/test/config_loader_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'rare_map/config_loader'
+require 'yaml'
+
+class ConfigLoaderTest < Test::Unit::TestCase
+  include RareMap::ConfigLoader
+  include RareMap::Errors
+  
+  def test_load_config
+    db_profiles = load_config File.dirname(__FILE__)
+    assert_equal 1, db_profiles.size
+    db_profile = db_profiles.first
+    assert db_profile.kind_of? RareMap::DatabaseProfile
+    assert_equal 'main', db_profile.name
+    assert_equal YAML.load_file(File.join(File.dirname(__FILE__), 'rare_map.yml'))['sample'][1]['main'], db_profile.connection
+    assert_equal 'sample', db_profile.options.group
+  end
+  
+  def test_load_config_simple
+    db_profiles = load_config File.dirname(__FILE__), 'rare_map_simple.yml'
+    assert_equal 1, db_profiles.size
+    db_profile = db_profiles.first
+    assert db_profile.kind_of? RareMap::DatabaseProfile
+    assert_equal 'main', db_profile.name
+    assert_equal YAML.load_file(File.join(File.dirname(__FILE__), 'rare_map_simple.yml'))['main'], db_profile.connection
+    assert_equal 'default', db_profile.options.group
+  end
+  
+  def test_load_config_error
+    assert_raise ConfigNotFoundError do
+      load_config 'no_file'
+    end
+  end
+end

data/test/database_profile_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'rare_map/database_profile'
+require 'rare_map/options'
+
+class DatabaseProfileTest < Test::Unit::TestCase
+  def setup
+    @connection = { adapter: 'sqlite3', database: 'db/test.sqlite3' }
+    @options = RareMap::Options.new
+    @db_profile = RareMap::DatabaseProfile.new 'profile1', @connection, @options
+  end
+  
+  def test_constructor
+    assert @db_profile.kind_of? RareMap::DatabaseProfile
+  end
+  
+  def test_properties
+    assert_equal 'profile1', @db_profile.name
+    assert_equal @connection, @db_profile.connection
+    assert_equal @options, @db_profile.options
+    assert_equal nil, @db_profile.schema
+    @db_profile.schema = ''
+    assert_equal '', @db_profile.schema
+    assert_equal [], @db_profile.tables
+  end
+end