shomen-yard 0.1.0

data/.ruby

@@ -0,0 +1,54 @@
+---
+source:
+- meta
+authors:
+- name: trans
+  email: transfire@gmail.com
+copyrights: []
+requirements:
+- name: yard
+- name: shomen-model
+- name: detroit
+  groups:
+  - build
+  development: true
+dependencies: []
+alternatives: []
+conflicts: []
+repositories:
+- uri: git://github.com/rubyworks/shomen-yard.git
+  scm: git
+  name: upstream
+resources:
+- uri: http://rubyworks.github.com/shomen-yard
+  name: home
+  type: home
+- uri: http://github.com/rubyworks/shomen-yard/wiki
+  name: docs
+  type: doc
+- uri: http://github.com/rubyworks/shomen-yard
+  name: code
+  type: code
+- uri: http://github.com/rubyworks/shomen-yard/issues
+  name: bugs
+  type: bugs
+- uri: http://groups.google.com/groups/rubyworks-mailinglist
+  name: mail
+  type: mail
+- uri: http://chat.us.freenode.net/rubyworks
+  name: chat
+  type: chat
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2010-07-01'
+summary: Shomen via YARD command line utility
+title: Shomen YARD
+version: 0.1.0
+name: shomen-yard
+description: ! 'Shomen YARD is a utiliity for generating Shomen documentation file
+
+  using YARD as a backend parser.'
+organization: rubyworks
+date: '2012-04-19'

data/.yardopts

@@ -0,0 +1,7 @@
+--private
+--protected
+-r README.md
+lib/
+-
+[A-Z]*.*
+log/[A-Z].*

data/HISTORY.md

@@ -0,0 +1,11 @@
+# RELEASE HISTORY
+
+## 0.1.0 / 2012-04-19
+
+This is the initial public release of Shomen YARD, spun-off
+from the main Shomen library.
+
+Changes:
+
+* Happy Release Day!
+

data/LICENSE.txt

@@ -0,0 +1,28 @@
+Shomen Yard - Shomen Generator via Yard Documentation
+(http://github.com/rubyworks/shomen)
+
+Copyright (c) 2011 Rubyworks. All rights reserved. 
+
+Redistribution and use in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+SPDX License: BSD-2-Clause

data/README.md

@@ -0,0 +1,7 @@
+# Shomen Yard
+
+## Description
+
+Shome Yard is a Shomen documentation generator utility that uses 
+YARD's documentation cache (usually stpred in `.yardoc`).
+

data/bin/shomen-yard

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'shomen-yard'
+Shomen::Yard::Command.run(*ARGV)

data/lib/shomen-yard.rb

@@ -0,0 +1,32 @@
+module Shomen
+
+  # Shomen Yard provides a utility for generating Shomen documentation
+  # from YARD cache.
+  #
+  module Yard
+    #
+    # Access project metadata.
+    #
+    # @return [Hash]
+    #
+    def self.metadata
+      @metadata ||= (
+        require 'yaml'
+        YAML.load_file(File.dirname(__FILE__) + '/shomen-yard.yml')
+      )
+    end
+
+    #
+    # If constant missing check metadata.
+    #
+    def self.const_missing(name)
+      metadata[name.to_s.downcase] || super(name)
+    end
+  end
+
+end
+
+require 'shomen-model'
+require 'shomen-yard/generator'
+require 'shomen-yard/command'
+

data/lib/shomen-yard/command.rb

@@ -0,0 +1,160 @@
+module Shomen
+
+  module Yard
+
+    # TODO: Instead of using command line options for shomen
+    # we could use environment variables. ?
+
+    # The YARD command line tool provides a utility to generate a Shomen documentation
+    # file using YARD's .yardoc cache.
+    #
+    # Examples:
+    #
+    #     $ shomen-yard --readme README.md lib - [A-Z]*.*
+    #
+    class Command
+      require 'optparse'
+
+      # Public: Shortcut for `CLI.new(*argv).run`.
+      #
+      # Returns nothing.
+      def self.run(*argv)
+        new(*argv).run
+      end
+
+      # Command line options.
+      attr :options
+
+      # Initialize new command.
+      #
+      # argv - Command line arguments. [Array]
+      #
+      # Returns CLI instance.
+      def initialize(*argv)
+        @options = {}
+
+        parse(argv)
+      end
+
+      # Public: Run command.
+      #
+      # Returns nothing.
+      def run
+        generator = Generator.new(options)
+        $stdout.puts generator
+      end
+
+      # Parse command line arguments.
+      #
+      # argv - List of command line arguments. [Array]
+      #
+      # Returns list of arguments. [Array]
+      #
+      def parse(argv)
+        if i = argv.index('-')
+          @documents = argv[i+1..-1]
+          argv = argv[0...i]
+        end
+
+        parser = OptionParser.new
+
+        parser_options(parser)
+
+        parser.parse!(argv)
+
+        if !(force? or root?)
+          $stderr.puts "ERROR: Not a project directory. Use --force to override."
+          exit -1
+        end
+
+        @scripts = argv
+      end
+
+      # Define command line options.
+      #
+      # parser - Instance of {OptionParser}.
+      #
+      # Returns nothing.
+      def parser_options(parser)
+        #parser.on('-Y', '--yard', 'use YARD for parsing') do
+        #  options[:engine] = :yard
+        #end
+        #parser.on('-R', '--rdoc', 'use RDoc for parsing') do
+        #  options[:engine] = :rdoc
+        #end
+
+        parser.on('-j', '--json', 'output JSON instead of YAML (default)') do
+          options[:format] = :json
+        end
+        parser.on('-y', '--yaml', 'output YAML instead of JSON') do
+          options[:format] = :yaml
+        end
+
+        parser.on('-d', '--db DIR', 'documentation store directory (deafult is `.rdoc` or `.yardoc`)') do |dir|
+          options[:store] = dir
+        end
+        parser.on('-c', '--use-cache', 'do not regenerate docs, use pre-existing cache') do
+          options[:use_cache] = true
+        end
+
+        parser.on('-s', '--source', 'include full source in script documentation') do
+          options[:source] = true
+        end
+        parser.on('-w', '--webcvs URI', 'prefix link to source code') do |uri|
+          options[:webcvs] = uri
+        end
+        parser.on('-r', '--readme FILE', 'which file to use as main') do |file|
+          options[:readme] = file
+        end
+
+        #parser.on('--save', 'save options for future use') do |markup|
+        #  options[:save] = true
+        #end
+
+        # TODO: shouldn't this be in .yardopts?
+        parser.on('--markup TYPE', 'markup type used for comments (rdoc, md, tomdoc)') do |markup|
+          options[:markup] = markup.to_sym
+        end
+
+        parser.on('-F', '--force') do
+          $FORCE = true
+        end
+
+        parser.on_tail('--debug', 'run with $DEBUG set to true') do
+          $DEBUG = true
+        end
+        parser.on_tail('--warn', 'run with $VERBOSE set to true') do
+          $VERBOSE = true
+        end
+
+        parser.on_tail('--help', 'see this help message') do
+          puts parser; exit -1
+        end
+      end
+
+      # Is `$FORCE` set?
+      #
+      # Returns true or false.
+      def force?
+        !!$FORCE
+      end
+
+      # Is this a project directory?
+      #
+      # Returns true or false.
+      def root?
+        root = false
+        root = true if File.exist?('.ruby')
+        root = true if File.exist?('.yardoc')
+        root = true if File.exist?('.rdoc')
+        root = true if File.exist?('.git')
+        root = true if File.exist?('.hg')
+        root = true if File.exist?('_darcs')
+        root
+      end
+
+    end
+
+  end
+
+end

data/lib/shomen-yard/generator.rb

@@ -0,0 +1,586 @@
+# encoding: UTF-8
+
+module Shomen
+
+  module Yard
+
+    # TODO: what about reading options from .yardopts ?
+    #       also yard.options[:yardopts] ?
+
+    # This adapter is used to convert YARD's documentation extracted
+    # from a local store (`.yardoc`) to Shomen's pure-data format.
+    #
+    class Generator < Shomen::Generator
+
+      STORE = '.yardoc'
+
+      # Require YARD library.
+      #
+      # Returns nothing.
+      def initialize(options)
+        require 'yard'
+
+        @store = STORE
+
+        super(options)
+      end
+
+      # The hash object that is used to store the generated 
+      # documentation.
+      #
+      # Returns Hash of documentation table.
+      attr :table
+
+      # The location YARD documentation cache. The default is `.yardoc`.
+      #
+      # Returns String.
+      attr_accessor :store
+
+      # Use pre-existant cache instead of regenerating documentation.
+      attr_accessor :use_cache
+
+      # Use pre-existant cache instead of regenerating documentation.
+      #
+      # Returns true/false.
+      def use_cache?
+        @use_cache
+      end
+
+      # Files to be documented.
+      #
+      # Returns Array of file paths.
+      def files
+        @files ||= (
+          list = []
+          list.concat scripts
+          list.concat documents
+          list.concat(['lib', 'README*']) if list.empty?
+          list
+        )
+      end
+
+      # Generate with YARD as backend processor.
+      #
+      # Returns documentation table. [Hash]
+      def generate
+        preconfigure unless use_cache?
+        generate_table
+      end
+
+      # The hash object that is used to store the generated 
+      # documentation.
+      #
+      # Returns documentation table. [Hash]
+      def table
+        @table
+      end
+
+    private
+
+      # Create YARD cache.
+      #
+      # Returns nothing.
+      def preconfigure
+        argv = []
+        argv.concat ["-q"]
+        argv.concat ["-n"]
+        argv.concat ["-b", store]
+        argv.concat ["--markup", markup] if markup
+        argv.concat ["--debug"] if $DEBUG
+        #argv.concat ["--no-save"] #unless save
+        argv.concat scripts
+        #argv.concat documents unless documents.empty?
+
+        # clear the registry in memory to remove any previous runs
+        YARD::Registry.clear
+
+        yard = YARD::CLI::Yardoc.new
+        $stderr.puts('yard ' + argv.join(' ')) if $DEBUG
+        yard.run(*argv)
+      end
+
+      # Generate the shomen data structure.
+      #
+      # Returns Hash of documentation table.
+      def generate_table
+        if not File.exist?(store)
+          $stderr.puts "ERROR: YARD database not found -- '#{store}`."
+          exit -1
+        end
+
+        @table = {}
+
+        scripts = []
+
+        generate_metadata
+
+        @registry = YARD::Registry.load!(store)
+        @registry.each do |object|
+          case object.type
+          when :constant
+            scripts.push(object.file)
+            generate_constant(object)
+          when :class, :module
+            scripts.push(object.file)
+            generate_class(object)
+            # TODO: is this needed?
+            #object.constants.each do |c|
+            #  generate_constant(c)
+            #end
+          when :method
+            scripts.push(object.file)
+            generate_method(object)
+          else
+            $stderr.puts "What is an #{object.type}? Ignored!"
+          end
+        end
+
+        # TODO: Are c/c++ sourse files working okay?
+        # TODO: Add a generator for non-ruby script (e.g. .js)?
+        collect_files.each do |file|
+          case File.extname(file)
+          when '.rb', '.rbx', '.c', '.cpp'
+            generate_script(file)
+          when '.rdoc', '.md', '.markdown', '.txt'
+            generate_document(file)
+          else
+            generate_document(file)
+          end
+        end
+
+        # TODO: Also pass parent ?
+        scripts.uniq.each do |file|
+          generate_script(file)
+        end
+
+        return @table
+      end
+
+      ## Project metadata.
+      ##
+      ## Returns Metadata instance.
+      #def project_metadata
+      #  @project_metadata ||= Shomen::Metadata.new
+      #end
+
+      # Collect files given list of +globs+.
+      #
+      # Returns Array of files.
+      def collect_files
+        globs = self.files
+        globs = globs.map{ |glob| Dir[glob] }.flatten.uniq
+        globs = globs.map do |glob|
+          if File.directory?(glob)
+            Dir[File.join(glob, '**/*')]
+          else
+            glob
+          end
+        end
+        list = globs.flatten.uniq.compact
+        list = list.reject{ |path| File.extname(path) == '.html' }
+        list = list.select{ |path| File.file?(path) }
+        list
+      end
+
+      # Generate project metadata entry.
+      #
+      # Returns Hash of metadata added to the documentation table.
+      def generate_metadata
+        metadata = Metadata.new
+        @table['(metadata)'] = metadata.to_h
+      end
+
+      # Generate a class or module structure. Note that as to whether `methods`
+      # also contains the accessor methods listed in `accessors` is left to
+      # YARD to determine.
+      #
+      # yard_class - YARD class documentation object.
+      #
+      # Returns Hash of class data that has been placed in the table
+      def generate_class(yard_class)
+        debug_msg(yard_class.path.to_s)
+
+        meths = yard_class.meths(:included=>false, :inherited=>false)
+
+        if yard_class.type == :class
+          model = Model::Class.new
+          model.superclass = yard_class.superclass ? yard_class.superclass.path : 'Object'
+        else 
+          model = Model::Module.new
+        end
+
+        model.path            = yard_class.path
+        model.name            = yard_class.name.to_s
+        model.namespace       = yard_class.namespace.path  #full_name.split('::')[0...-1].join('::'),
+        model.comment         = yard_class.docstring.to_s
+        model.format          = 'rdoc'  #TODO: how to determine? rdoc, markdown or plaintext ?
+        model.constants       = yard_class.constants.map{ |x| x.path }  #TODO: complete_name(x.name, c.full_name) }
+        model.includes        = yard_class.instance_mixins.map{ |x| x.path }
+        model.extensions      = yard_class.class_mixins.map{ |x| x.path }
+        model.modules         = yard_class.children.select{ |x| x.type == :module }.map{ |x| x.path }
+                                #yard_class.modules.map{ |x| complete_name(x.name, c.full_name) }
+        model.classes         = yard_class.children.select{ |x| x.type == :class }.map{ |x| x.path }
+                                #yard_class.classes.map{ |x| complete_name(x.name, c.full_name) }
+
+        model.methods         = meths.select.map{ |m| m.path }
+        #model.methods         = meths.select{ |m| m.scope == :instance }.map{ |m| m.path }
+        #model.class_methods   = meths.select{ |m| m.scope == :class }.map{ |m| m.path }
+
+        model.accessors       = yard_class.attributes[:class].map{ |k, rw| yard_class.path + '.' + k.to_s } +
+                                yard_class.attributes[:instance].map{ |k, rw| yard_class.path + '#' + k.to_s }
+        #model.class_accessors = yard_class.attributes[:class].map{ |k, rw| yard_class.path + '.' + k.to_s }
+
+        model.files           = yard_class.files.map{ |f, l| "/#{f}" } # :#{l}" }
+
+        model.tags            = translate_tags(yard_class)
+
+        #@files.concat(yard_class.files.map{ |f, l| f })
+
+        @table[model.path] = model.to_h
+      end
+
+=begin
+    # Generate a module structure.
+    #
+    def generate_module(object)
+      index = object.path.to_s
+      #meths = object.meths(:included=>false, :inherited=>false)
+
+      debug_msg(index)
+
+      data = Model::Module.new(Yard::ModuleAdapter.new(object)).to_h
+
+      #data = Shomen::Model::Module.new(
+      #  'name'          => object.name.to_s,
+      #  'namespace'     => object.namespace.path, #full_name.split('::')[0...-1].join('::')
+      #  'comment'       => object.docstring.to_s,
+      #  'constants'     => object.constants.map{ |x| x.path }, #complete_name(x.name, c.full_name) }
+      #  'includes'      => object.instance_mixins.map{ |x| x.path },
+      #  'extensions'    => object.class_mixins.map{ |x| x.path },
+      #  'modules'       => object.children.select{ |x| x.type == :module }.map{ |x| x.path }, 
+      #                     #object.modules.map{ |x| complete_name(x.name, c.full_name) }
+      #  'classes'       => object.children.select{ |x| x.type == :class }.map{ |x| x.path },
+      #                     #object.classes.map{ |x| complete_name(x.name, c.full_name) }
+      #  'methods'       => meths.select{ |m| m.scope == :instance }.map{ |m| m.path },
+      #  'class-methods' => meths.select{ |m| m.scope == :class }.map{ |m| m.path },
+      #  #'attributes'       => meths.select{ |m| m.scope == :instance }.map{ |m| m.path },
+      #  #'class-attributes' => meths.select{ |m| m.scope == :class }.map{ |m| m.path },
+      #  'files'         => object.files.map{ |f, l| "/#{f}:#{l}" }
+      #).to_h
+
+      #@files.concat(object.files.map{ |f, l| f })
+
+      @table[index] = data
+    end
+=end
+
+      # Generate a method structure.
+      #
+      def generate_method(yard_method)
+        debug_msg(yard_method.to_s)
+
+        # not sure what to do with methods with no signatures ?
+        if !yard_method.signature
+          debug_msg "no method signature -- #{yard_method.inspect}"
+          return 
+        end
+
+        model = Model::Method.new
+        #class_model = object.scope == :instance ? Shomen::Module::Method : Shomen::Model::Function
+
+        model.path        = yard_method.path
+        model.name        = yard_method.name.to_s
+        model.namespace   = yard_method.parent.path  
+        model.comment     = yard_method.docstring.to_s
+        model.format      = 'rdoc'  # TODO: how to determine? rdoc, markdown or plain 
+        model.aliases     = yard_method.aliases.map{ |a| a.path }  #method_name(a) }
+        # TODO: how to get alias_for from YARD?
+        #model.alias_for = method_name(yard_method.alias_for)
+        model.singleton   = (yard_method.scope == :class)
+
+        model.declarations << yard_method.scope.to_s
+        model.declarations << yard_method.visibility.to_s
+        # FIXME
+        #model.declarations << yard_method.attr_info
+
+        model.interfaces = []
+        yard_method.tags.each do |tag|
+          case tag
+          when ::YARD::Tags::OverloadTag
+            model.interfaces << parse_interface(tag)
+          end
+        end
+        model.interfaces << parse_interface(yard_method)
+
+        model.returns = (
+          rtns = []
+          yard_method.tags(:return).each do |tag|
+            tag.types.to_a.each do |t|
+              rtns << {'type'=>t, 'comment'=>tag.text}
+            end
+          end
+          rtns
+        )
+
+        model.file     = '/'+yard_method.file
+        model.line     = yard_method.line.to_i
+        model.source   = yard_method.source.to_s.strip
+        model.language = yard_method.source_type.to_s
+        model.dynamic  = yard_method.dynamic
+
+        model.tags     = translate_tags(yard_method)
+
+        @table[model.path] = model.to_h
+      end
+
+      # Parse a yard method's interface.
+      def parse_interface(yard_method)
+        args, block = [], {}
+        image, returns = yard_method.signature.split(/[=-]\>/)
+        image = image.strip
+        if i = image.index(/\)\s*\{/)
+          block['image'] = image[i+1..-1].strip
+          image          = image[0..i].strip
+        end
+        image = image.sub(/^def\s*/, '')
+        image = image.sub(/^self\./, '')
+        image = image.sub('( )','()')
+
+        yard_method.parameters.each do |n,v|
+          n = n.to_s
+          case n
+          when /^\&/
+            block['name'] = n
+          else
+            args << (v ? {'name'=>n,'default'=>v} : {'name'=>n})
+          end
+        end
+
+        result = {}
+        result['signature']  = image
+        result['arguments']  = args
+        #result['parameters'] = params
+        result['block']      = block unless block.empty?
+        result['returns']    = returns.strip if returns
+        result
+      end
+      private :parse_interface
+
+      # Generate a constant.
+      #
+      def generate_constant(yard_constant)
+        debug_msg(yard_constant.path.to_s)
+
+        model = Model::Constant.new
+
+        model.path      = yard_constant.path
+        model.name      = yard_constant.name.to_s
+        model.namespace = yard_constant.namespace.path  
+        model.comment   = yard_constant.docstring.to_s
+        model.format    = 'rdoc'  #  TODO: how to determine? rdoc, markdown or plain 
+        model.value     = yard_constant.value
+        model.tags      = translate_tags(yard_constant)
+        model.files     = yard_constant.files.map{|f,l| "/#{f}"}  # or "#{f}:#{l}" ?
+
+        @table[model.path] = model.to_h
+      end
+
+      # Generate a file.
+      #
+      def generate_document(yard_document)
+        debug_msg(yard_document)
+
+        model = Model::Document.new
+
+        # FIXME: make absolute
+        absolute_path = yard_document.to_s
+
+        model.path   = yard_document.to_s
+        model.name   = File.basename(absolute_path)
+        model.mtime  = File.ctime(absolute_path)
+        model.ctime  = File.mtime(absolute_path)
+        model.text   = File.read(absolute_path)
+        model.format = mime_type(absolute_path)
+
+        webcvs = project_metadata['webcvs'] || webcvs
+        if webcvs
+          model.uri = File.join(webcvs, model.path)
+        end
+
+        @table['/'+model.path] = model.to_h
+      end
+
+      # Generate a script entry.
+      #
+      def generate_script(yard_script)
+        debug_msg(yard_script)
+
+        model = Model::Script.new
+
+        # FIXME: make absolute
+        absolute_path = yard_script.to_s
+
+        model.path  = yard_script.to_s
+        model.name  = File.basename(absolute_path)
+        model.ctime = File.ctime(absolute_path)
+        model.mtime = File.mtime(absolute_path)
+
+        if source?
+          model.source   = File.read(absolute_path) #file.comment
+          model.language = mime_type(absolute_path)
+        end
+
+        webcvs = project_metadata['webcvs'] || webcvs
+        if webcvs
+          model.uri      = File.join(webcvs, model.path)
+          model.language = mime_type(absolute_path)
+        end
+
+        #  model.header        = ""
+        #  model.footer        = ""
+        #  model.requires      =
+        #  model.constants     =
+        #  model.modules       =
+        #  model.classes       =
+        #  model.methods       =
+        #  model.class_methods =
+
+        @table['/'+model.path] = model.to_h
+
+        #table[index] = Shomen::Model::Script.new(
+        #  "name"        => File.basename(object),
+        #  "path"        => object,
+        #  #"loadpath"    => "lib",
+        #  "mtime"       => File.mtime(object),
+        #  "header"      => "",
+        #  "footer"      => "",
+        #  # "requires"    : ["fileutils"],
+        #  # "constants"   : ["MusicStore::CONFIG_DIRECTORY"],
+        #  # "modules"     : ["MusicStore", "MusicStore::MusicMixin"],
+        #  # "classes"     : ["MusicStore::Song"],
+        #  # "functions"   : ["MusicStore.config_directory"],
+        #  # "methods"     : ["MusicStore::MusicMixin#play", "MusicStore::MusicMixin#artist"]
+        #  "source"      => File.read(object)
+        #).to_h
+
+        @table['/'+model.path] = model.to_h
+      end
+
+      # Output progress information if debugging is enabled
+      #
+      def debug_msg(msg)
+        return unless $DEBUG
+        case msg[-1,1]
+          when '.' then tab = "= "
+          when ':' then tab = "== "
+          else          tab = "* "
+        end
+        $stderr.puts(tab + msg)
+      end
+
+      # Given a file return offical mime-type basic on file extension.
+      #
+      # FIXME: official mime types?
+      def mime_type(path)
+        case File.extname(path)
+        when '.rb', '.rbx'      then 'text/x-ruby'
+        when '.c'               then 'text/c-source'  # x-c-code
+        when '.js'              then 'text/ecmascript'
+        when '.rdoc'            then 'text/rdoc'
+        when '.md', '.markdown' then 'text/markdown'
+        else 'text/plain'
+        end
+      end
+
+      # Convert YARD Tags to simple Hash.
+      #
+      # TODO: Remove param tags?
+      def translate_tags(yard_object)
+        tags = {}
+        yard_object.tags.each do |tag|
+          next if tag.tag_name == 'return'
+          tags[tag.tag_name] = tag.text
+        end
+        return tags
+      end
+
+    end
+
+  end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+=begin
+    # Generate a method structure.
+    #
+    def generate_attribute(object)
+      index = "#{object.path}"
+
+      debug_msg(index)
+
+      data = Model::Method.new(Yard::MethodAdapter.new(object)).to_h
+
+      ##code       = m.source_code_raw
+      ##file, line = m.source_code_location
+
+      ##full_name = method_name(m)
+
+      ##'prettyname'   => m.pretty_name,
+      ##'type'         => m.type, # class or instance
+
+      #args = []
+      #object.parameters.each do |var, val|
+      #  if val
+      #    args << { 'name' => var, 'default'=>val }
+      #  else
+      #    args << { 'name' => var }
+      #  end
+      #end
+      #
+      #rtns = []
+      #object.tags(:return).each do |t|
+      #  t.types.each do |ty|
+      #    rtns << { 'type' => ty, 'comment' => t.text }
+      #  end
+      #end
+      #
+      #table[index] = Shomen::Model::Attribute.new(
+      #  'name'         => object.name.to_s,
+      #  'namespace'    => object.parent.path,
+      #  'comment'      => object.docstring.to_s,
+      #  'access'       => object.visibility.to_s,
+      #  'singleton'    => object.scope == :class,
+      #  'aliases'      => object.aliases.map{ |a| a.path }, #method_name(a) },
+      #  #'alias_for'    => method_name(m.is_alias_for),
+      #  'interfaces'   => [{'interface'  => object.signature.sub('def ', ''), #m.params,
+      #                      'arguments'  => args,
+      #                      'parameters' => []
+      #                      #'block'     => m.block_params, # TODO: what is block?
+      #                    }],
+      #  'returns'      => rtns,
+      #  'file'         => "/#{object.file}",
+      #  'line'         => object.line,
+      #  'source'       => object.source,
+      #  'language'     => object.source_type.to_s,
+      #  'dynamic'      => object.dynamic
+      #).to_h
+
+      @table[index] = model.to_h
+    end
+=end
+