Version files are able to download

.gitignore

@@ -1 +1,2 @@
-builds/*
+builds/*
+dependencies/*

DependencyResolver.Mod

@@ -10,64 +10,111 @@ VAR
 
     j : LONGINT;
 
-PROCEDURE Resolve *(jsonString: ARRAY OF CHAR);
+PROCEDURE ResolveVersionFiles *(jsonString: ARRAY OF CHAR);
 VAR
     jsonRecord, dependencies: JsonParser.JsonTypePointer;
     keyFound: BOOLEAN;
-    packageName, version, returnedJSON: JsonParser.TString;
+    packageName, version, filePath: ARRAY 32 OF CHAR;
+    returnedJSON: JsonParser.TString;
     keys: ARRAY ArrayMaxNumber OF JsonParser.TString;
     i, k : LONGINT;
 BEGIN
     jsonRecord := JsonParser.Create(jsonString);
-    
     keyFound := jsonRecord.GetTerminal(jsonRecord, "Package", packageName);
-    
     IF keyFound THEN
         Logger.Log("Parsing package by name");
         Logger.Log(packageName);
         Logger.Log("------------------------");
     ELSE Logger.Log("Value for the Key is not found"); RETURN; END;
-
-    dependencies := jsonRecord.GetNonTerminal(jsonRecord, "Dependencies");
-    dependencies.GetTerminalKeys(dependencies, keys);    
     
-    FOR i := 0 TO LEN(keys) - 1 DO (* TODO: rewrite this logic to work with key count *)
+    dependencies := jsonRecord.GetNonTerminal(jsonRecord, "Dependencies");
-        IF ~Strings.Match(keys[i], "") THEN
-            keyFound := dependencies.GetTerminal(dependencies, keys[i], version);
-            IF ~keyFound THEN Logger.Log('ERROR while seatching key'); Logger.Log(keys[i]); END;
-            ASSERT(keyFound);
 
-            PackageResolver.ResolveFile(
+    IF dependencies = NIL THEN
-                Settings.host,
+        Logger.Log("Parsing package by name");
-                Settings.port,
+        Logger.Log(packageName);
-                keys[i],
+        Logger.Log("Error");
-                version,
+        Logger.Log("No dependency");
-                Settings.packageFileName,
+        Logger.Log("------------------------");
-                returnedJSON
+    END;
-            );
+    
-            
+    dependencies.GetTerminalKeys(dependencies, keys);    
-            keyFound := FALSE;
-            IF j >= LEN(moduleNames) THEN 
-                Logger.Log("Out of range in Resolve function in ...");
-            END;
-            ASSERT(j < LEN(moduleNames));
-            
-            FOR k := 0 TO j - 1 DO
-                IF Strings.Match(moduleNames[k], keys[i]) THEN
-                    keyFound := TRUE;
-                END;
-            END;
-            
 
-            IF ~keyFound THEN 
+    FOR i := 0 TO dependencies.TerminalNumber - 1 DO (* TODO: rewrite this logic to work with key count *)
-                COPY(keys[i], moduleNames[j]);
+        keyFound := dependencies.GetTerminal(dependencies, keys[i], version);
-                COPY(version, moduleVersions[j]);
+        
-                COPY(returnedJSON, moduleJson[j]);
+        IF ~keyFound THEN Logger.Log('ERROR while searching key'); Logger.Log(keys[i]); END;
-                INC(j);
+        ASSERT(keyFound);
-                Resolve(returnedJSON);
+
+        COPY("", filePath);
+        Strings.Append("/", filePath);
+        Strings.Append(keys[i], filePath);
+        Strings.Append("/", filePath);
+        Strings.Append(version, filePath);
+        Strings.Append("/", filePath);
+        Strings.Append(Settings.packageFileName, filePath);
+        
+        JsonParser.Empty(returnedJSON);
+        
+        PackageResolver.ResolveFile(
+            Settings.host,
+            Settings.port,
+            filePath,
+            keys[i],
+            version,
+            Settings.packageFileName,
+            returnedJSON
+        );
+
+        keyFound := FALSE;
+        IF j >= LEN(moduleNames) THEN 
+            Logger.Log("Out of range in ResolveVersionFiles function in ...");
+        END;
+        ASSERT(j < LEN(moduleNames));
+        
+        FOR k := 0 TO j - 1 DO
+            IF Strings.Match(moduleNames[k], keys[i]) THEN
+                keyFound := TRUE;
             END;
         END;
+        
+
+        IF ~keyFound THEN 
+            COPY(keys[i], moduleNames[j]);
+            COPY(version, moduleVersions[j]);
+            COPY(returnedJSON, moduleJson[j]);
+            INC(j);
+            ResolveVersionFiles(returnedJSON);
+        END;
     END;
-END Resolve;
+END ResolveVersionFiles;
+
+PROCEDURE ResolvePackages*();
+VAR
+    i, j: LONGINT;
+    keyFound: BOOLEAN;
+    jsonRecord, filesRecord: JsonParser.JsonTypePointer;
+    values: ARRAY ArrayMaxNumber OF JsonParser.TString;
+    host, port, path, packageName, version: JsonParser.TString;
+BEGIN
+    FOR i := 0 TO j - 1 DO
+        IF ~Strings.Match(moduleNames[i], "") THEN
+            jsonRecord := JsonParser.Create(moduleJson[i]);
+            filesRecord := jsonRecord.GetNonTerminal(jsonRecord, "Files");
+            
+            IF filesRecord = NIL THEN 
+                Logger.Log("Error: no files section found");
+            END;
+            
+            ASSERT(filesRecord # NIL);
+            keyFound := jsonRecord.GetTerminal(jsonRecord, "Remote", host);
+            keyFound := jsonRecord.GetTerminal(jsonRecord, "Port", port);
+            keyFound := jsonRecord.GetTerminal(jsonRecord, "Path", path);
+            keyFound := jsonRecord.GetTerminal(jsonRecord, "Package", packageName);
+            keyFound := jsonRecord.GetTerminal(jsonRecord, "Version", version);
+            filesRecord.GetTerminalValues(filesRecord, values);
+            PackageResolver.Resolve(host, port, path, packageName, version, values);
+        END;
+    END;
+END ResolvePackages;
 
 END DependencyResolver.

JsonParser.Mod

@@ -1,13 +1,13 @@
 MODULE JsonParser;
-IMPORT Logger, CharacterStack, Strings, Out, strutils;
+IMPORT Logger, CharacterStack, Strings, Out, strutils, Settings;
 CONST
     ArrayMaxNumber = 30;
-    ArrayMaxNumberChar = 10000;
+    ArrayMaxNumberChar = 1000;
     (* Const *)
     symbolBracketStart = "{";
     symbolBracketEnd = "}";
     (* TODO: Reverse " and ' *)
-    quote = "'";
+    quote = Settings.quote;
     coma = ",";
 TYPE
     TString* = ARRAY ArrayMaxNumberChar OF CHAR;
@@ -20,13 +20,18 @@ TYPE
         HasKey* : PROCEDURE(self : JsonTypePointer; key : ARRAY OF CHAR): BOOLEAN;
         TypeOfTheKey* : PROCEDURE(self : JsonTypePointer; key : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR);
         GetTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
+        GetTerminalValues* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
         GetNoneTerminalKeys* : PROCEDURE(self : JsonTypePointer; VAR destination : ARRAY OF TString);
+        GetTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
+        GetNonTerminalNumber* : PROCEDURE(self : JsonTypePointer): LONGINT;
 
         TerminalKeys : ARRAY ArrayMaxNumber OF TString;
-        TerminalsValues : ARRAY ArrayMaxNumber OF TString;
+        TerminalValues : ARRAY ArrayMaxNumber OF TString;
+        TerminalNumber* : LONGINT;
 
         NonTerminalKeys : ARRAY ArrayMaxNumber OF TString;
         NonTerminalValues : POINTER TO ARRAY OF JsonTypePointer;
+        NonTerminalNumber* : LONGINT;
     END;
     
 VAR
@@ -34,18 +39,24 @@ VAR
     testValue: ARRAY ArrayMaxNumber OF CHAR;
     keyFound: BOOLEAN;
 
+PROCEDURE GetTerminalNumber*(self : JsonTypePointer): LONGINT;
+BEGIN RETURN self.TerminalNumber END GetTerminalNumber;
+
+PROCEDURE GetNonTerminalNumber*(self : JsonTypePointer): LONGINT;
+BEGIN RETURN self.NonTerminalNumber END GetNonTerminalNumber;
+
 PROCEDURE GetNonTerminal(self : JsonTypePointer; key : ARRAY OF CHAR): JsonTypePointer;
 VAR
     i: LONGINT;
 BEGIN
-    FOR i := 0 TO LEN(self.NonTerminalKeys) - 1 DO
+    FOR i := 0 TO self.NonTerminalNumber - 1 DO
         IF Strings.Match(key, self.NonTerminalKeys[i]) THEN RETURN self.NonTerminalValues[i] END;
     END;
 
     RETURN NIL;
 END GetNonTerminal;
 
-PROCEDURE Empty(VAR string: ARRAY OF CHAR);
+PROCEDURE Empty *(VAR string: ARRAY OF CHAR);
 VAR
     i : LONGINT;
 BEGIN
@@ -60,8 +71,9 @@ VAR
     strings: strutils.strings;
     parent, children: ARRAY ArrayMaxNumber OF CHAR;
 BEGIN
-    FOR i := 0 TO LEN(self.TerminalKeys) - 1 DO
+
-        IF Strings.Match(key, self.TerminalKeys[i]) THEN COPY(self.TerminalsValues[i], returnValue); RETURN TRUE END;
+    FOR i := 0 TO self.TerminalNumber DO
+        IF Strings.Match(key, self.TerminalKeys[i]) THEN COPY(self.TerminalValues[i], returnValue); RETURN TRUE END;
     END;
     
     strings := strutils.tokenize(key, '.');
@@ -72,7 +84,7 @@ BEGIN
     
     IF Strings.Length(parent) < 1 THEN RETURN FALSE END;
     
-    noneTerminal := jsonRecord.GetNonTerminal(self, parent);
+    noneTerminal := self.GetNonTerminal(self, parent);
 
     IF noneTerminal = NIL THEN RETURN FALSE END;
     
@@ -92,11 +104,21 @@ PROCEDURE GetTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TSt
 VAR
     i: LONGINT;
 BEGIN
-    FOR i := 0 TO LEN(self.TerminalKeys) - 1 DO
+    FOR i := 0 TO self.TerminalNumber DO
         COPY(self.TerminalKeys[i], destination[i]);
     END;
 END GetTerminalKeys;
 
+PROCEDURE GetTerminalValues(self : JsonTypePointer; VAR destination : ARRAY OF TString);
+VAR
+    i: LONGINT;
+BEGIN
+    FOR i := 0 TO LEN(self.TerminalValues) - 1 DO
+        Empty(destination[i]);
+        COPY(self.TerminalValues[i], destination[i]);
+    END;
+END GetTerminalValues;
+
 PROCEDURE GetNoneTerminalKeys(self : JsonTypePointer; VAR destination : ARRAY OF TString);
 VAR
     i: LONGINT;
@@ -199,9 +221,12 @@ BEGIN
         IF symbol = symbolBracketStart THEN
             (* Logger.Log("End Parsing Json"); *)
         END;
-        
         symbol := text[i];
 
+        (* Logger.LogIntLn(i); *)
+        (* IF i > 508 THEN
+            Logger.Log(text);        
+        END; *)
         (* terminals *)
         IF symbol = quote THEN
             i := PushDownString(text, quote, quote, i, string);
@@ -219,7 +244,7 @@ BEGIN
 
         IF (Strings.Length(key) > 0) & (Strings.Length(val) > 0) THEN
             deQuote(key, self.TerminalKeys[terminalIterator]);
-            deQuote(val, self.TerminalsValues[terminalIterator]);
+            deQuote(val, self.TerminalValues[terminalIterator]);
 
             INC(terminalIterator);
                         
@@ -252,7 +277,10 @@ BEGIN
         
         INC(i);
     UNTIL (i >= LEN(text) - 1) OR (text[i] = 0X);
-
+    
+    self.NonTerminalNumber := noneTerminalIterator;
+    self.TerminalNumber := terminalIterator;
+    
     RETURN self;
 END Create;
 

PackageFileParser.Mod

@@ -7,7 +7,7 @@ IMPORT
     DependencyResolver,
     Settings;
 CONST
-    MAXARRAYNUMBER = 10000;
+    MAXARRAYNUMBER = 1000;
 PROCEDURE install*;
 VAR
     jsonData: ARRAY MAXARRAYNUMBER OF CHAR;
@@ -20,9 +20,9 @@ BEGIN
     ASSERT(success);
     
     Logger.Log("Starting resolving dependencies");
-    Logger.Log(jsonData);
 
-    DependencyResolver.Resolve(jsonData);
+    DependencyResolver.ResolveVersionFiles(jsonData);
+    DependencyResolver.ResolvePackages();
 END install;
 
 BEGIN

PackageResolver.Mod

@@ -1,27 +1,14 @@
 MODULE PackageResolver;
-IMPORT FileManager, http, Strings, Logger, Settings;
+IMPORT FileManager, http, Strings, Logger, Settings, JsonParser;
 
-CONST ArrayMaxNumber = 10000;
+CONST ArrayMaxNumber = 1000;
 
-PROCEDURE *Resolve(remoteURL, port, packageName, version : ARRAY OF CHAR);
+PROCEDURE ResolveFile *(host, port, path, packageName, version, fileName : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR);
-BEGIN
-
-END Resolve;
-
-PROCEDURE ResolveFile *(host, port, packageName, version, fileName : ARRAY OF CHAR; VAR returnValue : ARRAY OF CHAR);
 VAR
-    filePath, localPath: ARRAY ArrayMaxNumber OF CHAR;
+    localPath: ARRAY ArrayMaxNumber OF CHAR;
     isSuccessfull: BOOLEAN;
 BEGIN
-    filePath := "";
+    http.get(host, port, path, returnValue);
-    Strings.Append("/", filePath);
-    Strings.Append(packageName, filePath);
-    Strings.Append("/", filePath);
-    Strings.Append(version, filePath);
-    Strings.Append("/", filePath);
-    Strings.Append(fileName, filePath);
-
-    http.get(host, port, filePath, returnValue);
     http.getClean(returnValue, returnValue);
     isSuccessfull := FileManager.CreateDirectory(packageName, Settings.installPath);
     
@@ -35,5 +22,16 @@ BEGIN
     
 END ResolveFile;
 
+PROCEDURE Resolve *(host, port, path, packageName, version: ARRAY OF CHAR; files: ARRAY OF JsonParser.TString);
+VAR
+    i : LONGINT;
+    returnValue: JsonParser.TString;
+BEGIN
+    FOR i := 0 TO LEN(files) - 1 DO
+        IF ~Strings.Match(files[i], "") THEN
+            ResolveFile(host, port, path, packageName, version, files[i], returnValue);
+        END;
+    END;
+END Resolve;
 
 END PackageResolver.

Settings.Mod

@@ -4,5 +4,5 @@ CONST
     host* = "localhost";
     port* = "80";
     installPath* = "dependencies";
-
+    quote* = '"';
 END Settings.

VersionFile.json

@@ -1,18 +1,17 @@
 {
-    'Package': 'Package-name',
+    "Package": "Package-name",
-    'Author': 'Author Name',
+    "Author": "Ruben",
-    'License':'License name',
+    "License": "License name",
-    'Version': '1.0.0',
+    "Version": "1.0.0",
-    'Remote': 'vishap.oberon.com',
+    "Remote": "vishap.oberon.com",
-    'Port': '80',
+    "Port": "80",
-    'Files': {
+    "Files": {
-     '0': 'File1.Mod',
+        "0": "File1.Mod",
-     '1': 'File2.Mod',
+        "1": "File2.Mod",
-     '2': 'MakeFile'
+        "2": "MakeFile"
     },
-    'Dependencies': {
+    "Dependencies": {
-        'dep1': '1.0.0',
+        "lists": "1.0.0",
-        'dep2': '1.0.0'
+        "diaspora": "1.0.0"
     }
-  }
+}
-  

dependencies/dep1/VersionFile.json

@@ -1,15 +0,0 @@
-{
-  'Package': 'dep1',
-  'Author': 'Author Name',
-  'License':'License name',
-  'Version': '1.0.0',
-  'Remote': 'vishap.oberon.com',
-  'Port': '80',
-  'Files': {
-   '0': 'File1.Mod',
-   '1': 'File2.Mod',
-   '2': 'MakeFile'
-  },
-  'Dependencies': {
-  }
-}

dependencies/dep2/VersionFile.json

@@ -1,16 +0,0 @@
-{
-  'Package': 'dep2',
-  'Author': 'Author Name',
-  'License':'License name',
-  'Version': '1.0.0',
-  'Remote': 'vishap.oberon.com',
-  'Port': '80',
-  'Files': {
-   '0': 'File1.Mod',
-   '1': 'File2.Mod',
-   '2': 'MakeFile'
-  },
-  'Dependencies': {
-	'dep1': '1.0.0'
-  }
-}

http.Mod

@@ -1,8 +1,8 @@
 MODULE http;
 IMPORT Strings, Internet, Logger, Out;
 CONST 
-  MAXARRAYNUMBER = 10000;
+  MAXARRAYNUMBER = 1000;
-  MAXARRAYNUMBEREXTENDED = 1000000;
+  MAXARRAYNUMBEREXTENDED = 10000;
   
 TYPE 
   PSTRING = POINTER TO ARRAY OF CHAR;
@@ -10,6 +10,14 @@ TYPE
 VAR
   buff, buff2: ARRAY MAXARRAYNUMBEREXTENDED OF CHAR;
 
+PROCEDURE Empty *(VAR string: ARRAY OF CHAR);
+VAR
+    i : LONGINT;
+BEGIN
+    FOR i := 0 TO LEN(string) - 1 DO string[i] := 0X END;
+    COPY("", string);
+END Empty;
+
 PROCEDURE getClean *(buff: ARRAY OF CHAR; VAR clean: ARRAY OF CHAR);
 VAR
   i: INTEGER;
@@ -56,7 +64,7 @@ PROCEDURE addHeader(key, val: ARRAY OF CHAR; VAR buff: PSTRING);
 VAR
   header: ARRAY MAXARRAYNUMBER OF CHAR;
 BEGIN
-  COPY("", header);
+  Empty(header);
   Strings.Append(key, header);
   Strings.Append(": ", header);
   Strings.Append(val, header);
@@ -88,7 +96,7 @@ VAR
     endOfLine: ARRAY 3 OF CHAR;
     tmpBuff: ARRAY MAXARRAYNUMBER OF CHAR;
 BEGIN
-    COPY("", buff);
+    Empty( buff);
     httpTail := " HTTP/1.1";
     
     connectionFlag := Internet.Connect(host, port, socket);
@@ -114,6 +122,8 @@ BEGIN
     AppendEOLAndClean("", sendClean);
     connectionFlag := Internet.Write(socket, sendClean^);
     REPEAT 
+      Empty( tmpBuff);
+
       connectionFlag := Internet.Read(socket, tmpBuff);
       Strings.Append(tmpBuff, buff);
       getHeader(buff, "Content-Length", valueContentLengthString);