jsmetric 0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2@jsmetric

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README

@@ -0,0 +1,36 @@
+[WARNING: This project is not yet ready for proper use. Its very much an alpha at the moment]
+
+*** Installation
+
+$ gem install jsmetric
+
+
+*** Usage
+
+Cyclometric Complexity
+$ ./bin/jsmetric path_to_js_file
+
+
+*** Backlog/Future Work
+
+- JSLint options are buried in the options.js file. Need to pull these out.
+- Refactor the nasty code in the complexity analyser
+- Add Debug messages for when a JS file fails JSLint validation
+
+
+[Notes for developing JSMetric itself futher]
+
+*** To get started you need:
+
+Ruby 1.9.2
+Bundler 1.x
+
+This project contains a .rvmrc file for use with RVM.
+
+*** Setting up dev environment
+
+$ ./build
+
+*** Dev smoke
+
+$ ./bin/jsmetric features/sample_js_files_for_test/foobar.js

data/Rakefile

@@ -0,0 +1,37 @@
+require 'bundler'
+require "bundler/setup"
+require "rubygems"
+
+Bundler::GemHelper.install_tasks
+
+PROJECT_ROOT = File.expand_path("..", __FILE__)
+$:.unshift "#{PROJECT_ROOT}/lib"
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+# Cucumber configurations
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--format pretty"
+end
+
+# RSpec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+
+# other Project tasks
+Dir[File.join(File.dirname(__FILE__),"tasks","*.rb")].each {|file| require file }
+
+namespace :jsmetrics do
+  desc "master build"
+  task :build => [:spec, "cucumber"]
+end
+
+task :default => ["jsmetrics:build"]
+
+
+

data/bin/jsmetric

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+
+args = ARGV.dup
+ARGV.clear
+file_path = args.shift.strip rescue 'help'
+
+require 'report'
+puts Report.for file_path
+

data/boot.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+require "bundler/setup"
+
+Dir[File.join(File.dirname(__FILE__),"lib","*.rb")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__),"lib","graphing","*.rb")].each {|file| require file }

data/build

@@ -0,0 +1 @@
+bundle install && bundle exec rake

data/features/cyclometric_complexity/boolean_complexity_counting.feature

@@ -0,0 +1,46 @@
+@booloperator
+Feature: Calculate complexity for code that includes BOOLEAN decisions
+
+  Scenario: IF statement with BOOLEAN &&
+    Given javascript code as:
+    """
+      function foo() {
+        var bar,baz;
+        if(bar && baz) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: IF statement with BOOLEAN ||
+    Given javascript code as:
+    """
+      function foo() {
+        var bar,baz;
+        if(bar || baz) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: IF statement with multiple BOOLEAN &&
+    Given javascript code as:
+    """
+      function foo() {
+        var bar,baz;
+        if(bar && baz && bar) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "4"
+
+    Scenario: IF statement with multiple BOOLEAN operators
+    Given javascript code as:
+    """
+      function foo() {
+        var bar,baz;
+        if(bar && baz || bar && baz) {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "5"

data/features/cyclometric_complexity/case_complexity_counting.feature

@@ -0,0 +1,117 @@
+@switch
+Feature: Calculate CASE/DEFAULT complexity for a stand alone Javascript function
+
+  Scenario: SWITCH with DEFAULT only
+    Given javascript code as:
+    """
+      function foo() {
+        var bar;
+        switch(bar) {
+          default:
+          //do something
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: SWITCH with single CASE statement
+    Given javascript code as:
+    """
+      function foo() {
+        var bar;
+        switch(bar) {
+          case true:
+          //do something
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: SWITCH with single CASE and it breaks out the SWITCH statements
+    Given javascript code as:
+    """
+      function foo() {
+        var bar;
+        switch(bar) {
+          case true:
+            //do something
+            break;
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: SWITCH with multiple CASE and each breaks out the SWITCH
+    Given javascript code as:
+    """
+      function foo() {
+        var bar;
+        switch(bar) {
+          case true:
+            //do something
+            break;
+
+          case false:
+            //do something
+            break;
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: SWITCH with multiple CASE and neither break out the SWITCH
+    Given javascript code as:
+    """
+      function foo() {
+        var bar, temp;
+
+        switch(bar) {
+          case true:
+            temp = "first"
+            //do something
+
+          case false:
+             temp = "second"
+             //do something
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"    
+
+
+   Scenario: SWITCH with multiple CASE with no-ops are considered as a single Case
+    Given javascript code as:
+    """
+      function foo() {
+        var bar, temp;
+
+        switch(bar) {
+          case true:
+          case false:
+          case "blah":
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: SWITCH with multiple CASE with no-ops and Default
+    Given javascript code as:
+    """
+      function foo() {
+        var bar, temp;
+
+        switch(bar) {
+          case true:
+          case false:
+          default:
+          }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"

data/features/cyclometric_complexity/exception_complexity_counting.feature

@@ -0,0 +1,81 @@
+@exceptions
+Feature: Calculate TRY/CATCH complexity for a stand alone Javascript function
+
+  Scenario: Single TRY CATCH in a function
+    Given javascript code as:
+    """
+      function foo() {
+        try
+        {
+          //Run some code here
+        }
+        catch(err)
+        {
+          //Handle errors here
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: Single TRY FINALLY in a function
+    Given javascript code as:
+    """
+      function foo() {
+        try
+        {
+          //Run some code here
+        }
+        finally
+        {
+          //Handle errors here
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+   Scenario: Single TRY CATCH FINALLY in a function
+    Given javascript code as:
+    """
+      function foo() {
+        try
+        {
+          //Run some code here
+        }
+        catch(err)
+        {
+          //Handle errors here
+        }
+        finally
+        {
+          //Handle errors here
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: Nested TRY inside a CATCH in a function
+    Given javascript code as:
+    """
+      function foo() {
+        try
+        {
+          //Run some code here
+        }
+        catch(err)
+        {
+
+          try
+          {
+            //Run some code here
+          }
+          catch (anotherErr)
+          {
+            //Handle errors here
+          }
+        }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"

data/features/cyclometric_complexity/function_detection.feature

@@ -0,0 +1,128 @@
+@functions
+Feature: Calculate number of functions and their names for a stand alone Javascript snippet
+
+  Scenario: Only statements and no functions
+    Given javascript code as:
+    """
+      var foo = {} || "";
+      var baz = 2;
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "0"
+
+  Scenario: Single javascript function
+    Given javascript code as:
+    """
+      function foo() {};
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "1"
+    And the function name is "foo"
+
+  Scenario: Multiple javascript functions
+    Given javascript code as:
+    """
+      function foo() {};
+      function bar() {};
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name |
+      | foo  |
+      | bar  |
+
+
+  Scenario: Multiple javascript functions nested
+    Given javascript code as:
+    """
+      function foo() {
+        function bar() {};
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+
+  Scenario: Single outer function with inner private function assigned to a var
+    Given javascript code as:
+    """
+      function foo() {
+        var baz = function() {};
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name |
+      | foo  |
+      | baz  |
+
+  Scenario: Single outer function with inner private function that is unassigned
+    Given javascript code as:
+    """
+      function foo() {
+        function bar() {};
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name |
+      | foo  |
+      | bar  |
+
+  Scenario: Single outer function with inner public function
+    Given javascript code as:
+    """
+      function foo() {
+        this.baz.flaz = function() {};
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name          |
+      | foo           |
+      | this.baz.flaz |
+
+  Scenario: Single outer Object with inner public function
+    Given javascript code as:
+    """
+      var foo = {
+        flaz : function() {},
+        blah : "",
+        baz : function() {}
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name |
+      | flaz |
+      | baz  |
+
+  Scenario: Single outer function with inner annonymous function
+    Given javascript code as:
+    """
+      function foo() {
+        return function() {};
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "2"
+    And the function names are:
+      | Name       |
+      | foo       |
+      | Annonymous |
+
+
+  Scenario: Single javascript function containing the string "function"
+    Given javascript code as:
+    """
+      function foo() {
+        return "function";
+      };
+    """
+    When I run the complexity analysis on it
+    Then the number of functions is reported as "1"
+    And the function name is "foo"