schemard 0.2.0

data/lib/locales/messages.yml

@@ -0,0 +1,37 @@
+en:
+  views:
+    edit_checkbox_label: "Edit table position"
+    table_summary_title: "Table Information"
+    table_name: "Table Name"
+    parent_tables: "Parent Tables"
+    child_tables: "Child Tables"
+    description: "Description"
+    column_definition: "Column Information"
+    column_name: "Column Name"
+    column_type: "Type"
+    column_precision: "precision"
+    column_default: "Default"
+    index_definition: "Index Information"
+    index_unique: "Unique"
+    index_target_columns: "Columns"
+    index_name: "Index Name"
+
+ja:
+  views:
+    edit_checkbox_label: "テーブルの位置を編集"
+    table_summary_title: "テーブル基本情報"
+    table_name: "テーブル名"
+    table_name_en: "テーブル英名"
+    parent_tables: "親テーブル"
+    child_tables: "子テーブル"
+    description: "説明"
+    column_definition: "カラム定義"
+    column_name: "列名"
+    column_name_en: "列名(英)"
+    column_type: "型"
+    column_precision: "精度"
+    column_default: "デフォルト"
+    index_definition: "インデックス定義"
+    index_unique: "ユニーク"
+    index_target_columns: "対象カラム"
+    index_name: "インデックス名"

data/lib/schemard/controller.rb

@@ -0,0 +1,160 @@
+require 'optparse'
+require 'yaml'
+require_relative "schema"
+require_relative "schema_parser"
+require_relative "metadata"
+require_relative "utils/localizer"
+require_relative "utils/struct_assigner"
+
+module SchemaRD
+  class Controller
+    attr_reader :config
+
+    def initialize(config)
+      @config = config;
+    end
+
+    def index(req, res)
+      locale = localizer(req)
+      schema = SchemaRD::SchemaParser.new(config.input_file).parse(with_comment: config.parse_db_comment?)
+      SchemaRD::Metadata.load(config: self.config, lang: locale.lang, schema: schema)
+      send(req, res, render("index.html.erb", binding))
+    end
+
+    def show(req, res)
+      locale = localizer(req)
+      match = req.path.match(/\/tables\/(\w+)/)
+      unless match
+        res.status = 404
+      else
+        schema = SchemaRD::SchemaParser.new(config.input_file).parse(with_comment: config.parse_db_comment?)
+        SchemaRD::Metadata.load(config: self.config, lang: locale.lang, schema: schema)
+        table_name = match[1]
+        send(req, res, render("show.html.erb", binding))
+      end
+    end
+
+    def update(req, res)
+      match = req.path.match(/\/tables\/(\w+)/)
+      unless match
+        res.status = 404
+      else
+        if req.query['layout']
+          pos = req.query['layout'].split(",")
+          SchemaRD::Metadata::Writer.new(config.output_file).save(match[1], { "left" => pos[0], "top" => pos[1] })
+        end
+        send(req, res, "OK")
+      end
+    end
+
+    def static_file(req, res)
+      send(req, res, File.new(CONTENTS_DIR + req.path).read)
+    end
+
+    TEMPLATES_DIR = "#{File.dirname(File.expand_path(__FILE__))}/../templates/"
+    CONTENTS_DIR = "#{File.dirname(File.expand_path(__FILE__))}/../contents/"
+
+    private
+
+    def localizer(req)
+      SchemaRD::Utils::MessageLocalizer.new(req.accept_language[0] || "en")
+    end
+
+    def send(req, res, body = nil)
+      res.status = 200
+      res.content_type = case req.path
+      when /.*\.js\Z/
+        "text/javascript"
+      when /.*\.css\Z/
+        "text/css"
+      when /.*\.ico\Z/
+        "image/x-icon"
+      else
+        "text/html"
+      end
+      res.body = body
+    end
+
+    def render(filename, current_binding)
+      ERB.new(File.new(TEMPLATES_DIR + filename).read, nil, '-').result(current_binding)
+    end
+  end
+
+  CONFIG_FILE = ".schamard.config"
+  DEFAULT_CONFIG = {
+    input_file: "db/schema.rb",
+    output_file: "schema.metadata",
+    metadata_files: [],
+    rdoc_enabled: false,
+    parse_db_comment_as: "ignore",
+    log_output: STDOUT,
+    webserver_host: "127.0.0.1",
+    webserver_port: "10080"
+  }
+
+  class Configuration < Struct.new(*DEFAULT_CONFIG.keys)
+    include SchemaRD::Utils::StructAssigner
+    attr_reader :errors
+    def initialize(argv = nil)
+      hash = {}.merge(DEFAULT_CONFIG)
+      hash.merge(YAML.load_file(CONFIG_FILE)) if File.readable?(CONFIG_FILE)
+
+      unless argv.nil?
+        opt = OptionParser.new
+        opt.on('-i VAL', '--input-file=VAL') {|v| hash[:input_file] = v }
+        opt.on('-o VAL', '--output-file=VAL') {|v| hash[:output_file] = v }
+        opt.on('-f VAL', '-m VAL', '--metadata-file=VAL') {|v| hash[:metadata_files] << v }
+        opt.on('--rdoc', '--rdoc-enabled') { hash[:rdoc_enabled] = true }
+        opt.on('--parse-db-comment-as=VAL') {|v| hash[:parse_db_comment_as] = v }
+        opt.on('-s', '--silent', '--no-log-output') {|v| hash[:log_output] = File.open(File::NULL, 'w') }
+        opt.on('-h VAL', '--host=VAL') {|v| hash[:webserver_host] = v }
+        opt.on('-p VAL', '--port=VAL') {|v| hash[:webserver_port] = v }
+        opt.on('-l VAL', '--log-output=VAL') {|v| hash[:log_output] = self.class.str_to_io(v) }
+        opt.parse(argv)
+      end
+      self.assign(hash)
+    end
+
+    def parse_db_comment?
+      self.parse_db_comment_as != "ignore"
+    end
+
+    def valid?
+      @errors = []
+      unless File.readable?(self.input_file)
+        self.errors << "InputFile: \"#{self.input_file}\" is not readable!"
+      end
+      unless (File.writable?(self.output_file) || File.writable?(File.dirname(self.output_file)))
+        self.errors << "OutputFile: \"#{self.output_file}\" is not writable!"
+      end
+      self.metadata_files.each do |metadata_file|
+        unless File.readable?(metadata_file)
+          self.errors << "MetadataFile: \"#{metadata_file}\" is not readable!"
+        end
+      end
+      unless %w(ignore name localized_name description custom).include?(self.parse_db_comment_as)
+        self.errors << "ParseDBCommentAs: \"#{self.parse_db_comment_as}\" is not allowed!"
+      end
+      if self.log_output.is_a?(String)
+        self.errors << "LogFile: \"#{self.log_output}\" is not writable!"
+      end
+      unless self.webserver_port =~ /^[0-9]+$/
+        self.errors << "WebServerPort: \"#{self.webserver_port}\" is invalid!"
+      end
+      self.errors.empty?
+    end
+
+    private
+
+    def self.str_to_io(str)
+      case str
+      when "stdout", "STDOUT"
+        STDOUT
+      when "stderr", "STDERR"
+        STDERR
+      else
+        File.open(str, 'w') rescue str
+      end
+    end
+  end
+end

data/lib/schemard/metadata.rb

@@ -0,0 +1,134 @@
+require 'yaml'
+require_relative 'utils/localizer'
+require_relative 'rdoc_parser'
+
+module SchemaRD
+  module Metadata
+    def self.load(config:, lang:, schema:)
+      metadata = Parser.new(config.output_file, *config.metadata_files).parse()
+      localizer = SchemaRD::Utils::SchemaLocalizer.new(lang, metadata)
+      # localized_name を設定
+      schema.tables.each do |table|
+        table.localized_name = localizer.table_name(table.name)
+        table.columns.each do |column|
+          column.localized_name = localizer.column_name(table.name, column.name)
+        end
+      end
+      # set position, and relations
+      (metadata["tables"] || {}).each do |table_name, hash|
+        # skip when table name exists in metadata only.
+        next unless schema.table(table_name)
+        if hash["position_left"] && hash["position_top"]
+          schema.table(table_name).position =
+            { "left" => hash["position_left"], "top" => hash["position_top"] }
+        end
+        self.add_relations(table_name, "belongs_to", hash["belongs_to"], schema)
+        self.add_relations(table_name, "has_many",   hash["has_many"], schema)
+        self.add_relations(table_name, "has_one",    hash["has_one"], schema)
+      end
+      # db_comment にメタ情報が含まれる場合に設定
+      if config.parse_db_comment?
+        schema.tables.each do |table|
+          if table.parsed_db_comment && table.parsed_db_comment.strip != ""
+            case config.parse_db_comment_as
+            when 'name', 'localized_name'
+              table.localized_name = table.parsed_db_comment.strip
+            when 'description'
+              table.description = table.parsed_db_comment.strip
+            when 'custom'
+              config.db_comment_parser.call(table: table)
+            end
+          end
+          table.columns
+          .select{|c| c.parsed_db_comment && c.parsed_db_comment.strip != ""}.each do |column|
+            case config.parse_db_comment_as
+            when 'name', 'localized_name'
+              column.localized_name = column.parsed_db_comment.strip
+            when 'description'
+              column.description = column.parsed_db_comment.strip
+            when 'custom'
+              config.db_comment_parser.call(column: column)
+            end
+          end
+        end
+      end
+      # RDocコメントとしてメタ情報が含まれる場合に設定
+      if config.rdoc_enabled
+        rdoc = SchemaRD::RDocParser.new(config.input_file)
+        schema.tables.select{|t| rdoc.table_comment(t.name) }.each do |table|
+          parser = DefaultTableCommentParser.new(rdoc.table_comment(table.name))
+          table.localized_name = parser.localized_name if parser.has_localized_name?
+          table.description = parser.description if parser.has_description?
+
+          %i(belongs_to has_many has_one).each do |rel_type|
+            if parser.has_relation_of?(rel_type)
+              self.add_relations(table.name, rel_type.to_s, parser.relation_of(rel_type), schema)
+            end
+          end
+        end
+      end
+      # output_file がなければ作成
+      Writer.new(config.output_file).save_all(schema.tables) unless File.exist?(config.output_file)
+      schema
+    end
+
+    def self.add_relations(table_name, type, relation_table_names, schema)
+      return unless relation_table_names
+      relation_table_names = relation_table_names.split(",") if relation_table_names.is_a?(String)
+
+      relation_table_names.map{|rel_table_name| schema.table(rel_table_name) }.compact.each do |rel_table|
+        parent_table = type == "belongs_to" ? rel_table : schema.table(table_name)
+        child_table = type == "belongs_to" ? schema.table(table_name) : rel_table
+
+        if parent_table.relation_to(child_table.name).nil?
+          schema.add_relation(TableRelation.new(parent_table: parent_table, child_table: child_table))
+        end
+        parent_table.relation_to(child_table.name).child_cardinality = "1" if type == "has_one"
+      end
+    end
+
+    # Writer for metadata yaml
+    class Writer
+      def initialize(output_file)
+        @output_file = output_file
+      end
+      def save_all(tables)
+        hash = tables.each_with_object({}) do |t, hash|
+          hash[t.name] = { "position_top" => t.position["top"], "position_left" => t.position["left"] }
+        end
+        File.write(@output_file, YAML.dump({ "tables" => hash }))
+      end
+      def save(table_name, position)
+        hash = YAML.load_file(@output_file) || {}
+        hash["tables"] = {} unless hash.has_key?("tables")
+        hash["tables"] = {} unless hash["tables"].is_a?(Hash)
+        hash["tables"][table_name] = {} unless hash["tables"][table_name]
+        hash["tables"][table_name] = {} unless hash["tables"][table_name].is_a?(Hash)
+        hash["tables"][table_name]["position_top"] = position["top"].to_s
+        hash["tables"][table_name]["position_left"] = position["left"].to_s
+        File.write(@output_file, YAML.dump(hash))
+      end
+    end
+
+    # parser for metadata yaml
+    class Parser
+      def initialize(output_file, *metadata_files)
+        @parsed = {}
+        metadata_files.select{|metadata_file| File.exist?(metadata_file) }.each do |metadata_file|
+          self.class.deep_merge(@parsed, YAML.load_file(metadata_file))
+        end
+        self.class.deep_merge(@parsed, YAML.load_file(output_file)) if File.exist?(output_file)
+      end
+      # get hash of metadata
+      def parse
+        @parsed
+      end
+      def self.deep_merge(source, other)
+        other.each do |k,v|
+          next self.deep_merge(source[k], other[k]) if other[k].is_a?(Hash) && source[k].is_a?(Hash)
+          source[k] = other[k]
+        end
+      end
+    end # end of Parser
+  end # end of Metadata
+end

data/lib/schemard/rdoc_parser.rb

@@ -0,0 +1,66 @@
+require 'rdoc'
+module SchemaRD
+  class RDocParser
+    def initialize(filename)
+      parse(filename)
+    end
+
+    def table_comment(name)
+      method_obj = @clazz.find_method_named(name)
+      method_obj ? method_obj.comment.text : ""
+    end
+
+    private
+
+    def parse(filename)
+      file_content = File.read(filename)
+      content = "module Schemafile\n#{file_content}\nend"
+
+      rdoc = RDoc::RDoc.new
+      store = RDoc::Store.new
+      options = rdoc.load_options
+      stats = RDoc::Stats.new(store, 1, options.verbosity)
+      top_level = store.add_file(filename)
+      RDoc::Parser::Ruby.new(top_level, filename, content, options, stats).scan
+      @clazz = top_level.find_module_named("Schemafile")
+    end
+  end
+
+  class DefaultTableCommentParser
+    def initialize(comment_text)
+      @hash = { relations: {} }
+      @hash[:description] = comment_text.split("\n").map(&:strip).map{|line|
+        if line =~ /^name\:\:/ || line =~ /^localized_name\:\:/
+          @hash[:localized_name] = line.match(/^[^:]*name\:\:(.+)$/)[1].strip
+          next
+        end
+        %w(belongs_to has_many has_one).each do |rel_type|
+          if line =~ /^#{rel_type}\:\:/
+            tables = line.match(/^#{rel_type}\:\:(.+)$/)[1].split(",").map(&:strip).select{|s| s != "" }
+            @hash[:relations][rel_type.to_sym] = tables unless tables.empty?
+            line = nil # skip this line (by compact)
+          end
+        end
+        line
+      }.compact.join("\n")
+    end
+    def has_localized_name?
+      @hash[:localized_name] && @hash[:localized_name] != ""
+    end
+    def localized_name
+      @hash[:localized_name]
+    end
+    def has_description?
+      !!@hash[:description]
+    end
+    def description
+      @hash[:description]
+    end
+    def has_relation_of?(rel_type)
+      !!@hash[:relations][rel_type]
+    end
+    def relation_of(rel_type)
+      @hash[:relations][rel_type]
+    end
+  end
+end

data/lib/schemard/relation_generator.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'pathname'
+require 'optparse'
+
+module SchemaRD
+  class RelationGenerator
+    def initialize(argv)
+      rails_root = Pathname.pwd
+      opt = OptionParser.new
+      opt.on('-d VAL', 'Rails.root.directory') {|v| rails_root = Pathname.new(v).expand_path }
+      opt.parse(argv)
+
+      require_path = rails_root + "config/environment.rb"
+      unless require_path.exist?
+        puts "<#{rails_root}> is not Rails.root Directory, Abort!"
+        puts "Usage: schemard -d <Rails.root.dir>"
+      else
+        Dir.chdir(rails_root) do
+          require require_path.to_s
+        end
+      end
+    end
+    def ready?
+      defined?(Rails)
+    end
+    def run
+      Dir.glob(Rails.root + "app/models/**/*")
+      .reject{|path| Dir.exist?(path) }.each{|filepath| require filepath }
+
+      hash = ObjectSpace.each_object(Class)
+      .select{|o| o.ancestors.include?(ActiveRecord::Base) && o != ActiveRecord::Base }
+      .select{|o| o.table_name }
+      .each_with_object({}) do |model, hash|
+        hash[model.table_name] = {}
+
+        relation_selector = ->(klass){ model._reflections.values.select{|r| r.is_a?(klass) } }
+        has_one_rels = relation_selector.call(ActiveRecord::Reflection::HasOneReflection)
+        has_many_rels = relation_selector.call(ActiveRecord::Reflection::HasManyReflection)
+        belongs_to_rels = relation_selector.call(ActiveRecord::Reflection::BelongsToReflection)
+
+        if has_one_rels.present?
+          hash[model.table_name]["has_one"] = has_one_rels.map{|r| r.klass.table_name }
+        end
+        if has_many_rels.present?
+          hash[model.table_name]["has_many"] = has_many_rels.map{|r| r.klass.table_name }
+        end
+        if belongs_to_rels.present?
+          hash[model.table_name]["belongs_to"] = belongs_to_rels.map{|r| r.klass.table_name }
+        end
+      end
+      puts YAML.dump({ "tables" => hash })
+    end
+  end
+end

data/lib/schemard/schema.rb

@@ -0,0 +1,79 @@
+require_relative 'utils/struct_assigner'
+
+module SchemaRD
+  class Schema
+    attr_reader :relations
+    def initialize
+      @tables = {}
+      @relations = []
+    end
+    def tables
+      @tables.values
+    end
+    def table(name)
+      @tables[name.to_s]
+    end
+    def add_table(name, table_object)
+      @tables[name.to_s] = table_object
+      table_object.set_schema(self)
+    end
+    def add_relation(relation)
+      @relations << relation
+    end
+  end
+
+  class Table < Struct.new(*%i(columns indexes name localized_name description position parsed_db_comment))
+    include SchemaRD::Utils::StructAssigner
+    def initialize(hash = nil)
+      self.columns = []
+      self.indexes = []
+      self.position = { "left" => 0, "top" => 0 }
+      self.assign(hash)
+    end
+    def set_schema(schema)
+      @schema = schema
+    end
+    def relations_as_parent
+      @schema.relations.select{|r| r.parent_table == self }
+    end
+    def relations_as_child
+      @schema.relations.select{|r| r.child_table == self }
+    end
+    def relation_to(table_name)
+      self.relations_as_parent.find{|r| r.child_table.name == table_name }
+    end
+    def display_name
+      self.localized_name || self.name
+    end
+    def default_position?
+      self.position["left"] == 0 && self.position["top"] == 0
+    end
+  end
+
+  class TableRelation < Struct.new(*%i(parent_table child_table parent_cardinality child_cardinality))
+    include SchemaRD::Utils::StructAssigner
+    def initialize(hash = nil)
+      self.parent_cardinality = "1"
+      self.child_cardinality = "N"
+      self.assign(hash)
+    end
+  end
+
+  class TableColumn < Struct.new(
+    *%i(name localized_name type null default limit precision scale description parsed_db_comment))
+    include SchemaRD::Utils::StructAssigner
+    def initialize(hash = nil)
+      self.assign(hash)
+    end
+    def display_name
+      self.localized_name || self.name
+    end
+  end
+  class TableIndex < Struct.new(*%i(name columns unique))
+    include SchemaRD::Utils::StructAssigner
+    def initialize(hash = nil)
+      self.columns = []
+      self.assign(hash)
+    end
+  end
+end

data/lib/schemard/schema_parser.rb

@@ -0,0 +1,92 @@
+require_relative "schema"
+
+module SchemaRD
+  module MigrationContext
+    class Loader
+      class TableDefinition
+        [
+          :bigint,
+          :binary,
+          :boolean,
+          :date,
+          :datetime,
+          :decimal,
+          :float,
+          :integer,
+          :string,
+          :text,
+          :time,
+          :timestamp,
+          :virtual,
+        ].each do |column_type|
+          module_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{column_type}(*args, **options)
+              args.each { |name| column(name, :#{column_type}, options) }
+            end
+          CODE
+        end
+        alias_method :numeric, :decimal
+        def initialize(table, with_comment:)
+          @table = table
+          @parse_db_comment = with_comment
+        end
+        def method_missing(name, *args)
+          self.column(args[0], "unknown", args[1])
+        end
+        def column(name, type, options = {})
+          if options[:comment] && @parse_db_comment
+            options[:parsed_db_comment] = options.delete(:comment)
+          end
+          @table.columns << SchemaRD::TableColumn.new(options.merge({ name: name, type: type }))
+        end
+        def timestamps
+          column("created_at", :timestamp, null: false)
+          column("updated_at", :timestamp, null: false)
+        end
+        def index(column_name, options = {})
+          column_name = [ column_name ] unless column_name.is_a?(Array)
+          @table.indexes << SchemaRD::TableIndex.new(options.merge({ columns: column_name }))
+        end
+      end
+      def initialize(schema, with_comment:)
+        @schema = schema
+        @parse_db_comment = with_comment
+      end
+      def create_table(table_name, options = {})
+        if options[:comment] && @parse_db_comment
+          options[:parsed_db_comment] = options.delete(:comment)
+        end
+        table = SchemaRD::Table.new(options.merge(name: table_name))
+        @schema.add_table(table_name, table)
+        yield TableDefinition.new(table, with_comment: @parse_db_comment)
+      end
+      def add_index(table_name, column_name, options = {})
+        column_name = [ column_name ] unless column_name.is_a?(Array)
+        index = SchemaRD::TableIndex.new(options.merge({ columns: column_name }))
+        @schema.table(table_name).indexes << index
+      end
+      def enable_extension(*args); end
+
+      module ActiveRecord
+        class Schema
+          def self.define(*args)
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  class SchemaParser
+    def initialize(filename)
+      @filename = filename
+    end
+    def parse(with_comment: false)
+      Schema.new.tap do |schema|
+        File.open(@filename) do |file|
+          MigrationContext::Loader.new(schema, with_comment: with_comment).instance_eval(file.read, @filename)
+        end
+      end
+    end
+  end
+end

data/lib/schemard/utils/localizer.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require_relative 'singularizer'
+
+module SchemaRD::Utils
+  class Localizer
+    attr_reader :lang
+    def initialize(lang)
+      @lang = self.dictionary && self.dictionary.has_key?(lang) ? lang : "en"
+    end
+    def translate(key)
+      key.split(".").inject(self.dictionary[lang]) do |dict, k|
+        break if dict.nil? || !dict.is_a?(Hash)
+        dict[k]
+      end
+    end
+    alias_method :t, :translate
+  end
+
+  class MessageLocalizer < Localizer
+    MESSAGES_FILE = "#{File.dirname(File.expand_path(__FILE__))}/../../locales/messages.yml"
+
+    def initialize(lang)
+      super(lang)
+    end
+    def dictionary
+      YAML.load_file(MESSAGES_FILE)
+    end
+  end
+
+  class SchemaLocalizer < Localizer
+    attr_reader :dictionary
+    def initialize(lang, hash)
+      super(lang)
+      @dictionary = hash
+    end
+    def table_name(name)
+      self.t("activerecord.models.#{name.singularize}")
+    end
+    def column_name(table_name, column_name)
+      self.t("activerecord.attributes.#{table_name.singularize}.#{column_name}")
+    end
+  end
+end