@twilio/conversations 1.3.0-rc8 → 2.0.0-rc.4

package/tools/sdk-release-tool/sdk_release_tools/rpm.py

@@ -1,28 +0,0 @@
-from sdk_release_tools import log
-from sdk_release_tools.versions import parse_version
-
-import os
-import subprocess
-
-
-def get_version(rpm):
-    rpm_cmd = 'rpm -qp --queryformat \'%{VERSION}\' ' + rpm
-    rpm_version = subprocess.check_output(rpm_cmd, shell=True)
-    rpm_version = rpm_version.replace('_', '-')
-    if rpm_version.startswith('release-'):
-        rpm_version = rpm_version[8:]
-    return parse_version(rpm_version)
-
-
-def unpack(rpm, prefix=None):
-    prefix = prefix or '/tmp/'
-    version = get_version(rpm)
-    dst = prefix + str(version)
-    log.log(rpm)
-    log.info('  Unpacking to ' + dst)
-    unpack_cmd = (
-        'rm -rf {}; rpm2cpio {} | cpio -idmv; mv mnt {}'.format(dst, rpm, dst))
-    FNULL = open(os.devnull, 'wb')
-    subprocess.check_call(unpack_cmd, shell=True, stdout=FNULL, stderr=FNULL,
-                          close_fds=True)
-    return dst

package/tools/sdk-release-tool/sdk_release_tools/util.py

@@ -1,186 +0,0 @@
-from collections import OrderedDict
-from sdk_release_tools import ops
-from sdk_release_tools import rpm
-from sdk_release_tools.aws import get_bucket
-from sdk_release_tools.versions import parse_major_minor, parse_version
-import json
-import os
-
-
-
-def load_schema(schema_name):
-    filepath = (schema_name if schema_name.endswith('.json') else
-                '{}.json'.format(schema_name))
-    with open(filepath) as schema_file:
-        return json.loads(schema_file.read())
-
-
-def get_variables(schema, version):
-    """
-    Get the variables defined in the schema and merge them with any version
-    number variables (e.g., "major", "minor", "patch", etc.).
-    """
-    variables = schema.get('variables', {})
-    variables.update(version.__dict__)
-    variables.update(version=str(version))
-    return variables
-
-
-def delete(realm, schema, version, dry_run=True, silent=False):
-    artifacts = schema.get('artifacts', {})
-    variables = get_variables(schema, version)
-    return ops.delete(artifacts, bucket=get_bucket(realm), variables=variables,
-                      dry_run=dry_run, silent=silent)
-
-
-def download(realm, schema, version, root, dry_run=True):
-    artifacts = schema.get('artifacts', {})
-    variables = get_variables(schema, version)
-    return ops.download(artifacts, root=root, bucket=get_bucket(realm),
-                        variables=variables, dry_run=dry_run)
-
-
-def pin(realm, schema, version, dry_run=False):
-    rules = schema.get('pin', {})
-    variables = get_variables(schema, version)
-    copy_on_pin = schema.get('copy_on_pin', False)
-    return ops.pin(rules, bucket=get_bucket(realm), variables=variables,
-                   dry_run=dry_run, copy_on_pin=copy_on_pin)
-
-
-def pin_latest(realm, schema, version, dry_run=False):
-    rules = schema.get('latest', {})
-    variables = get_variables(schema, version)
-    copy_on_pin = schema.get('copy_on_pin', False)
-    return ops.pin(rules, bucket=get_bucket(realm), variables=variables,
-                   dry_run=dry_run, copy_on_pin=copy_on_pin)
-
-
-def unpin(realm, schema, version, dry_run=False):
-    rules = schema.get('pin', {})
-    variables = get_variables(schema, version)
-    return ops.unpin(rules, bucket=get_bucket(realm), variables=variables,
-                     dry_run=dry_run)
-
-
-def unpin_latest(realm, schema, version, dry_run=False):
-    rules = schema.get('latest', {})
-    variables = get_variables(schema, version)
-    return ops.unpin(rules, bucket=get_bucket(realm), variables=variables,
-                     dry_run=dry_run)
-
-
-def upload(realm, schema, version, root, dry_run=True):
-    artifacts = schema.get('artifacts', {})
-    variables = get_variables(schema, version)
-    if not os.path.isdir(root):
-        root = rpm.unpack(root)
-    return ops.upload(artifacts, root=root, bucket=get_bucket(realm),
-                      variables=variables, dry_run=dry_run)
-
-
-def get_cors(realm):
-    bucket = get_bucket(realm)
-    return bucket.get_cors()
-
-def get_versions(realm, schema):
-    bucket = get_bucket(realm)
-    config = bucket.get_website_configuration_obj()
-
-    unordered_versions = []
-    versions_dir = schema.get('versions').format(**schema.get('variables', {}))
-
-    for key in bucket.list(versions_dir, '/'):
-        try:
-            version = parse_version(os.path.split(key.name.rstrip('/'))[1])
-        except:
-            continue
-        unordered_versions.append(version)
-
-    ordered_versions = OrderedDict()
-    for version in sorted(unordered_versions):
-        ordered_versions[str(version)] = None
-
-    major_minor_versions_dir = schema.get('major_minor_versions').format(
-        **schema.get('variables', {}))
-    ordered_major_minors = OrderedDict()
-
-    latest = None
-
-    # First, try to identify any versions pinned by S3 Key redirects.
-    for key in bucket.list(major_minor_versions_dir, '/'):
-        major_minor = None
-        try:
-            major_minor = parse_major_minor(
-                os.path.split(key.name.rstrip('/'))[1])
-        except:
-            if os.path.split(key.name.rstrip('/'))[1] != "latest":
-                continue
-
-        # This is a little bit of a hack: we are going to iterate through the
-        # prefixes until we find one that matches a key. Once we have the key,
-        # we need to check if it has a redirect to a version number.
-        version = None
-        for key in bucket.list(key.name, '/'):
-            if key.name.endswith('/'):
-                continue
-            key = bucket.get_key(key.name)
-            if not key:
-                continue
-            redirect = key.get_redirect()
-            if not redirect:
-                continue
-            if redirect.startswith('/' + versions_dir.lstrip('/')):
-                redirect = redirect[len('/' + versions_dir.lstrip('/')):]
-                try:
-                    version = parse_version(redirect.split('/')[0])
-                except:
-                    continue
-                break
-
-        if not version:
-            continue
-
-        if not major_minor:
-            latest = version
-
-        version_str = str(version)
-        if version_str in ordered_versions:
-            ordered_versions[version_str] = major_minor
-        ordered_major_minors[str(major_minor)] = version
-
-    # Then, try to identify any versions pinned by RoutingRules (legacy).
-    for rule in config.routing_rules:
-        key_prefix = rule.condition.key_prefix
-        if not key_prefix.startswith(major_minor_versions_dir):
-            continue
-
-        replace_key_prefix = rule.redirect.replace_key_prefix
-
-        try:
-            major_minor = parse_major_minor(
-                os.path.split(key_prefix.rstrip('/'))[1])
-            version = parse_version(
-                os.path.split(replace_key_prefix.rstrip('/'))[1])
-        except:
-            continue
-
-        version_str = str(version)
-        if version_str in ordered_versions:
-            ordered_versions[version_str] = major_minor
-        ordered_major_minors[str(major_minor)] = version
-
-    return (ordered_versions, ordered_major_minors, latest)
-
-
-def version_exists(realm, schema, version):
-    ordered_versions, _, _ = get_versions(realm, schema)
-    return str(version) in ordered_versions
-
-
-def get_pinned_by(realm, schema, version):
-    """
-    Get the major/minor pair that pins a version.
-    """
-    ordered_versions, _, _ = get_versions(realm, schema)
-    return ordered_versions.get(str(version))

package/tools/sdk-release-tool/sdk_release_tools/versions.py

@@ -1,362 +0,0 @@
-from functools import total_ordering
-
-import re
-
-
-__all__ = ['Version', 'MajorMinor', 'MajorMinorPatch', 'SemVer',
-           'TwilioVersion', 'parse_major_minor', 'parse_version']
-
-
-def drop_leading_v(string):
-    if string and string[0] == 'v':
-        return string[1:]
-    return string
-
-
-def contains_leading_zeroes(string):
-    """
-    Check if a string representing a digit contains leading zeroes.
-    """
-    return string.isdigit() and re.match(r'^0[0-9]', string)
-
-
-def parse_major_minor_patch(string):
-    """
-    Parse major, minor, and patch versions out of a string and return the rest.
-    """
-    match = re.match(r'^([0-9]+)\.([0-9]+)\.([0-9]+)', string)
-
-    exception = ValueError(
-        ('A normal version number MUST take the form X.Y.Z where X, Y, and Z '
-         'are non-negative integers, and MUST NOT contain leading zeroes: ' +
-         string))
-
-    if not match:
-        raise exception
-
-    identifiers = match.groups()
-    if any([contains_leading_zeroes(identifier) for identifier in
-            identifiers]):
-        raise exception
-
-    major = int(match.group(1))
-    minor = int(match.group(2))
-    patch = int(match.group(3))
-    rest = string[match.end():]
-
-    return (major, minor, patch, rest)
-
-
-class Version(object):
-    def __ne__(self, other):
-        return not self == other
-
-
-@total_ordering
-class MajorMinor(Version):
-    """
-    A version number with major and minor components, e.g.
-
-        1.2
-
-    """
-    def __eq__(self, other):
-        return (self.major == other.major and
-                self.minor == other.minor)
-
-    def __init__(self, major, minor):
-        self.major = major
-        self.minor = minor
-
-    def __le__(self, other):
-        if self.major < other.major:
-            return True
-        elif self.major == other.major:
-            return self.minor <= other.minor
-        return False
-
-    def __str__(self):
-        return '{}.{}'.format(self.major, self.minor)
-
-    @classmethod
-    def parse(cls, string):
-        """
-        Parse a string to a MajorMinorPatch, or raise a ValueError.
-        """
-        string = drop_leading_v(string)
-
-        match = re.match(r'^([0-9]+)\.([0-9]+)$', string)
-
-        exception = ValueError('Unparsed: ' + string)
-
-        if not match:
-            raise exception
-
-        identifiers = match.groups()
-        if any([contains_leading_zeroes(identifier) for identifier in
-                identifiers]):
-            raise exception
-
-        major = int(match.group(1))
-        minor = int(match.group(2))
-
-        return MajorMinor(major, minor)
-
-
-@total_ordering
-class MajorMinorPatch(MajorMinor):
-    """
-    A version number with major, minor, and patch components, e.g.
-
-        1.2.3
-
-    """
-    def __eq__(self, other):
-        return (super(MajorMinorPatch, self).__eq__(other) and
-                self.patch == other.patch)
-
-    def __init__(self, major, minor, patch):
-        super(MajorMinorPatch, self).__init__(major, minor)
-        self.patch = patch
-
-    def __le__(self, other):
-        if super(MajorMinorPatch, self).__le__(other):
-            if not super(MajorMinorPatch, self).__eq__(other):
-                return True
-            return self.patch <= other.patch
-        return False
-
-    def __str__(self):
-        return '{}.{}'.format(super(MajorMinorPatch, self).__str__(),
-                              self.patch)
-
-    @classmethod
-    def parse(cls, string):
-        """
-        Parse a string to a MajorMinorPatch, or raise a ValueError.
-        """
-        string = drop_leading_v(string)
-
-        (major, minor, patch, rest) = (
-            parse_major_minor_patch(string))
-
-        if rest:
-            raise ValueError('Unparsed: ' + rest)
-
-        return MajorMinorPatch(major, minor, patch)
-
-
-def lt_pre_release(self, other):
-    """
-    Check to see if one SemVer's pre_release version is less than that of
-    another. From the SemVer spec:
-
-        Pre-release versions have a lower precedence than the associated
-        normal version.
-
-    """
-    if self.pre_release and other.pre_release:
-        return self.pre_release < other.pre_release
-    elif self.pre_release and not other.pre_release:
-        return True
-    return False
-
-
-def le_build_metadata(self, other):
-    """
-    Check to see if one SemVer's build_metadata is less than or equal to
-    another. Like le_pre_release, this function gives versions with
-    build_metadata a lower precedence than those without; however, it is
-    unclear if this is useful and we may very well change it.
-    """
-    if self.build_metadata and other.build_metadata:
-        return self.build_metadata <= other.build_metadata
-    elif self.build_metadata and not other.build_metadata:
-        return True
-    return self.build_metadata == other.build_metadata
-
-
-@total_ordering
-class SemVer(MajorMinorPatch):
-    """
-    A Semantic Version (SemVer) number per the SemVer spec at
-
-        <http://semver.org/>
-
-    """
-    def __eq__(self, other):
-        return (super(SemVer, self).__eq__(other) and
-                self.pre_release == other.pre_release and
-                self.build_metadata == other.build_metadata)
-
-    def __init__(self, major, minor, patch, pre_release=None,
-                 build_metadata=None):
-        super(SemVer, self).__init__(major, minor, patch)
-        self.pre_release = pre_release
-        self.build_metadata = build_metadata
-
-    def __le__(self, other):
-        if super(SemVer, self).__le__(other):
-            if type(self) is type(other):
-                if not super(SemVer, self).__eq__(other):
-                    return True
-                elif lt_pre_release(self, other):
-                    return True
-                elif self.pre_release == other.pre_release:
-                    return le_build_metadata(self, other)
-        return False
-
-    def __str__(self):
-        string = super(SemVer, self).__str__()
-        if self.pre_release:
-            string += '-' + self.pre_release
-        if self.build_metadata:
-            string += '+' + self.build_metadata
-        return string
-
-    @classmethod
-    def parse(cls, string):
-        """
-        Parse a string to a SemVer, or raise a ValueError.
-        """
-        string = drop_leading_v(string)
-
-        (major, minor, patch, rest) = (
-            parse_major_minor_patch(string))
-
-        # A pre-release version MAY be denoted by appending a hyphen and a
-        # series of dot separated identifiers immediately following the patch
-        # version.
-        pre_release = None
-        if rest and rest[0] == '-':
-
-            match = re.match(r'-([0-9A-Za-z-.]+)', rest)
-            if not match:
-                raise ValueError(
-                    ('Identifiers MUST comprise only ASCII alphanumerics and '
-                     'hyphen [0-9A-Za-z-]' + string))
-
-            pre_release = match.group(1)
-            identifiers = pre_release.split('.')
-
-            if not all(identifiers):
-                raise ValueError('Identifiers MUST NOT be empty: ' + string)
-
-            if any([contains_leading_zeroes(identifier) for identifier in
-                    identifiers]):
-                raise ValueError(
-                    'Numeric identifiers MUST NOT include leading zeroes: ' +
-                    string)
-
-            rest = rest[match.end():]
-
-        # Build metadata MAY be denoted by appending a plus sign and a series
-        # of dot separated identifiers immediately following the patch or
-        # pre-release version.
-        build_metadata = None
-        if rest and rest[0] == '+':
-
-            match = re.match(r'\+([0-9A-Za-z-.]+)$', rest)
-            if not match:
-                raise ValueError(
-                    ('Identifiers MUST comprise only ASCII alphanumerics and '
-                     'hyphen [0-9A-Za-z-]: ' + string))
-
-            build_metadata = match.group(1)
-            identifiers = build_metadata.split('.')
-
-            if not all(identifiers):
-                return None
-
-            rest = rest[match.end():]
-
-        if rest:
-            raise ValueError('Unparsed: ' + rest)
-
-        return SemVer(major, minor, patch, pre_release, build_metadata)
-
-
-@total_ordering
-class TwilioVersion(MajorMinorPatch):
-    """
-    The Twilio version numbers we use have the form
-
-        1.2.3.b4-deadbee
-
-    and they aren't quite SemVer. Essentially, we are tacking on build metadata
-    with a "." instead of a "+", and in this build metadata we specify a build
-    number and the git commit hash.
-    """
-    def __eq__(self, other):
-        return (super(TwilioVersion, self).__eq__(other) and
-                self.build_number == other.build_number and
-                self.git_commit == other.git_commit)
-
-    def __init__(self, major, minor, patch, git_commit, build_number=1):
-        super(TwilioVersion, self).__init__(major, minor, patch)
-        self.git_commit = git_commit
-        self.build_number = build_number
-
-    def __le__(self, other):
-        if super(TwilioVersion, self).__le__(other):
-            if type(self) is type(other):
-                if not super(TwilioVersion, self).__eq__(other):
-                    return True
-                elif self.build_number < other.build_number:
-                    return True
-                elif self.build_number == other.build_number:
-                    return self.git_commit <= other.git_commit
-        return False
-
-    def __str__(self):
-        return (super(TwilioVersion, self).__str__() +
-                '.b{}-{}'.format(self.build_number, self.git_commit))
-
-    @classmethod
-    def parse(cls, string):
-        """
-        Parse a string to a TwilioVersion, or raise a ValueError.
-        """
-        string = drop_leading_v(string)
-
-        (major, minor, patch, rest) = (
-            parse_major_minor_patch(string))
-
-        match = re.match(r'^\.b([0-9]+)-([a-z0-9]{7})$', rest)
-        if not match:
-            raise ValueError(
-                'Expecting build number and git commit: ' + string)
-
-        build_number = match.group(1)
-        git_commit = match.group(2)
-        rest = rest[match.end():]
-
-        if contains_leading_zeroes(build_number):
-            raise ValueError('Build number contains leading zeroes: ' + string)
-
-        build_number = int(build_number)
-        if not build_number:
-            raise ValueError('Build number must be non-zero: ' + string)
-
-        if rest:
-            raise ValueError('Unparsed: ' + rest)
-
-        return TwilioVersion(major, minor, patch, git_commit, build_number)
-
-
-def parse_version(string):
-    """
-    Attempt to parse a string to a SemVer or TwilioVersion.
-    """
-    version_classes = [
-        SemVer,
-        TwilioVersion,
-    ]
-    for version_class in version_classes:
-        try:
-            return version_class.parse(string)
-        except ValueError:
-            pass
-    raise ValueError('Input is neither a SemVer nor TwilioVersion: ' + string)
-
-parse_major_minor = MajorMinor.parse

package/tools/sdk-release-tool/signal-sdk-js.json

@@ -1,28 +0,0 @@
-{
-  "variables": {
-    "platform": "js",
-    "product_name": "conversations"
-  },
-  "public_dir": "sdk/{product_name}/",
-  "release_dir": "sdk/{product_name}/{public_version}/{platform}/releases/",
-  "schema": {
-    "sdk": {
-      "{product_name}": {
-        "{public_version}": {
-          "{platform}": {
-            "docs": "releases/{release_version}/docs",
-            "releases": {
-              "{release_version}": {
-                "docs/": null,
-                "twilio-{product_name}.js": null,
-                "twilio-{product_name}.min.js": null
-              }
-            },
-            "twilio-{product_name}.js": "releases/{release_version}/twilio-{product_name}.js",
-            "twilio-{product_name}.min.js": "releases/{release_version}/twilio-{product_name}.min.js"
-          }
-        }
-      }
-    }
-  }
-}

package/tools/sdk-release-tool/tests/test_versions.py

@@ -1,94 +0,0 @@
-from random import shuffle
-from sdk_release_tools.versions import (MajorMinorPatch, SemVer, TwilioVersion,
-                                        parse_version)
-import unittest
-
-
-class TestMajorMinorPatch(unittest.TestCase):
-    version_class = MajorMinorPatch
-
-    valid_sorted = [
-        '0.0.1',
-        '0.1.0',
-        '1.0.0',
-        '1.2.3',
-        '1.2.30',
-        '1.20.3',
-        '10.2.3',
-    ]
-
-    invalid = [
-        '',
-        '1',
-        '0.1',
-        '01.2.3',
-        '1.02.3',
-        '1.2.03',
-        'x.y.z',
-    ]
-
-    def test_parse(self):
-        for version in self.valid_sorted:
-            assert self.version_class.parse(version)
-        for version in self.invalid:
-            with self.assertRaises(ValueError):
-                self.version_class.parse(version)
-
-    def test_str(self):
-        for version in self.valid_sorted:
-            assert str(self.version_class.parse(version)) == version
-
-    def test_sort(self):
-        shuffled_and_sorted = map(self.version_class.parse, self.valid_sorted)
-        shuffle(shuffled_and_sorted)
-        shuffled_and_sorted.sort()
-        assert map(str, shuffled_and_sorted) == self.valid_sorted
-
-
-class TestSemVer(TestMajorMinorPatch):
-    version_class = SemVer
-
-    valid_sorted = [
-        '0.1.0',
-        '1.2.3-alpha',
-        '1.2.3-beta',
-        '1.2.3-dev+build',
-        '1.2.3-dev',
-        '1.2.3+build',
-        '1.2.3',
-    ]
-
-    invalid = [
-        '00.00.00',
-        '01.2.3',
-        '1.02.3',
-        '1.2.03',
-        'x.y.z',
-    ]
-
-
-class TestTwilioVersion(TestMajorMinorPatch):
-    version_class = TwilioVersion
-
-    valid_sorted = [
-        '1.2.3.b1-deadbee',
-        '1.2.3.b20-aaaaaaa',
-        '1.2.3.b20-deadbee',
-    ]
-
-    invalid = [
-        '1.2.3.b0-deadbee',
-        '1.2.3.b1-deadbe',
-        '1.2.3',
-        '1.2.3-dev',
-        '1.2.3-dev+build',
-        '1.2.3+build',
-    ]
-
-
-def test_parse_version():
-    versions = (TestMajorMinorPatch.valid_sorted +
-                TestSemVer.valid_sorted +
-                TestTwilioVersion.valid_sorted)
-    for version in versions:
-        assert parse_version(version)