code_stats2 0.1.1

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake_ext'
+
+project(
+  name: "code_stats",
+  official_name: 'code_stats2',
+  gem: true,
+  summary: "Language-agnostic Code Statistics",
+
+  bin: 'bin',
+  executables: ['code_stats'],
+  dirs: %w(bin),
+  version: '0.1.1',
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/misc/code_stats"
+)

data/bin/code_stats

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+lib_dir = %(#{File.expand_path "#{__FILE__}/../.."}/lib)
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include? lib_dir
+
+require 'code_stats'
+
+if ARGV.empty? or %w(-h --help help).any?{|k| ARGV.include? k}
+  puts <<-TEXT
+  Language-agnostic Code Statistics
+
+  Usage:
+    $ code_stats /projects/wordpress /projects/drupal
+    $ code_stats /projects/*
+    $ code_stats /projects/wordpress /projects/drupal except: JavaScript skip_filter: /tmp/
+  
+  Options:
+    except: JavaScript - analyze all languages except JavaScript
+    only: Ruby - analyze Ruby language only
+    specs_filter: regex, specifies should be path threated as specs, default: #{CodeStats::Project::DEFAUL_SPEC_FILTER.source}
+    skip_filter: regex, specifies paths that should be skipped, default: #{CodeStats::Project::DEFAUL_SKIP_FILTER.source}
+TEXT
+  exit
+end
+  
+args = RubyExt.argv
+options = args.extract_options!
+options2 = {}; options.each{|k, v| options2[k] = v ? v.to_sym : v}
+args << options2
+
+CodeStats.analyze_and_report *args

data/lib/code_stats.rb

@@ -0,0 +1,28 @@
+raise 'ruby 1.9.2 or higher required!' if RUBY_VERSION < '1.9.2'
+
+require 'code_stats/gems'
+
+require 'ruby_ext'
+require 'vfs'
+require 'haml'
+require 'tilt'
+
+class CodeStats
+  class << self
+    def extensions; @extensions ||= {} end
+    
+    attr_accessor :file_size_limit
+    attr_required :file_size_limit    
+  end
+  
+  self.file_size_limit = 500 * 1024
+end
+
+%w(
+  support
+  languages
+  file_set
+  project
+  report
+  code_stats
+).each{|f| require "code_stats/#{f}"}

data/lib/code_stats/code_stats.rb

@@ -0,0 +1,51 @@
+class CodeStats
+  class << self    
+    def know? extension
+      extensions.include? extension
+    end
+  
+    def parse text, extension
+      language = extensions[extension] || raise("no language for :#{extension} extension!")
+      language.new text
+    end
+    
+    def analyze *args
+      options = args.extract_options!
+      paths = args      
+      paths.collect!{|path| Dir[path]}.flatten!
+      
+      puts <<-TEXT
+please wait, analyzing:
+  #{paths.join("\n  ")}
+TEXT
+      
+      projects = paths.collect do |path|
+        project = Project.new path, options
+        project.analyze!
+        project
+      end
+      projects.sort{|a, b| b.characters_count <=> a.characters_count}
+    end
+    
+    def analyze_and_report *args
+      # parsing options
+      options = args.extract_options!
+      paths = args
+      
+      options.validate_options! *(FileSet::AVAILIABLE_OPTIONS + Project::AVAILIABLE_OPTIONS)
+      project_options = options.select{|k, v| Project::AVAILIABLE_OPTIONS.include? k}
+      lang_options = options.select{|k, v| FileSet::AVAILIABLE_OPTIONS.include? k}
+      
+      # analyzing & reporting
+      projects = analyze *(paths << project_options)
+      report = Report.new(*(projects << lang_options)).render
+      
+      report_file = "./projects_statistics.html".to_file
+      report_file.write! report
+
+      puts "done, statistics are in #{report_file}"      
+
+      Kernel.exec "open #{report_file}"
+    end
+  end
+end

data/lib/code_stats/file_set.rb

@@ -0,0 +1,43 @@
+class CodeStats::FileSet
+  def initialize
+    @lines_count_by_language, @characters_count_by_language = Hash.new(0), Hash.new(0)
+  end
+  
+  def lines_count options = {}
+    total_count = 0
+    lines_count_by_language(options).each{|lang, count| total_count += count}
+    total_count
+  end
+
+  def characters_count options = {}
+    total_count = 0
+    characters_count_by_language(options).each{|lang, count| total_count += count}
+    total_count
+  end
+
+  def lines_count_by_language options = {}
+    filter_by_lang(@lines_count_by_language, options)
+  end
+
+  def characters_count_by_language options = {}
+    filter_by_lang(@characters_count_by_language, options)
+  end
+
+  def add script
+    @lines_count_by_language[script.class.alias.to_sym] += script.lines_count
+    @characters_count_by_language[script.class.alias.to_sym] += script.characters_count
+  end
+  
+  AVAILIABLE_OPTIONS = [:only, :except]
+
+  protected
+    def filter_by_lang languages, options
+      options.validate_options! *AVAILIABLE_OPTIONS
+      only = options[:only] && Array.wrap(options[:only]).collect{|v| v.to_sym}
+      except = options[:except] && Array.wrap(options[:except]).collect{|v| v.to_sym}
+
+      languages.reject do |lang, count|
+        (only && !only.include?(lang)) or (except and except.include?(lang))
+      end
+    end
+end

data/lib/code_stats/gems.rb

@@ -0,0 +1,6 @@
+if respond_to? :fake_gem  
+  fake_gem 'ruby_ext'
+  fake_gem 'vfs'
+  fake_gem 'haml'  
+  fake_gem 'tilt'
+end

data/lib/code_stats/languages.rb

@@ -0,0 +1,134 @@
+module CodeStats::Languages
+  class Abstract
+    attr_reader :text    
+    
+    def initialize text
+      @text = text
+    end
+    
+    def self.extensions *args
+      if args.size > 0
+        @extensions = args
+        
+        @extensions.each{|ext| CodeStats.extensions[ext] = self}
+      else
+        @extensions ||= []
+      end
+    end
+    
+    def lines_count
+      calculate_basic_statistics
+      @lines_count
+    end
+    
+    def characters_count
+      calculate_basic_statistics
+      @characters_count
+    end
+    
+    def analyze
+      calculate_basic_statistics
+    end
+    
+    protected
+      def calculate_basic_statistics
+        return if @basic_statistics_calculated
+        @basic_statistics_calculated = true
+        
+        @lines_count = code.blank? ? 0 : 1
+        @characters_count = 0
+        code.chars do |c|
+          @lines_count += 1 if c == "\n"
+          @characters_count += 1 unless c =~ /\s/
+        end
+      end
+  end
+  
+  module CComments
+    def code
+      @code ||= text.substitute(/\/\*.+?\*\/\n?/m, '').substitute(/^\/\/.+?[\n\z]/m, '')
+    end
+  end
+  
+  module SharpComments
+    def code
+      @code ||= text.substitute(/^#.+?[\n\z]/m, '')
+    end
+  end
+  
+  class Java < Abstract
+    include CComments
+    
+    extensions :java        
+  end
+  
+  class JavaScript < Abstract
+    include CComments
+    
+    extensions :js
+  end
+  
+  class Ruby < Abstract
+    include SharpComments
+    
+    extensions :rb
+  end
+  
+  class Cpp < Abstract
+    include CComments
+    
+    extensions :c, :cpp, :h
+  end
+  
+  class Yaml < Abstract
+    include SharpComments
+    
+    extensions :yml
+  end
+  
+  class CoffeeScript < Abstract
+    include SharpComments
+    
+    extensions :coffee
+    
+    def code
+      @code ||= text.substitute(/###.+?###\n?/m, '').substitute(/^#.+?[\n\z]/m, '')
+    end
+  end
+  
+  class Haml < Abstract
+    extensions :haml
+    
+    def code
+      @code ||= text.substitute(/^\/.+?[\n\z]/m, '')
+    end
+  end
+  
+  class Erb < Abstract
+    extensions :erb
+    
+    def code
+      @code ||= text
+    end
+  end
+  
+  class Rjs < Abstract
+    extensions :rjs
+    
+    def code
+      @code ||= text
+    end
+  end
+  
+  class Php < Abstract
+    include CComments
+    
+    extensions :php        
+  end
+  
+  class Python < Abstract
+    include SharpComments
+    
+    extensions :py
+  end
+end

data/lib/code_stats/project.rb

@@ -0,0 +1,55 @@
+class CodeStats::Project
+  attr_reader :path, :name, :specs_filter, :skip_filter, :unknown_extensions
+  attr_reader :sources, :specs
+  
+  AVAILIABLE_OPTIONS = [:specs_filter, :skip_filter]
+  DEFAUL_SPEC_FILTER = /\/tests?\/|\/specs?\//
+  DEFAUL_SKIP_FILTER = /\/docs?\/|\/(s|ex)amples?\/|\/guides?\/|\/.git\/|\/tmp\/|database\.php/
+  
+  def initialize path, options = {}
+    @path, @name = path, path.to_entry.name    
+    options.validate_options! *AVAILIABLE_OPTIONS
+    @specs_filter = options.include?(:specs_filter) ? options[:specs_filter] : DEFAUL_SPEC_FILTER
+    @skip_filter = options.include?(:skip_filter) ? options[:skip_filter] : DEFAUL_SKIP_FILTER
+    clear
+  end
+  
+  def files &b
+    files = []
+    path.to_dir.files '**/*.*' do |file|
+      next if skip?(file)
+      b ? b.call(file) : files.push(file)
+    end
+    b ? nil : files
+  end
+  
+  delegate :lines_count, :characters_count, :lines_count_by_language, :characters_count_by_language, to: :sources
+    
+  def analyze!
+    clear    
+    files do |file|      
+      ext = file.extension.to_sym
+      if CodeStats.know?(ext)
+        warn("file #{file} is too big, skipping") and next if file.size > CodeStats.file_size_limit
+        script = CodeStats.parse file.read.force_utf8_encoding, ext        
+        source?(file) ? sources.add(script) : specs.add(script)
+      else
+        unknown_extensions << ext unless unknown_extensions.include? ext
+      end
+    end
+  end
+  
+  protected
+    def clear
+      @unknown_extensions = []
+      @sources, @specs = CodeStats::FileSet.new, CodeStats::FileSet.new
+    end
+  
+    def source? file
+      !(specs_filter && (file.path.sub(path, '') =~ specs_filter))
+    end
+    
+    def skip? file
+      skip_filter && (file.path.sub(path, '') =~ skip_filter)
+    end
+end

data/lib/code_stats/report.html.haml

@@ -0,0 +1,59 @@
+!!! 5
+%html  
+  %head
+    %style{type: 'text/css'}
+      = css
+      
+    / Ignore all this JS stuff, it's just some JS libraries explicitly embedded into single HTML file
+    %script{type: 'text/javascript'}
+      = js
+  %body
+    - print_by_lang = -> counts {counts.to_a.sort{|a, b| b[1] <=> a[1]}.collect{|lang, count| "#{lang}: #{count.to_s_with_delimiter}"}.join('<br/>')}
+         
+    %h1 Projects Statistics                
+    
+    #plot.plot      
+    
+    %h1 Details
+    
+    %script{type: 'text/javascript'}
+      - projects_js = projects.collect{|p| "['#{p.name}', #{p.characters_count}, #{p.specs.characters_count}]"}.join(",\n")
+      Report.plot('#chart', [
+      = projects_js
+      ]);
+  
+    %table.report
+      %thead
+        %tr
+          %th Name          
+          
+          %th Chars          
+          %th By Lang
+          - unless filters.empty?
+            %th Ignored
+          
+          %th Spec Chars
+          %th Spec by Lang
+          - unless filters.empty?
+            %th Spec Ignored
+            
+          %th Unknown
+      %tbody
+        - projects.each do |p|
+          %tr                        
+            %td= p.name
+            
+            %td.nowrap.bold= p.characters_count.to_s_with_delimiter
+            %td.nowrap= print_by_lang.call p.characters_count_by_language
+            - unless filters.empty?
+              %td.nowrap= print_by_lang.call p.ignored_characters_count_by_language
+            
+            %td.nowrap.bold= p.specs.characters_count.to_s_with_delimiter
+            %td.nowrap= print_by_lang.call p.specs.characters_count_by_language
+            - unless filters.empty?
+              %td.nowrap= print_by_lang.call p.specs.ignored_characters_count_by_language
+              
+            %td= p.unknown_extensions.sort.join(', ')
+    
+    %p.powered
+      Powered by <a href='https://github.com/alexeypetrushin/code_stats'>code_stat</a>

data/lib/code_stats/report.rb

@@ -0,0 +1,42 @@
+class CodeStats::Report
+  attr_reader :filters, :projects
+  def initialize *args
+    @filters = args.extract_options!
+    @projects = args    
+  end
+  
+  def render
+    # preparing data
+    data = projects.clone
+    data.sort!{|a, b| b.characters_count(filters) <=> a.characters_count(filters)}
+    data.collect! do |p|
+      o = OpenObject.new
+      o.name = p.name
+      
+      o.characters_count = p.characters_count(filters)
+      o.characters_count_by_language = p.characters_count_by_language(filters)                
+      o.ignored_characters_count_by_language = p.characters_count_by_language.reject do |lang, count|
+        o.characters_count_by_language.include?(lang)
+      end
+      
+      o.specs = OpenObject.new        
+      o.specs.characters_count = p.specs.characters_count(filters)
+      o.specs.characters_count_by_language = p.specs.characters_count_by_language(filters)                
+      o.specs.ignored_characters_count_by_language = p.specs.characters_count_by_language.reject do |lang, count|
+        o.specs.characters_count_by_language.include?(lang)
+      end
+      
+      o.unknown_extensions = p.unknown_extensions
+      
+      o
+    end
+            
+    # rendering
+    dir = __FILE__.dirname.to_dir
+    css = [dir['report/style.css'].read].join("\n")
+    js = %w(jquery.js highchart.js report.js).collect{|n| dir["report/#{n}"].read}.join("\n")
+    
+    report = dir / 'report.html.haml'
+    report.render(projects: data, filters: filters, css: css, js: js)
+  end
+end