even_more_snippets (#20)

* Implement indent manager

* Add new line to conform to linter

* Add test for indent manager

* Integrate indent manager in compiler

* Integrate indent manager with homotopy class

* Move inside block to main and add/change few snippets

* Add snippets for not implemented methods/constructors and emtpy constructors

* Add singleton pattern

* Add wide_block and make regular block narrow

* Change switch to use wide_block

* Change how extend works

* Fix for loop missing start parameter

* Change for loop design

* Changed extend specifier character

* Change method name from $ to @

* Add composite pattern snippets and include snippets

* Add snippets for enums

* Add template snippet

* Add method/constructor implementation snippets

homotopy/parser.py

@@ -5,7 +5,7 @@ class Parser:
     """
     Class for parsing a string to produce a syntax tree.
     """
-    parameter_chars = "!@#$%:~"
+    parameter_chars = "!@#$%:~^"
     in_operator = '>'
     out_operator = '<'
     and_operator = '&'

homotopy/stdlib/core.json

@@ -1,4 +1,10 @@
 [
   {"name": "block","language": "all","snippet": ">>>{{opt_block}}"},
-  {"name": "opt_block","language": "all","snippet": "\n>>>{{opt_block}}"}
+  {"name": "opt_block","language": "all","snippet": "\n>>>{{opt_block}}"},
+  {"name": "wide_block","language": "all","snippet": ">>>{{opt_wide_block}}"},
+  {"name": "opt_wide_block","language": "all","snippet": "\n\n>>>{{opt_wide_block}}"},
+  {"name": "inside_block","language": "C++","snippet": "\t>>>{{opt_inside_block}}"},
+  {"name": "opt_inside_block","language": "C++","snippet": "\n\t>>>{{opt_inside_block}}"},
+  {"name": "wide_inside_block","language": "C++","snippet": "\t>>>{{opt_wide_inside_block}}"},
+  {"name": "opt_wide_inside_block","language": "C++","snippet": "\n\n\t>>>{{opt_wide_inside_block}}"}
 ]

homotopy/stdlib/cpp.json

@@ -1,25 +1,49 @@
 [
-  {"name": "for","language": "C++","snippet": "for(### $$$; $$$<%%%; $$$++){\n{{inside_block}}\n}"},
-  {"name": "forr","language": "C++","snippet": "for(### $$$=%%%; $$$>=0; $$$--){\n{{inside_block}}\n}"},
+  {"name": "for","language": "C++","snippet": "for(### $$$=%%%; $$$<{{for_end}}; $$$++){\n{{inside_block}}\n}"},
+  {"name": "forr","language": "C++","snippet": "for(### $$$=%%%; $$$>={{for_end}}; $$$--){\n{{inside_block}}\n}"},
+  {"name": "for_end","language": "C++","snippet": "%%%"},
   {"name": "forin","language": "C++","snippet": "for(auto&& $$$: %%%){\n{{inside_block}}\n}"},
   {"name": "if","language": "C++","snippet": "if($$$){\n{{inside_block}}\n}"},
   {"name": "while","language": "C++","snippet": "while($$$){\n{{inside_block}}\n}"},
-  {"name": "inside_block","language": "C++","snippet": "\t>>>{{opt_inside_block}}"},
-  {"name": "opt_inside_block","language": "C++","snippet": "\n\t>>>{{opt_inside_block}}"},
-  {"name": "switch","language": "C++","snippet": "switch($$$){\n{{inside_block}}\n}"},
+  {"name": "switch","language": "C++","snippet": "switch($$$){\n{{wide_inside_block}}\n}"},
   {"name": "case","language": "C++","snippet": "case $$$:\n{{inside_block}}\n\tbreak;{{opt_case}}"},
   {"name": "opt_case","language": "C++","snippet": "\ncase $$$:\n{{inside_block}}\n\tbreak;{{opt_case}}"},
-  {"name": "struct","language": "C++","snippet": "struct ###{{pub_extend}} {\n{{inside_block}}\n};"},
-  {"name": "class","language": "C++","snippet": "class ###{{pub_extend}}{{priv_extend}}{{prot_extend}} {\n{{inside_block}}\n};"},
-  {"name": "pub_extend","language": "C++","snippet": ": public :::"},
-  {"name": "priv_extend","language": "C++","snippet": ": private ~~~"},
-  {"name": "prot_extend","language": "C++","snippet": ": protected %%%"},
-  {"name": "method","language": "C++","snippet": "public: ### $$$({{params}}){\n{{inside_block}}\n}"},
-  {"name": "pmethod","language": "C++","snippet": "private: ### $$$({{params}}){\n{{inside_block}}\n}"},
-  {"name": "amethod","language": "C++","snippet": "private: ### $$$({{params}}) = 0;"},
-  {"name": "constr","language": "C++","snippet": "public: {{?###}}({{params}}){\n{{inside_block}}\n}"},
-  {"name": "pconstr","language": "C++","snippet": "private: {{?###}}({{params}}){\n{{inside_block}}\n}"},
-  {"name": "func","language": "C++","snippet": "### $$$({{params}}){\n{{inside_block}}\n}"},
+  {"name": "struct","language": "C++","snippet": "struct !!!{{extend}} {\n{{wide_inside_block}}\n};"},
+  {"name": "class","language": "C++","snippet": "class !!!{{extend}} {\n{{wide_inside_block}}\n};"},
+  {"name": "extend","language": "C++","snippet": ": %%% :::{{opt_extend}}"},
+  {"name": "opt_extend","language": "C++","snippet": ", %%% :::{{opt_extend}}"},
+  {"name": "method","language": "C++","snippet": "public: ### @@@({{params}}){\n{{wide_inside_block}}\n}"},
+  {"name": "pmethod","language": "C++","snippet": "private: ### @@@({{params}}){\n{{wide_inside_block}}\n}"},
+  {"name": "nimethod","language": "C++","snippet": "public: ### @@@({{params}});"},
+  {"name": "nipmethod","language": "C++","snippet": "private: ### @@@({{params}});"},
+  {"name": "amethod","language": "C++","snippet": "public: ### @@@({{params}}) = 0;"},
+  {"name": "apmethod","language": "C++","snippet": "private: ### @@@({{params}}) = 0;"},
+  {"name": "constr","language": "C++","snippet": "public: {{?!!!}}({{params}}){\n{{wide_inside_block}}\n}"},
+  {"name": "pconstr","language": "C++","snippet": "private: {{?!!!}}({{params}}){\n{{wide_inside_block}}\n}"},
+  {"name": "niconstr","language": "C++","snippet": "public: {{?!!!}}({{params}});"},
+  {"name": "nipconstr","language": "C++","snippet": "private: {{?!!!}}({{params}});"},
+  {"name": "econstr","language": "C++","snippet": "public: {{?!!!}}({{params}}){}"},
+  {"name": "epconstr","language": "C++","snippet": "private: {{?!!!}}({{params}}){}"},
+  {"name": "func","language": "C++","snippet": "### @@@({{params}}){\n{{wide_inside_block}}\n}"},
   {"name": "params","language": "C++","snippet": "### $$${{opt_params}}"},
-  {"name": "opt_params","language": "C++","snippet": ", ### $$${{opt_params}}"}
+  {"name": "opt_params","language": "C++","snippet": ", ### $$${{opt_params}}"},
+  {"name": "enum","language": "C++","snippet": "enum !!!{{enum_type}} {\n{{enum_body}}\n};"},
+  {"name": "enum_body","language": "C++","snippet": "\t>>>{{opt_enum_body}}"},
+  {"name": "opt_enum_body","language": "C++","snippet": ",\n\t>>>{{opt_enum_body}}"},
+  {"name": "enum1","language": "C++","snippet": "enum !!!{{enum1_type}} { {{enum1_body}} };"},
+  {"name": "enum1_body","language": "C++","snippet": ">>>{{opt_enum1_body}}"},
+  {"name": "opt_enum1_body","language": "C++","snippet": ", >>>{{opt_enum1_body}}"},
+  {"name": "template","language": "C++","snippet": "template <{{template_params}}>\n{{wide_block}}"},
+  {"name": "template_params","language": "C++","snippet": "class ^^^{{opt_template_params}}"},
+  {"name": "opt_template_params","language": "C++","snippet": ", class ^^^{{opt_template_params}}"},
+  {"name": "methodi","language": "C++","snippet": "### !!!::@@@({{params}}){\n{{wide_inside_block}}\n}"},
+  {"name": "constri","language": "C++","snippet": "!!!::!!!({{params}}){\n{{wide_inside_block}}\n}"},
+
+
+  {"name": "inc","language": "C++","snippet": "#include \"$$$\""},
+  {"name": "stdinc","language": "C++","snippet": "#include <$$$>"},
+
+  {"name": "singleton","language": "C++","snippet": "method#{{?\\!\\!\\!}}\\&@getInstance>static {{?\\!\\!\\!}} instance;&return instance<block>epconstr&nipconstr#{{?\\!\\!\\!}} const\\&$origin&nipmethod#void@operator=#{{?\\!\\!\\!}} const\\&$origin<"},
+  {"name": "compositeclass","language": "C++","snippet": "private\\: std\\:\\:vector\\<{{?\\:\\:\\:}}*\\> children;&method#void@add#{{?\\:\\:\\:}}$*item>children.puch_back(item);<"},
+  {"name": "compositemethod","language": "C++","snippet": ">for#int$i%0%children.size()>children[i]-\\>{{?\\@\\@\\@}}();<<"}
 ]

test/testParser.py

@@ -19,7 +19,7 @@ def test_basic(self):
                          )
 
     def test_parameters(self):
-        operators = '!@#$%:~'
+        operators = '!@#$%:~^'
         for l in operators:
             self.assertEqual(parser.parse('first{0}second{0}third'.format(l)),
                              CompositeSnippet(

test/testStdlib.py

@@ -13,21 +13,21 @@ def singleSnippet(self, snippet, expected_output):
         self.assertEqual(expected_output.lstrip('\n').rstrip(), compiled_snippet)
 
     def testCpp(self):
-        self.singleSnippet("for#int$i%n", """
-for(int i; i<n; i++){
+        self.singleSnippet("for#int$i%0%n", """
+for(int i=0; i<n; i++){
 
 }
 [{cursor_marker}]
 """)
 
-        self.singleSnippet("for#int$i%n>", """
-for(int i; i<n; i++){
+        self.singleSnippet("for#int$i%0%n>", """
+for(int i=0; i<n; i++){
 \t[{cursor_marker}]
 }
 """)
 
-        self.singleSnippet('for#int$i%n>printf("hello");', """
-for(int i; i<n; i++){
+        self.singleSnippet('for#int$i%0%n>printf("hello");', """
+for(int i=0; i<n; i++){
 \tprintf("hello");
 \t[{cursor_marker}]
 }
@@ -38,7 +38,6 @@ def testCpp(self):
 \treturn 5;
 \t[{cursor_marker}]
 }
-
 """)
         self.singleSnippet('while$i==3>return 5;', """
 while(i==3){
@@ -47,13 +46,13 @@ def testCpp(self):
 }
 
 """)
-        self.singleSnippet('forr#int$i%n>printf("hello");', """
+        self.singleSnippet('forr#int$i%n%0>printf("hello");', """
 for(int i=n; i>=0; i--){
 \tprintf("hello");
 \t[{cursor_marker}]
 }
 """)
-        self.singleSnippet('forr#int$i%n>printf("hello");<', """
+        self.singleSnippet('forr#int$i%n%0>printf("hello");<', """
 for(int i=n; i>=0; i--){
 \tprintf("hello");
 }
@@ -71,6 +70,7 @@ def testCpp(self):
 \tcase 1:
 \t\tasd
 \t\tbreak;
+
 \tcase 2:
 \t\tdsa
 \t\t[{cursor_marker}]
@@ -82,81 +82,218 @@ def testCpp(self):
 \tcase 1:
 \t\tasd
 \t\tbreak;
+
 \tcase 2:
 \t\tdsa
 \t\tbreak;
 }
 [{cursor_marker}]
 """)
-        self.singleSnippet('struct#A:B>', """
+        self.singleSnippet('switch$i>case$1>asd<case$2>dsa<', """
+switch(i){
+\tcase 1:
+\t\tasd
+\t\tbreak;
+
+\tcase 2:
+\t\tdsa
+\t\tbreak;
+
+\t[{cursor_marker}]
+}
+""")
+        self.singleSnippet('struct!A%public:B>', """
 struct A: public B {
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A%B>blah', """
-class A: protected B {
-\tblah
+        self.singleSnippet('struct!A:B:C%public>', """
+struct A: public B, public C {
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A~B>func#void$foo#int$a#int$b', """
-class A: private B {
-\tvoid foo(int a, int b){
+        self.singleSnippet('class!A%protected:B%public:C>blah', """
+class A: protected B, public C {
+\tblah
 
-\t}
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A>constr#int$i&constr#int$i#int$j', """
+        self.singleSnippet('class!A>constr#int$i&constr#int$i#int$j', """
 class A {
 \tpublic: A(int i){
 
 \t}
+
 \tpublic: A(int i, int j){
 
 \t}
+
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A:B>pconstr#int$i', """
+        self.singleSnippet('class!A%public:B>pconstr#int$i', """
 class A: public B {
 \tprivate: A(int i){
 
 \t}
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('class!A%public:B>econstr#int$i', """
+class A: public B {
+\tpublic: A(int i){}
+
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A:B>pconstr#int$i&method#void$test#int$value', """
+        self.singleSnippet('class!A%public:B>epconstr#int$i', """
+class A: public B {
+\tprivate: A(int i){}
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('class!A%public:B>niconstr#int$i', """
+class A: public B {
+\tpublic: A(int i);
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('class!A%public:B>nipconstr#int$i', """
+class A: public B {
+\tprivate: A(int i);
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('class!A%public:B>pconstr#int$i&method#void@test#int$value', """
 class A: public B {
 \tprivate: A(int i){
 
 \t}
+
 \tpublic: void test(int value){
 
 \t}
+
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('class#A:B>pconstr#int$i>// c++ comment<pmethod#int$five>return 5', """
+        self.singleSnippet('class!A%public:B>pconstr#int$i>// c++ comment<pmethod#int@five>return 5', """
 class A: public B {
 \tprivate: A(int i){
 \t\t// c++ comment
 \t}
+
 \tprivate: int five(){
 \t\treturn 5
+
 \t\t[{cursor_marker}]
 \t}
 };
 """)
-        self.singleSnippet('class#A:B>amethod#void$name', """
+        self.singleSnippet('class!A%public:B>amethod#void@name', """
 class A: public B {
-\tprivate: void name() = 0;
+\tpublic: void name() = 0;
+
 \t[{cursor_marker}]
 };
 """)
-        self.singleSnippet('  class#A:B>amethod#void$name', """
+        self.singleSnippet('  class!A%public:B>apmethod#void@name', """
   class A: public B {
   \tprivate: void name() = 0;
+
   \t[{cursor_marker}]
   };
-""")
+""")
+        self.singleSnippet('  class!A%public:B>amethod#void@name', """
+  class A: public B {
+  \tpublic: void name() = 0;
+
+  \t[{cursor_marker}]
+  };
+""")
+        self.singleSnippet('  class!A%public:B>nimethod#void@name', """
+  class A: public B {
+  \tpublic: void name();
+
+  \t[{cursor_marker}]
+  };
+""")
+        self.singleSnippet('  class!A%public:B>nipmethod#void@name', """
+  class A: public B {
+  \tprivate: void name();
+
+  \t[{cursor_marker}]
+  };
+""")
+        self.singleSnippet('class!A%public:B>[[singleton]]', """
+class A: public B {
+\tpublic: A& getInstance(){
+\t\tstatic A instance;
+
+\t\treturn instance
+\t}
+
+\tprivate: A(){}
+\tprivate: A(A const& origin);
+\tprivate: void operator=(A const& origin);
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('class!Composite:Component%public>[[compositeclass]]&pmethod#void@traverse[[compositemethod]]', """
+class Composite: public Component {
+\tprivate: std::vector<Component*> children;
+
+\tpublic: void add(Component *item){
+\t\tchildren.puch_back(item);
+\t}
+
+\tprivate: void traverse(){
+\t\tfor(int i=0; i<children.size(); i++){
+\t\t\t\tchildren[i]->traverse();
+\t\t\t}
+\t}
+
+\t[{cursor_marker}]
+};
+""")
+        self.singleSnippet('enum1!deca>pera&mika = 2&zika = 3', """
+enum deca { pera, mika = 2, zika = 3, [{cursor_marker}] };
+""")
+        self.singleSnippet('enum1!deca>pera&mika = 2&zika = 3<', """
+enum deca { pera, mika = 2, zika = 3 };
+[{cursor_marker}]
+""")
+        self.singleSnippet('enum!deca>pera&mika = 2&zika = 3<', """
+enum deca {
+\tpera,
+\tmika = 2,
+\tzika = 3
+};
+[{cursor_marker}]
+""")
+        self.singleSnippet('template^T>class!A', """
+template <class T>
+class A {
+
+};
+
+[{cursor_marker}]
+""")
+        self.singleSnippet('constri!A#int$i', """
+A::A(int i){
+
+}
+[{cursor_marker}]
+""")
+        self.singleSnippet('methodi!A#void@pera#int$i', """
+void A::pera(int i){
+
+}
+[{cursor_marker}]
+""")