locat 0.1.0

data/.ruby

@@ -0,0 +1,48 @@
+--- 
+name: locat
+version: 0.1.0
+title: LOCat
+summary: Lines of Code Attache
+description: LOCat is a customizable Line-Of-Code metric system. LOC might not be the most useful metric in the universe but it still provide useful inforamtion and can be a lot of fun.
+loadpath: 
+- lib
+manifest: MANIFEST
+requires: 
+- name: ansi
+  version: 0+
+  group: []
+
+- name: detroit
+  version: 0+
+  group: 
+  - build
+- name: qed
+  version: 0+
+  group: 
+  - test
+conflicts: []
+
+replaces: []
+
+engine_check: []
+
+organization: Rubyworks
+contact: trans <transfire@gmail.com>
+created: 2011-07-07
+copyright: Copyright (c) 2011 Thomas Sawyer
+licenses: 
+- BSD-2-Clause
+authors: 
+- Thomas Sawyer
+maintainers: []
+
+resources: 
+  home: http://rubyworks.github.com/locat
+  code: http://github.com/rubyworks/locat
+  docs: http://wiki.github.com/rubyworks/locat/docs/qed
+  wiki: http://wiki.github.com/rubyworks/locat
+  bugs: http://github.com/rubyworks/locat/issues
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+repositories: 
+  public: git://github.com/rubyworks/locat.git
+spec_version: 1.0.0

data/COPYING.rdoc

@@ -0,0 +1,33 @@
+= COPYRIGHT NOTICES
+
+== LOCat
+
+Copyright:: (c) 2011 Thomas Sawyer, Rubyworks
+License:: BSD-2-Clause
+
+    Copyright (c) 2011 Thomas Sawyer. 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 BY Thomas Sawyer ``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 Thomas Sawyer 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.
+
+    The views and conclusions contained in the software and documentation are those of the
+    authors and should not be interpreted as representing official policies, either expressed
+    or implied, of Thomas Sawyer.
+

data/README.rdoc

@@ -0,0 +1,55 @@
+= LOCAT
+
+
+== DESCRIPTION
+
+LOCat is a fancy LOC code analysis tool.
+
+
+== RESOURCES
+
+* {Homepage}[http://rubyworks.github.com/locat]
+* {Development}[http://github.com/rubyworks/locat]
+* {Issue Tracker}[http://github.com/rubyworks/locat/issues]
+* {Mailing List}[http://groups.google.com/group/rubyworks-mailinglist]
+
+
+== SYNOPSIS
+
+Define a `.locat` Ruby script in your project, e.g.
+
+    match 'lib/**.rb' do |file, line|
+      case line
+      when /^\s*#/
+        'Comment'
+      when /^\s*$/
+        'Blank'
+      else
+        'Code'
+      end
+    end
+
+    match 'test/**.rb' do |file, line|
+      case line
+      when /^\s*#/
+        'Comment'
+      when /^\s*$/
+        'Blank'
+      else
+        'Test'
+      end
+    end
+
+Then run `locat`, e.g.
+
+    $ locat -o locat.html
+
+
+== COPYRIGHT
+
+Copyright (c) 2011 Thomas Sawyer, Rubyworks
+
+BSD 2-Clause License
+
+See COPYING.rdoc for details.
+

data/bin/locat

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'locat'
+LOCat.cli(*ARGV)

data/lib/locat.rb

@@ -0,0 +1,14 @@
+module LOCat
+
+  require 'json'
+  require 'optparse'
+  require 'fileutils'
+  require 'erb'
+
+  require 'locat/matcher'
+  require 'locat/counter'
+  require 'locat/template'
+  require 'locat/gitloc'
+  require 'locat/command'
+
+end

data/lib/locat/command.rb

@@ -0,0 +1,129 @@
+module LOCat
+
+  #
+  def self.cli(*argv)
+    options = {}
+
+    OptionParser.new do |opt|
+      opt.on('-o', '--output FILE', 'output file') do |output|
+        options[:output] = output
+      end
+      opt.on('-j', '--json', 'output JSON formmated data') do
+        options[:format] = 'json'
+      end
+      opt.on('-y', '--yaml', 'output YAML formmated data') do
+        options[:format] = 'yaml'
+      end
+      opt.on('-c', '--config NAME', 'matcher configuraton') do |name|
+        options[:config] ||= []
+        options[:config] << name
+      end
+      opt.on('-D', '--debug', 'run in debug mode') do
+        $DEBUG = true
+      end
+      opt.on('-h', '--help', 'display this help message') do
+        puts opt
+        exit 0
+      end
+    end.parse!(argv)
+
+    options[:files] = argv
+
+    command = Command.new(options)
+    command.run
+  end
+
+  #
+  class Command
+
+    #
+    def initialize(options)
+      @files        = nil
+      @output       = nil
+      @format       = 'highchart'
+      @config       = default_config_files
+
+      options.each do |k,v|
+        send("#{k}=", v)
+      end
+    end
+
+    # Files to include in analysis.
+    attr_accessor :files
+
+    # The output format (json, yaml, highchart).
+    attr_accessor :format
+
+    # List of configuration files.
+    attr_accessor :config
+
+    # Output file.
+    attr_reader :output
+
+    # Set output file name.
+    def output=(file)
+      @output = file
+    end
+
+    #
+    def run
+      save
+    end
+
+   private
+
+    #
+    def default_config_files
+      Dir['.locat{,/*.rb}'].select{ |f| File.file?(f) }
+    end
+
+    #
+    def matcher
+      @matcher ||= Matcher.new(*config)
+    end
+
+    #
+    def counter
+      @counter ||= Counter.new(matcher, :files=>files)
+    end
+
+    #
+    def template
+      @template ||= Template.new(counter)
+    end
+
+    # Save.
+    def save
+      case format.downcase
+      when 'json'
+        json = counter.to_h.to_json
+        save_file(json)
+      when 'yaml'
+        yaml = counter.to_h.to_yaml
+        save_file(yaml)
+      else
+        html = template.render(format)
+        save_file(html)
+      end
+    end
+
+    #
+    def save_file(text)
+      if output
+        FileUtils.mkdir_p(File.dirname(output))
+        File.open(File.join(output), 'w') do |f|
+          f << text
+        end
+      else
+        puts text
+      end
+    end
+
+    #
+    def template_dir
+      File.dirname(__FILE__) + '/locat/template'
+    end
+
+  end
+
+end

data/lib/locat/counter.rb

@@ -0,0 +1,155 @@
+module LOCat
+
+  #
+  class Counter
+
+    #
+    def initialize(matcher, options)
+      @matcher = matcher
+
+      options.each do |k,v|
+        send("#{k}=", v)
+      end
+    end
+
+    #
+    attr :matcher
+
+    #
+    attr :files
+
+    #
+    def files=(files)
+      @files = files.map{ |f| Dir[f] }.flatten
+    end
+
+    #
+    def counts
+      @counts ||= (
+        table = Hash.new{ |h,k| h[k] = 0 }
+        matcher.each do |pattern, block|
+          files = resolve_files(pattern)
+          files.each do |file|
+            File.readlines(file).each do |line|
+              line = line.chomp("\n")
+              group = block.call(file, line)
+              if group
+                table[group.to_s] += 1
+              end
+            end
+          end
+        end
+        table
+      )
+    end
+
+    #
+    def total
+      @total = counts.values.inject(0){ |s,v| s+=v; s }
+    end
+
+    #
+    def loc
+      @loc ||= (
+        a = []
+        a << [nil  , *counts.keys]
+        a << ['loc', *counts.values]
+        a
+      )
+    end
+
+    # Compute the ratios between each group,
+    # returning a two-dimensional array.
+    def ratio
+      @ratio ||= (
+        rcounts = counts.dup
+        rcounts['Total'] = total
+        r = Array.new(rcounts.size+1){ [] }
+        x = 1
+        rcounts.each do |type1, count1|
+          r[x][0] = type1
+          y = 1
+          rcounts.each do |type2, count2|
+            r[0][y] = type2
+            if count2 == 0 or count2 == 0
+              r[x][y] = 0
+            else
+              r[x][y] = (1000 * (count2.to_f / count1.to_f)).round.to_f / 1000.0
+            end
+            y += 1
+          end
+          x += 1
+        end
+        r
+      )
+    end
+
+    # Calculate the percentages.
+    def percent
+      @percent ||= (
+        a = []
+        a << [nil  ,  *counts.keys]
+        a << ['%', *counts.values.map{ |f| 100 * f / total }]
+        a
+      )
+    end
+
+    #
+    def to_h
+      h = {}
+      h['loc']   = loc
+      h['pcnt']  = percent
+      h['ratio'] = ratio
+      h['scm']   = scm if scm?
+      h
+    end
+
+    #
+    #def to_json
+    #  to_h.to_json
+    #end
+
+    #
+    def gitloc
+      @gitloc ||= GitLOC.new(matcher)
+    end
+
+    #
+    def scm?
+      File.directory?('.git')
+    end
+
+    #
+    def scm
+      if scm?
+        gitloc.timeline_table
+      else
+        nil
+      end
+    end
+
+    private
+
+    # Resolve file glob.
+    def resolve_files(pattern)
+      case pattern
+      when String
+        Dir['**/*'].select{ |path| File.fnmatch(pattern, path) }
+      when Regexp
+        Dir['**/*'].select{ |path| pattern =~ path }
+      else
+        []
+      end
+      #if File.directory?(glob)
+      #  glob = File.join(glob, '**', '*')
+      #end
+      #if files.nil? or files.empty?
+      #  Dir[glob].flatten
+      #else
+      #  Dir[glob].flatten & files
+      #end
+    end
+
+  end
+
+end

data/lib/locat/gitloc.rb

@@ -0,0 +1,139 @@
+require 'rubygems'
+#require 'active_support'
+require 'grit'
+require 'open-uri'
+require 'fileutils'
+
+module LOCat
+
+  # Based on `git-line-count.rb` by Tieg Zaharia
+  class GitLOC
+
+    include Grit
+
+    MAX_COMMITS    = 1_000_000
+    OUTPUT_FILE    = "gitloc.html"
+    #FILE_EXTENSION = /\.(rb|js)$/
+    #EXCLUDED_FILES = %w(files.js to.js exclude.js).map{ |str| Regexp.escape(str) }.join('|')
+    #EXCLUDED       = /#{EXCLUDED_FILES}/i
+    PER_DAY        = false # true = show 1-commit-per-day, false = show all commits
+    DATA_POINTS    = 25
+
+    attr :matcher
+
+    attr :repo
+
+    #
+    def initialize(matcher)
+      @matcher = matcher
+      @repo    = Repo.new(".")
+
+      @data_points      = DATA_POINTS
+      @output_file      = OUTPUT_FILE
+      #@file_extension   = FILE_EXTENSION
+      #@exclude          = EXCLUDED
+      @per_day          = PER_DAY
+    end
+
+    #
+    def title
+      "'#{repo.head.name}' branch JavaScript LOC #{@per_day ? 'per day' : 'per commit'}"
+    end
+
+    # Count lines by groups.
+    def recursive_loc_count(dir, tree_or_blob, total_count=nil)
+      total_count ||= Hash.new{|h,k| h[k]=0 }
+      if tree_or_blob.is_a?(Grit::Tree) # directory
+        tree_or_blob.contents.each do |tob|
+          dname = dir ? File.join(dir, tree_or_blob.name) : tree_or_blob.name
+          recursive_loc_count(dname, tob, total_count)
+        end
+      elsif tree_or_blob.is_a?(Grit::Blob) # file
+        file = dir ? File.join(dir, tree_or_blob.name) : tree_or_blob.name
+        matcher.each do |glob, block|
+          if File.fnmatch?(glob, file)
+            tree_or_blob.data.lines.each do |line|
+              group = block.call(file, line)
+              if group
+                total_count[group] += 1
+              end
+              #total_count['Total'] += 1
+            end
+          end
+        end
+      else
+        # what is it then?
+      end
+      total_count
+    end
+
+    #
+    def commits_with_loc
+      @commits_with_loc ||= (
+        table        = []
+        total_count  = Hash.new{|h,k|h[k]=0}   # gets reset every commit
+        current_date = nil                     # gets reset every commit
+
+        size = repo.commits('master', MAX_COMMITS).size
+        mod  = size < @data_points ? 1 : (size / @data_points).round
+
+        # puts repo.commits[0].methods.sort.join(', ')
+        repo.commits('master', MAX_COMMITS).each_with_index do |commit, index|
+          next unless index % mod == 0
+
+          total_count = Hash.new{|h,k|h[k]=0}
+          this_date   = commit.committed_date.to_date
+          if !@per_day || (@per_day && this_date != current_date)
+            # Record this commit as end-of-day commit
+            current_date = this_date
+            commit.tree.contents.each do |tob|
+              recursive_loc_count(nil, tob, total_count)
+            end
+            table << {
+              :date => commit.committed_date.to_datetime,
+              :id   => commit.id,
+              :loc  => total_count
+            }
+          else
+            # The day this commits falls on has already been recorded
+          end
+        end
+
+        table.reverse
+      )
+    end
+
+    #
+    def timeline_table
+      #mod = 7
+      th = [nil]
+      commits_with_loc.each_with_index do |commit, index|
+        #if index % mod == 0 || index == commits_with_loc.size - 1
+        #  th << commit[:date].strftime("%-y %-m %-d")
+        #else
+          th << commit[:date].strftime("%y %m %d")
+        #end
+      end
+      tg = []
+      groups = []
+      commits_with_loc.each do |commit|
+        groups = groups | commit[:loc].keys
+      end
+      groups.each_with_index do |g, i|
+        tg[i] = [g]
+      end
+      tt = ['Total']
+      commits_with_loc.each do |commit|
+        sum = 0
+        groups.each_with_index do |g, i|
+          tg[i] << commit[:loc][g]
+          sum += commit[:loc][g]
+        end
+        tt << sum
+      end
+      [th] + tg + [tt]
+    end
+
+  end
+
+end