예제 #1
0
파일: clojure.py 프로젝트: janus/clojure-py
def requireClj(filename, stopafter = None):
    with open(filename) as fl:
        r = StringReader(fl.read())

    RT.init()
    comp = Compiler()
    currentCompiler.set(comp)

    try:
        while True:
            s = read(r, True, None, True)

            try:
                res = comp.compile(s)
                comp.executeCode(res)
                if stopafter is not None:
                    if hasattr(comp.getNS(), stopafter):
                        break
            except IOError as exp:
                print s
                raise exp

            while True:
                ch = r.read()

                if ch == "":
                    raise IOError()

                if ch not in [" ", "\t", "\n", "\r"]:
                    r.back()
                    break
    except IOError as e:
        pass
예제 #2
0
class PyNamespaceTests(unittest.TestCase):
    def setUp(self):
        RT.init()
        self.comp = Compiler()
        currentCompiler.set(self.comp)
        self.comp.setNS(symbol("clojure.core"))

    def testBuiltinsNamespaced(self):
        self.assertEqual(self.eval("(py/str [1 2 3])"), "[1 2 3]")
        self.assertEqual(self.eval('(py/list "abc")'), ["a", "b", "c"])
        self.assertEqual(self.eval('((py/getattr "namespace" "__len__"))'), 9)

    def eval(self, code):
        r = StringReader(code)
        s = read(r, True, None, True)
        res = self.comp.compile(s)
        return self.comp.executeCode(res)
예제 #3
0
class ClojureCoreTests(unittest.TestCase):
    def eval(self, code):
        r = StringReader(code)
        s = read(r, True, None, True)
        res = self.comp.compile(s)
        return self.comp.executeCode(res)

    def setUp(self):
        RT.init()
        self.comp = Compiler()
        currentCompiler.set(self.comp)
        self.comp.setNS(symbol('clojure.core'))

    def testList(self):
        self.assertEqual(self.eval('(list 1 2 3)'), [1, 2, 3])
        self.assertEqual(self.eval('(list)'), [])
        self.assertTrue(isinstance(self.eval('(list 1 2 3)'),
                                   PersistentList))

    def testVector(self):
        self.assertEqual(self.eval('(vector 1 2 3)'), [1, 2, 3])
        self.assertEqual(self.eval('(vector)'), [])
        self.assertTrue(isinstance(self.eval('(vector 1 2 3)'),
                                   PersistentVector))

    def testCons(self):
        self.assertEqual(self.eval('(cons 1 nil)'), [1])
        self.assertEqual(self.eval('(cons 1 [2])'), [1, 2])
        self.assertEqual(self.eval('(cons 1 (cons 2 (cons 3 nil)))'),
                         [1, 2, 3])

    def testSeq(self):
        self.assertEqual(self.eval('(seq [])'), None)
        self.assertEqual(self.eval('(seq nil)'), None)

    def testFirst(self):
        self.assertEqual(self.eval('(first [1 2])'), 1)
        self.assertEqual(self.eval('(first nil)'), None)

    def testNext(self):
        self.assertEqual(self.eval('(next [1 2])'), [2])
        self.assertEqual(self.eval('(next nil)'), None)
예제 #4
0
파일: tests.py 프로젝트: janus/clojure-py
class PyNamespaceTests(unittest.TestCase):
    def setUp(self):
        RT.init()
        self.comp = Compiler()
        currentCompiler.set(self.comp)
        self.comp.setNS(Symbol.intern('clojure.core'))

    def testBuiltinsNamespaced(self):
        self.assertEqual(self.eval('(py/str [1 2 3])'), '[1 2 3]')
        self.assertEqual(self.eval('(py/list "abc")'), ['a', 'b', 'c'])
        self.assertEqual(self.eval('((py/getattr "namespace" "__len__"))'), 9)

    def testBuiltinsNotIncluded(self):
        self.assertRaises(NameError, self.eval, '(str [1 2 3])')
        self.assertRaises(NameError, self.eval, '(getattr [1 2 3] "pop")')

    def eval(self, code):
        r = StringReader(code)
        s = read(r, True, None, True)
        res = self.comp.compile(s)
        return self.comp.executeCode(res)
예제 #5
0
class TruthinessTests(unittest.TestCase):
    def setUp(self):
        RT.init()
        self.comp = Compiler()
        currentCompiler.set(self.comp)
        self.comp.setNS(symbol("clojure.core"))

    def testTrue(self):
        self.assertTrue(self.eval("(if true true false)"))

    def testList(self):
        self.assertTrue(self.eval("(if '() true false)"))
        self.assertTrue(self.eval("(if '(1) true false)"))

    def testVector(self):
        self.assertTrue(self.eval("(if [] true false)"))
        self.assertTrue(self.eval("(if [1] true false)"))

    def testMap(self):
        self.assertTrue(self.eval("(if {} true false)"))
        self.assertTrue(self.eval("(if {1 2} true false)"))

    @skip  # hash sets aren't implemented yet
    def testSet(self):
        self.assertTrue(self.eval("(if #{} true false)"))
        self.assertTrue(self.eval("(if #{1} true false)"))

    def testNil(self):
        self.assertFalse(self.eval("(if nil true false)"))
        self.assertFalse(self.eval("(if None true false)"))

    def testFalse(self):
        self.assertFalse(self.eval("(if false true false)"))

    def eval(self, code):
        r = StringReader(code)
        s = read(r, True, None, True)
        res = self.comp.compile(s)
        return self.comp.executeCode(res)
예제 #6
0
def main():
    requireClj(os.path.dirname(__file__) + "/clj/clojure/core.clj")

    RT.init()
    comp = Compiler()
    currentCompiler.set(comp)
    comp.setNS(symbol("user"))

    if not sys.argv[1:]:
        while True:
            try:
                line = raw_input(comp.getNS().__name__ + "=> ")
            except EOFError:
                break

            if not line:
                continue

            while unbalanced(line):
                try:
                    line += raw_input('.' * len(comp.getNS().__name__) + '.. ')
                except EOFError:
                    break

            # Propogate break from above loop.
            if unbalanced(line):
                break

            r = StringReader(line)
            s = read(r, True, None, True)

            try:
                res = comp.compile(s)
                print comp.executeCode(res)
            except Exception:
                traceback.print_exc()
    else:
        for x in sys.argv[1:]:
            requireClj(x)
예제 #7
0
 def setUp(self):
     RT.init()
     self.comp = Compiler()
     currentCompiler.set(self.comp)
     self.comp.setNS(symbol("clojure.core"))
예제 #8
0
class NonOverloadedFunctions(unittest.TestCase):
    def setUp(self):
        RT.init()
        self.comp = Compiler()
        currentCompiler.set(self.comp)
        self.comp.setNS(symbol("clojure.core"))

    def testZeroArguments(self):
        actual = self.compileActual("(defn abc [] 2)")
        expected = self.compileExpected(
            """
            def abc():
                return 2"""
        )
        items = [(a == e, a, e) for a, e in self.zipActualExpected(actual, expected)]
        try:
            assert all(item[0] for item in items)
        except AssertionError:
            pprint.pprint(items)

    def testOneArgument(self):
        actual = self.compileActual("(defn abc ([x] x))")
        expected = self.compileExpected(
            """
            def abc(x):
                return x"""
        )
        items = [(a == e, a, e) for a, e in self.zipActualExpected(actual, expected)]
        try:
            assert all(item[0] for item in items)
        except AssertionError:
            pprint.pprint(items)

    def testMultipleArguments(self):
        actual = self.compileActual("(defn abc ([x] x) ([x y] y))")
        expected = self.compileExpected(
            """
            def abc(*__argsv__):
                if __argsv__.__len__() == 1:
                    x = __argsv__[0]
                    return x
                elif __argsv__.__len__() == 2:
                    x = __argsv__[0]
                    y = __argsv__[1]
                    return y
                raise Exception()"""
        )
        # There's a slight different between clojure-py's compiled code and
        # Python's: clojure-py produces (LOAD_CONST, <type
        # 'exceptions.Exception'>) while Python produces (LOAD_CONST,
        # 'Exception'). Just ignore it; it's not what we're testing here.

        # Also the last to two bytecodes generated by Python are to load None
        # and return it, which isn't necessary after raising an exception.
        items = [(a == e, a, e) for a, e in self.zipActualExpected(actual, expected[:-2]) if e[1] != "Exception"]
        try:
            assert all(item[0] for item in items)
        except AssertionError:
            pprint.pprint(items)

    def zipActualExpected(self, actual, expected):
        difference = len(expected) - len(actual)
        return zip(chain(actual, repeat(None, difference)), chain(expected, repeat(None, -difference)))

    def compileActual(self, code):
        r = StringReader(code)
        s = read(r, True, None, True)
        res = self.comp.compile(s)
        fn = self.comp.executeCode(res)
        return [c for c in Code.from_code(fn.func_code).code[:] if c[0] is not SetLineno]

    def compileExpected(self, code):
        codeobject = compile(dedent(code), "string", "exec")
        globs = {}
        result = eval(codeobject, {}, globs)
        return [c for c in Code.from_code(globs["abc"].func_code).code[:] if c[0] is not SetLineno]
예제 #9
0
파일: tests.py 프로젝트: janus/clojure-py
 def setUp(self):
     RT.init()
     self.comp = Compiler()
     currentCompiler.set(self.comp)
     self.comp.setNS(Symbol.intern('clojure.core'))