crosslanguagespotter 0.0.2-java

data/test/data/angular_puzzle/slidingPuzzle.js

@@ -0,0 +1,203 @@
+(function(angular) {
+    'use strict';
+
+    var module = angular.module('slidingPuzzle', []);
+
+    /**
+     * Service
+     */
+    module.factory('slidingPuzzle', function() {
+        function shuffle(a) {
+            var q;
+            for (var j, x, i = a.length; i; j = parseInt(Math.random() * i, 10), x = a[--i], a[i] = a[j], a[j] = x) { q = 0; }
+            return a;
+        }
+
+        function SlidingPuzzle(rows, cols) {
+            /**
+             * Puzzle grid
+             * @type {Array}
+             */
+            this.grid = [];
+
+            /**
+             * Moves count
+             * @type {Number}
+             */
+            this.moves = 0;
+
+            /**
+             * Moves tile
+             * @param srow
+             * @param scol
+             */
+            this.move = function(srow, scol) {
+                var dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]],
+                    tref, trow, tcol;
+
+                for (var d = 0; d < dirs.length; d++) {
+                    trow = srow + dirs[d][0];
+                    tcol = scol + dirs[d][1];
+                    if (this.grid[trow] && this.grid[trow][tcol] && this.grid[trow][tcol].empty) {
+                        tref = this.grid[srow][scol];
+                        this.grid[srow][scol] = this.grid[trow][tcol];
+                        this.grid[trow][tcol] = tref;
+                        this.moves++;
+                    }
+                }
+            };
+
+            /**
+             * Shuffles grid
+             */
+            this.shuffle = function() {
+                var tiles = [];
+                this.traverse(function(tile) {
+                    tiles.push(tile);
+                });
+                shuffle(tiles);
+                this.traverse(function(tile, row, col) {
+                    this.grid[row][col] = tiles.shift();
+                });
+                this.moves = 0;
+            };
+
+            /**
+             * Solves puzzle
+             */
+            this.solve = function() {
+                var tiles = [];
+                this.traverse(function(tile) {
+                    tiles.push(tile);
+                });
+                tiles.sort(function(x, y) {
+                    return (x.id - y.id);
+                });
+                this.traverse(function(tile, row, col) {
+                    this.grid[row][col] = tiles.shift();
+                });
+            };
+
+            /**
+             * Is solved?
+             * @type {Boolean}
+             */
+            this.isSolved = function() {
+                var id = 1;
+                for (var row = 0; row < rows; row++) {
+                    for (var col = 0; col < cols; col++) {
+                        if (this.grid[row][col].id !== id++) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            };
+
+            /**
+             * Traverses grid and executes fn on every tile
+             * @param fn
+             */
+            this.traverse = function(fn) {
+                for (var row = 0; row < rows; row++) {
+                    for (var col = 0; col < cols; col++) {
+                        fn.call(this, this.grid && this.grid[row] ? this.grid[row][col] : undefined, row, col);
+                    }
+                }
+            };
+
+            // initialize grid
+            var id = 1;
+            this.traverse(function(tile, row, col) {
+                if (!this.grid[row]) {
+                    this.grid[row] = [];
+                }
+                this.grid[row][col] = {
+                    id: id++,
+                    empty: (row === rows - 1) && (col === cols - 1)
+                };
+                if (this.grid[row][col].empty) {
+                    this.empty = this.grid[row][col];
+                }
+            });
+        }
+
+        return function(rows, cols) {
+            return new SlidingPuzzle(rows, cols);
+        };
+    });
+
+    /**
+     * Directive
+     */
+    module.directive('slidingPuzzle', function(slidingPuzzle) {
+        return {
+            restrict: 'EA',
+            replace: true,
+            template: '<table class="sliding-puzzle" ng-class="{\'puzzle-solved\': puzzle.isSolved()}">' +
+                '<tr ng-repeat="($row, row) in puzzle.grid">' +
+                '<td ng-repeat="($col, tile) in row" ng-click="puzzle.move($row, $col)" ng-style="tile.style" ng-class="{\'puzzle-empty\': tile.empty}" title="{{tile.id}}"></td>' +
+                '</tr>' +
+                '</table>',
+            scope: {
+                size: '@',
+                src: '@',
+                api: '='
+            },
+            link: function(scope, element, attrs) {
+                var rows, cols,
+                    loading = true,
+                    image = new Image();
+
+                function create() {
+                    scope.puzzle = slidingPuzzle(rows, cols);
+
+                    if (attrs.api) {
+                        scope.api = scope.puzzle;
+                    }
+
+                    tile();
+                }
+
+                function tile() {
+                    if (loading) {
+                        return;
+                    }
+
+                    var width = image.width / cols,
+                        height = image.height / rows;
+
+                    scope.puzzle.traverse(function(tile, row, col) {
+                        tile.style = {
+                            width: width + 'px',
+                            height: height + 'px',
+                            background: (tile.empty ? 'none' : "url('" + scope.src + "') no-repeat -" + (col * width) + 'px -' + (row * height) + 'px')
+                        };
+                    });
+
+                    scope.puzzle.shuffle();
+                }
+
+                attrs.$observe('size', function(size) {
+                    size = size.split('x');
+                    if (size[0] >= 2 && size[1] >= 2) {
+                        rows = size[0];
+                        cols = size[1];
+                        create();
+                    }
+                });
+
+                attrs.$observe('src', function(src) {
+                    loading = true;
+                    image.src = src;
+                    image.onload = function() {
+                        loading = false;
+                        scope.$apply(function() {
+                            tile();
+                        });
+                    };
+                });
+            }
+        };
+    });
+})(window.angular);

data/test/data/angular_puzzle/wordSearchPuzzle.js

@@ -0,0 +1,270 @@
+(function(angular) {
+    'use strict';
+
+    var module = angular.module('wordSearchPuzzle', []);
+
+    /**
+     * Service
+     */
+    module.factory('wordSearchPuzzle', function() {
+        /**
+         * Word search puzzle
+         * @param matrix
+         * @param words
+         * @constructor
+         */
+        function WordSearchPuzzle(matrix, words) {
+            var maxRow = 0,
+                maxCol = 0;
+
+            /**
+             * Matrix
+             * @type {Array}
+             */
+            this.matrix = [];
+
+            /**
+             * Words
+             * @type {Array}
+             */
+            this.words = [];
+
+            /**
+             * Is solved?
+             * @type {Boolean}
+             */
+            this.solved = false;
+
+            // parse matrix and words
+            angular.forEach(matrix, function(letters, row) {
+                angular.forEach(letters, function(letter, col) {
+                    var item = {
+                        letter: letter,
+                        col: col,
+                        row: row,
+                        used: false
+                    };
+                    if (!this.matrix[row]) {
+                        this.matrix[row] = [];
+                    }
+                    this.matrix[row].push(item);
+                    maxCol = col;
+                }, this);
+                maxRow = row;
+            }, this);
+            angular.forEach(words, function(word) {
+                this.words.push({
+                    name: word
+                });
+            }, this);
+
+            /**
+             * Returns matrix item by coords
+             * @param col
+             * @param row
+             * @return {*}
+             */
+            this.getItem = function(col, row) {
+                return (this.matrix[row] ? this.matrix[row][col] : undefined);
+            };
+
+            /**
+             * Returns matrix items by start/end coords
+             * @param colFrom
+             * @param rowFrom
+             * @param colTo
+             * @param rowTo
+             * @return {Array}
+             */
+            this.getItems = function(colFrom, rowFrom, colTo, rowTo) {
+                var items = [];
+
+                if (rowTo > maxRow) {
+                    rowTo = maxRow;
+                }
+                if (colTo > maxCol) {
+                    colTo = maxCol;
+                }
+
+                if (this.getItem(colTo, rowTo) === undefined) {
+                    return items;
+                }
+
+                if (colFrom === colTo || rowFrom === rowTo || Math.abs(colTo - colFrom) === Math.abs(rowTo - rowFrom)) {
+                    var shiftX = (colFrom === colTo ? 0 : (colTo > colFrom ? 1 : -1)),
+                        shiftY = (rowFrom === rowTo ? 0 : (rowTo > rowFrom ? 1 : -1)),
+                        col = colFrom,
+                        row = rowFrom;
+
+                    items.push(this.getItem(col, row));
+                    do {
+                        col += shiftX;
+                        row += shiftY;
+                        items.push(this.getItem(col, row));
+                    } while (col !== colTo || row !== rowTo);
+                }
+
+                return items;
+            };
+
+            /**
+             * Check items - find word
+             * @param items
+             */
+            this.lookup = function(items) {
+                if (!items.length) {
+                    return;
+                }
+
+                // create words
+                var words = [''];
+                angular.forEach(items, function(item) {
+                    words[0] += item.letter;
+                });
+                words.push(words[0].split('').reverse().join(''));	// word in reverse order (when selecting)
+
+                // check words
+                this.solved = true;
+                angular.forEach(this.words, function(word) {
+                    if (word.found) {
+                        return;
+                    }
+                    angular.forEach(words, function(itemWord) {
+                        if (word.name === itemWord) {
+                            word.found = true;
+                            angular.forEach(items, function(item) {
+                                item.found = true;
+                            });
+                        }
+                    });
+                    if (!word.found) {
+                        this.solved = false;
+                    }
+                }, this);
+            };
+
+            /**
+             * Solves puzzle
+             */
+            this.solve = function() {
+                var start = {},
+                    directions = {
+                        N: [0, -1], E: [1, 0], S: [0, 1], W: [-1, 0],
+                        NE: [1, -1], NW: [-1, -1], SE: [1, 1], SW: [-1, 1]
+                    };
+
+                // group items by letters for faster search
+                angular.forEach(this.matrix, function(items) {
+                    angular.forEach(items, function(item) {
+                        if (!start[item.letter]) {
+                            start[item.letter] = [];
+                        }
+                        start[item.letter].push(item);
+                    });
+                });
+
+                angular.forEach(this.words, function(word) {
+                    angular.forEach(start[word.name.charAt(0)], function(start) {
+                        if (word.found) {
+                            return;
+                        }
+                        angular.forEach(directions, function(shift) {
+                            if (word.found) {
+                                return;
+                            }
+                            this.lookup(this.getItems(
+                                start.col, start.row,
+                                start.col + (word.name.length - 1) * shift[0],
+                                start.row + (word.name.length - 1) * shift[1]
+                            ));
+                        }, this);
+                    }, this);
+                }, this);
+            };
+        }
+
+        return function(matrix, words) {
+            return new WordSearchPuzzle(matrix, words);
+        };
+    });
+
+    /**
+     * Directive
+     */
+    module.directive('wordSearchPuzzle', function(wordSearchPuzzle) {
+        return {
+            restrict: 'EA',
+            replace: true,
+            template: '<table class="word-search-puzzle" cellspacing="0" ng-class="{\'puzzle-solved\': puzzle.solved}">' +
+                '<tr ng-repeat="items in puzzle.matrix">' +
+                '<td ng-repeat="item in items" unselectable="on"' +
+                ' ng-class="{\'puzzle-found\': item.found, \'puzzle-selected\': item.selected, \'puzzle-message\': puzzle.solved && !item.found}"' +
+                ' ng-mousedown="selectStart(item)" ng-mouseup="selectEnd()" ng-mouseenter="selectEnter(item)">' +
+                ' <span>{{item.letter}}</span>' +
+                '</td>' +
+                '</tr>' +
+                '</table>',
+            scope: {
+                matrix: '=',
+                words: '=',
+                api: '='
+            },
+            link: function(scope, element, attrs) {
+                var selectFrom;
+
+                // setup puzzle
+                scope.$watch('matrix', function(matrix) {
+                    scope.puzzle = wordSearchPuzzle(matrix, scope.words);
+
+                    // link service
+                    if (attrs.api) {
+                        scope.api = scope.puzzle;
+                    }
+                });
+
+                /**
+                 * Selected items
+                 * @type {Array}
+                 */
+                scope.selected = [];
+
+                /**
+                 * Selection start
+                 * @param item
+                 */
+                scope.selectStart = function(item) {
+                    selectFrom = item;
+                };
+
+                /**
+                 * Selection enter (over)
+                 * @param item
+                 */
+                scope.selectEnter = function(item) {
+                    if (selectFrom) {
+                        scope.selected = scope.puzzle.getItems(selectFrom.col, selectFrom.row, item.col, item.row);
+                    }
+                };
+
+                /**
+                 * Selection end
+                 */
+                scope.selectEnd = function() {
+                    selectFrom = null;
+                    scope.puzzle.lookup(scope.selected);
+                    scope.selected = [];
+                };
+
+                // propagate selection state to matrix
+                scope.$watch('selected', function(newItems, oldItems) {
+                    angular.forEach(oldItems, function(item) {
+                        item.selected = false;
+                    });
+                    angular.forEach(newItems, function(item) {
+                        item.selected = true;
+                    });
+                });
+            }
+        };
+    });
+})(window.angular);

data/test/data/example.html

@@ -0,0 +1,5 @@
+<html>
+<body>
+    The beatiful page.
+</body>
+</html>

data/test/data/example.js

@@ -0,0 +1,4 @@
+function myFunction()
+{
+    alert("Hello World!");
+}

data/test/data/services/index.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+
+    <head>
+        <meta charset="utf-8"/>
+        <title>Your First AngularJS App</title>
+
+        <!-- Google web fonts -->
+        <link href="http://fonts.googleapis.com/css?family=PT+Sans:400,700" rel='stylesheet' />
+
+        <!-- The main CSS file -->
+        <link href="assets/css/style.css" rel="stylesheet" />
+    </head>
+
+    <body>
+
+        <form id="main" ng-app ng-controller="myservices">
+            <h1>My Services</h1>
+
+            <ul id="services">
+                <!-- The services will be inserted here -->
+                <li ng-repeat="service in services">
+                </li>
+            </ul>
+
+            <p id="total">total: <span>${{total()}}</span></p>
+
+            <input type="submit" id="order" value="Order"/>
+
+        </form>
+
+    </body>
+</html>

data/test/data/services/script.js

@@ -0,0 +1,15 @@
+function myservices($scope){
+    $scope.services=[
+        { title: 'web development', price: 200},
+        { title: 'web design', price: 250},
+        { title: 'photography', price: 100},
+        { title: 'coffee drinking', price: 10}];
+    $scope.total=function(){
+        var t = 0;
+        angular.forEach($scope.services, function(s){
+            if(s.selected)
+                t+=s.price;
+        });
+        return t;
+    };
+}

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+SimpleCov.start do
+	add_filter "/test/"	
+end
+
+require 'crosslanguagespotter'
+require 'test/unit'
+
+include CrossLanguageSpotter

data/test/test_parsing.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'codemodels'
+require 'codemodels/xml'
+require 'codemodels/properties'
+require 'codemodels/html'
+require 'codemodels/js'
+
+class TestParsing < Test::Unit::TestCase
+
+def setup
+end
+
+def test_parse_html_file
+	root = CodeModels.parse_file('./test/data/example.html')
+	assert root.is_a?(CodeModels::Html::HtmlDocument)
+end
+
+def test_parse_js_file
+    root = CodeModels.parse_file('./test/data/example.js')
+    assert root.is_a?(CodeModels::Js::AstRoot)
+end
+
+end

data/test/test_spotter.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'codemodels'
+require 'codemodels/xml'
+require 'codemodels/properties'
+require 'codemodels/html'
+require 'codemodels/js'
+
+class TestSpotter < Test::Unit::TestCase
+
+def setup
+end
+
+def test_models_loading
+	models = CrossLanguageSpotter._load_models('./test/data/angular_puzzle')
+    assert_equal 4,models.count
+    assert models.has_key?('/app.js')
+    assert models.has_key?('/index.html')
+    assert models.has_key?('/slidingPuzzle.js')
+    assert models.has_key?('/wordSearchPuzzle.js')
+end
+
+def test_features_calc
+    dir = './test/data/angular_puzzle'
+    spotter = CrossLanguageSpotter::Spotter.new()
+    spotter.features_for_dir(dir)
+end
+
+def test_oracle
+    dir = './test/data/angular_puzzle'
+    oracle_loader = OracleLoader.new
+    oracle_loader.to_train_data(dir,'./test/data/angular-puzzle.GS')
+end
+
+def test_full_behavior
+    oracle_loader = OracleLoader.new
+    classifier = oracle_loader.build_weka_classifier('./test/data/angular_puzzle','./test/data/angular-puzzle.GS')
+    spotter = CrossLanguageSpotter::Spotter.new()
+    project = Project.new('./test/data/services')
+    results = spotter.classify_relations(project,classifier)
+end
+
+end

data/test/test_wekaintegration.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class TestWekaIntegration < Test::Unit::TestCase
+
+def setup
+    @train_data = [
+        {a: 10.0, b:7,  c:false},
+        {a: 12.0, b:3,  c:false},
+        {a: 18.4, b:-4, c:true}
+    ]
+    @sample_data = [
+        {a: 10.5, b:6},
+        {a: 12.1, b:2},
+        {a: 21.4, b:-8}
+    ]
+    @sample_data2 = [
+        {a: 10.5, b:6, c:false},
+        {a: 12.1, b:2, c:false},
+        {a: 21.4, b:-8, c:false}
+    ]
+end
+
+def test_hash2weka_instances_with_train_data
+    instances = hash2weka_instances('my_dataset',@train_data,{a: :numeric, b: :numeric, c: :boolean},:c)
+end
+
+def test_hash2weka_instances_with_data_to_classify
+    instances = hash2weka_instances('my_dataset',@sample_data,{a: :numeric, b: :numeric},nil)
+end
+
+def test_build_classifier
+    instances = hash2weka_instances('my_dataset',@train_data,{a: :numeric, b: :numeric, c: :boolean},:c)
+    c = build_classifier(instances)
+end
+
+def test_classify    
+    train_instances = hash2weka_instances('my_train_dataset',@train_data,{a: :numeric, b: :numeric, c: :boolean},:c)
+    data_instances = hash2weka_instances('my_sample_dataset',@sample_data2,{a: :numeric, b: :numeric, c: :boolean},:c)
+    classifier = WekaClassifier.new(train_instances)
+    results = classifier.classify(data_instances)
+end
+
+end