haplo 2.1.0-java

data/lib/auth.rb

@@ -0,0 +1,168 @@
+
+module PluginTool
+
+  @@keys_pathname = "#{Dir.getwd}/.server.json"
+
+  # ---------------------------------------------------------------------------------------------------------
+
+  def self.setup_auth(options)
+    keys = load_keys_file()
+    server = keys['default']
+    if options.server_substring
+      server = select_server(keys, options.server_substring)
+      end_on_error "No server found for substring '#{options.server_substring}'" unless server
+    end
+    key = keys['keys'][server]
+    if key
+      hostname, port, url_base = parse_hostname_with_port(server)
+      set_server(hostname, port, key)
+      puts "Application: #{url_base}"
+    else
+      end_on_error "No server authorised. Run haplo-plugin auth SERVER_NAME"
+    end
+  end
+
+  # ---------------------------------------------------------------------------------------------------------
+
+  def self.cmd_server(options)
+    end_on_error "No server name substring given on command line" if options.args.empty?
+    keys = load_keys_file()
+    server = select_server(keys, options.args.first)
+    end_on_error "No server found for substring '#{options.args.first}" unless server
+    keys['default'] = server
+    puts "Selected server #{server}"
+    save_keys_file(keys)
+  end
+
+  # ---------------------------------------------------------------------------------------------------------
+
+  def self.cmd_auth(options)
+    end_on_error "No hostname given on command line" if options.args.empty?
+    hostname, port, url_base, server_name = parse_hostname_with_port(options.args.first)
+
+    keys = load_keys_file()
+    if keys['keys'].has_key?(server_name) && !options.force
+      puts
+      puts "Already authorised with #{server_name}"
+      puts "Use the --force argument to reauthorise with the server."
+      return
+    end
+
+    set_server(hostname, port, nil)
+    check_for_certificate_file()
+    http = get_http()
+
+    this_hostname = java.net.InetAddress.getLocalHost().getHostName() || "unknown"
+
+    puts "Requesting token from #{url_base} ..."
+    start_auth_path = "/api/plugin-tool-auth/start-auth?name=#{URI.encode(this_hostname)}"
+    request = Net::HTTP::Get.new(start_auth_path)
+    setup_request(request)
+    token = nil
+    begin
+      response = http.request(request)
+      end_on_error "Server returned an error. Check hostname and port." unless response.code == "200"
+      parsed_json = JSON.parse(response.body)
+      token = parsed_json['token']
+      end_on_error "Server doesn't look like a Haplo server with plugin debugging enabled" unless ((parsed_json['Haplo'] == 'plugin-tool-auth') || (parsed_json['ONEIS'] == 'plugin-tool-auth')) && token
+    rescue => e
+      end_on_error "Failed to start authorisation process. Check hostname and port."
+    end
+
+    # Check token looks OK so we don't form dodgy URLs
+    end_on_error "Bad token" unless token =~ /\A[a-z0-9A-Z_-]+\z/
+
+    user_url = "#{url_base}/do/plugin-tool-auth/create/#{token}"
+    poll_path = "/api/plugin-tool-auth/poll/#{token}"
+
+    puts
+    if java.lang.System.getProperty("os.name") == 'Mac OS X'
+      puts "Attempting to open the following URL in your browser."
+      puts "If the browser does not open, please visit this URL in your browser."
+      system "open #{user_url}"
+    else
+      puts "Please visit this URL in your browser, and authenticate if necessary."
+    end
+    puts "  #{user_url}"
+    puts
+
+    # Poll for a few minutes, waiting for the user to authenticate
+    puts "Waiting for server to authorise..."
+    poll_count = 0
+    key = nil
+    while poll_count < 60 && !key
+      delay = if poll_count < 10
+        2
+      elsif poll_count < 20
+        4
+      else
+        8
+      end
+      sleep delay
+      begin
+        request = Net::HTTP::Get.new(poll_path)
+        setup_request(request)
+        response = http.request(request)
+        parsed_json = JSON.parse(response.body)
+        case parsed_json['status']
+        when 'wait'
+          # poll again
+        when 'available'
+          key = parsed_json['key']
+        else
+          end_on_error "Authorisation process failed."
+        end
+      rescue => e
+        end_on_error "Error communicating with server"
+      end
+    end
+    finish_with_connection()
+
+    end_on_error "Didn't managed to authorise with server." unless key
+
+    puts "Successfully authorised with server."
+
+    keys['default'] = server_name
+    keys['keys'][server_name] = key
+    save_keys_file(keys)
+
+    puts
+    puts "Key stored in #{@@keys_pathname}"
+    puts "#{server_name} selected as default server."
+  end
+
+  # ---------------------------------------------------------------------------------------------------------
+
+  def self.parse_hostname_with_port(hostname_with_port)
+    hostname_with_port = hostname_with_port.downcase.strip
+    unless hostname_with_port =~ /\A(https?:\/\/)?([a-z0-9\.-]+)(:(\d+))?/i
+      end_on_error "Bad hostname #{hostname_with_port}"
+    end
+    hostname = $2
+    port = $4 ? $4.to_i : 443
+    server_name = "#{hostname}#{(port != 443) ? ":#{port}" : ''}"
+    [hostname, port, "https://#{server_name}", server_name]
+  end
+
+  # ---------------------------------------------------------------------------------------------------------
+
+  def self.load_keys_file
+    if File.exist?(@@keys_pathname)
+      File.open(@@keys_pathname) { |f| JSON.parse(f.read) }
+    else
+      {"_" => "Contains server keys. DO NOT COMMIT TO SOURCE CONTROL.", "default" => nil, "keys" => {}}
+    end
+  end
+
+  def self.save_keys_file(keys)
+    pn = "#{@@keys_pathname}.n"
+    File.open(pn, "w") { |f| f.write(JSON.pretty_generate(keys)) }
+    File.rename(pn, @@keys_pathname)
+  end
+
+  def self.select_server(keys, substring)
+    s = substring.downcase.strip
+    keys['keys'].keys.sort { |a,b| (a.length == b.length) ? (a <=> b) : (a.length <=> b.length) } .find { |a| a.include? s }
+  end
+
+end

data/lib/check.rb

@@ -0,0 +1,60 @@
+
+module PluginTool
+
+  def self.check_plugins(plugins)
+    init_syntax_checking
+    @@check_report = ''
+    @@check_ok = true
+    @@check_warn = false
+    plugins.each { |p| check_plugin(p) }
+    if @@check_warn || !(@@check_ok)
+      puts "\nFILES WITH ERRORS"
+      puts @@check_report
+    end
+    # Output the verdict
+    puts
+    if @@check_ok && !@@check_warn
+      puts "PASSED"
+    elsif @@check_warn
+      puts "PASSED WITH WARNINGS"
+    else
+      puts "FAILED"
+      exit 1
+    end
+  end
+
+  def self.check_plugin(plugin)
+    plugin_dir = plugin.plugin_dir
+    STDOUT.write(plugin.name+" ")
+    Dir.glob("#{plugin_dir}/**/*").each do |pathname|
+      next unless File.file?(pathname)
+      next if plugin.exclude_files_from_syntax_check.include?(pathname)
+      plugin_relative_name = pathname[plugin_dir.length+1, pathname.length]
+      if pathname =~ /\.(js|hsvt)\z/i
+        STDOUT.write("."); STDOUT.flush
+        # Check JavaScript
+        report = syntax_check_one_file(plugin, plugin_relative_name)
+        if report == nil
+          check_file_result(plugin, plugin_relative_name, :OK)
+        else
+          puts "\n**** #{plugin_relative_name} has errors:\n#{report}\n"
+          check_file_result(plugin, plugin_relative_name, (plugin_relative_name =~ /\Ajs\//) ? :FAIL : :WARN)
+        end
+      else
+        # TODO: Checks for other file types, including the plugin.json
+        check_file_result(plugin, plugin_relative_name, :OK)        
+      end
+    end
+    STDOUT.write("\n"); STDOUT.flush
+  end
+  
+  def self.check_file_result(plugin, name, result)
+    unless result == :OK
+      @@check_report << "  #{plugin.plugin_dir}/#{name}: #{result}\n"
+    end
+    @@check_ok = false if result == :FAIL
+    @@check_warn = true if result == :WARN
+  end
+
+end
+

data/lib/custom.rb

@@ -0,0 +1,73 @@
+
+module PluginTool
+
+  LOCAL_CUSTOM_BEHAVIOUR_FILENAME = "server.behaviour.rb"
+
+  # Digests of trusted code are stored outside the source code repo, so it can't be written by the repo contents
+  TRUSTED_CODE_DIGESTS_FILENAME = "~/.haplo-plugin-tool-trusted.json"
+
+  class CustomBehaviour
+    def start(plugins, command, options, is_local_command)
+    end
+    def server_ready(plugins, command, options)
+    end
+  end
+
+  @@custom = CustomBehaviour.new
+
+  def self.set_custom_behaviour(custom)
+    @@custom = custom
+  end
+
+  def self.custom_behaviour
+    @@custom
+  end
+
+  def self.try_load_custom
+    return unless File.exist?(LOCAL_CUSTOM_BEHAVIOUR_FILENAME)
+
+    trusted_code = nil
+    untrusted_code = File.open(LOCAL_CUSTOM_BEHAVIOUR_FILENAME) { |f| f.read }
+    untrusted_code_digest = Digest::SHA256.hexdigest(untrusted_code)
+
+    trusted_code_digests = {"trust" => []}
+    trusted_code_filename = File.expand_path(TRUSTED_CODE_DIGESTS_FILENAME)
+    if File.exist?(trusted_code_filename)
+      trusted_code_digests = JSON.parse(File.open(trusted_code_filename) { |f| f.read })
+    end
+
+    unless trusted_code_digests["trust"].include?(untrusted_code_digest)
+      # Make sure the user wants to run this code. Otherwise running the plugin tool in a repo you've just
+      # downloaded could unexpectedly execute code on your local machine.
+      if ARGV.length == 2 && ARGV[0] == 'trust' && ARGV[1] =~ /\A[0-9a-z]{64}\z/ && ARGV[1] == untrusted_code_digest
+        trusted_code_digests["trust"].push(untrusted_code_digest)
+        File.open(trusted_code_filename,"w") { |f| f.write JSON.pretty_generate(trusted_code_digests) }
+        puts "Stored trust for #{LOCAL_CUSTOM_BEHAVIOUR_FILENAME} with contents #{untrusted_code_digest}."
+        exit 0
+      else
+        puts
+        puts "-------------------------------------------------------------------------------------------"
+        puts "  Do you trust the code in #{LOCAL_CUSTOM_BEHAVIOUR_FILENAME} to be run every time you run the"
+        puts "  plugin tool? If yes, run"
+        puts "      haplo-plugin trust #{untrusted_code_digest}"
+        puts "  to permanently trust this version of #{LOCAL_CUSTOM_BEHAVIOUR_FILENAME}"
+        puts "-------------------------------------------------------------------------------------------"
+        puts
+        PluginTool.beep
+        exit 1
+      end
+    end
+
+    if ARGV.length > 0 && ARGV[0] == "trust"
+      puts "Unexpected trust command."
+      exit 1
+    end
+
+    # User trusts the code, run it
+    # There is a race condition here, but we're trying to protect against code in repositories, not
+    # against software running on the local machine.
+    load LOCAL_CUSTOM_BEHAVIOUR_FILENAME
+
+  end
+
+end

data/lib/hmac.rb

@@ -0,0 +1,12 @@
+
+module HMAC
+  module SHA1
+    def self.sign(key, message)
+      mac = javax.crypto.Mac.getInstance("HmacSHA1")
+      mac.init(javax.crypto.spec.SecretKeySpec.new(key.to_java_bytes, "HmacSHA1"))
+      result = mac.doFinal(message.to_java_bytes)
+      String.from_java_bytes(result).unpack('H*').join
+    end    
+  end
+end
+

data/lib/js_min.js

@@ -0,0 +1,38 @@
+
+// Emulate enough of CommonJS to load unmodified UglifyJS files
+var exports = {};
+function require() {
+    return exports;
+}
+
+// Enough compatibility with JavaScript 1.8
+// Copied from https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/Reduce
+if(!Array.prototype.reduce) {
+    Array.prototype.reduce = function reduce(accumlator){
+        var i, l = this.length, curr;
+        if(typeof accumlator !== "function") // ES5 : "If IsCallable(callbackfn) is false, throw a TypeError exception."
+        throw new TypeError("First argument is not callable");
+        if((l == 0 || l === null) && (arguments.length <= 1))// == on purpose to test 0 and false.
+        throw new TypeError("Array length is 0 and no second argument");
+        if(arguments.length <= 1){
+            curr = this[0]; // Increase i to start searching the secondly defined element in the array
+            i = 1; // start accumulating at the second element
+        } else {
+            curr = arguments[1];
+        }
+        for(i = i || 0 ; i < l ; ++i){
+            if(i in this)
+            curr = accumlator.call(undefined, curr, this[i], i, this);
+        }
+        return curr;
+    };
+}
+
+// Function to call from the Ruby PluginTool::Minimiser#process function
+function js_min(orig_code) {
+    // usage from https://github.com/mishoo/UglifyJS
+    var ast = jsp.parse(orig_code); // parse code and get the initial AST
+    ast = exports.ast_mangle(ast); // get a new AST with mangled names
+    ast = exports.ast_squeeze(ast); // get an AST with compression optimizations
+    return exports.gen_code(ast); // compressed code here    
+}

data/lib/js_syntax_test.js

@@ -0,0 +1,88 @@
+
+(function() {
+    var root = this;
+
+    // Options for the syntax checking
+    
+    var opts = function() {
+        return {
+            asi: false,
+            bitwise: false,
+            boss: false,
+            curly: true,
+            debug: false,
+            devel: false,
+            eqeqeq: false,
+            evil: false,
+            forin: false,
+            immed: false,
+            laxbreak: false,
+            newcap: true,
+            noarg: true,
+            noempty: false,
+            nonew: true,
+            nomen: false,
+            onevar: false,
+            plusplus: false,
+            regexp: false,
+            undef: true,
+            sub: true,
+            strict: false,
+            white: false
+        };
+    };
+    
+    // Options
+    var optionsServer = opts();
+    var optionsBrowser = opts();
+    optionsBrowser.browser = true;
+    
+    // Predefined globals
+    var globalsServer = [
+        'O',
+        'SCHEMA', 'TYPE', 'ATTR', 'ALIASED_ATTR', 'QUAL', 'LABEL', 'GROUP',
+        'HTTP', 'DBTime',
+        'console', 'JSON',
+        '_', 'Handlebars', 'oForms', 'moment', 'XDate'
+    ];
+    var globalsBrowser = ['Haplo', 'ONEIS', 'jQuery', '_'];
+    var globalsTest = globalsServer.concat('T');
+    
+    // Set globals
+    root.syntax_tester_globals = function(string) {
+        globals = eval("("+string+")");
+    };
+
+    // Syntax tester function
+    root.syntax_tester = function(source, kind, extraGlobals) {
+        var globalList;
+        switch(kind) {
+            case "js":      globalList = globalsServer;    break;
+            case "static":  globalList = globalsBrowser;   break;
+            case "test":    globalList = globalsTest;      break;
+        }
+        if(!globalList) { return "Wrong kind of file"; }
+        var globals = {}, addGlobal = function(g) { globals[g] = false; };
+        globalList.forEach(addGlobal);
+        if(extraGlobals) {
+            JSON.parse(extraGlobals).forEach(addGlobal);
+        }
+        var result = JSHINT(source,
+            (kind !== 'static') ? optionsServer : optionsBrowser,
+            globals
+        );
+        if(result == true) { return null; } // success
+        // Errors - compile a report, can't use the default one as it's HTML
+        var data = JSHINT.data();
+        var errors = data.errors;
+        var report = '';
+        for(var e = 0; e < errors.length; e++) {
+            var err = errors[e];
+            if(err !== null && err !== undefined) { // oddly it will do that
+                report += "line "+err.line+": "+err.reason+"\n    "+err.evidence+"\n";
+            }
+        }
+        return (report == '') ? null : report;
+    };
+
+})();