jsmetric4java 0.1

data/.gitignore

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm jruby@jsmetric4java

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+gemspec
+
+group :development do
+  gem 'rake', '~> 0.8.7'
+  gem 'rspec', '~> 2.4.0'
+  gem 'cucumber', '~> 0.10.0'
+end

data/README

@@ -0,0 +1,16 @@
+[WARNING: This project is not yet ready for proper use. Its very much an alpha at the moment]
+
+Dependencies: (Jruby 1.6.1 or greater)
+
+*** Installation
+
+$ gem install jsmetric4java
+
+
+*** Usage
+
+Cyclometric complexity for a file:
+$ ./bin/jsmetric4java path_to_js_file
+
+Cyclometric complexity for all .js files in a Directory
+$ ./bin/jsmetric4java path_to_dir

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/jsmetric4java

@@ -0,0 +1,20 @@
+#!/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
+begin
+    file_path = args.shift.strip
+rescue
+    puts "Missing js file or directory as argument"
+    exit false
+end
+
+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 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"

data/features/cyclometric_complexity/if_else_complexity_counting.feature

@@ -0,0 +1,178 @@
+@ifelse
+Feature: Calculate IF/ELSE complexity for a stand alone Javascript function
+
+  Scenario: No branches
+    Given javascript code as:
+    """
+      function foo() { };
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "1"
+
+  Scenario: Just one IF statement
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: 2 sequential IF statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        if (true) {
+          // do something else
+        }        
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: 2 nested IF statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+          if (true) {
+            // do something else
+          }
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: A single IF with Else statement
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        else {
+          // do something else
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+  Scenario: 2 nested IF/Else statements
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+          if (true) {
+            // do something else
+          }
+          else {
+            // do this
+          }
+        }
+        else {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: An IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+        }
+        else if(true) {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+  Scenario: An IF-ELSE-IF and then ELSE type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          // do something
+        }
+        else if(true) {
+          // do this
+        }
+        else {
+          // do that
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"
+
+
+  Scenario: A nested IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          if (true) {
+          }
+          else if(true) {
+            // do that
+          }
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "4"
+
+  Scenario: Multiple nested IF-ELSE-IF type scenario
+    Given javascript code as:
+    """
+      function foo() {
+        if (true) {
+          if (true) {
+            // do this
+          }
+          else if(true) {
+            // do that
+          }
+        }
+        else if(true) {
+            // do something
+        }
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "5"
+
+  Scenario: IF statement implied with ?
+    Given javascript code as:
+    """
+      function foo() {
+        (true)? true : false;
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "2"
+
+
+  Scenario: IF statement nested inside a ternary operator
+    Given javascript code as:
+    """
+      function foo() {
+        (true)? "" : (false) ? true :"" ;
+      }
+    """
+    When I run the complexity analysis on it
+    Then the complexity is reported as "3"