vagrant-unbundled 2.3.2.0 → 2.3.3.0

data/thirdparty/proto/api-common-protos/google/type/postal_address.proto

@@ -0,0 +1,135 @@
+// Copyright 2019 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+syntax = "proto3";
+
+package google.type;
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/type/postaladdress;postaladdress";
+option java_multiple_files = true;
+option java_outer_classname = "PostalAddressProto";
+option java_package = "com.google.type";
+option objc_class_prefix = "GTP";
+
+// Represents a postal address, e.g. for postal delivery or payments addresses.
+// Given a postal address, a postal service can deliver items to a premise, P.O.
+// Box or similar.
+// It is not intended to model geographical locations (roads, towns,
+// mountains).
+//
+// In typical usage an address would be created via user input or from importing
+// existing data, depending on the type of process.
+//
+// Advice on address input / editing:
+//  - Use an i18n-ready address widget such as
+//    https://github.com/google/libaddressinput)
+// - Users should not be presented with UI elements for input or editing of
+//   fields outside countries where that field is used.
+//
+// For more guidance on how to use this schema, please see:
+// https://support.google.com/business/answer/6397478
+message PostalAddress {
+  // The schema revision of the `PostalAddress`. This must be set to 0, which is
+  // the latest revision.
+  //
+  // All new revisions **must** be backward compatible with old revisions.
+  int32 revision = 1;
+
+  // Required. CLDR region code of the country/region of the address. This
+  // is never inferred and it is up to the user to ensure the value is
+  // correct. See http://cldr.unicode.org/ and
+  // http://www.unicode.org/cldr/charts/30/supplemental/territory_information.html
+  // for details. Example: "CH" for Switzerland.
+  string region_code = 2;
+
+  // Optional. BCP-47 language code of the contents of this address (if
+  // known). This is often the UI language of the input form or is expected
+  // to match one of the languages used in the address' country/region, or their
+  // transliterated equivalents.
+  // This can affect formatting in certain countries, but is not critical
+  // to the correctness of the data and will never affect any validation or
+  // other non-formatting related operations.
+  //
+  // If this value is not known, it should be omitted (rather than specifying a
+  // possibly incorrect default).
+  //
+  // Examples: "zh-Hant", "ja", "ja-Latn", "en".
+  string language_code = 3;
+
+  // Optional. Postal code of the address. Not all countries use or require
+  // postal codes to be present, but where they are used, they may trigger
+  // additional validation with other parts of the address (e.g. state/zip
+  // validation in the U.S.A.).
+  string postal_code = 4;
+
+  // Optional. Additional, country-specific, sorting code. This is not used
+  // in most regions. Where it is used, the value is either a string like
+  // "CEDEX", optionally followed by a number (e.g. "CEDEX 7"), or just a number
+  // alone, representing the "sector code" (Jamaica), "delivery area indicator"
+  // (Malawi) or "post office indicator" (e.g. Côte d'Ivoire).
+  string sorting_code = 5;
+
+  // Optional. Highest administrative subdivision which is used for postal
+  // addresses of a country or region.
+  // For example, this can be a state, a province, an oblast, or a prefecture.
+  // Specifically, for Spain this is the province and not the autonomous
+  // community (e.g. "Barcelona" and not "Catalonia").
+  // Many countries don't use an administrative area in postal addresses. E.g.
+  // in Switzerland this should be left unpopulated.
+  string administrative_area = 6;
+
+  // Optional. Generally refers to the city/town portion of the address.
+  // Examples: US city, IT comune, UK post town.
+  // In regions of the world where localities are not well defined or do not fit
+  // into this structure well, leave locality empty and use address_lines.
+  string locality = 7;
+
+  // Optional. Sublocality of the address.
+  // For example, this can be neighborhoods, boroughs, districts.
+  string sublocality = 8;
+
+  // Unstructured address lines describing the lower levels of an address.
+  //
+  // Because values in address_lines do not have type information and may
+  // sometimes contain multiple values in a single field (e.g.
+  // "Austin, TX"), it is important that the line order is clear. The order of
+  // address lines should be "envelope order" for the country/region of the
+  // address. In places where this can vary (e.g. Japan), address_language is
+  // used to make it explicit (e.g. "ja" for large-to-small ordering and
+  // "ja-Latn" or "en" for small-to-large). This way, the most specific line of
+  // an address can be selected based on the language.
+  //
+  // The minimum permitted structural representation of an address consists
+  // of a region_code with all remaining information placed in the
+  // address_lines. It would be possible to format such an address very
+  // approximately without geocoding, but no semantic reasoning could be
+  // made about any of the address components until it was at least
+  // partially resolved.
+  //
+  // Creating an address only containing a region_code and address_lines, and
+  // then geocoding is the recommended way to handle completely unstructured
+  // addresses (as opposed to guessing which parts of the address should be
+  // localities or administrative areas).
+  repeated string address_lines = 9;
+
+  // Optional. The recipient at the address.
+  // This field may, under certain circumstances, contain multiline information.
+  // For example, it might contain "care of" information.
+  repeated string recipients = 10;
+
+  // Optional. The name of the organization at the address.
+  string organization = 11;
+}

data/thirdparty/proto/api-common-protos/google/type/quaternion.proto

@@ -0,0 +1,95 @@
+// Copyright 2019 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+syntax = "proto3";
+
+package google.type;
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/type/quaternion;quaternion";
+option java_multiple_files = true;
+option java_outer_classname = "QuaternionProto";
+option java_package = "com.google.type";
+option objc_class_prefix = "GTP";
+
+// A quaternion is defined as the quotient of two directed lines in a
+// three-dimensional space or equivalently as the quotient of two Euclidean
+// vectors (https://en.wikipedia.org/wiki/Quaternion).
+//
+// Quaternions are often used in calculations involving three-dimensional
+// rotations (https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation),
+// as they provide greater mathematical robustness by avoiding the gimbal lock
+// problems that can be encountered when using Euler angles
+// (https://en.wikipedia.org/wiki/Gimbal_lock).
+//
+// Quaternions are generally represented in this form:
+//
+//     w + xi + yj + zk
+//
+// where x, y, z, and w are real numbers, and i, j, and k are three imaginary
+// numbers.
+//
+// Our naming choice `(x, y, z, w)` comes from the desire to avoid confusion for
+// those interested in the geometric properties of the quaternion in the 3D
+// Cartesian space. Other texts often use alternative names or subscripts, such
+// as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps
+// better suited for mathematical interpretations.
+//
+// To avoid any confusion, as well as to maintain compatibility with a large
+// number of software libraries, the quaternions represented using the protocol
+// buffer below *must* follow the Hamilton convention, which defines `ij = k`
+// (i.e. a right-handed algebra), and therefore:
+//
+//     i^2 = j^2 = k^2 = ijk = −1
+//     ij = −ji = k
+//     jk = −kj = i
+//     ki = −ik = j
+//
+// Please DO NOT use this to represent quaternions that follow the JPL
+// convention, or any of the other quaternion flavors out there.
+//
+// Definitions:
+//
+//   - Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`.
+//   - Unit (or normalized) quaternion: a quaternion whose norm is 1.
+//   - Pure quaternion: a quaternion whose scalar component (`w`) is 0.
+//   - Rotation quaternion: a unit quaternion used to represent rotation.
+//   - Orientation quaternion: a unit quaternion used to represent orientation.
+//
+// A quaternion can be normalized by dividing it by its norm. The resulting
+// quaternion maintains the same direction, but has a norm of 1, i.e. it moves
+// on the unit sphere. This is generally necessary for rotation and orientation
+// quaternions, to avoid rounding errors:
+// https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions
+//
+// Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation,
+// but normalization would be even more useful, e.g. for comparison purposes, if
+// it would produce a unique representation. It is thus recommended that `w` be
+// kept positive, which can be achieved by changing all the signs when `w` is
+// negative.
+//
+message Quaternion {
+  // The x component.
+  double x = 1;
+
+  // The y component.
+  double y = 2;
+
+  // The z component.
+  double z = 3;
+
+  // The scalar component.
+  double w = 4;
+}

data/thirdparty/proto/api-common-protos/google/type/timeofday.proto

@@ -0,0 +1,44 @@
+// Copyright 2019 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+syntax = "proto3";
+
+package google.type;
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/type/timeofday;timeofday";
+option java_multiple_files = true;
+option java_outer_classname = "TimeOfDayProto";
+option java_package = "com.google.type";
+option objc_class_prefix = "GTP";
+
+// Represents a time of day. The date and time zone are either not significant
+// or are specified elsewhere. An API may choose to allow leap seconds. Related
+// types are [google.type.Date][google.type.Date] and `google.protobuf.Timestamp`.
+message TimeOfDay {
+  // Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
+  // to allow the value "24:00:00" for scenarios like business closing time.
+  int32 hours = 1;
+
+  // Minutes of hour of day. Must be from 0 to 59.
+  int32 minutes = 2;
+
+  // Seconds of minutes of the time. Must normally be from 0 to 59. An API may
+  // allow the value 60 if it allows leap-seconds.
+  int32 seconds = 3;
+
+  // Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+  int32 nanos = 4;
+}

data/thirdparty/proto/api-common-protos/renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

data/thirdparty/proto/api-common-protos/repository_rules.bzl

@@ -0,0 +1,222 @@
+"""Repository rules and macros which are expected to be called from WORKSPACE file of either
+googleapis itself or any third_party repository which consumes googleapis as its dependency.
+"""
+
+def _switched_rules_impl(ctx):
+    disabled_rule_script = """
+def {rule_name}(**kwargs):
+    pass
+"""
+    enabled_native_rule_script = """
+{rule_name} = {native_rule_name}
+"""
+    enabled_rule_script = """
+load("{file_label}", _{rule_name} = "{rule_name}")
+"""
+    elabled_rule_scrip_alias = """
+{rule_name} = _{rule_name}
+"""
+    load_rules = []  # load() must go before everythin else in .bzl files since Bazel 0.25.0
+    rules = []
+
+    for rule_name, value in ctx.attr.rules.items():
+        if not value:
+            rules.append(disabled_rule_script.format(rule_name = rule_name))
+        elif value.startswith("@"):
+            load_rules.append(enabled_rule_script.format(file_label = value, rule_name = rule_name))
+            rules.append(elabled_rule_scrip_alias.format(rule_name = rule_name))
+        elif value.startswith("native."):
+            rules.append(
+                enabled_native_rule_script.format(rule_name = rule_name, native_rule_name = value),
+            )
+        else:
+            rules.append(value)
+
+    ctx.file("BUILD.bazel", "")
+    ctx.file("imports.bzl", "".join(load_rules + rules))
+
+switched_rules = repository_rule(
+    implementation = _switched_rules_impl,
+    attrs = {
+        "rules": attr.string_dict(
+            allow_empty = True,
+            mandatory = False,
+            default = {},
+        ),
+    },
+)
+
+def switched_rules_by_language(
+        name,
+        gapic = False,
+        grpc = False,
+        java = False,
+        go = False,
+        cc = False,
+        php = False,
+        nodejs = False,
+        python = False,
+        ruby = False,
+        csharp = False,
+        rules_override = {}):
+    """Switches rules in the generated imports.bzl between no-op and the actual implementation.
+
+    This defines which language-specific rules (or client type specific, like grpc or gapic) should
+    be enabled during the build. All non-enabled language-specific rules will default to no-op
+    implementations. Examples of the language-specific rules are: java_gapic_library
+    (Java-specific), go_proto_library (Go-specific), proto_library_with_info (gapic-specific) etc.
+    Note, proto_library rule is always enabled.
+
+    For example, to use this rule and enable Java and Go rules, add the following in the external
+    repository which imports com_google_googleapis repository and its corresponding dependencies:
+
+        load("@com_google_googleapis//:repository_rules.bzl", "enabled_rules")
+
+        enabled_rules(
+            name = "com_google_googleapis_imports",
+            grpc = True,
+            gapic = True,
+            go = True,
+            java = True,
+        )
+
+    Note, for build to work you should also import the language-specific transitive dependencies.
+
+    Args:
+        name (str): name of a target, is expected to be "com_google_googleapis_imports".
+        gapic (bool): Enable GAPIC specific rules. The GAPIC rules are also language-specific, so
+            the actual enabled rules will be determined by the other language-specific arguments of
+            this rule. False by default.
+        grpc (bool): Enable gRPC specific rules. The gRPC rules are also language-specific, so
+            the actual enabled rules will be determined by the other language-specific arguments of
+            this rule. False by default.
+        java (bool): Enable Java specific rules. False by default.
+        go (bool): Enable Go specific rules. False by default.
+        cc (bool): Enable C++ specific rules. False by default. Partially implemented.
+        php (bool): Enable PHP specific rules. False by default.
+        nodejs (bool): Enable Node.js specific rules. False by default.
+        ruby (bool): Enable Ruby specific rules. False by default. Not implemented yet.
+        python (bool): Enable Python-specific rules. False by default. Not implemented yet.
+        csharp (bool): Enable C# specific rules. False by default. Not implemented yet.
+        rules_override (dict): Custom rule overrides (for advanced usage).
+    """
+
+    rules = {}
+
+    #
+    # Common
+    #
+    rules["proto_library_with_info"] = _switch(
+        gapic,
+        "@com_google_api_codegen//rules_gapic:gapic.bzl",
+    )
+
+    #
+    # Java
+    #
+    rules["java_proto_library"] = _switch(
+        java,
+        "native.java_proto_library",
+    )
+    rules["java_grpc_library"] = _switch(
+        java and grpc,
+        "@io_grpc_grpc_java//:java_grpc_library.bzl",
+    )
+    rules["java_gapic_library"] = _switch(
+        java and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/java:java_gapic.bzl",
+    )
+    rules["java_resource_name_proto_library"] = _switch(
+        java and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/java:java_gapic.bzl",
+    )
+    rules["java_gapic_assembly_gradle_pkg"] = _switch(
+        java and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/java:java_gapic_pkg.bzl",
+    )
+    rules["java_test"] = _switch(
+        java and grpc and gapic,
+        "native.java_test",
+    )
+
+    #
+    # Go
+    #
+    rules["go_proto_library"] = _switch(
+        go,
+        "@io_bazel_rules_go//proto:def.bzl",
+    )
+    rules["go_library"] = _switch(
+        go,
+        "@io_bazel_rules_go//go:def.bzl",
+    )
+    rules["go_test"] = _switch(
+        go and grpc and gapic,
+        "@io_bazel_rules_go//go:def.bzl",
+    )
+    rules["go_gapic_library"] = _switch(
+        go and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/go:go_gapic.bzl",
+    )
+    rules["go_gapic_assembly_pkg"] = _switch(
+        go and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/go:go_gapic_pkg.bzl",
+    )
+
+    #
+    # C++
+    #
+    rules["cc_proto_library"] = _switch(
+        cc,
+        "native.cc_proto_library",
+    )
+    rules["cc_grpc_library"] = _switch(
+        cc and grpc,
+        "@com_github_grpc_grpc//bazel:cc_grpc_library.bzl",
+    )
+    rules["cc_gapic_library"] = _switch(
+        cc and grpc and gapic,
+        "@com_google_gapic_generator_cpp//rules_gapic/cpp:cc_gapic.bzl",
+    )
+
+    #
+    # PHP
+    #
+    rules["php_proto_library"] = _switch(
+        php,
+        "@com_google_api_codegen//rules_gapic/php:php_gapic.bzl",
+    )
+    rules["php_grpc_library"] = _switch(
+        php and grpc,
+        "@com_google_api_codegen//rules_gapic/php:php_gapic.bzl",
+    )
+    rules["php_gapic_library"] = _switch(
+        php and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/php:php_gapic.bzl",
+    )
+    rules["php_gapic_assembly_pkg"] = _switch(
+        php and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/php:php_gapic_pkg.bzl",
+    )
+
+    #
+    # Node.js
+    #
+    rules["nodejs_gapic_library"] = _switch(
+        nodejs and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/nodejs:nodejs_gapic.bzl",
+    )
+    rules["nodejs_gapic_assembly_pkg"] = _switch(
+        nodejs and grpc and gapic,
+        "@com_google_api_codegen//rules_gapic/nodejs:nodejs_gapic_pkg.bzl",
+    )
+
+    rules.update(rules_override)
+
+    switched_rules(
+        name = name,
+        rules = rules,
+    )
+
+def _switch(enabled, enabled_value):
+    return enabled_value if enabled else ""

data/vagrant.gemspec

@@ -26,9 +26,9 @@ Gem::Specification.new do |s|
   s.add_dependency "log4r", "~> 1.1.9", "< 1.1.11"
   s.add_dependency "mime-types", "~> 3.3"
   s.add_dependency "net-ftp", "~> 0.1"
-  s.add_dependency "net-ssh", ">= 6.1.0", "< 6.2"
-  s.add_dependency "net-sftp", "~> 3.0"
-  s.add_dependency "net-scp", "~> 3.0.0"
+  s.add_dependency "net-ssh", "~> 7.0"
+  s.add_dependency "net-sftp", "~> 4.0"
+  s.add_dependency "net-scp", "~> 4.0"
   s.add_dependency "rb-kqueue", "~> 0.2.0"
   s.add_dependency "rexml", "~> 3.2"
   s.add_dependency "rgl", "~> 0.5.7"
@@ -48,7 +48,7 @@ Gem::Specification.new do |s|
   # Constraint rake to properly handle deprecated method usage
   # from within rspec
   s.add_development_dependency "rake", "~> 13.0"
-  s.add_development_dependency "rspec", "~> 3.11.0"
+  s.add_development_dependency "rspec", "~> 3.11"
   s.add_development_dependency "rspec-its", "~> 1.3.0"
   s.add_development_dependency "fake_ftp", "~> 0.3.0"
   s.add_development_dependency "webrick", "~> 1.7.0"

data/version.txt

@@ -1 +1 @@
-2.3.2.0
+2.3.3.0