def test_weave_old_style_method_no_warn_patch_module():
    calls = []
    with aspectlib.weave('warnings.warn', record(calls=calls)):
        with aspectlib.weave('test_aspectlib.LegacyTestClass.foobar', mock('stuff')):
            assert LegacyTestClass().foobar() == 'stuff'

    assert calls == []

def enable_aspectlib_maybe():                               # pragma: debugging
    """For debugging, we can use aspectlib to trace execution.

    Define COVERAGE_ASPECTLIB to enable and configure aspectlib to trace
    execution::

        $ export COVERAGE_LOG=covaspect.txt
        $ export COVERAGE_ASPECTLIB=coverage.Coverage:coverage.data.CoverageData
        $ coverage run blah.py ...

    This will trace all the public methods on Coverage and CoverageData,
    writing the information to covaspect.txt.

    """
    aspects = os.environ.get("COVERAGE_ASPECTLIB", "")
    if not aspects:
        return

    import aspectlib                            # pylint: disable=import-error
    import aspectlib.debug                      # pylint: disable=import-error

    filename = os.environ.get("COVERAGE_LOG", "/tmp/covlog.txt")
    filters = [add_pid_and_tid, filter_aspectlib_frames]
    aspects_file = DebugOutputFile.the_one(open(filename, "a"), show_process=True, filters=filters)
    aspect_log = aspectlib.debug.log(
        print_to=aspects_file, attributes=['id'], stacktrace=30, use_logging=False
    )
    public_methods = re.compile(r'^(__init__|[a-zA-Z].*)$')
    for aspect in aspects.split(':'):
        aspectlib.weave(aspect, aspect_log, methods=public_methods)

def test_weave_class_old_style_all_magic():
    history = []

    @aspectlib.Aspect
    def aspect(*args):
        history.append(args)
        yield aspectlib.Proceed

    inst = LegacyTestClass()

    with aspectlib.weave(LegacyTestClass, aspect, subclasses=False):
        with aspectlib.weave(LegacyTestSubClass, aspect, subclasses=False):
            with aspectlib.weave(LegacyTestSubSubClass, aspect, subclasses=False):
                inst = LegacyTestClass("stuff")
                assert history == [(inst, "stuff"), (LegacyTestClass, "stuff"), ("stuff",)]
                del history[:]

                inst = LegacyTestSubClass("stuff")
                assert history == [(inst, "stuff"), (LegacyTestSubClass, "stuff"), ("stuff",)]
                del history[:]

                inst = LegacyTestSubSubClass("stuff")
                assert history == [(inst, "stuff"), (LegacyTestSubSubClass, "stuff"), ("stuff",)]
                del history[:]

    inst = LegacyTestClass("stuff")
    inst = LegacyTestSubClass("stuff")
    inst = LegacyTestSubSubClass("stuff")

    assert history == []

def test_list_of_aspects():
    with aspectlib.weave(module_func, [mock('foobar'), record]):
        assert module_func(1, 2, 3) == 'foobar'
        assert module_func.calls == [(None, (1, 2, 3), {})]

    with aspectlib.weave(module_func, [mock('foobar', call=True), record]):
        raises(TypeError, module_func, 1, 2, 3)
        assert module_func.calls == [(None, (1, 2, 3), {})]

def test_weave_wrong_module():
    calls = []
    with aspectlib.weave('warnings.warn', record(calls=calls)):
        aspectlib.weave(AliasedGlobal, mock('stuff'), lazy=True)
    assert calls == [
        (None,
         ("Setting test_aspectlib.MissingGlobal to <class 'test_aspectlib.MissingGlobal'>. "
          "There was no previous definition, probably patching the wrong module.",),
         {})
    ]

def test_weave_class_meth_no_aliases_unsupported_on_py3():
    with aspectlib.weave(Global.meth, mock("stuff")):
        assert Global().meth() == "stuff"
        assert Global2().meth() == "stuff"

    assert Global().meth() == "base"
    assert Global2().meth() == "base"

def test_weave_str_target():
    with aspectlib.weave('test_pkg1.test_pkg2.test_mod.target', mock('foobar')):
        from test_pkg1.test_pkg2.test_mod import target
        assert target() == 'foobar'

    from test_pkg1.test_pkg2.test_mod import target
    assert target() is None

def test_weave_str_class_meth_target():
    with aspectlib.weave('test_pkg1.test_pkg2.test_mod.Stuff.meth', mock('foobar')):
        from test_pkg1.test_pkg2.test_mod import Stuff
        assert Stuff().meth() == 'foobar'

    from test_pkg1.test_pkg2.test_mod import Stuff
    assert Stuff().meth() is None

def test_weave_multiple():
    with aspectlib.weave((module_func, module_func2), mock('foobar')):
        assert module_func() == 'foobar'
        assert module_func2() == 'foobar'

    assert module_func() is None
    assert module_func2() is None

def test_weave_class_all_magic():
    history = []

    @aspectlib.Aspect
    def aspect(*args):
        history.append(args)
        yield aspectlib.Proceed

    inst = NormalTestClass()

    with aspectlib.weave(NormalTestClass, aspect, methods=aspectlib.ALL_METHODS):
        inst = NormalTestClass("stuff")
        assert history == [(inst, "stuff"), (inst, "stuff"), (NormalTestClass, "stuff"), ("stuff",)]
        del history[:]

        inst = NormalTestSubClass("stuff")
        assert history == [(inst, "stuff"), (inst, "stuff"), (NormalTestSubClass, "stuff"), ("stuff",)]
        del history[:]

        inst = NormalTestSubSubClass("stuff")
        assert history == [(inst, "stuff"), (inst, "stuff"), (NormalTestSubSubClass, "stuff"), ("stuff",)]
        del history[:]

    inst = NormalTestClass("stuff")
    inst = NormalTestSubClass("stuff")
    inst = NormalTestSubSubClass("stuff")

    assert history == []

 def __enter__(self):
     self._rollback = weave(
         self._logger,
         record(callback=self._callback, extended=True, iscalled=True),
         methods='_log$'
     )
     return self

def main(template, target, no_input, checkout, verbose):
    if verbose:
        logging.basicConfig(
            format='%(levelname)s %(filename)s: %(message)s',
            level=logging.DEBUG
        )
    else:
        logging.basicConfig(
            format='%(levelname)s: %(message)s',
            level=logging.INFO
        )

    try:
        src = os.path.join(target, '.cookiecutterrc')
        if os.path.exists(src):
            logger.info("Loading config from %r", src)
            extra_context = get_config(src)
            logger.debug("Loaded %r", extra_context)
            extra_context = extra_context.get('cookiecutter') or extra_context.get('default_context')
            logger.debug("Loaded %r", extra_context)
        else:
            logger.info("No .cookiecutterrc in %r", target)
            extra_context = None

        with weave('cookiecutter.main.generate_files', save_context):
            cookiecutter(
                template, checkout, no_input,
                overwrite_if_exists=True,
                output_dir=os.path.dirname(target),
                extra_context=extra_context,
            )
    except (OutputDirExistsException, InvalidModeException) as e:
        click.echo(e)
        sys.exit(1)

def test_simple():
    buf = StringIO()
    with aspectlib.weave(some_meth, aspectlib.debug.log(print_to=buf, module=False, stacktrace=10)):
        some_meth(1, 2, 3, a=4)

    assert re.match(LOG_TEST_SIMPLE, buf.getvalue())
    some_meth(1, 2, 3, a=4)
    assert re.match(LOG_TEST_SIMPLE, buf.getvalue())

def test_weave_class_meth_no_aliases():
    with aspectlib.weave(Global.meth, mock("stuff"), aliases=False, lazy=True):
        assert Global().meth() == "stuff"
        assert Global2 is not Global
        assert Global2().meth() == "base"

    assert Global().meth() == "base"
    assert Global2 is Global
    assert Global2().meth() == "base"

def test_weave_class_no_aliases():
    with aspectlib.weave(Global, mock('stuff'), aliases=False, lazy=True):
        assert Global().meth() == 'stuff'
        assert Global2 is not Global
        assert Global2().meth() == 'base'

    assert Global().meth() == 'base'
    assert Global2 is Global
    assert Global2().meth() == 'base'

def test_weave_no_aliases():
    with aspectlib.weave(module_func2, mock('stuff'), aliases=False):
        assert module_func2() == 'stuff'
        assert module_func2 is not module_func3
        assert module_func3() is None

    assert module_func2() is None
    assert module_func3() is None
    assert module_func2 is module_func3

def enable_aspectlib_maybe():                               # pragma: debugging
    """For debugging, we can use aspectlib to trace execution.

    Define COVERAGE_ASPECTLIB to enable and configure aspectlib to trace
    execution::

        COVERAGE_ASPECTLIB=covaspect.txt:coverage.Coverage:coverage.data.CoverageData program...

    This will trace all the public methods on Coverage and CoverageData,
    writing the information to covaspect.txt.

    """
    aspects = os.environ.get("COVERAGE_ASPECTLIB", "")
    if not aspects:
        return

    import aspectlib                            # pylint: disable=import-error
    import aspectlib.debug                      # pylint: disable=import-error

    class AspectlibOutputFile(object):
        """A file-like object that includes pid and cwd information."""
        def __init__(self, outfile):
            self.outfile = outfile
            self.cwd = None

        def write(self, text):
            """Just like file.write"""
            cwd = os.getcwd()
            if cwd != self.cwd:
                self._write("cwd is now {0!r}\n".format(cwd))
                self.cwd = cwd
            self._write(text)

        def _write(self, text):
            """The raw text-writer, so that we can use it ourselves."""
            self.outfile.write("{0:5d}: {1}".format(os.getpid(), text))

    aspects = aspects.split(':')
    aspects_file = AspectlibOutputFile(open(aspects[0], "a"))
    aspect_log = aspectlib.debug.log(print_to=aspects_file, use_logging=False)
    aspects = aspects[1:]
    public_methods = re.compile(r'^(__init__|[a-zA-Z].*)$')
    for aspect in aspects:
        aspectlib.weave(aspect, aspect_log, methods=public_methods)

def test_invalid_string_target():
    raises(SyntaxError, aspectlib.weave, "inva lid", mock(None))
    raises(SyntaxError, aspectlib.weave, "os.inva lid", mock(None))
    raises(SyntaxError, aspectlib.weave, "os.2invalid", mock(None))
    raises(SyntaxError, aspectlib.weave, "os.some,junk", mock(None))
    raises(SyntaxError, aspectlib.weave, "os.some?junk", mock(None))
    raises(SyntaxError, aspectlib.weave, "os.some*junk", mock(None))

    with aspectlib.weave("test_aspectlib._internal", mock("stuff")):
        assert _internal() == "stuff"

def test_no_stack():
    buf = StringIO()
    with aspectlib.weave(MyStuff, aspectlib.debug.log(
        print_to=buf,
        stacktrace=None,
        attributes=('foo', 'bar()')
    ), methods='(?!bar)(?!__.*__$)'):
        MyStuff('bar').stuff()
    print(buf.getvalue())
    assert "{test_aspectlib_debug.MyStuff foo='bar' bar='foo'}.stuff()\n{test_aspectlib_debug.MyStuff foo='bar' bar='foo'}.stuff => bar\n" == buf.getvalue()

def test_socket_all_methods():
    buf = StringIO()
    with aspectlib.weave(
        socket.socket,
        aspectlib.debug.log(print_to=buf, stacktrace=False),
        lazy=True,
        methods=aspectlib.ALL_METHODS
    ):
        s = socket.socket()

    assert "}.__init__ => None" in buf.getvalue()