@enervance/insight-cim-model 0.0.1

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/dataset-stats.js

@@ -0,0 +1,41 @@
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        datasetStatsViewTpl = require( "plugins/text!app/templates/dataset-stats.tpl" );
+
+    var DatasetStatsView = Backbone.Marionette.ItemView.extend( {
+      initialize: function() {
+        _.bindAll( this, "onShowTab" );
+
+        fui.vent.on( "shown.bs.tab", this.onShowTab );
+      },
+
+      template: _.template( datasetStatsViewTpl ),
+
+      ui: {
+      },
+
+      el: "#statistics",
+
+      modelEvents: {
+        'change': "modelChanged"
+      },
+
+      modelChanged: function() {
+          this.render();
+      },
+
+      onShowTab: function( tab ) {
+        if (tab.attr("href") === "#info") {
+          this.model.refresh();
+        }
+      }
+
+    });
+
+
+    return DatasetStatsView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/datasets-dropdown-list.js

@@ -0,0 +1,43 @@
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" );
+
+    var DatasetDropDownListView = Backbone.Marionette.ItemView.extend( {
+      initialize: function(){
+      },
+
+      template:"",
+
+      el: "ul.dropdown-menu.dataset-list",
+
+      ui: {
+      },
+
+      events: {
+      },
+
+      render: function() {
+        var e = $(this.el).empty();
+        _.each( this.model, function( ds ) {
+          e.append( sprintf( "<li><a class='action select-dataset'href='?ds=%s'>%s</a></li>", ds.name(), ds.name() ));
+        } );
+      },
+
+      /** Change the currently selected dataset name. If required, notify other units via an event */
+      setCurrentDatasetName: function( dsName, notify ) {
+        if (dsName) {
+          $(".current-dataset").text( dsName );
+        }
+
+        if (notify) {
+          fui.vent.trigger( "views.datasets-dropdown-list.dataset-changed", dsName )
+        }
+      }
+    });
+
+
+    return DatasetDropDownListView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/file-upload.js

@@ -0,0 +1,225 @@
+/**
+ * This view presents a control to upload files to the current dataset, and a recently-uploaded
+ * log to track what has been done.
+ */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        sprintf = require( "sprintf" ),
+        fui = require( "app/fui" ),
+        fileUploadTemplate = require( "plugins/text!app/templates/file-upload.tpl" ),
+        UploadableFileView = require( "app/views/uploadable-file" );
+
+    var FileUploadView = Backbone.Marionette.CompositeView.extend( {
+      initialize: function(){
+        _.bindAll( this,
+                   "onUploadAdd", "onRemoveUpload", "onUploadAll",
+                   "onProgress", "onUploadDone", "onUploadFail",
+                   "onPerformUpload" );
+
+        fui.vent.on( "upload.remove", this.onRemoveUpload );
+        fui.vent.on( "upload.perform", this.onPerformUpload );
+      },
+
+      template: _.template( fileUploadTemplate ),
+
+      el: "#file-upload",
+
+      itemViewContainer: "ul",
+      itemView: UploadableFileView,
+      collection: new Backbone.Collection(),
+
+      ui: {
+        fileUpload: '#fileuploadForm',
+        graphLabel: '.graph-label input'
+      },
+
+      events: {
+        "click .action-upload-all": "onUploadAll"
+      },
+
+      templateHelpers: {
+      },
+
+      onRender: function() {
+        // initialise the file upload widget
+        this.ui.fileUpload.fileupload( {
+          dataType: 'json',
+          add: this.onUploadAdd,
+          progress: this.onProgress
+        } );
+      },
+
+      /** User has added a file */
+      onUploadAdd: function( e, data ) {
+        var collection = this.collection;
+        var self = this;
+
+        _.each( data.files, function( file ) {
+          file.readableFileSize = self.readableFileSize( file );
+          collection.add( new Backbone.Model( {file: file} ) );
+        } );
+
+        this.enableUploadAll( true );
+      },
+
+      /** Return file size in bytes in a human-readable form */
+      readableFileSize: function( file ) {
+        var k = 1024;
+        var m = k * k;
+
+        if (file.size >= m) {
+          return sprintf( "%.1fmb", file.size / m );
+        }
+        else if (file.size >= k) {
+          return sprintf( "%.1fkb", file.size / k );
+        }
+        else {
+          return sprintf( "%d bytes", file.size );
+        }
+      },
+
+      /** User has requested to remove a selected upload */
+      onRemoveUpload: function( file ) {
+        this.collection.remove( file );
+        this.enableUploadAll( this.collection.size() > 0 )
+      },
+
+      /** User has requested to perform a selected upload */
+      onPerformUpload: function( model ) {
+        this.loadAll = false;
+        this.uploadFileFromModel( model );
+      },
+
+      /** Return the list of active files waiting for upload */
+      activeFiles: function() {
+        var activeModels = _.filter( this.collection.models, function( m ) {
+            return !m.completed;
+          } );
+
+        return _.map( activeModels,  function( m ) {
+            return m.get( "file" );
+          } );
+      },
+
+      /** User action to upload all active files */
+      onUploadAll: function( e ) {
+        if (e) {
+          e.preventDefault();
+        }
+
+        this.$el.find( ".file-description .action" ).attr( 'disabled', 'disabled' );
+        this.loadNextAvailableFile( true );
+      },
+
+      /** Load the next file in the sequence */
+      loadNextAvailableFile: function( all ) {
+        this.loadAll = all;
+        var files = this.activeFiles();
+
+        if (files.length > 0) {
+          this.uploadFile( files.shift() );
+        }
+        else {
+          this.enableUploadAll( false );
+        }
+      },
+
+      /** Upload the given file to the server */
+      uploadFile: function( file ) {
+        this.uploadFileFromModel( this.collection.findWhere( {file: file} ) );
+      },
+
+      /** Upload the file attached to a given model */
+      uploadFileFromModel: function( model ) {
+        this.cacheModel( model );
+
+        var file = model.get( "file" );
+        var ds = fui.models.fusekiServer.selectedDataset();
+        var url = ds.uploadURL( this.destinationGraphName() );
+
+        this.ui.fileUpload.fileupload( 'send', {
+          files: [file],
+          url: url
+        })
+          .success( this.onUploadDone )
+          .fail( this.onUploadFail );
+      },
+
+      /** Return the selected graph name, or 'default' */
+      destinationGraphName: function() {
+        var gName = this.ui.graphLabel.val();
+        return (gName && gName !== "") ? gName : 'default';
+      },
+
+      /** Callback on progress against an upload */
+      onProgress: function( e, data ) {
+        var complete = Math.round( 100.0 * data.loaded/ data.total);
+        $(this.activeView.el).find( ".progress-bar" )
+                             .attr( 'aria-valuenow', complete )
+                             .css( 'width', sprintf( "%s%%", complete ));
+      },
+
+      /** Callback on successful completion */
+      onUploadDone: function( data, response ) {
+        var label = "Data file was empty.";
+        if ((data.count) > 0) {
+          var s = (data.count === 1) ? "" : "s";
+          label = sprintf( "%d %s%s", data.count, ((data.tripleCount > 0) ? "triple" : "quad"), s );
+        }
+
+        this.displayUploadResult( sprintf( "<p><small>Result: <strong>success</strong>. %s</small></p>", label ), "" );
+
+        if (this.loadAll) {
+          this.loadNextAvailableFile( true );
+        }
+      },
+
+      /** Callback on error */
+      onUploadFail: function( jqxhr, error, msg ) {
+        $(this.activeView.el).find( ".progress-bar" )
+                             .removeClass( "progress-bar-success" )
+                             .addClass( "progress-bar-warning" );
+        this.displayUploadResult( sprintf( "<p><small>Result: <strong>failed</strong> with message &quot;%s&quot;</small></p>", msg ), "text-danger" );
+
+        if (this.loadAll) {
+          this.loadNextAvailableFile( true );
+        }
+      },
+
+      /** Show the result of uploading a file */
+      displayUploadResult: function( html, cls ) {
+        var el = $(this.activeView.el);
+        this.activeModel.completed = true;
+        el.find( ".action" ).hide();
+
+        el.find( ".result" )
+          .addClass( cls )
+          .append( html );
+      },
+
+      /** Cache the currently active model so that we can attach actions to the corresponding view */
+      cacheModel: function( model ) {
+        this.activeModel = model;
+        this.activeView = this.children.findByModel( model );
+      },
+
+      /** Enable or disable the upload all button */
+      enableUploadAll: function( enabled ) {
+        if (enabled) {
+          $(".action-upload-all").removeAttr( 'disabled' );
+        }
+        else {
+          $(".action-upload-all").attr( 'disabled', 'disabled' );
+        }
+      }
+
+
+    });
+
+
+    return FileUploadView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/tabbed-view-manager.js

@@ -0,0 +1,63 @@
+/**
+ * Reusable component that encapsulates managing a collection of sub-views as
+ * tabs, with the active tab being selected via the URL query param `tab`.
+ **/
+
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" ),
+        PageUtils = require( "app/util/page-utils" );
+
+    var TabbedViewManagerView = Backbone.View.extend( {
+
+      initialize: function(){
+        this._tab = PageUtils.queryParam( "tab" );
+        this._firstRender = false;
+      },
+
+      render: function() {
+        if (!this._firstRender) {
+          this._firstRender = true;
+          this.activateCurrentTab();
+
+          $(".nav-tabs").on( "shown.bs.tab", function( e ) {
+            fui.vent.trigger( "shown.bs.tab", $(e.target) );
+          } );
+        }
+      },
+
+      /**
+       * Make the tab named as the current tab active. If no named tab, make
+       * the first tab active by default.
+       */
+      activateCurrentTab: function() {
+        var tabs = $(".nav-tabs");
+        var tab = tabs.children().first();
+
+        if (this._tab) {
+          tab = tabs.find( sprintf( "a[href=#%s]", this._tab ) )
+                    .parent();
+        }
+
+        if (!tab.is(".active")) {
+          tabs.children( "li" ).removeClass( "active" );
+          tabs.parent().children(".tab-pane").removeClass("active");
+
+          tab.addClass( "active" );
+          $( tab.children( "a" ).attr( "href" ) ).addClass("active");
+        }
+      }
+
+
+    });
+
+
+    return TabbedViewManagerView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/uploadable-file.js

@@ -0,0 +1,39 @@
+/**
+ * This view encapsulates a single uploadable file
+ */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        uploadableFileTemplate = require( "plugins/text!app/templates/uploadable-file.tpl" );
+
+    var UploadableFileView = Backbone.Marionette.ItemView.extend( {
+      initialize: function(){
+      },
+
+      tagName: "li",
+
+      template: _.template( uploadableFileTemplate ),
+
+      events: {
+        "click .action-remove-upload": "onActionRemoveUpload",
+        "click .action-upload-file": "onActionUploadFile"
+      },
+
+      onActionRemoveUpload: function( e ) {
+        e.preventDefault();
+        fui.vent.trigger( "upload.remove", this.model );
+      },
+
+      onActionUploadFile: function( e ) {
+        e.preventDefault();
+        fui.vent.trigger( "upload.perform", this.model );
+      }
+
+    });
+
+    return UploadableFileView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/validation-options.js

@@ -0,0 +1,54 @@
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" );
+
+    var ValidationOptions = Backbone.Marionette.ItemView.extend( {
+      initialize: function(){
+        _.bindAll( this, "onValidateAs", "onOutputFormat", "onModelChange" );
+        this.listenTo( this.model, "change", this.onModelChange, this );
+      },
+
+      el: ".validation",
+
+      events: {
+        "click .validate-as-options a": "onValidateAs",
+        "click .output-format-options a": "onOutputFormat",
+      },
+
+      templateHelpers: {
+      },
+
+      onValidateAs: function( e ) {
+        e.preventDefault();
+        var elem = $(e.currentTarget);
+        this.model.setValidateAs( elem.data( "validate-as" ) );
+        this.$el.find(".validate-as-options a").removeClass("active");
+        elem.addClass("active");
+
+        if (this.model.validateAsQuery()) {
+          this.$el.find(".output-format-options").removeClass("hidden");
+        }
+        else {
+          this.$el.find(".output-format-options").addClass("hidden");
+        }
+      },
+
+      onOutputFormat: function( e ) {
+        e.preventDefault();
+        var elem = $(e.currentTarget);
+        this.model.setOutputFormat( elem.data( "output-format" ) );
+        this.$el.find(".output-format-options a").removeClass("active");
+        elem.addClass("active");
+      },
+
+      onModelChange: function( event ) {
+      }
+
+    });
+
+
+    return ValidationOptions;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/common-config.js

@@ -0,0 +1,94 @@
+require.config({
+  baseUrl: 'js/lib',
+  paths: {
+    'app':                  '../app',
+    // lib paths
+    'bootstrap':            'bootstrap.min',
+    'jquery':               'jquery-1.10.2.min',
+    'marionette':           'backbone.marionette',
+    'sprintf':              'sprintf-0.7-beta1',
+    'datatables':           'jquery.dataTables.min',
+    'yasqe':                'yasqe.min',
+    'yasr':                 'yasr.min',
+    'pivottable':           'pivot.min',
+    'jquery-ui':            'jquery-ui.min'
+  },
+  map: {
+      '*': {
+          'codemirror': 'lib/codemirror',
+          'jquery.dataTables.min' : 'datatables',
+          'jquery-ui': 'jquery-ui'
+      },
+  },
+  shim: {
+    'underscore': {
+      exports: '_'
+    },
+    'backbone': {
+      deps: ['underscore', 'jquery'],
+      exports: 'Backbone'
+    },
+    'bootstrap': {
+      deps: ['jquery']
+    },
+    'bootstrap-select.min': {
+      deps: ['bootstrap']
+    },
+    'jquery.xdomainrequest': {
+      deps: ['jquery']
+    },
+    'jquery.dataTables.min': {
+      deps: ['jquery']
+    },
+    'jquery.form': {
+      deps: ['jquery']
+    },
+    'jquery.ui.widget': {
+      deps: ['jquery']
+    },
+    'qonsole': {
+      deps: ['yasqe', 'yasr'],
+      exports: 'qonsole'
+    },
+    'yasqe': {
+      deps: ['jquery', 'lib/codemirror'],
+      exports: 'YASQE'
+    },
+    'yasr': {
+//        deps: ['pivottable', 'jquery', 'lib/codemirror', 'datatables'],
+        deps: ['jquery', 'lib/codemirror', 'datatables'],
+        exports: 'YASR'
+    },
+    'pivottable': {
+        deps: ['jquery-ui']
+    },
+    'jquery-ui': {
+        deps: ['jquery']
+    },
+    'jquery.fileupload': {
+      deps: ['jquery.fileupload.local', 'jquery.iframe-transport', 'jquery.ui.widget']
+    },
+    'jquery.fileupload.local': {
+      deps: ['jquery']
+    },
+    'jquery.iframe-transport': {
+      deps: ['jquery']
+    },
+    'sprintf': {
+      exports: 'sprintf'
+    },
+    'marionette': {
+      deps: ['backbone'],
+      exports: 'Marionette'
+    },
+    'addon/fold/foldcode': {deps: ['lib/codemirror']},
+    'addon/fold/brace-fold': {deps: ['addon/fold/foldcode']},
+    'addon/fold/comment-fold': {deps: ['addon/fold/foldcode']},
+    'addon/fold/foldgutter': {deps: ['addon/fold/foldcode']},
+    'addon/fold/xml-fold': {deps: ['addon/fold/foldcode']},
+    'mode/javascript/javascript': {deps: ['lib/codemirror']},
+    'mode/sparql/sparql': {deps: ['lib/codemirror']},
+    'mode/xml/xml': {deps: ['lib/codemirror']},
+    'mode/turtle/turtle': {deps: ['lib/codemirror']}
+  }
+});

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/lib/addon/fold/brace-fold.js

@@ -0,0 +1,105 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.registerHelper("fold", "brace", function(cm, start) {
+  var line = start.line, lineText = cm.getLine(line);
+  var startCh, tokenType;
+
+  function findOpening(openCh) {
+    for (var at = start.ch, pass = 0;;) {
+      var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1);
+      if (found == -1) {
+        if (pass == 1) break;
+        pass = 1;
+        at = lineText.length;
+        continue;
+      }
+      if (pass == 1 && found < start.ch) break;
+      tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1));
+      if (!/^(comment|string)/.test(tokenType)) return found + 1;
+      at = found - 1;
+    }
+  }
+
+  var startToken = "{", endToken = "}", startCh = findOpening("{");
+  if (startCh == null) {
+    startToken = "[", endToken = "]";
+    startCh = findOpening("[");
+  }
+
+  if (startCh == null) return;
+  var count = 1, lastLine = cm.lastLine(), end, endCh;
+  outer: for (var i = line; i <= lastLine; ++i) {
+    var text = cm.getLine(i), pos = i == line ? startCh : 0;
+    for (;;) {
+      var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
+      if (nextOpen < 0) nextOpen = text.length;
+      if (nextClose < 0) nextClose = text.length;
+      pos = Math.min(nextOpen, nextClose);
+      if (pos == text.length) break;
+      if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) {
+        if (pos == nextOpen) ++count;
+        else if (!--count) { end = i; endCh = pos; break outer; }
+      }
+      ++pos;
+    }
+  }
+  if (end == null || line == end && endCh == startCh) return;
+  return {from: CodeMirror.Pos(line, startCh),
+          to: CodeMirror.Pos(end, endCh)};
+});
+
+CodeMirror.registerHelper("fold", "import", function(cm, start) {
+  function hasImport(line) {
+    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+    if (start.type != "keyword" || start.string != "import") return null;
+    // Now find closing semicolon, return its position
+    for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) {
+      var text = cm.getLine(i), semi = text.indexOf(";");
+      if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)};
+    }
+  }
+
+  var start = start.line, has = hasImport(start), prev;
+  if (!has || hasImport(start - 1) || ((prev = hasImport(start - 2)) && prev.end.line == start - 1))
+    return null;
+  for (var end = has.end;;) {
+    var next = hasImport(end.line + 1);
+    if (next == null) break;
+    end = next.end;
+  }
+  return {from: cm.clipPos(CodeMirror.Pos(start, has.startCh + 1)), to: end};
+});
+
+CodeMirror.registerHelper("fold", "include", function(cm, start) {
+  function hasInclude(line) {
+    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+    if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8;
+  }
+
+  var start = start.line, has = hasInclude(start);
+  if (has == null || hasInclude(start - 1) != null) return null;
+  for (var end = start;;) {
+    var next = hasInclude(end + 1);
+    if (next == null) break;
+    ++end;
+  }
+  return {from: CodeMirror.Pos(start, has + 1),
+          to: cm.clipPos(CodeMirror.Pos(end))};
+});
+
+});