rare_map 0.9.7 → 1.0.0

data/README.rdoc

@@ -1,6 +1,187 @@
-= rare_map
+= rare_map >= 1.0.0
+
+Relational db to ActiveREcord models MAPper
+
+RareMap can be used for BOTH standalone application & Rails
+
+WARN: rare_map >= 1.0.0 is totally not compatible with 0.9.x
+
+* Installation:
+
+   gem install rare_map
+
+== Basic RareMap use
+
+==== Standalone:
+Create a new database.yml with following lines in the root of your application
+
+====  Rails:
+Add following lines to config/database.yml of rails
+
+*  database.yml
+
+    rare_map:
+      legacy_db:
+        adapter: sqlite3
+        database: db/db1.sqlite3
+
+      your_db:
+        adapter: mysql2
+        host: localhost
+        database: db_name
+        port: 3306
+        username: user
+        password: pw
+
+* Run following command in the root of your application or rails
+
+   $ raremap
+
+* Standalone: A demo.rb example is generated for you in the root of your applicaiton
+
+* Rails: Add following line to your config/application.rb
+   config.autoload_paths += Dir[Rails.root.join('app', 'models', '{**}')]
+
+== Advanced RareMap use
+
+==== Seperate databases to groups(highly recommended)
+   
+    rare_map:
+      her_group:
+        -
+          db1:
+            adapter: sqlite3
+            database: db/db1.sqlite3
+        -
+          db2:
+            adapter: sqlite3
+            database: db/db1.sqlite3
+
+      his_group:
+        -
+          db1:
+            adapter: sqlite3
+            database: db/db3.sqlite3
+        -
+          db2:
+            adapter: sqlite3
+            database: db/db4.sqlite3
+
+There are benefits by separating databases into groups
+1. Associations are built between databases within a group
+2. Model name is prepended with group name
+3. Models of a group are organized within a folder
+
+If all your data reside in several legacy databases, it is important to build back those associations across databases
+
+If there are 2 or more tables with the same name, giving them group names could avoid naming collision
+
+If there are tons of tables, it is better to organize them well
+
+
+==== Set up RareMap Options
+ rare_map_opts:
+   foreign_key:
+     suffix: fk
+     alias:
+       abnormal_fk1: table1
+       abnormal_fk2: table2
+   primary_key:
+     table1: abnormal_pk
+
+* rare_map_opts[foreign_key][suffix]: If your foreign keys are not ended with 'id', you can specify the suffix you want here
+* rare_map_opts[foreign_key][alias]: If naming convention is not followed by some foreign keys, you can list them here
+* rare_map_opts[primary_key]: Usually rare_map can identify the primary key of a table, if it fails, please list primary keys here
+
+==== RareMap Options Precedence
+
+You can place rare_map options in 3 ways
+
+ rare_map:
+   rare_map_opts:             # Global options
+     ...
+   group1:
+     -
+       rare_map_opts:         # Group options
+         ...
+     -
+       db1:
+         ...
+   legacy_db:
+     adapter: sqlite3
+     database: db/db.sqlite3
+     rare_map_opts:           # DB options
+       ...
+
+* Precedence: DB > Group > Global
+
+
+= rare_map ~> 0.9.x(deprecated)
+
+Relational DB to ActiveRecord models Mapper
+
+* Installation:
+
+   gem install rare_map
+
+== Basic RareMap use
+
+Set up your legacay db under your Rails applicaiton
+
+*  database.yml
+
+    mylegacy_db1:
+      adapter: sqlite3
+      database: db/db1.sqlite3
+
+    mylegacy_db2:
+      adapter: sqlite3
+      database: db/db2/sqlite3
+
+    hislegacy_db1:
+      adapter: sqlite3
+      database: db/db1.sqlite3
+
+"mylegacy" is treated as a group name.
+
+You MUST give all your legacy databases a group name.
+
+The associations of databases with the same group name will be built together.
+
+
+* Create a {RAILS_ROOT}/demo.rb file with following content under your Rails application
+
+   RareMap.mapping
+
+* Under terminal
+
+   ruby demo.rb
+
+* Add following line to your config/application.rb
+
+   config.autoload_paths += Dir[Rails.root.join('app', 'models', '{**}')]
+
+== Advanced RareMap use
+
+If the foreign key of your legacy db is not end with '_id', you can change it manually.
+
+  foreign_keys = { :mylegacy => 'id', :hislegacy => 'id' }
+
+If the foreign key is not started with regular table names, you can create aliases for them.
+
+  aliases = { :mylegacy => { :pclid => :protocol, personid => people }, :hislegacy => { :measid => measurement } }
+
+Some of the databases like Oracle won't show the primary key on the dump of schema. If your primary key of a table is not 'id' and it didn't show the schema either. You can specify your special primary key beside 'id' if you want.
+
+  primary_keys = { :mylegacy => { :table1 => 'table1id' }, :hislegacy => { :table2 => 'table2id' } }
+
+When you using the RareMap
+
+  info = RareMap.mapping(:foreign_key => foreign_keys, :alias => aliases, :primary_key => primary_keys)
+
+[info]
+It contains all details of your tables.
 
-Description goes here.
 
 == Contributing to rare_map
  

data/bin/raremap

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rare_map'
+
+RareMap.mapping

data/lib/rare_map/config_loader.rb

@@ -0,0 +1,108 @@
+require 'yaml'
+
+module RareMap
+  module ConfigLoader
+    OPTS_KEY = 'rare_map_opts'
+    
+    def load_config(path, file_name = 'database.yml')
+      config = YAML.load_file "#{path}#{file_name}"
+      organize_config_properties config['rare_map'] || {}
+    end
+    
+    private
+    def organize_config_properties(raw_config)
+      db_profiles = []
+      global_opts = Options.new(raw_config.delete OPTS_KEY) if raw_config[OPTS_KEY]
+      
+      raw_config.each do |k, v|
+        case v.class.name
+        when 'Hash'
+          if v[OPTS_KEY]
+            db_profiles << DatabaseProfile.new(remove_opts(v), Options.new(v[OPTS_KEY]))
+          else
+            db_profiles << DatabaseProfile.new(v, global_opts)
+          end
+        when 'Array'
+          v = v.reduce(:merge)
+          group_opts = Options.new(v.delete(OPTS_KEY), k)
+          v.each do |db, config|
+            if config[OPTS_KEY]
+              db_profiles << DatabaseProfile.new(remove_opts(config), Options.new(config[OPTS_KEY], k))
+            else
+              db_profiles << DatabaseProfile.new(config, group_opts || global_opts)
+            end
+          end
+        end
+      end
+      
+      db_profiles
+    end
+    
+    def remove_opts(db)
+      db.select { |k, _| k != OPTS_KEY }
+    end
+  end
+  
+  class DatabaseProfile
+    attr_reader :connection, :options
+    attr_accessor :schema, :tables
+    
+    def initialize(connection, options)
+      @connection = connection
+      @options = options || Options.new
+      @tables = []
+    end
+  end
+  
+  class Options
+    attr_reader :opts
+    
+    def initialize(raw_opts = nil, group = nil)
+      @opts = { 'group'       => 'default',
+                'primary_key' => {},
+                'foreign_key' => { 'suffix' => nil, 'alias' => {} } }
+                
+      if raw_opts and 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'] and raw_opts['foreign_key']['suffix'].kind_of? String
+           @opts['foreign_key']['suffix'] = raw_opts['foreign_key']['suffix']
+        end
+        if raw_opts['foreign_key'] 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
+      end
+      @opts['group'] = group if group.kind_of? String
+    end
+    
+    def group?
+      @opts['group'] != 'default'
+    end
+    
+    def group
+      @opts['group'] || 'default'
+    end
+    
+    def find_primary_key_by_table(table_name)
+      @opts['primary_key'].each { |k, v| return v if k == table_name }
+      nil
+    end
+    
+    def find_table_by_foreign_key(column_name)
+      @opts['foreign_key']['alias'].each { |k, v| return v if k == column_name }
+      nil
+    end
+    
+    def fk_suffix
+      @opts['foreign_key']['suffix']
+    end
+    
+    def to_s
+      @opts.to_s
+    end
+  end
+end

data/lib/rare_map/model_builder.rb

@@ -0,0 +1,112 @@
+require 'active_support/inflector'
+
+module RareMap
+  module ModelBuilder
+    def build_models(db_profiles)
+      models = []
+      
+      default_id = 1
+      db_profiles.each do |db_prof|
+        db_prof.tables.each do |table|
+          opts = db_prof.options
+          set_primary_key_by_options(table, opts)
+          set_foreign_keys_by_options(table, opts)
+          set_fk_suffix_by_options(table, opts)
+          if opts.group?
+            models << Model.new(db_prof.connection, table, opts.group)
+          else
+            models << Model.new(db_prof.connection, table, 'default', default_id)
+          end
+        end
+        default_id += 1 unless db_prof.options.group?
+      end
+      
+      build_relations models
+      
+      models
+    end
+    
+    private
+    def build_relations(models)
+      models.each do |model|
+        group_models = models.select { |m| m.group == model.group && m.default_id == model.default_id }
+        
+        model.table.columns.each do |col|
+          group_models.each do |gm|
+            if gm.table.match_foreign_key(col) && model != gm
+              model.relations << Relation.new(:belongs_to, col.name, gm.table.name)
+              gm.relations << Relation.new(col.unique? ? :has_one : :has_many, col.name, model.table.name)
+            end
+          end
+        end
+      end
+      
+      models.each do |model|
+        group_models = models.select { |m| m.group == model.group && m.default_id == model.default_id }
+        
+        model.relations.each do |rel_from|
+          model.relations.each do |rel_to|
+            if rel_from != rel_to &&
+               rel_from.type == :belongs_to &&
+               rel_to.type == :belongs_to &&
+               rel_from.table != rel_to.table
+              model_from = models.find { |m| m.table.name == rel_from.table }
+              model_to = models.find { |m| m.table.name == rel_to.table }
+              model_from.relations << Relation.new(:has_many_through, rel_to.foreign_key, model_to.table.name, model.table.name)
+              model_to.relations << Relation.new(:has_many_through, rel_from.foreign_key, model_from.table.name, model.table.name)
+            end
+          end
+        end
+      end
+      
+      models.each do |model|
+        model.relations.uniq! { |rel| "#{rel.type} #{rel.table} #{rel.through}" }
+      end
+    end
+    
+    def set_fk_suffix_by_options(table, options)
+      table.fk_suffix = options.fk_suffix if options.fk_suffix
+    end
+    
+    def set_foreign_keys_by_options(table, options)
+      table.columns.each do |col|
+        ref = options.find_table_by_foreign_key col.name
+        col.references = ref if ref
+      end
+    end
+    
+    def set_primary_key_by_options(table, options)
+      pk = options.find_primary_key_by_table table.name
+      table.primary_key = pk if pk
+    end
+  end
+  
+  class Model
+    attr_reader :connection, :table, :group, :relations, :default_id
+    
+    def initialize(connection, table, group = 'default', default_id = nil)
+      @connection, @table, @group, @default_id = connection, table, group, default_id
+      @relations = []
+    end
+    
+    def group?
+      group != 'default'
+    end
+    
+    def classify
+      if group?
+        "#{group}_#{table.name}".pluralize.classify
+      else
+        "#{table.name}".pluralize.classify
+      end
+    end
+  end
+  
+  class Relation
+    attr_reader :type, :foreign_key, :table, :through
+    
+    def initialize(type, foreign_key, table, through = nil)
+      @type, @foreign_key, @table, @through = type, foreign_key, table, through
+    end
+  end
+end

data/lib/rare_map/model_generator.rb

@@ -0,0 +1,66 @@
+require 'active_support/inflector'
+
+module RareMap
+  module ModelGenerator
+    def generate_models(models, root = './')
+      root ||= './'
+      path = root + 'app/models/'
+      
+      models.each do |model|
+        output = ''
+        output <<
+        "class #{model.classify} < ActiveRecord::Base\n" <<
+        "  establish_connection #{model.connection.to_s[1..-2]}\n" <<
+        "  self.table_name = '#{model.table.name}'\n" <<
+        "  self.inheritance_column = 'ruby_type'\n" <<
+        "  #{ "self.primary_key = '#{model.table.primary_key}'\n" if model.table.primary_key }\n" <<
+        "  attr_accessible #{model.table.columns.map { |col| ":#{col.name}" }.join(', ')}\n\n"
+        
+        belongs_to = model.relations.select { |rel| rel.type == :belongs_to }
+        unless belongs_to.empty?
+          output << belongs_to.
+            map { |rel| "  belongs_to :#{rel.table.pluralize.singularize}, :foreign_key => '#{rel.foreign_key}', :class_name => '#{classify_by_table(rel.table, models)}'" }.
+            join("\n") << "\n"
+        end
+        
+        has_one = model.relations.select { |rel| rel.type == :has_one }
+        unless has_one.empty?
+          output << has_one.
+            map { |rel| "  has_one :#{rel.table.pluralize.singularize}, :foreign_key => '#{rel.foreign_key}', :class_name => '#{classify_by_table(rel.table, models)}'" }.
+            join("\n") << "\n"
+        end
+        
+        has_many = model.relations.select { |rel| rel.type == :has_many }
+        unless has_many.empty?
+          output << has_many.
+            map { |rel| "  has_many :#{rel.table.pluralize}, :foreign_key => '#{rel.foreign_key}', :class_name => '#{classify_by_table(rel.table, models)}'" }.
+            join("\n") << "\n"
+        end
+        
+        has_many_through = model.relations.select { |rel| rel.type == :has_many_through }
+        unless has_many_through.empty?
+          output << has_many_through.
+            map { |rel| "  has_many :#{rel.table.pluralize}#{"_by_#{rel.through}, :source => :#{rel.table.pluralize.singularize}" if has_many_through.count { |hmt| hmt.table == rel.table } > 1}, :through => :#{rel.through.pluralize}, :foreign_key => '#{rel.foreign_key}', :class_name => '#{classify_by_table(rel.table, models)}'" }.
+            join("\n") << "\n"
+        end
+        
+        output << 'end'
+        
+        Dir.mkdir root + 'app' unless Dir.exist? root + 'app'
+        Dir.mkdir path unless Dir.exist? path
+        Dir.mkdir path + "#{model.group}" unless Dir.exist? path + "#{model.group}"
+        f = File.new(path + "#{model.group}/#{model.classify.underscore}.rb", 'w')
+        f.write output
+        f.close
+      end
+      
+      models
+    end
+    
+    private
+    def classify_by_table(table, models)
+      model = models.find { |m| m.table.name == table }
+      model.classify
+    end
+  end
+end

data/lib/rare_map/rails_locator.rb

@@ -1,22 +1,22 @@
-module RailsLocator
-  
- def self.locate(level = 5)
-    rails_dirs = ['app', 'config', 'db', 'doc', 'lib']
-    
-    level.times do |i|
-      found = true
-      path = ''
+module RareMap
+  module RailsLocator
+   def locate_rails_root(depth = 5)
+      rails_dirs = ['app', 'config', 'db', 'lib', 'log', 'public', 'script']
       
-      i.times { path += '../' }
-      
-      rails_dirs.each do |dir|
-        found = false unless Dir.exist?(path + dir)
+      depth.times do |level|
+        found = true
+        path = ''
+        
+        level.times { path << '../' }
+        
+        rails_dirs.each do |dir|
+          found = false unless Dir.exist?(path + dir)
+        end
+        
+        return path if found
       end
       
-      return path if found
+      nil
     end
-    
-    nil
   end
-  
 end

data/lib/rare_map/schema_parser.rb

@@ -0,0 +1,93 @@
+require 'active_support/inflector'
+
+module RareMap
+  module SchemaParser
+    def parse_schema(schema)
+      tables = []
+      
+      schema.split(/\n/).each do |line|
+        case line.strip!
+        when /^create_table/
+          name = line.match(/create_table\s+['"]([^'"]+)['"]/)[1]
+          id = line.match(/:id\s*=>\s*false/) ? false : true
+          primary_key = pk[1] if (pk = line.match(/:primary_key\s*=>\s*['"](.+)['"]/))
+          tables << Table.new(name, :id => id, :primary_key => primary_key)
+        when /^t\./
+          name = line.match(/t\.\w+\s+['"]([^'"]+)['"]/)[1]
+          type = line.match(/t\.(\w+)\s+/)[1]
+          tables.last.columns << Column.new(name, type)
+        when /^add_index\s+.*\[\s*['"]([^'"]+)['"]\s*\].*:unique\s*=>\s*true/
+          unique_column = line.match(/add_index\s+.*\[\s*['"]([^'"]+)['"]\s*\].*:unique\s*=>\s*true/)[1]
+          column = tables.last.columns.find { |col| col.name == unique_column }
+          column.unique = true
+        end
+      end
+      
+      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 '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 || ["#{@name}_#{fk_suffix}",
+                                        "#{@name}#{fk_suffix}",
+                                        "#{singularize}_#{fk_suffix}",
+                                        "#{singularize}#{fk_suffix}",
+                                        "#{pluralize}_#{fk_suffix}",
+                                        "#{pluralize}#{fk_suffix}"].include?(column.name)
+        @name if primary_key
+      end
+    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

@@ -0,0 +1,19 @@
+require 'active_record'
+
+module RareMap
+  module SchemaReader
+    def read_schema(db_profile)
+      conn = db_profile.connection.map { |k, v| v.kind_of?(Integer) ? "'#{k}'=>#{v}" : "'#{k}'=>'#{v}'" }.join(', ')
+      if RUBY_PLATFORM == "java"
+        %x[jruby -e "require 'active_record'; ActiveRecord::Base.establish_connection(#{conn}); ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection);"]
+      else
+        %x[ruby -e "require 'active_record'; ActiveRecord::Base.establish_connection(#{conn}); ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection);"]
+      end
+      # schema = StringIO.new
+      # ActiveRecord::Base.establish_connection db_profile.connection
+      # ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, schema)
+      # schema.close
+      # schema.string
+    end
+  end
+end

data/lib/rare_map/version.rb

@@ -1,8 +1,8 @@
 class RareMap
   module Version
-    MAJOR = 0
-    MINOR = 9
-    PATCH = 7
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/rare_map.rb

@@ -1,42 +1,56 @@
-require 'rare_map/database_to_schema_builder'
-require 'rare_map/schema_to_relation_builder'
-require 'rare_map/schema_to_model_builder'
+# $:.unshift File.dirname(__FILE__)
+
 require 'rare_map/rails_locator'
+require 'rare_map/config_loader'
+require 'rare_map/schema_reader'
+require 'rare_map/schema_parser'
+require 'rare_map/model_builder'
+require 'rare_map/model_generator'
 
-class RareMap
+module RareMap
+  def self.mapping
+    Mapper.new.mapping
+  end
   
-  def self.mapping(opt = {})
-    unless RailsLocator.locate
-      $stderr.puts 'Run RareMap under Rails root directory'
-      return
-    end
+  class Mapper
+    include RailsLocator, ConfigLoader, SchemaReader, SchemaParser, ModelBuilder, ModelGenerator
     
-    info = {}
+    def initialize
+      @rails_root = locate_rails_root
+    end
     
-    databases = DatabaseToSchemaBuilder.build
-    databases.each do |group_name, tables|
-      [:foreign_key, :alias, :primary_key].each { |sym| opt[sym] ||= {} }
-      foreign_keys = opt[:foreign_key][group_name] || nil
-      aliases = opt[:alias][group_name] || {}
-      primary_keys = opt[:primary_key][group_name] || {}
-      
-      schemata = tables.inject({}) { |o, i| o = o.merge(i[:schema]) }
-      primary_keys.each do |table, primary_key|
-        schemata[table][:primary_key] = primary_key if schemata[table]
+    def mapping
+      @db_profiles = load_config @rails_root ? @rails_root + 'config/' : './'
+      @db_profiles.each do |profile|
+        profile.schema = read_schema profile
+        profile.tables = parse_schema profile.schema
+      end
+      @models = build_models @db_profiles
+      generate_models @models, @rails_root
+      if @rails_root
+        puts '*****************************************************************************'
+        puts '  Add following line to your config/application.rb'
+        puts "    config.autoload_paths += Dir[Rails.root.join('app', 'models', '{**}')]"
+        puts '*****************************************************************************'
+      else
+        puts '*****************************************************************************'
+        puts '  A demo.rb is generated'
+        puts '*****************************************************************************'
+        generate_demo unless File.exist?('demo.rb')
       end
-      relations = SchemaToRelationBuilder.build(schemata, foreign_keys, aliases)
-      SchemaToModelBuilder.build(schemata, relations, group_name, databases)
-      
-      info[group_name] ||= {}
-      info[group_name][:schemata] = schemata
-      info[group_name][:relations] = relations
+      @models
     end
     
-    $stdout.puts %{Add following line to your config/application.rb}
-    $stdout.puts %{config.autoload_paths += Dir[Rails.root.join('app', 'models', '{**}')]}
-    
-    info[:databases] = databases
-    info
+    private
+    def generate_demo
+      f = File.new('demo.rb', 'w')
+      f.write "require 'active_record'\n"
+      f.write "Dir[File.dirname(__FILE__) + '/app/models/**/*.rb'].each { |file| require file }\n"
+      f.close
+    end
   end
-  
 end
+
+if __FILE__ == $0
+  RareMap.mapping
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rare_map
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-08 00:00:00.000000000 Z
+date: 2012-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -107,24 +107,26 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.9.11
-description: Translate legacy db to ActiveRecord models
+description: Relational db to ActiveREcord models MAPper
 email: wnameless@gmail.com
-executables: []
+executables:
+- raremap
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
 files:
 - lib/rare_map.rb
-- lib/rare_map/database_to_schema_builder.rb
-- lib/rare_map/inheritor_util.rb
+- lib/rare_map/config_loader.rb
+- lib/rare_map/model_builder.rb
+- lib/rare_map/model_generator.rb
 - lib/rare_map/rails_locator.rb
-- lib/rare_map/schema_to_hash_mapping.rb
-- lib/rare_map/schema_to_model_builder.rb
-- lib/rare_map/schema_to_relation_builder.rb
+- lib/rare_map/schema_parser.rb
+- lib/rare_map/schema_reader.rb
 - lib/rare_map/version.rb
 - LICENSE.txt
 - README.rdoc
+- bin/raremap
 homepage: http://github.com/wnameless/rare_map
 licenses:
 - Apache License, Version 2.0
@@ -140,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4273128051063044158
+      hash: 2391284993457456649
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -152,5 +154,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: RelationDB-ActiveRecord Mapper
+summary: rare_map-
 test_files: []

data/lib/rare_map/database_to_schema_builder.rb

@@ -1,27 +0,0 @@
-require 'rare_map/rails_locator'
-require 'rare_map/schema_to_hash_mapping'
-
-module DatabaseToSchemaBuilder
-  
-  def self.build
-    file = File.open(RailsLocator.locate + 'config/database.yml') { |f| f.read }
-    database = file.split("\n").select do |line|
-      line.match(/^[a-z]+/) && line != 'development:' && line != 'test:' && line != 'production:'
-    end
-    database.map! { |db| db.delete(':') }
-    
-    database_hash = Hash.new { |hash, key| hash[key] = [] }
-    database.each { |db| database_hash[db.split('_').first.to_sym] << { :dbname => db } }
-    
-    database_hash.each do |group, dbs|
-      dbs.each do |db|
-        puts "db:schema:dump RAILS_ENV=#{db[:dbname]}"
-        system "rake db:schema:dump RAILS_ENV=#{db[:dbname]}"
-        schema = File.open(RailsLocator.locate + 'db/schema.rb') { |f| f.read }
-        db[:schema] = SchemaToHashMapping.convert(schema.split("\n"))
-      end
-    end
-    database_hash
-  end
-  
-end

data/lib/rare_map/inheritor_util.rb

@@ -1,50 +0,0 @@
-require 'rare_map/rails_locator'
-
-module InheritorUtil
-  
-  def self.to_class_name(name)
-    name.to_s.split('_').map { |word| word.capitalize }.join
-  end
-  
-  def self.remove_underline_between_numbers(line)
-    line = line.to_s
-    md = line.match(/(\d+)(_)(\d+)/)
-    md.size.times { line.gsub!(/(\d+)_(\d+)/, '\1\2') } unless md.nil?
-    line.gsub!(/([a-zA-Z])(_)(\d)/, '\1\3')
-    line.to_sym
-  end
-  
-  def self.write_model_file(file_name, content, group_name)
-    write_file(file_name, content, group_name, 'models')
-  end
-  
-  def self.write_controller_file(file_name, content, group_name)
-    write_file(file_name, content, group_name, 'controllers')
-  end
-  
-  def self.complex_flatten(node, flatAry = [])
-    if node.kind_of?(Array)
-      node.map { |leaf| complex_flatten(leaf, flatAry) }
-    elsif node.kind_of?(Hash)
-      node.each do |key, val|
-        flatAry << key
-        complex_flatten(val, flatAry)
-      end
-    else
-      flatAry << node
-    end
-    flatAry
-  end
-  
-  
-  private
-  
-  
-  def self.write_file(file_name, content, group_name, mvc)
-    Dir.mkdir(RailsLocator.locate + "app/#{mvc}/#{group_name}") unless Dir.exist?(RailsLocator.locate + "app/#{mvc}/#{group_name}")
-    f = File.new(RailsLocator.locate + "app/#{mvc}/#{group_name}/#{group_name}_#{remove_underline_between_numbers(file_name)}.rb", 'w')
-    f.write(content)
-    f.close
-  end
-  
-end

data/lib/rare_map/schema_to_hash_mapping.rb

@@ -1,53 +0,0 @@
-module SchemaToHashMapping
-  
-  def self.convert(schema)
-    schema_hash = {}
-    table_name_sym = :Blank
-    
-    schema.each do |line|
-      case line.strip!
-      when /^create_table/
-        table_name_sym = filter_table_name_sym(line)
-        schema_hash[table_name_sym] = {}
-        if line.match(/:primary_key\s*=>\s*"[^"]+",/)
-          schema_hash[table_name_sym][:primary_key] = line.match(/:primary_key\s*=>\s*"[^"]+",/).to_s.delete('",').split(/\s+/)[2].to_sym
-        end
-      when /^t\./
-        column_name_sym = filter_column_name_sym(line)
-        column_type_sym = filter_column_type_sym(line)
-        schema_hash[table_name_sym][column_name_sym] ||= {}
-        schema_hash[table_name_sym][column_name_sym][:type] = table_name_sym
-        schema_hash[table_name_sym][column_name_sym][:unique] = false
-      when /^add_index.*:unique\s*=>\s*true/
-        uniqueColumns = filter_unique_columns(line)
-        uniqueColumns.each do |column|
-          schema_hash[table_name_sym][column][:unique] = true
-        end
-      end
-    end
-    
-    return schema_hash
-  end
-  
-  
-  private
-  
-  
-  def self.filter_unique_columns(line)
-    cols = line.match(/\[[^\]]*\]/).to_s.delete('"[],').split(/\s+/).map { |col| col.to_sym }
-    cols.size == 1 ? cols : []
-  end
-  
-  def self.filter_table_name_sym(line)
-    line.delete('",').split(/\s+/)[1].to_sym
-  end
-  
-  def self.filter_column_name_sym(line)
-    line.delete('",').split(/\s+/)[1].to_sym
-  end
-  
-  def self.filter_column_type_sym(line)
-    line.delete('",').split(/\s+/)[0][2 .. -1].to_sym
-  end
-  
-end

data/lib/rare_map/schema_to_model_builder.rb

@@ -1,74 +0,0 @@
-require 'rare_map/inheritor_util'
-
-module SchemaToModelBuilder
-  
-  def self.build(schema_hash, rel_hash, group_name, database_hash)
-    schema_hash.each do |table_name, table_content|
-      model_content = generate_header(table_name, schema_hash, group_name, database_hash)
-      model_content << generate_attributes_permission(table_content, 'attr_accessible') unless table_content.size == 0
-      model_content << generate_relationships(table_name, rel_hash, group_name)
-      model_content << generate_footer
-      InheritorUtil.write_model_file(table_name, model_content, group_name)
-    end
-  end
-  
-  
-  private
-  
-  
-  def self.generate_relationships(table_name, rel_hash, group_name)
-    return '' if rel_hash.count { |_, hash| hash[table_name] != nil } == 0
-    
-    has_one_ary = []
-    rel_hash[:has_one][table_name].each do |table, foreign_key|
-      has_one_ary << "  has_one :#{table}, :foreign_key => '#{foreign_key}', :class_name => '#{group_name.to_s.capitalize}#{InheritorUtil.to_class_name(table)}'"
-    end if rel_hash[:has_one][table_name] != nil
-    
-    has_many_ary = []
-    rel_hash[:has_many][table_name].each do |table, foreign_key|
-      has_many_ary << "  has_many :#{table}, :foreign_key => '#{foreign_key}', :class_name => '#{group_name.to_s.capitalize}#{InheritorUtil.to_class_name(table)}'"
-    end if rel_hash[:has_many][table_name] != nil
-    
-    belongs_to_ary = []
-    rel_hash[:belongs_to][table_name].each do |table, foreign_key|
-      belongs_to_ary << "  belongs_to :#{table}, :foreign_key => '#{foreign_key}', :class_name => '#{group_name.to_s.capitalize}#{InheritorUtil.to_class_name(table)}'"
-    end if rel_hash[:belongs_to][table_name] != nil
-    
-    has_many_through_ary = []
-    rel_hash[:has_many_through][table_name].each do |table, foreign_key, through|
-      has_many_through_ary << "  has_many :#{table}, :foreign_key => '#{foreign_key}', :class_name => '#{group_name.to_s.capitalize}#{InheritorUtil.to_class_name(table)}', :through => :#{through}"
-    end if  rel_hash[:has_many_through][table_name] != nil
-    
-    has_one_ary.join("\n") << "\n" <<
-    has_many_ary.join("\n") << "\n" <<
-    belongs_to_ary.join("\n") + "\n" <<
-    has_many_through_ary.join("\n") << "\n"
-  end
-  
-  def self.generate_attributes_permission(table_content, permission)
-    table_content.keys.inject('  ' + permission) { |o, i| o = o + " :#{i}," }[0 .. -2] + "\n"
-  end
-  
-  def self.generate_header(table_name, schema_hash, group_name, database_hash)
-    "class #{group_name.to_s.capitalize}#{InheritorUtil.to_class_name(table_name)} < ActiveRecord::Base\n" <<
-    "  establish_connection :#{get_connection_name(table_name, group_name, database_hash)}\n" <<
-    "  self.table_name = '#{table_name}'\n" <<
-    "  self.inheritance_column = 'ruby_type'\n" <<
-    "  self.primary_key = '#{check_primary_key(table_name, schema_hash)}'\n"
-  end
-  
-  def self.get_connection_name(table_name, group_name, database_hash)
-    database_hash[group_name].each do |db|
-      return db[:dbname] unless db[:schema][table_name].nil?
-    end
-  end
-  
-  def self.check_primary_key(table_name, schema_hash)
-    schema_hash[table_name][:primary_key].nil? ? 'id' : schema_hash[table_name][:primary_key]
-  end
-  
-  def self.generate_footer
-    "end\n"
-  end
-  
-end

data/lib/rare_map/schema_to_relation_builder.rb

@@ -1,104 +0,0 @@
-module BelongsTo2HasManyThroughtRelationBuilder
-  
-  def self.build(belongs_to_hash, has_one_hash, has_many_hash)
-    belongs_to_hash = belongs_to_hash.clone
-    has_many_through_hash = {}
-  
-    belongs_to_hash = belongs_to_hash.delete_if { |table, rels| rels.size < 2 }
-    belongs_to_hash.each do |table, rels|
-      rels.each do |from_table, from_table_key|
-        rels.each do |to_table, to_table_key|
-          if from_table != to_table
-            has_many_through_hash[from_table] ||= []
-            rel = [to_table, to_table_key, table]
-            has_many_through_hash[from_table] << rel 
-          end
-        end
-      end
-    end
-    
-    final_has_many_through_hash = {}
-    has_many_through_hash.each do |table, rels|
-      rels.each do |rel|
-        if has_many_hash[table] != nil && has_many_hash[table].count { |i| i.first == rel.first } == 0
-          final_has_many_through_hash[table] ||= []
-          final_has_many_through_hash[table] << rel
-        end
-      end
-    end
-    has_many_through_hash = final_has_many_through_hash
-    
-    final_has_many_through_hash = {}
-    has_many_through_hash.each do |table, rels|
-      rels.each do |rel|
-        if has_one_hash[table] != nil && has_one_hash[table].count { |i| i.first == rel.first } == 0
-          final_has_many_through_hash[table] ||= []
-          final_has_many_through_hash[table] << rel
-        end
-      end
-    end
-    has_many_through_hash = final_has_many_through_hash
-    
-    final_has_many_through_hash = {}
-    has_many_through_hash.each do |table, rels|
-      rels.each do |rel|
-        if belongs_to_hash[table] != nil && belongs_to_hash[table].count { |i| i.first == rel.first } == 0
-          final_has_many_through_hash[table] ||= []
-          final_has_many_through_hash[table] << rel
-        end
-      end
-    end
-    has_many_through_hash = final_has_many_through_hash
-    
-    has_many_through_hash
-  end
-  
-end
-
-module SchemaToRelationBuilder
-  
-  def self.build(schema_hash, relation_mark, alias_hash = {})
-    relation_mark ||= '_id'
-    has_one_hash = {}; has_many_hash = {}; belongs_to_hash = {}
-    
-    schema_hash.each do |table_name, table_content|
-      table_content.each do |column, type|
-        if alias_hash[column] != nil
-          belongs_to = alias_hash[column]
-          if schema_hash[belongs_to] != nil
-            if schema_hash[table_name][column][:unique] == true
-              has_one_hash[belongs_to] ||= []
-              has_one_hash[belongs_to] << [table_name, column]
-            else
-              has_many_hash[belongs_to] ||= []
-              has_many_hash[belongs_to] << [table_name, column]
-            end
-            belongs_to_hash[table_name] ||= []
-            belongs_to_hash[table_name] << [belongs_to, column]
-          end
-        elsif column.to_s.match(eval("/#{relation_mark}$/")) && column.to_s[0 .. -(relation_mark.length + 1)].to_sym != table_name
-          belongs_to = column.to_s[0 .. -(relation_mark.length + 1)].to_sym
-          if schema_hash[belongs_to] != nil
-            if schema_hash[table_name][column][:unique] == true
-              has_one_hash[belongs_to] ||= []
-              has_one_hash[belongs_to] << [table_name, column]
-            else
-              has_many_hash[belongs_to] ||= []
-              has_many_hash[belongs_to] << [table_name, column]
-            end
-            belongs_to_hash[table_name] ||= []
-            belongs_to_hash[table_name] << [belongs_to, column]
-          end
-        end
-      end
-    end
-    
-    has_many_through_hash = BelongsTo2HasManyThroughtRelationBuilder.build(belongs_to_hash, has_one_hash, has_many_hash)
-    
-    return { :has_one => has_one_hash,
-             :has_many => has_many_hash,
-             :belongs_to => belongs_to_hash,
-             :has_many_through => has_many_through_hash }
-  end
-  
-end