cloc 0.9.0

data/bin/cloc

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+begin
+  # If we were installed as a gem we can just:
+  require 'cloc'
+rescue LoadError
+  # No, we weren't installed as a gem. Let's try to make Ruby aware
+  # of our library folder.
+  lib = File.join(File.dirname(__FILE__), '..', 'lib')
+  $: << lib
+  require 'cloc'
+end
+
+require 'optparse'
+
+SETTINGS = { :version => Cloc::Database.default_version }
+
+def process_files
+  db = Cloc::Database.new SETTINGS[:version]
+  linker = Cloc::Linker.new
+  ARGV.each do |file|
+    if File.directory? file
+      Dir.glob(File.join(file, '**', '*.[cy]')).each do |file|
+        linker.process_file file
+      end
+    else
+      linker.process_file file
+    end
+  end
+  linker.resolve_non_static_functions
+  linker.remove_missing
+  db.merge linker.data
+  db.save
+end
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: cloc [options] files-or-folders ...'
+  opts.separator ''
+  opts.separator <<EOS
+DESCRIPTION
+
+'cloc' is a program that locates Ruby methods in C source files and
+records their location (filepath + line number) in ~/.cloc-VERSION
+
+VERSIONS
+
+Since you may have several different versions of Ruby's source code on
+your system, cloc's data file has a "version" embedded in it. E.g.,
+~/.cloc-1.8.7 and ~/.cloc-1.9.1. It's up to you to decide on these version
+strings (they have absolutely no meaning for cloc). You may specify the
+version to work with with the '-v' switch.
+
+Common options:
+EOS
+  opts.on('-v', '--version VERSION', "Select the version (default: #{SETTINGS[:version]}).") do |v|
+    SETTINGS[:version] = v
+  end
+  opts.on('-l', '--list', 'List existing versions and exit.') do
+    p Cloc::Database.versions
+    exit
+  end
+
+  opts.separator ''
+  opts.separator 'Debugging options:'
+
+  opts.on('-p', '--pp', 'Print out the database contents and exit.') do
+    require 'pp'
+    pp Cloc::Database.new(SETTINGS[:version]).data
+    exit
+  end
+  opts.on('-w', '--warnings', "Show warnings (these are usually harmless).") do
+    Cloc.warn = true
+  end
+  opts.on('-b', 'Print out the process memory consumption (linux only).', 'and do some benchmarking.') do
+    system("ps -p #{$$} -o vsz,rss,cmd")
+    db = Cloc::Database.new(SETTINGS[:version])
+    system("ps -p #{$$} -o vsz,rss,cmd")
+    require 'benchmark'
+    Benchmark.bm do |x|
+      x.report { 10.times { db.load } }
+    end
+    exit
+  end
+end.parse!
+
+if ARGV.empty?
+  puts "No file(s) or folder(s) specified. Nothing to do. Exiting"
+  puts "Invoke with `--help' for help."
+  exit
+else
+  process_files
+end

data/lib/cloc.rb

@@ -0,0 +1,14 @@
+
+module Cloc
+
+  class << self
+    # Whether to warn of various things (parsing/linking problems).
+    attr_accessor :warn
+    alias warn? warn
+  end
+
+  autoload :Database, 'cloc/database'
+  autoload :Linker, 'cloc/linker'
+  autoload :FileSource, 'cloc/filesource'
+
+end

data/lib/cloc/database.rb

@@ -0,0 +1,63 @@
+
+module Cloc
+
+  HOME = ENV['HOME'] ? File.expand_path('~') : Dir.pwd
+
+  class Database
+
+    # Find all existing versions.
+    def self.versions
+      @versions ||= Dir.entries(HOME).grep(/^.cloc-(.*)/) { $1 }.sort
+    end
+
+    # Pick a default version.
+    #
+    # We give preference to RUBY_VERSION.
+    def self.default_version
+      versions.include?(RUBY_VERSION) ? RUBY_VERSION : (versions.first || RUBY_VERSION)
+    end
+
+    def initialize(version)
+      @version = version
+      @table = {}
+      load if File.exist? path
+    end
+
+    def version; @version; end
+
+    def merge(hash)
+      @table.merge!(hash) do |key, oldval, newval|
+        oldval.merge(newval)
+      end
+    end
+
+    def data
+      @table
+    end
+
+    # Returns the source-code location where a method is defined.
+    #
+    # Returned value is either [ path_to_file, line_number ], or nil if
+    # the method isn't known.
+    def lookup(object_name, method_name)
+      if @table[object_name] and (loc = @table[object_name][method_name])
+        # Since the pathname is stored as a symbol, we convert
+        # it back to a string.
+        return [loc[0].to_s, loc[1]]
+      end
+    end
+
+    def path
+      File.join(HOME, ".cloc-#{@version}")
+    end
+
+    def save
+      File.open(path, 'w') { |f| Marshal.dump(@table, f) }
+    end
+
+    def load
+      @table = File.open(path) { |f| Marshal.load(f) }
+    end
+  end
+
+end

data/lib/cloc/filesource.rb

@@ -0,0 +1,115 @@
+
+module Cloc
+
+  class NmNtFnd < Exception
+  end
+
+  class FileSource
+
+    def initialize(pathname)
+      @pathname = pathname
+      @c2r_cache = {}
+    end
+
+    def raw_source
+      @raw_source ||= IO.read(@pathname).gsub!(/\r?\n|\r/, "\n").freeze
+    end
+
+    # Returns the source after processing it a bit to make it easier
+    # for other parsing functions to not care about edge cases.
+    def source
+      return @source if defined? @source
+
+      @source = raw_source.dup
+      @source.gsub!('rb_define_global_function(', 'rb_define_module_function(rb_mKernel,')
+      @source.gsub!('define_filetest_function(', 'rb_define_singleton_method(rb_cFile,')
+
+      # Add any special cases here. As an example, here are some
+      # "macro expansions" required to process DataObjects extensions.
+      @source.gsub!('CONST_GET(rb_mKernel,', 'rb_path2class(')
+      @source.gsub!('SQLITE3_CLASS(', 'rb_define_class_under(mSqlite3,');
+      @source.gsub!('DRIVER_CLASS(', 'rb_define_class_under(mDOMysql,');
+
+      @source.freeze
+    end
+
+    # Converts a character offset to a line number.
+    def offs_to_line(offs)
+      # The following isn't as inefficient as it seems: slice() returns
+      # a string pointing inside the original string's allocated space.
+      return source.slice(0, offs).count("\n") + 1
+    end
+
+    # Returns a list of all the C functions that are callable from Ruby.
+    def cfunctions
+      @cfunction ||= begin
+        list = {}
+        source.scan( /\n (?:static\s+)? VALUE\s+ (\w+) \( /x ) do |func, |
+          list[func] = offs_to_line($~.begin(1))
+        end
+        list
+      end
+    end
+
+    # Returns the fully-qualified Ruby class/module name behind a C variable.
+    #
+    #   Examples:
+    #     "rb_mKernel" -> "Kernel"
+    #     "cResolver" -> "YAML::Syck::Resolver"
+    def c2r(cvar)
+      return @c2r_cache[cvar] if @c2r_cache[cvar]
+      @c2r_cache[cvar] = _c2r(cvar)
+    end
+
+    def _c2r(cvar)
+      if source =~ /#{cvar} \s* = \s* rb_define_(?:class|module) \( \s* "([^"]+)" /x
+        return $1
+      end
+      if source =~ /#{cvar} \s* = \s* rb_define_(?:class|module)_under \( \s* (\w+) \s* , \s* "([^"]+)" /x
+        return c2r($1) + '::' + $2
+      end
+      if source =~ /#{cvar} \s* = \s* rb_path2class \( \s* "([^"]+)" /x
+        return $1
+      end
+      # As a last resort we use C naming conventions:
+      if cvar =~ /rb_[cm](.*)/
+        return $1
+      end
+      raise NmNtFnd
+    end
+
+    # Returns a list of all the method definitions.
+    def refs
+      errors = {}
+      list = []
+      source.scan( / (rb_define_method|rb_define_private_method|rb_define_singleton_method|rb_define_module_function)
+                       \(
+                          \s* (\w+) \s* ,
+                          \s* "([^"]+)" \s* ,                                          #  "
+                          \s* (\w+) /x ) do |definer, cvar, rfunc, cfunc |
+        begin
+          klass = c2r(cvar)
+          is_singleton = (definer == 'rb_define_singleton_method' or definer == 'rb_define_module_function')
+          is_instance  = (definer != 'rb_define_singleton_method')
+          if is_singleton
+            list << [klass + '--singleton', rfunc, cfunc]
+          end
+          if is_instance
+            list << [klass, rfunc, cfunc]
+          end
+        rescue NmNtFnd
+          errors[cvar] = true
+        end
+      end
+
+      if Cloc.warn?
+        errors.keys.each do |cvar|
+          puts "-- Couldn't find variable '#{cvar}'"
+        end
+      end
+
+      list
+    end
+  end
+
+end

data/lib/cloc/linker.rb

@@ -0,0 +1,72 @@
+
+module Cloc
+
+  # Connects method declarations to location of c functions.
+  # The result is written to the database.
+  class Linker
+
+    def initialize
+      @table = {}
+      @non_static_functions = {}
+    end
+
+    def process_file(pathname)
+      puts "Processing #{pathname} ..."
+      # Since same pathnames appear many many times, we store them as
+      # symbols to conserve memory.
+      absolute_pathname = File.expand_path(pathname).to_sym
+
+      src = FileSource.new(pathname)
+      src.refs.each do |klass, rmethod, cfunc|
+        if @table[klass]
+          klass = @table[klass]
+        else
+          klass = @table[klass] = {}
+        end
+        klass[rmethod] = begin
+          if src.cfunctions[cfunc]
+            # Resolve static methods.
+            [ absolute_pathname, src.cfunctions[cfunc] ]
+          else
+            # Postpone to later.
+            cfunc
+          end
+        end
+      end
+
+      # Save non-static functions for later.
+      src.cfunctions.each_pair do |cfunc, lineno|
+        @non_static_functions[cfunc] = [ absolute_pathname, lineno ]
+      end
+    end
+
+    def resolve_non_static_functions
+      @table.each_pair do |klass, methods_table|
+        methods_table.each_pair do |method, location_or_cfunction|
+          if location_or_cfunction.is_a? String
+            if @non_static_functions[location_or_cfunction]
+              methods_table[method] = @non_static_functions[location_or_cfunction]
+            end
+          end
+        end
+      end
+    end
+
+    def remove_missing
+      @table.each_pair do |klass, methods_table|
+        methods_table.each_pair do |method, location_or_cfunction|
+          if location_or_cfunction.is_a? String
+            puts "-- Couldn't resolve #{klass}##{method}" if Cloc.warn?
+            methods_table.delete(method)
+          end
+        end
+      end
+    end
+
+    def data
+      @table
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: cloc
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Mooffie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mooffie@gmail.com
+executables: 
+- cloc
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/cloc
+- lib/cloc.rb
+- lib/cloc/database.rb
+- lib/cloc/filesource.rb
+- lib/cloc/linker.rb
+has_rdoc: true
+homepage: http://github.com/mooffie/cloc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Locates Ruby methods in C source files.
+test_files: []
+