bitclust-core 0.6.0 → 0.7.0

data/lib/bitclust/subcommands/init_command.rb

@@ -8,39 +8,38 @@ require 'yaml'
 require 'bitclust'
 require 'bitclust/subcommand'
 
-module BitClust::Subcommands
-  class InitCommand < BitClust::Subcommand
-    def initialize
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} init [KEY=VALUE ...]"
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
+module BitClust
+  module Subcommands
+    class InitCommand < Subcommand
+      def initialize
+        super
+        @parser.banner = "Usage: #{File.basename($0, '.*')} init [KEY=VALUE ...]"
+      end
 
-    STANDARD_PROPERTIES = %w( encoding version )
+      STANDARD_PROPERTIES = %w( encoding version )
 
-    def exec(db, argv)
-      db.init
-      db.transaction {
-        argv.each do |kv|
-          k, v = kv.split('=', 2)
-          db.propset k, v
-        end
-      }
-      fail = false
-      STANDARD_PROPERTIES.each do |key|
-        unless db.propget(key)
-          $stderr.puts "#{File.basename($0, '.*')}: warning: standard property `#{key}' not given"
-          fail = true
+      def exec(argv, options)
+        prefix = options[:prefix]
+        db = MethodDatabase.new(prefix)
+        db.init
+        db.transaction {
+          argv.each do |kv|
+            k, v = kv.split('=', 2)
+            db.propset k, v
+          end
+        }
+        fail = false
+        STANDARD_PROPERTIES.each do |key|
+          unless db.propget(key)
+            $stderr.puts "#{File.basename($0, '.*')}: warning: standard property `#{key}' not given"
+            fail = true
+          end
         end
-      end
-      if fail
-        $stderr.puts "---- Current Properties ----"
-        db.properties.each do |key, value|
-          $stderr.puts "#{key}=#{value}"
+        if fail
+          $stderr.puts "---- Current Properties ----"
+          db.properties.each do |key, value|
+            $stderr.puts "#{key}=#{value}"
+          end
         end
       end
     end

data/lib/bitclust/subcommands/list_command.rb

@@ -8,60 +8,58 @@ require 'yaml'
 require 'bitclust'
 require 'bitclust/subcommand'
 
-module BitClust::Subcommands
-  class ListCommand < BitClust::Subcommand
-    def initialize
-      @mode = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} list (--library|--class|--method|--function)"
-        opt.on('--library', 'List libraries.') {
+module BitClust
+  module Subcommands
+    class ListCommand < Subcommand
+      def initialize
+        super
+        @mode = nil
+        @parser.banner = "Usage: #{File.basename($0, '.*')} list (--library|--class|--method|--function)"
+        @parser.on('--library', 'List libraries.') {
           @mode = :library
         }
-        opt.on('--class', 'List classes.') {
+        @parser.on('--class', 'List classes.') {
           @mode = :class
         }
-        opt.on('--method', 'List methods.') {
+        @parser.on('--method', 'List methods.') {
           @mode = :method
         }
-        opt.on('--function', 'List functions.') {
+        @parser.on('--function', 'List functions (C API).') {
           @mode = :function
         }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      unless @mode
-        error 'one of (--library|--class|--method|--function) is required'
       end
-    end
 
-    def exec(db, argv)
-      case @mode
-      when :library
-        db.libraries.map {|lib| lib.name }.sort.each do |name|
-          puts name
-        end
-      when :class
-        db.classes.map {|c| c.name }.sort.each do |name|
-          puts name
+      def parse(argv)
+        super
+        unless @mode
+          error 'one of (--library|--class|--method|--function) is required'
         end
-      when :method
-        db.classes.sort_by {|c| c.name }.each do |c|
-          c.entries.sort_by {|m| m.id }.each do |m|
-            puts m.label
+      end
+
+      def exec(argv, options)
+        super
+        case @mode
+        when :library
+          @db.libraries.map {|lib| lib.name }.sort.each do |name|
+            puts name
           end
+        when :class
+          @db.classes.map {|c| c.name }.sort.each do |name|
+            puts name
+          end
+        when :method
+          @db.classes.sort_by {|c| c.name }.each do |c|
+            c.entries.sort_by {|m| m.id }.each do |m|
+              puts m.label
+            end
+          end
+        when :function
+          @db.functions.sort_by {|f| f.name }.each do |f|
+            puts f.name
+          end
+        else
+          raise "must not happen: @mode=#{@mode.inspect}"
         end
-      when :function
-        db.functions.sort_by {|f| f.name }.each do |f|
-          puts f.name
-        end
-      else
-        raise "must not happen: @mode=#{@mode.inspect}"
       end
     end
   end

data/lib/bitclust/subcommands/lookup_command.rb

@@ -8,82 +8,79 @@ require 'yaml'
 require 'bitclust'
 require 'bitclust/subcommand'
 
-module BitClust::Subcommands
-  class LookupCommand < BitClust::Subcommand
-    def initialize
-      @format = :text
-      @type = nil
-      @key = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} lookup (--library|--class|--method|--function) [--html] <key>"
-        opt.on('--library=NAME', 'Lookup library.') {|name|
+module BitClust
+  module Subcommands
+    class LookupCommand < Subcommand
+      def initialize
+        super
+        @format = :text
+        @type = nil
+        @key = nil
+        @parser.banner = "Usage: #{File.basename($0, '.*')} lookup (--library|--class|--method|--function) [--html] <key>"
+        @parser.on('--library=NAME', 'Lookup library.') {|name|
           @type = :library
           @key = name
         }
-        opt.on('--class=NAME', 'Lookup class.') {|name|
+        @parser.on('--class=NAME', 'Lookup class.') {|name|
           @type = :class
           @key = name
         }
-        opt.on('--method=NAME', 'Lookup method.') {|name|
+        @parser.on('--method=NAME', 'Lookup method.') {|name|
           @type = :method
           @key = name
         }
-        opt.on('--function=NAME', 'Lookup function.') {|name|
+        @parser.on('--function=NAME', 'Lookup function. (C API)') {|name|
           @type = :function
           @key = name
         }
-        opt.on('--html', 'Show result in HTML.') {
+        @parser.on('--html', 'Show result in HTML.') {
           @format = :html
         }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      unless @type
-        error "one of --library/--class/--method/--function is required"
       end
-      unless argv.empty?
-        error "too many arguments"
+
+      def parse(argv)
+        super
+        unless @type
+          error "one of --library/--class/--method/--function is required"
+        end
+        unless argv.empty?
+          error "too many arguments"
+        end
       end
-    end
 
-    def exec(db, argv)
-      entry = fetch_entry(db, @type, @key)
-      puts fill_template(get_template(@type, @format), entry)
-    end
+      def exec(argv, options)
+        super
+        entry = fetch_entry(@db, @type, @key)
+        puts fill_template(get_template(@type, @format), entry)
+      end
 
-    def fetch_entry(db, type, key)
-      case type
-      when :library
-        db.fetch_library(key)
-      when :class
-        db.fetch_class(key)
-      when :method
-        db.fetch_method(BitClust::MethodSpec.parse(key))
-      when :function
-        db.fetch_function(key)
-      else
-        raise "must not happen: #{type.inspect}"
+      def fetch_entry(db, type, key)
+        case type
+        when :library
+          db.fetch_library(key)
+        when :class
+          db.fetch_class(key)
+        when :method
+          db.fetch_method(MethodSpec.parse(key))
+        when :function
+          db.fetch_function(key)
+        else
+          raise "must not happen: #{type.inspect}"
+        end
       end
-    end
 
-    def fill_template(template, entry)
-      ERB.new(template).result(binding())
-    end
+      def fill_template(template, entry)
+        ERB.new(template).result(binding())
+      end
 
-    def get_template(type, format)
-      template = TEMPLATE[type][format]
-      BitClust::TextUtils.unindent_block(template.lines).join('')
-    end
+      def get_template(type, format)
+        template = TEMPLATE[type][format]
+        TextUtils.unindent_block(template.lines).join('')
+      end
 
-    TEMPLATE = {
-      :library => {
-        :text => <<-End,
+      TEMPLATE = {
+        :library => {
+          :text => <<-End,
            type: library
            name: <%= entry.name %>
            classes: <%= entry.classes.map {|c| c.name }.sort.join(', ') %>
@@ -91,7 +88,7 @@ module BitClust::Subcommands
 
            <%= entry.source %>
            End
-        :html => <<-End
+          :html => <<-End
            <dl>
            <dt>type</dt><dd>library</dd>
            <dt>name</dt><dd><%= entry.name %></dd>
@@ -100,9 +97,9 @@ module BitClust::Subcommands
            </dl>
            <%= compile_rd(entry.source) %>
            End
-      },
-      :class   => {
-        :text => <<-End,
+        },
+        :class   => {
+          :text => <<-End,
            type: class
            name: <%= entry.name %>
            library: <%= entry.library.name %>
@@ -113,7 +110,7 @@ module BitClust::Subcommands
 
            <%= entry.source %>
            End
-        :html => <<-End
+          :html => <<-End
            <dl>
            <dt>type</dt><dd>class</dd>
            <dt>name</dt><dd><%= entry.name %></dd>
@@ -123,9 +120,9 @@ module BitClust::Subcommands
            </dl>
            <%= compile_rd(entry.source) %>
            End
-      },
-      :method  => {
-        :text => <<-End,
+        },
+        :method  => {
+          :text => <<-End,
            type: <%= entry.type %>
            name: <%= entry.name %>
            names: <%= entry.names.sort.join(', ') %>
@@ -135,7 +132,7 @@ module BitClust::Subcommands
 
            <%= entry.source %>
            End
-        :html => <<-End
+          :html => <<-End
            <dl>
            <dt>type</dt><dd><%= entry.type %></dd>
            <dt>name</dt><dd><%= entry.name %></dd>
@@ -146,16 +143,16 @@ module BitClust::Subcommands
            </dl>
            <%= compile_rd(entry.source) %>
            End
-      },
-      :function => {
-        :text => <<-End,
+        },
+        :function => {
+          :text => <<-End,
            kind: <%= entry.kind %>
            header: <%= entry.header %>
            filename: <%= entry.filename %>
 
            <%= entry.source %>
            End
-        :html => <<-End
+          :html => <<-End
            <dl>
            <dt>kind</dt><dd><%= entry.kind %></dd>
            <dt>header</dt><dd><%= entry.header %></dd>
@@ -163,14 +160,15 @@ module BitClust::Subcommands
            </dl>
            <%= compile_rd(entry.source) %>
            End
+        }
       }
-    }
 
-    def compile_rd(src)
-      umap = BitClust::URLMapper.new(:base_url => 'http://example.com',
-                                     :cgi_url  => 'http://example.com/view')
-      compiler = BitClust::RDCompiler.new(umap, 2)
-      compiler.compile(src)
+      def compile_rd(src)
+        umap = URLMapper.new(:base_url => 'http://example.com',
+                             :cgi_url  => 'http://example.com/view')
+        compiler = RDCompiler.new(umap, 2)
+        compiler.compile(src)
+      end
     end
   end
 end

data/lib/bitclust/subcommands/methods_command.rb

@@ -0,0 +1,159 @@
+require 'pathname'
+require 'optparse'
+
+require 'bitclust'
+require 'bitclust/crossrubyutils'
+require 'bitclust/subcommand'
+
+module BitClust
+  module Subcommands
+    class MethodsCommand < Subcommand
+      include CrossRubyUtils
+
+      def initialize
+        super
+        @requires = []
+        @verbose = false
+        @version = RUBY_VERSION
+        @mode = :list
+        @target = nil
+        @parser.banner = "Usage: #{File.basename($0, '.*')} [-r<lib>] <classname>"
+        @parser.on('-r LIB', 'Requires library LIB') {|lib|
+          @requires.push lib
+        }
+        @parser.on('-v', '--verbose', "Prints each ruby's version") {
+          @verbose = true
+        }
+        @parser.on('--diff=RDFILE', 'RD file name') {|path|
+          @mode = :diff
+          @target = path
+        }
+        @parser.on('-c', '') {
+          @content = true
+          require 'bitclust/ridatabase'
+        }
+        @parser.on('--ruby=[VER]', "The version of Ruby interpreter"){|version|
+          @version = version
+        }
+        @parser.on('--ri-database', 'The path of ri database'){|path|
+          @ri_path = path
+        }
+      end
+
+      def parse(argv)
+        super
+        option_error("wrong number of arguments") unless argv.size == 1
+      end
+
+      def exec(argv, options)
+        classname = argv[0]
+        case @mode
+        when :list
+          print_crossruby_table {|ruby| defined_methods(ruby, classname) }
+        when :diff
+          unless ruby = get_ruby(@version)
+            raise "Not found Ruby interpreter of the given version"
+          end
+          keys = defined_methods(ruby, classname)
+          lib = RRDParser.parse_stdlib_file(@target, { 'version' => @version })
+          c = lib.fetch_class(classname)
+          list0 = lib.classes.find_all{|c0| /\A#{classname}\b/o =~ c0.name }
+          list0 = c.entries + list0
+          list = list0.map {|ent| ent.labels.map {|n| expand_mf(n) } }.flatten
+          if @content
+            ri = @ri_path ? RiDatabase.open(@ri_path, nil) : RiDatabase.open_system_db
+            ri.current_class = c.name
+            mthds = ( ri.singleton_methods + ri.instance_methods )
+            fmt = Formatter.new
+            (keys - list).sort.each do |name|
+              mthd = mthds.find{|m| name == m.fullname }
+              if mthd
+                puts fmt.method_info(mthd.entry)
+              else
+                name = name.sub(/\A\w+#/, '')
+                puts "--- #{name}\n\#@todo\n\n"
+              end
+            end
+          else
+            (keys - list).sort.each do |name|
+              puts "-#{name}"
+            end
+            (list - keys).sort.each do |name|
+              puts "+#{name}"
+            end
+          end
+        else
+          raise "must not happen: #{mode.inspect}"
+        end
+      end
+
+      def expand_mf(n)
+        if /\.\#/ =~ n
+          [n.sub(/\.\#/, '.'), n.sub(/\.\#/, '#')]
+        else
+          n
+        end
+      end
+
+      def crossrubyutils_sort_entries(ents)
+        ents.sort_by {|m| m_order(m) }
+      end
+
+      ORDER = { '.' => 1, '#' => 2, '::' => 3 }
+
+      def m_order(m)
+        m, t, c = *m.reverse.split(/(\#|\.|::)/, 2)
+        [ORDER[t] || 0, m.reverse]
+      end
+
+      def defined_methods(ruby, classname)
+        req = @requires.map {|lib| "-r#{lib}" }.join(' ')
+        avoid_tracer = ""
+        avoid_tracer = "Tracer.off" if @requires.include?("tracer")
+        case classname
+        when 'Object'
+          script = <<-SCRIPT
+            c = #{classname}
+            c.singleton_methods(false).each do |m|
+              puts "#{classname}.\#{m}"
+            end
+            c.instance_methods(true).each do |m|
+              puts "#{classname}\\#\#{m}"
+            end
+          SCRIPT
+        when 'Kernel'
+          script = <<-SCRIPT
+            c = #{classname}
+            c.singleton_methods(true).each do |m|
+              puts "#{classname}.\#{m}"
+            end
+            ( c.private_instance_methods(false) && c.methods(false) ).each do |m|
+              puts "#{classname}\\#\#{m}"
+            end
+            Object::constants.delete_if{|c| cl = Object.const_get(c).class; cl == Class or cl == Module }.each do |m|
+              puts "#{classname}::\#{m}"
+            end
+            global_variables.each do |m|
+              puts "#{classname}\#{m}"
+            end
+          SCRIPT
+        else
+          script = <<-SCRIPT
+            #{avoid_tracer}
+            c = #{classname}
+            c.singleton_methods(false).each do |m|
+              puts "#{classname}.\#{m}"
+            end
+            c.instance_methods(false).each do |m|
+              puts "#{classname}\\#\#{m}"
+            end
+            c.ancestors.map {|mod| mod.constants }.inject {|r,n| r-n }.each do |m|
+              puts "#{classname}::\#{m}"
+            end
+          SCRIPT
+        end
+        `#{ruby} #{req} -e '#{script}'`.split
+      end
+    end
+  end
+end