JezK

Edit File: hosted-git-resolver.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
exports.explodeHostedGitFragment = explodeHostedGitFragment;
function _regenerator() {
  var data = _interopRequireDefault(require("@babel/runtime/regenerator"));
  _regenerator = function _regenerator() {
    return data;
  };
  return data;
}
function _asyncToGenerator2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
  _asyncToGenerator2 = function _asyncToGenerator2() {
    return data;
  };
  return data;
}
function _classCallCheck2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
  _classCallCheck2 = function _classCallCheck2() {
    return data;
  };
  return data;
}
function _createClass2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
  _createClass2 = function _createClass2() {
    return data;
  };
  return data;
}
function _assertThisInitialized2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
  _assertThisInitialized2 = function _assertThisInitialized2() {
    return data;
  };
  return data;
}
function _inherits2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
  _inherits2 = function _inherits2() {
    return data;
  };
  return data;
}
function _possibleConstructorReturn2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
  _possibleConstructorReturn2 = function _possibleConstructorReturn2() {
    return data;
  };
  return data;
}
function _getPrototypeOf2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
  _getPrototypeOf2 = function _getPrototypeOf2() {
    return data;
  };
  return data;
}
function _defineProperty2() {
  var data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
  _defineProperty2 = function _defineProperty2() {
    return data;
  };
  return data;
}
function _errors() {
  var data = require("../../errors.js");
  _errors = function _errors() {
    return data;
  };
  return data;
}
function _index() {
  var data = require("../../registries/index.js");
  _index = function _index() {
    return data;
  };
  return data;
}
function _gitResolver() {
  var data = _interopRequireDefault(require("./git-resolver.js"));
  _gitResolver = function _gitResolver() {
    return data;
  };
  return data;
}
function _exoticResolver() {
  var data = _interopRequireDefault(require("./exotic-resolver.js"));
  _exoticResolver = function _exoticResolver() {
    return data;
  };
  return data;
}
function _git() {
  var data = _interopRequireDefault(require("../../util/git.js"));
  _git = function _git() {
    return data;
  };
  return data;
}
function _guessName() {
  var data = _interopRequireDefault(require("../../util/guess-name.js"));
  _guessName = function _guessName() {
    return data;
  };
  return data;
}
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2()["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2()["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2()["default"])(this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function parseHash(fragment) {
  var hashPosition = fragment.indexOf('#');
  return hashPosition === -1 ? '' : fragment.substr(hashPosition + 1);
}
function explodeHostedGitFragment(fragment, reporter) {
  var hash = parseHash(fragment);
  var preParts = fragment.split('@');
  if (preParts.length > 2) {
    fragment = preParts[1] + '@' + preParts[2];
  }
  var parts = fragment.replace(/(.*?)#.*/, '$1') // Strip hash
  .replace(/.*:(.*)/, '$1') // Strip prefixed protocols
  .replace(/.git$/, '') // Strip the .git suffix
  .split('/');
  var user = parts[parts.length - 2];
  var repo = parts[parts.length - 1];
  if (user === undefined || repo === undefined) {
    throw new (_errors().MessageError)(reporter.lang('invalidHostedGitFragment', fragment));
  }
  return {
    user: user,
    repo: repo,
    hash: hash
  };
}
var HostedGitResolver = /*#__PURE__*/function (_ExoticResolver) {
  (0, _inherits2()["default"])(HostedGitResolver, _ExoticResolver);
  var _super = _createSuper(HostedGitResolver);
  function HostedGitResolver(request, fragment) {
    var _this;
    (0, _classCallCheck2()["default"])(this, HostedGitResolver);
    _this = _super.call(this, request, fragment);
    (0, _defineProperty2()["default"])((0, _assertThisInitialized2()["default"])(_this), "exploded", void 0);
    (0, _defineProperty2()["default"])((0, _assertThisInitialized2()["default"])(_this), "url", void 0);
    (0, _defineProperty2()["default"])((0, _assertThisInitialized2()["default"])(_this), "user", void 0);
    (0, _defineProperty2()["default"])((0, _assertThisInitialized2()["default"])(_this), "repo", void 0);
    (0, _defineProperty2()["default"])((0, _assertThisInitialized2()["default"])(_this), "hash", void 0);
    var exploded = _this.exploded = explodeHostedGitFragment(fragment, _this.reporter);
    var user = exploded.user,
      repo = exploded.repo,
      hash = exploded.hash;
    _this.user = user;
    _this.repo = repo;
    _this.hash = hash;
    return _this;
  }
  (0, _createClass2()["default"])(HostedGitResolver, [{
    key: "getRefOverHTTP",
    value: function () {
      var _getRefOverHTTP = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee(url) {
        var gitUrl, client, out, lines;
        return _regenerator()["default"].wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              gitUrl = _git()["default"].npmUrlToGitUrl(url);
              client = new (_git()["default"])(this.config, gitUrl, this.hash);
              _context.next = 4;
              return this.config.requestManager.request({
                url: "".concat(url, "/info/refs?service=git-upload-pack"),
                queue: this.resolver.fetchingQueue
              });
            case 4:
              out = _context.sent;
              if (!out) {
                _context.next = 13;
                break;
              }
              // clean up output
              lines = out.trim().split('\n'); // remove first two lines which contains compatibility info etc
              lines = lines.slice(2);

// remove last line which contains the terminator "0000"
              lines.pop();

// remove line lengths from start of each line
              lines = lines.map(function (line) {
                return line.slice(4);
              });
              out = lines.join('\n');
              _context.next = 14;
              break;
            case 13:
              throw new Error(this.reporter.lang('hostedGitResolveError'));
            case 14:
              return _context.abrupt("return", client.setRefHosted(out));
            case 15:
            case "end":
              return _context.stop();
          }
        }, _callee, this);
      }));
      function getRefOverHTTP(_x) {
        return _getRefOverHTTP.apply(this, arguments);
      }
      return getRefOverHTTP;
    }()
  }, {
    key: "resolveOverHTTP",
    value: function () {
      var _resolveOverHTTP = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee3(url) {
        var _this2 = this;
        var commit, config, tarballUrl, tryRegistry, file, registry, _file;
        return _regenerator()["default"].wrap(function _callee3$(_context3) {
          while (1) switch (_context3.prev = _context3.next) {
            case 0:
              _context3.next = 2;
              return this.getRefOverHTTP(url);
            case 2:
              commit = _context3.sent;
              config = this.config;
              tarballUrl = this.constructor.getTarballUrl(this.exploded, commit);
              tryRegistry = /*#__PURE__*/function () {
                var _ref = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee2(registry) {
                  var filename, href, file, json;
                  return _regenerator()["default"].wrap(function _callee2$(_context2) {
                    while (1) switch (_context2.prev = _context2.next) {
                      case 0:
                        filename = _index().registries[registry].filename;
                        href = _this2.constructor.getHTTPFileUrl(_this2.exploded, filename, commit);
                        _context2.next = 4;
                        return config.requestManager.request({
                          url: href,
                          queue: _this2.resolver.fetchingQueue
                        });
                      case 4:
                        file = _context2.sent;
                        if (file) {
                          _context2.next = 7;
                          break;
                        }
                        return _context2.abrupt("return", null);
                      case 7:
                        _context2.next = 9;
                        return config.readJson(href, function () {
                          return JSON.parse(file);
                        });
                      case 9:
                        json = _context2.sent;
                        json._uid = commit;
                        json._remote = {
                          resolved: tarballUrl,
                          type: 'tarball',
                          reference: tarballUrl,
                          registry: registry
                        };
                        return _context2.abrupt("return", json);
                      case 13:
                      case "end":
                        return _context2.stop();
                    }
                  }, _callee2);
                }));
                return function tryRegistry(_x3) {
                  return _ref.apply(this, arguments);
                };
              }();
              _context3.next = 8;
              return tryRegistry(this.registry);
            case 8:
              file = _context3.sent;
              if (!file) {
                _context3.next = 11;
                break;
              }
              return _context3.abrupt("return", file);
            case 11:
              _context3.t0 = _regenerator()["default"].keys(_index().registries);
            case 12:
              if ((_context3.t1 = _context3.t0()).done) {
                _context3.next = 23;
                break;
              }
              registry = _context3.t1.value;
              if (!(registry === this.registry)) {
                _context3.next = 16;
                break;
              }
              return _context3.abrupt("continue", 12);
            case 16:
              _context3.next = 18;
              return tryRegistry(registry);
            case 18:
              _file = _context3.sent;
              if (!_file) {
                _context3.next = 21;
                break;
              }
              return _context3.abrupt("return", _file);
            case 21:
              _context3.next = 12;
              break;
            case 23:
              return _context3.abrupt("return", {
                name: (0, _guessName()["default"])(url),
                version: '0.0.0',
                _uid: commit,
                _remote: {
                  resolved: tarballUrl,
                  type: 'tarball',
                  reference: tarballUrl,
                  registry: 'npm',
                  hash: undefined
                }
              });
            case 24:
            case "end":
              return _context3.stop();
          }
        }, _callee3, this);
      }));
      function resolveOverHTTP(_x2) {
        return _resolveOverHTTP.apply(this, arguments);
      }
      return resolveOverHTTP;
    }()
  }, {
    key: "hasHTTPCapability",
    value: function () {
      var _hasHTTPCapability = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee4(url) {
        return _regenerator()["default"].wrap(function _callee4$(_context4) {
          while (1) switch (_context4.prev = _context4.next) {
            case 0:
              _context4.next = 2;
              return this.config.requestManager.request({
                url: url,
                method: 'HEAD',
                queue: this.resolver.fetchingQueue,
                followRedirect: false
              });
            case 2:
              _context4.t0 = _context4.sent;
              return _context4.abrupt("return", _context4.t0 !== false);
            case 4:
            case "end":
              return _context4.stop();
          }
        }, _callee4, this);
      }));
      function hasHTTPCapability(_x4) {
        return _hasHTTPCapability.apply(this, arguments);
      }
      return hasHTTPCapability;
    }()
  }, {
    key: "resolve",
    value: function () {
      var _resolve = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee5() {
        var shrunk, httpUrl, httpBaseUrl, sshUrl, sshGitUrl, archiveClient, commit;
        return _regenerator()["default"].wrap(function _callee5$(_context5) {
          while (1) switch (_context5.prev = _context5.next) {
            case 0:
              // If we already have the tarball, just return it without having to make any HTTP requests.
              shrunk = this.request.getLocked('tarball');
              if (!shrunk) {
                _context5.next = 3;
                break;
              }
              return _context5.abrupt("return", shrunk);
            case 3:
              httpUrl = this.constructor.getGitHTTPUrl(this.exploded);
              httpBaseUrl = this.constructor.getGitHTTPBaseUrl(this.exploded);
              sshUrl = this.constructor.getGitSSHUrl(this.exploded); // If we can access the files over HTTP then we should as it's MUCH faster than git
              // archive and tarball unarchiving. The HTTP API is only available for public repos
              // though.
              _context5.next = 8;
              return this.hasHTTPCapability(httpBaseUrl);
            case 8:
              if (!_context5.sent) {
                _context5.next = 10;
                break;
              }
              return _context5.abrupt("return", this.resolveOverHTTP(httpUrl));
            case 10:
              // If the url is accessible over git archive then we should immediately delegate to
              // the git resolver.
              //
              // NOTE: Here we use a different url than when we delegate to the git resolver later on.
              // This is because `git archive` requires access over ssh and github only allows that
              // if you have write permissions
              sshGitUrl = _git()["default"].npmUrlToGitUrl(sshUrl);
              _context5.next = 13;
              return _git()["default"].hasArchiveCapability(sshGitUrl);
            case 13:
              if (!_context5.sent) {
                _context5.next = 19;
                break;
              }
              archiveClient = new (_git()["default"])(this.config, sshGitUrl, this.hash);
              _context5.next = 17;
              return archiveClient.init();
            case 17:
              commit = _context5.sent;
              return _context5.abrupt("return", this.fork(_gitResolver()["default"], true, "".concat(sshUrl, "#").concat(commit)));
            case 19:
              return _context5.abrupt("return", this.fork(_gitResolver()["default"], true, sshUrl));
            case 20:
            case "end":
              return _context5.stop();
          }
        }, _callee5, this);
      }));
      function resolve() {
        return _resolve.apply(this, arguments);
      }
      return resolve;
    }()
  }], [{
    key: "getTarballUrl",
    value: function getTarballUrl(exploded, commit) {
      exploded;
      commit;
      throw new Error('Not implemented');
    }
  }, {
    key: "getGitHTTPUrl",
    value: function getGitHTTPUrl(exploded) {
      exploded;
      throw new Error('Not implemented');
    }
  }, {
    key: "getGitHTTPBaseUrl",
    value: function getGitHTTPBaseUrl(exploded) {
      exploded;
      throw new Error('Not implemented');
    }
  }, {
    key: "getGitSSHUrl",
    value: function getGitSSHUrl(exploded) {
      exploded;
      throw new Error('Not implemented');
    }
  }, {
    key: "getHTTPFileUrl",
    value: function getHTTPFileUrl(exploded, filename, commit) {
      exploded;
      filename;
      commit;
      throw new Error('Not implemented');
    }
  }]);
  return HostedGitResolver;
}(_exoticResolver()["default"]);
exports["default"] = HostedGitResolver;
//# sourceMappingURL=hosted-git-resolver.js.map

Fairnetzt-Hochrhein | Vernetzung . Nachhaltigkeit . Gemeinschaft

VERNETZUNG

NACHHALTIGKEIT

GEMEINSCHAFT

VERANTWORTUNG

Willkommen auf Fairnetzt-Hochrhein,

Auf beiden Seiten der Rheingrenze gibt es viele Initiativen, Organisationen, Vereine und auch engagierte Einzelpersonen, welche sich für eine nachhaltige, lebenswerte Zukunft in unserer Region und darüber hinaus einsetzen.

Mit Fairnetzt-Hochrhein.de wollen wir eine Plattform bieten, welche auf lebendige und unkomplizierte Weise es Gruppen aus dem Landkreis Waldshut und aus den Kantonen Aargau und Schaffhausen ermöglicht, Veranstaltungen zu veröffentlichen und andererseits interessierte Menschen erfahren können, was wo stattfindet.

Wir wünschen Euch und uns allen
Ein Gutes Leben und Freude am Abenteuer der Mitgestaltung unserer eigenen Zukunft.

Das Redaktionsteam von Fairnetzt Hochrhein

Direktlink zu: Ihre Veranstaltungen einstellen? oder Anmeldung zum Newsletter?

Veranstaltungen

Dritter Nachhaltigkeitsstammtisch in Dogern

Ziel der Treffen ist, miteinander und voneinander zu lernen, wie man sich in verschiedenen Alltagsbereichen nachhaltiger verhalten kann:
• Einkauf von Dingen des täglichen und langfristigen Bedarfs
• Essen
• Energie sparen und erzeugen
• Unterwegs sein und Reisen, Mobilität
• Informationsaustausch
• …………
Jede*r ist willkommen, sich mit seinen und ihren Fragen und Erfahrungen einzubringen.
Grundidee: wir sind alle in bestimmten Lebensbereichen „Expert*innen“ und können so andere mit unserem Wissen bereichern und bei der Umsetzung im Alltag unterstützen.