kuniri 0.0.1 → 0.2

data/spec/parser/xmlSchemaValidate/simpleFunction.xsd

@@ -0,0 +1,25 @@
+<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="kuniri">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="functionData" maxOccurs="unbounded" minOccurs="0">
+          <xs:complexType mixed="true">
+            <xs:sequence>
+              <xs:element name="parameterData" maxOccurs="unbounded" minOccurs="0">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:extension base="xs:string">
+                      <xs:attribute type="xs:string" name="name" use="optional"/>
+                    </xs:extension>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            </xs:sequence>
+            <xs:attribute type="xs:string" name="name" use="optional"/>
+            <xs:attribute type="xs:string" name="visibility" use="optional"/>
+          </xs:complexType>
+        </xs:element>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>

data/spec/parser/xmlSchemaValidate/validate_xml_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../../spec_helper'
+require "xml"
+
+RSpec.describe 'Xml Schema Validate' do
+
+  before :all do
+    @targetFolder = "./spec/parser/xmlSchemaValidate/"
+  end
+
+  RSpec.shared_examples "Multiple validation" do |config, xmlOutput, xsdFile, description|
+
+    it "Validate XSD: #{description}" do
+      kuniri = Kuniri::Kuniri.new
+      kuniri.read_configuration_file(@targetFolder + config)
+      kuniri.run_analysis
+      parser = Parser::XMLOutputFormat.new(kuniri.configurationInfo[:output])
+      parser.create_all_data(kuniri.get_parser())
+      xml = XML::Document.file(@targetFolder + xmlOutput)
+      schema = XML::Schema.document(XML::Document.file(@targetFolder + xsdFile))
+
+      expect(xml.validate_schema(schema)).to be true
+    end
+
+  end
+
+  context "When have support to the parser." do
+
+    config = '.kuniri1.yml'
+    xsd = 'fullCodeTwo.xsd'
+    xml = 'fullCodeTwo.xml'
+    description = 'Check simple class'
+    include_examples "Multiple validation", config, xml, xsd, description
+
+    config = '.kuniri2.yml'
+    xsd = 'fullCodeWithComments.xsd'
+    xml = 'fullCodeWithComments.xml'
+    description = 'Check class with comments'
+    include_examples "Multiple validation", config, xml, xsd, description
+
+    config = '.kuniri3.yml'
+    xsd = 'simpleFunction.xsd'
+    xml = 'simpleFunction.xml'
+    description = 'Check simple function'
+    include_examples "Multiple validation", config, xml, xsd, description
+
+  end
+
+  after :all do
+    @targetFolder = nil
+  end
+
+end

data/spec/parser/xml_builder_engine_spec.rb

@@ -0,0 +1,258 @@
+require_relative '../spec_helper'
+
+RSpec.describe Parser::XMLBuilderEngine do
+
+  before :each do
+    @builder = Parser::XMLBuilderEngine.new
+    @basicHeader = '<?xml version="1.0" encoding="UTF-8"?>'
+  end
+
+  context "Default options" do
+    it "Nothing" do
+      tag = @builder.to_xml
+      expect(tag).to eq(@basicHeader)
+    end
+
+    it "Reset" do
+      @builder.reset_engine
+      tag = @builder.to_xml
+      expect(tag).to eq(@basicHeader)
+    end
+  end
+
+  context "Generate class" do
+    it "Generate simple class" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+        end
+      end
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Generate simple class with inheritance" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          inheritanceData :name => "Abc"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <inheritanceData name="Abc"/>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Class with attribute" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          attributeData :name => "abc", :visibility => "public"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <attributeData name="abc" visibility="public"/>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Class with constructor" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          constructorData :name => "initialize", :visibility => "public" do
+          end
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <constructorData name="initialize" visibility="public">',
+                '    </constructorData>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Class with method" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          methodData :name => "abc", :visibility => "public" do
+          end
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <methodData name="abc" visibility="public">',
+                '    </methodData>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+  end
+
+  context "Conditional and repetition statement" do
+    it "If statement" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          methodData :name => "abc", :visibility => "public" do
+            conditionalData :type => "if",
+                            :expression => "x > 2"
+          end
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <methodData name="abc" visibility="public">',
+                '      <conditionalData type="if" expression="x &gt; 2"/>',
+                '    </methodData>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Unless statement" do
+      @builder.kuniri do
+        classData :name => "Xpto", :visibility => "public" do
+          methodData :name => "abc", :visibility => "public" do
+            conditionalData :type => "unless",
+                            :expression => "(abc < 3) && (kto > 20)"
+          end
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <classData name="Xpto" visibility="public">',
+                '    <methodData name="abc" visibility="public">',
+                '      <conditionalData type="unless" expression="(abc &lt; 3)' +
+                      ' &amp;&amp; (kto &gt; 20)"/>',
+                '    </methodData>',
+                '  </classData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+  end
+
+  context "Global function" do
+    it "Simple global function" do
+      @builder.kuniri do
+        functionData :name => "xpto", :visibility => "global" do
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <functionData name="xpto" visibility="global">',
+                '  </functionData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Global function with conditional" do
+      @builder.kuniri do
+        functionData :name => "xpto", :visibility => "global" do
+          conditionalData :type => "if", :expression => "u == 5"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <functionData name="xpto" visibility="global">',
+                '    <conditionalData type="if" expression="u == 5"/>',
+                '  </functionData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Global function with repetition" do
+      @builder.kuniri do
+        functionData :name => "xpto", :visibility => "global" do
+          repetitionData :type => "while", :expression => "(x < 0)"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <functionData name="xpto" visibility="global">',
+                '    <repetitionData type="while" expression="(x &lt; 0)"/>',
+                '  </functionData>',
+                '</kuniri>',].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Global function with parameters" do
+      @builder.kuniri do
+        functionData :name => "xpto", :visibility => "global" do
+          parameterData :name => "one"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <functionData name="xpto" visibility="global">',
+                '    <parameterData name="one"/>',
+                '  </functionData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+    it "Full global function" do
+      @builder.kuniri do
+        functionData :name => "xpto", :visibility => "global" do
+          parameterData :name => "two"
+          conditionalData :type => "if", :expression => "y == x"
+          repetitionData :type => "while", :expression => "k and y"
+        end
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <functionData name="xpto" visibility="global">',
+                '    <parameterData name="two"/>',
+                '    <conditionalData type="if" expression="y == x"/>',
+                '    <repetitionData type="while" expression="k and y"/>',
+                '  </functionData>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+
+  end
+
+  context "Global variable" do
+    it "Simple global variable" do
+      @builder.kuniri do
+        globalVariableData :name => "xpto"
+      end
+
+      output = [@basicHeader,
+                '<kuniri>',
+                '  <globalVariableData name="xpto"/>',
+                '</kuniri>'].join("\n") + "\n"
+      expect(@builder.to_xml).to eq(output)
+    end
+  end
+
+#  context "Extern requirements" do
+#  end
+
+  after :each do
+    @builder = nil
+  end
+
+end

data/spec/parser/xml_output_format_spec.rb

@@ -0,0 +1,274 @@
+require_relative '../spec_helper'
+
+RSpec.describe Parser::XMLOutputFormat do
+
+  before :each do
+    @outputFormat = Parser::XMLOutputFormat.new
+    @stringHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+  end
+
+  context "Generate class" do
+
+   it "::Simple case class" do
+      expectedString = @stringHeader
+      expectedString += "<classData name=\"Xpto\" visibility=\"public\">\n"
+      expectedString += "</classData>\n"
+      classTmp = Languages::ClassData.new
+      classTmp.name = "Xpto"
+      @outputFormat.class_generate([classTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+   it "::Set visibility" do
+      expectedString = @stringHeader
+      expectedString += "<classData name=\"Xpto\" visibility=\"private\">\n"
+      expectedString += "</classData>\n"
+      classTmp = Languages::ClassData.new
+      classTmp.name = "Xpto"
+      classTmp.visibility = "private"
+      @outputFormat.class_generate([classTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+   it "::Set comment" do
+      expectedString = @stringHeader
+      expectedString += "<classData name=\"Xpto\" visibility=\"public\">\n"
+      expectedString += "  <commentData text=\"This is a simple comment\"/>\n"
+      expectedString += "</classData>\n"
+      classTmp = Languages::ClassData.new
+      classTmp.name = "Xpto"
+      classTmp.comments = "This is a simple comment"
+      @outputFormat.class_generate([classTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+   it "::Set aggregation" do
+     expectedString = @stringHeader
+     expectedString += "<aggregationData name=\"Class1\"/>\n"
+     aggregationTmp = Languages::AggregationData.new "Class1"
+     @outputFormat.aggregation_generate([aggregationTmp])
+     expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+   end
+
+
+  end
+
+  context "Generate constructor" do
+
+    it "::Simple constructor" do
+      expectedString = @stringHeader
+      expectedString += "<constructorData name=\"initialize\" "
+      expectedString += "visibility=\"public\">\n"
+      expectedString += "</constructorData>\n"
+      constructorTmp = Languages::ConstructorData.new("initialize")
+      @outputFormat.function_behaviour_generate("constructorData",
+                                                constructorTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::Constructor with comment" do
+      expectedString = @stringHeader
+      expectedString += "<constructorData name=\"initialize\" "
+      expectedString += "visibility=\"public\">\n"
+      expectedString += "  <commentData text=\"Comment constructor\"/>\n"
+      expectedString += "</constructorData>\n"
+      constructorTmp = Languages::ConstructorData.new("initialize")
+      constructorTmp.comments = "Comment constructor"
+      @outputFormat.function_behaviour_generate("constructorData",
+                                                constructorTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::Constructor with conditional" do
+      expectedString = @stringHeader
+      expectedString += "<constructorData name=\"initialize\" "
+      expectedString += "visibility=\"public\">\n"
+      expectedString += '  <if expression="(x &lt; 3)" level="0"/>'
+      expectedString += "\n</constructorData>\n"
+
+      constructorTmp = Languages::ConstructorData.new("initialize")
+      conditionalTmp = Languages::ConditionalData.new
+      conditionalTmp.type = Languages::IF_LABEL
+      conditionalTmp.expression = "(x < 3)"
+
+      constructorTmp.add_conditional(conditionalTmp)
+
+      @outputFormat.function_behaviour_generate("constructorData",
+                                                constructorTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::Constructor with repetition" do
+      expectedString = @stringHeader
+      expectedString += "<constructorData name=\"initialize\" "
+      expectedString += "visibility=\"public\">\n"
+      expectedString += '  <for expression="i in x" level="0"/>'
+      expectedString += "\n</constructorData>\n"
+
+      constructorTmp = Languages::ConstructorData.new("initialize")
+      conditionalTmp = Languages::RepetitionData.new
+      conditionalTmp.type = Languages::FOR_LABEL
+      conditionalTmp.expression = "i in x"
+
+      constructorTmp.add_repetition(conditionalTmp)
+
+      @outputFormat.function_behaviour_generate("constructorData",
+                                                constructorTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::Constructor with conditional and repetition" do
+      expectedString = @stringHeader
+      expectedString += "<constructorData name=\"initialize\" "
+      expectedString += "visibility=\"public\">\n"
+      expectedString += '  <if expression="(x &lt; 3)" level="0"/>' + "\n"
+      expectedString += '  <for expression="i in x" level="0"/>'
+      expectedString += "\n</constructorData>\n"
+
+      constructorTmp = Languages::ConstructorData.new("initialize")
+
+      conditionalTmp = Languages::ConditionalData.new
+      conditionalTmp.type = Languages::IF_LABEL
+      conditionalTmp.expression = "(x < 3)"
+      constructorTmp.add_conditional(conditionalTmp)
+
+      conditionalTmp = Languages::RepetitionData.new
+      conditionalTmp.type = Languages::FOR_LABEL
+      conditionalTmp.expression = "i in x"
+      constructorTmp.add_repetition(conditionalTmp)
+
+      @outputFormat.function_behaviour_generate("constructorData",
+                                                constructorTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+  end
+
+  context "::Generate initialize" do
+
+    it "::Simple inheritance" do
+      expectedString = @stringHeader
+      expectedString += "<inheritanceData name=\"Xpto\"/>\n"
+      inheritanceTmp = Languages::ClassData.new
+      inheritanceTmp.inheritances.push("Xpto")
+      @outputFormat.inheritance_generate(inheritanceTmp.inheritances)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::Double inheritance" do
+      expectedString = @stringHeader
+      expectedString += "<inheritanceData name=\"Xpto1\"/>\n\n"
+      expectedString += "<inheritanceData name=\"Xpto2\"/>\n"
+      inheritanceTmp = Languages::ClassData.new
+      inheritanceTmp.inheritances.push("Xpto1")
+      inheritanceTmp.inheritances.push("Xpto2")
+      @outputFormat.inheritance_generate(inheritanceTmp.inheritances)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "::No inheritance" do
+      expectedString = @stringHeader.gsub("\n", "")
+      inheritanceTmp = Languages::ClassData.new
+      @outputFormat.inheritance_generate(inheritanceTmp.inheritances)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+  end
+
+  context "::Generate methods" do
+
+    it "::Generate simple method" do
+      expectedString = @stringHeader
+      expectedString += "<methodData name=\"xpto\" visibility=\"public\">\n"
+      expectedString += "</methodData>\n"
+      methodTmp = Languages::MethodData.new("xpto")
+      @outputFormat.function_behaviour_generate("methodData", methodTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+  end
+
+  context "Cannot call unimplemented method." do
+
+    it "Create all data" do
+      expect(@outputFormat.create_all_data(nil)).to eq(nil)
+    end
+
+    it "Generate parameters" do
+      expectedString = @stringHeader
+      expectedString += "<parameterData name=\"value=1\"/>\n"
+      parameterTmp = {"value" => "1"}
+      @outputFormat.parameters_generate(parameterTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate attribute" do
+      expectedString = @stringHeader
+      expectedString += "<attributeData name=\"xpto\" "
+      expectedString += "visibility=\"public\"/>\n"
+      attributeTmp = Languages::AttributeData.new("xpto")
+      @outputFormat.attribute_generate([attributeTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate function" do
+      expectedString = @stringHeader
+      expectedString += '<functionData name="xpto" visibility="global">'
+      expectedString += "\n</functionData>\n"
+      functionTmp = Languages::FunctionData.new("xpto")
+      functionTmp.visibility = "global"
+      @outputFormat.function_behaviour_generate("functionData", functionTmp)
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate global variable" do
+      expectedString = @stringHeader
+      expectedString += "<globalVariableData name=\"xpto\"/>\n"
+      globalVariableTmp = Languages::VariableGlobalData.new("xpto")
+      @outputFormat.global_variable_generate([globalVariableTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate require" do
+      expectedString = @stringHeader
+      expectedString += "<externRequirementData name=\"xpto\"/>\n"
+      requireTmp = Languages::ExternRequirementData.new("xpto")
+      @outputFormat.extern_requirement_generate([requireTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate module" do
+      expectedString = @stringHeader
+      expectedString += "<moduleData name=\"xpto\"/>\n"
+      moduleTmp = Languages::ModuleNamespaceData.new("xpto")
+      @outputFormat.module_generate([moduleTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate repetition" do
+      expectedString = @stringHeader
+      expectedString += "<while expression=\"x&gt;3\" level=\"0\"/>\n"
+      repetitionTmp = Languages::RepetitionData.new
+      repetitionTmp.type = Languages::WHILE_LABEL
+      repetitionTmp.expression = "x>3"
+      @outputFormat.basic_structure_generate([repetitionTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+    it "Generate conditional" do
+      expectedString = @stringHeader
+      expectedString += "<if expression=\"y &lt; 3\" level=\"0\"/>\n"
+      conditionalTmp = Languages::ConditionalData.new
+      conditionalTmp.type = Languages::IF_LABEL
+      conditionalTmp.expression = "y < 3"
+      @outputFormat.basic_structure_generate([conditionalTmp])
+      expect(@outputFormat.outputEngine.to_xml).to eq(expectedString)
+    end
+
+  end
+
+  after :each do
+    @outputFormat = nil
+  end
+
+end