def test_let_syntax_with_scope(self): class m: from zenmai.actions import partial # NOQA prefix = staticmethod(lambda d, prefix=":": prefix + d) add = staticmethod(lambda n, v=1: n + v) source = textwrap.dedent(""" $let: withPlus: {$partial: $prefix, prefix: +} person: name: {$withPlus: foo} age: $let: withPlus: {$partial: $add, v: 10} body: $withPlus: 10 friends: - name: {$withPlus: bar} """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" person: name: +foo age: 20 friends: - name: +bar """) self.assertDiff(actual.strip(), expected.strip())
def test_unless_syntax(self): class m: pass source = textwrap.dedent(""" ok0: $unless: false body: ok ng0: $unless: true body: ng ok1: $unless: false body: message: ok ok2: $unless: false message: ok """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" ok0: ok ok1: message: ok ok2: message: ok """) self.assertDiff(actual.strip(), expected.strip())
def test_jinja2(self): class m: from zenmai.actions import jinja2_template # NOQA source = textwrap.dedent(""" $let: item-template: $jinja2_template: | items: {% for i in nums %} - {{prefix|default("no")}}.{{i}} {% endfor %} body: listing: $item-template: nums: [1,2,3] """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" listing: items: - no.1 - no.2 - no.3 """) self.assertDiff(actual.strip(), expected.strip())
def test_import_with_physical_path(self): class m: from zenmai.actions import import_ # NOQA source = textwrap.dedent(""" main: {$import: ./_inc.py, as: f} n: {$f.inc: 10} """) d = self._callFUT(source, m, filename=__file__) actual = loading.dumps(d) expected = textwrap.dedent(""" n: 11 """) self.assertDiff(actual.strip(), expected.strip())
def test_quote_syntax2(self): class m: pass source = textwrap.dedent(""" body: $$load: foo.yaml """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" body: $load: foo.yaml """) self.assertDiff(actual.strip(), expected.strip())
def test_concat(self): class m: from zenmai.actions import concat # NOQA source = textwrap.dedent(""" person: $concat: - name: foo - age: 10 """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" person: name: foo age: 10 """) self.assertDiff(actual.strip(), expected.strip())
def test_let_syntax(self): class m: from zenmai.actions import partial # NOQA prefix = staticmethod(lambda d, prefix=":": prefix + d) source = textwrap.dedent(""" $let: withPlus: {$partial: $prefix, prefix: +} body: definitions: name: {$withPlus: foo} """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" definitions: name: +foo """) self.assertDiff(actual.strip(), expected.strip())
def test_return_value_with_action(self): class m: @staticmethod def inc(n): return n + 1 @staticmethod def inc2(n): return {"$inc": n + 1} source = textwrap.dedent(""" n: $inc2: 10 """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" n: 12 """) self.assertDiff(actual.strip(), expected.strip())
def test_format2(self): class m: from zenmai.actions import format # NOQA from zenmai.actions import get # NOQA source = textwrap.dedent(""" $let: items: app: "{prefix}-app" batch: "{prefix}-batch" body: $format: {$get: items} prefix: dev """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" app: dev-app batch: dev-batch """) self.assertDiff(actual.strip(), expected.strip())
def test_get(self): class m: from zenmai.actions import get # NOQA source = textwrap.dedent(""" $let: person: name: foo body: - {$get: person} - {$get: "person#/name"} - {$get: "person#/age", default: 0} """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" - name: foo - foo - 0 """) self.assertDiff(actual.strip(), expected.strip())
def test_import(self): class m: from zenmai.actions import import_ # NOQA source = textwrap.dedent(""" main: $import: zenmai.actions.suffix as: s definitions: $s.suffix: name: foo suffix: + """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" definitions: name+: foo """) self.assertDiff(actual.strip(), expected.strip())
def test_load__with_kwargs(self): from tempfile import TemporaryDirectory from pathlib import Path with TemporaryDirectory() as d: d = Path(d) a = textwrap.dedent(""" b: $let: mydata: {value: 10} body: $load: ./b.yaml data: {$get: mydata} """) loading.dumpfile(loading.loads(a), str(d.joinpath("./a.yaml"))) b = textwrap.dedent(""" # need: data name: b data: {$get: data} """) loading.dumpfile(loading.loads(b), str(d.joinpath("./b.yaml"))) class m: from zenmai.actions import get # NOQA from zenmai.actions import load # NOQA d = self._callFUT(a, m, filename=str(d.joinpath("./a.yaml"))) actual = loading.dumps(d) expected = textwrap.dedent(""" b: name: b data: value: 10 """) self.assertDiff(actual.strip(), expected.strip())
def test_counter(self): class m: from zenmai.actions import counter # NOQA source = textwrap.dedent(""" $let: c0: {$counter: 3} c1: {$counter: 0} body: - {$c0: "item{:04}"} - {$c1} - {$c0: "item{:04}"} - {$c1} """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" - item0003 - 0 - item0004 - 1 """) self.assertDiff(actual.strip(), expected.strip())
def test_format(self): class m: from zenmai.actions import format # NOQA source = textwrap.dedent(""" - $format: "{prefix}{number:04}" prefix: foo number: 0 - $format: "{prefix}{number:04}" prefix: foo number: 1 - $format: "{prefix}{number:04}" prefix: bar number: 0 """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" - foo0000 - foo0001 - bar0000 """) self.assertDiff(actual.strip(), expected.strip())
def dumps(d): return loading.dumps(d)
def test_load(self): from tempfile import TemporaryDirectory from pathlib import Path with TemporaryDirectory() as d: d = Path(d) main = textwrap.dedent(""" definitions: one: $load: "./one/one.yaml" two: $load: "./two/two.yaml" """) loading.dumpfile(loading.loads(main), str(d.joinpath("./main.yaml"))) one = textwrap.dedent(""" type: object properties: value: $load: "./value.yaml" """) loading.dumpfile(loading.loads(one), str(d.joinpath("./one/one.yaml"))) value = textwrap.dedent(""" description: value type: integer """) loading.dumpfile(loading.loads(value), str(d.joinpath("./one/value.yaml"))) two = textwrap.dedent(""" type: object properties: value: $load: "../one/value.yaml" """) loading.dumpfile(loading.loads(two), str(d.joinpath("./two/two.yaml"))) class m: from zenmai.actions import load # NOQA d = self._callFUT(main, m, filename=str(d.joinpath("./main.yaml"))) actual = loading.dumps(d) expected = textwrap.dedent(""" definitions: one: type: object properties: value: description: value type: integer two: type: object properties: value: description: value type: integer """) self.assertDiff(actual.strip(), expected.strip())
def test_jinja2_raw_format(self): from tempfile import TemporaryDirectory from pathlib import Path class m: from zenmai.actions import jinja2_templatefile, jinja2_template # NOQA from zenmai.actions import load # NOQA with TemporaryDirectory() as d: d = Path(d) main = textwrap.dedent(""" $let: readme-template: $jinja2_templatefile: ./readme.jinja2 format: raw body: ./one.md: $readme-template: name: one ./two.md: $readme-template: name: two ./three.md: $readme-template: name: three """) loading.dumpfile(loading.loads(main), str(d.joinpath("./main.yaml"))) template = textwrap.dedent("""\ # {{name}} this is {{name}}. """) with open(str(d.joinpath("./readme.jinja2")), "w") as wf: wf.write(template) d = self._callFUT(main, m, filename=str(d.joinpath("./main.yaml"))) actual = loading.dumps(d) expected = textwrap.dedent(""" ./one.md: |- # one this is one. ./two.md: |- # two this is two. ./three.md: |- # three this is three. """) self.assertDiff(actual.strip(), expected.strip()) source = textwrap.dedent(""" $let: item-template: $jinja2_template: | items: {% for i in nums %} - {{prefix|default("no")}}.{{i}} {% endfor %} body: listing: $item-template: nums: [1,2,3] """) d = self._callFUT(source, m) actual = loading.dumps(d) expected = textwrap.dedent(""" listing: items: - no.1 - no.2 - no.3 """) self.assertDiff(actual.strip(), expected.strip())
loading.setup() yaml = """ definitions: person: type: object properties: name: type: string age: type: integer """ d = loading.loads(yaml, format="yaml") with indent(2, "load data\n"): print(loading.dumps(d, format="yaml")) with indent(2, "access by json pointer\n"): from dictknife.jsonknife import access_by_json_pointer q = "/definitions/person/properties" v = access_by_json_pointer(d, q) print("access : {}".format(q)) print(loading.dumps(v, format="yaml")) # this is also ok(but this is json reference). q = "#/definitions/person/properties" v = access_by_json_pointer(d, q) print("access : {}".format(q)) print(loading.dumps(v, format="yaml"))
import jedi from dictknife.loading import dumps defs = jedi.Script("""import marshmallow""", 1, 7, ".").goto_definitions() print(dumps({d.name: d.module_path for d in defs}, format="json")) # (ffap-python:find-program ffap-python:python-program-name)
def dumps(d): return loading.dumps(d)