├── .blade
    └── libs
    │   ├── cocoa
    │       ├── README.md
    │       ├── format.b
    │       ├── html.b
    │       ├── index.b
    │       ├── lexer.b
    │       ├── parser.b
    │       └── tags.b
    │   └── drawdown
    │       ├── .gitattributes
    │       ├── .gitignore
    │       ├── README.md
    │       ├── app
    │           └── index.b
    │       ├── examples
    │           └── example1.b
    │       ├── index.b
    │       └── nyssa.json
├── .gitattributes
├── .github
    └── workflows
    │   └── release.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── app
    ├── commands
    │   ├── account.b
    │   ├── clean.b
    │   ├── doc.b
    │   ├── info.b
    │   ├── init.b
    │   ├── install.b
    │   ├── publish.b
    │   ├── restore.b
    │   ├── serve.b
    │   └── uninstall.b
    ├── config.b
    ├── index.b
    ├── log.b
    ├── options
    │   └── version.b
    ├── package.b
    ├── publisher.b
    ├── server
    │   ├── api.b
    │   ├── db.b
    │   ├── errors.b
    │   ├── index.b
    │   ├── router.b
    │   ├── routes.b
    │   ├── statics.b
    │   ├── template.b
    │   ├── util.b
    │   └── views.b
    ├── setup.b
    └── util.b
├── docs
    ├── cleaning-cache-and-logs.md
    ├── commands.md
    ├── creating-projects.md
    ├── getting-project-info.md
    ├── hosting-a-private-repository.md
    ├── install-and-uninstall-actions.md
    ├── installing-nyssa.md
    ├── managing-dependencies.md
    ├── package-layout.md
    ├── publishers-account.md
    └── publishing-packages.md
├── examples
    └── .gitignore
├── index.b
├── nyssa
├── nyssa-cli.png
├── nyssa.cmd
├── nyssa.json
├── nyssa.png
├── public
    ├── css
    │   ├── bulma.min.css
    │   └── style.css
    ├── images
    │   ├── android-chrome-192x192.png
    │   ├── android-chrome-512x512.png
    │   ├── apple-touch-icon.png
    │   ├── favicon-16x16.png
    │   ├── favicon-32x32.png
    │   ├── favicon.ico
    │   ├── hero-bg-1.png
    │   ├── logo.png
    │   └── svg
    │   │   └── github.svg
    └── site.webmanifest
├── templates
    ├── 404.html
    ├── account.html
    ├── doc.html
    ├── home.html
    ├── inc
    │   ├── footer.html
    │   ├── header.html
    │   ├── logo.html
    │   ├── meta.html
    │   └── search-bar.html
    ├── login.html
    ├── search.html
    └── view.html
└── tests
    └── .gitignore


/.blade/libs/cocoa/README.md:
--------------------------------------------------------------------------------
 1 | # cocoa
 2 | 
 3 | Cocoa is a HTML to Blade object parser and Blade object to HTML converter developed as part of the Nyssa package manager.
 4 | 
 5 | 
 6 | ### Features
 7 | 
 8 | - Preserves whitespace
 9 | - Line, column and index positions information
10 | 
11 | 
12 | ### Usage
13 | 
14 | ```
15 | import cocoa
16 | var asJson = cocoa.decode('<p class="x">Hello <br /></p>')  # convert to blade
17 | echo asJson
18 | echo cocoa.encode(asJson)  # convert to html string
19 | ```
20 | 
21 | ### Edge-cases handled
22 | Cocoaa handles a lot of HTML's edge-cases, like:
23 | 
24 | - Closes unclosed tags `<p><b>...</p>`
25 | - Ignores extra closing tags `<span>...</b></span>`
26 | - Properly handles void tags like `<meta>` and `<img>`
27 | - Properly handles self-closing tags like `<input/>`
28 | - Handles `<!doctype>` and `<-- comments -->`
29 | - Does not parse the contents of `<script>`, `<style>`, and HTML5 `<template>` tags
30 | 
31 | 
32 | ### Decoding line, column and index positions information
33 | 
34 | You can show the line, column and index positions by enabling the `includePositions` option.
35 | 
36 | ```
37 | import cocoa
38 | echo cocoa.decode('<img>', {includePositions: true})
39 | 
40 | /**
41 |  * Output
42 |  * -----------
43 |  * [{type: element, tagName: img, attributes: [], children: [], position: {start: 
44 |  * {index: 0, column: 0, line: 0}, end: {index: 5, column: 5, line: 0}}}]
45 |  */
46 | ```
47 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/format.b:
--------------------------------------------------------------------------------
 1 | import iters
 2 | 
 3 | def splitHead(str, sep) {
 4 |   var idx = str.index_of(sep)
 5 |   if idx == -1 return [str]
 6 |   return [str[0, idx], str[idx + sep.length(),]]
 7 | }
 8 | 
 9 | def unquote(str) {
10 |   var car = str[0]
11 |   var end = str.length() - 1
12 |   var isQuoteStart = car == '"' or car == "'"
13 |   if isQuoteStart and car == str[end] {
14 |     return str[1, end]
15 |   }
16 |   return str
17 | }
18 | 
19 | def format(nodes, options) {
20 |   return iters.map(nodes, | node | {
21 |     var type = node.type
22 |     var outputNode = type == 'element' ? {
23 |         type: type,
24 |         tagName: node.tagName,
25 |         attributes: formatAttributes(node.attributes),
26 |         children: format(node.children, options),
27 |       } : { 
28 |         type: type, 
29 |         content: node.content, 
30 |       }
31 |     if options.get('includePositions', false) {
32 |       outputNode.position = node.position
33 |     }
34 |     return outputNode
35 |   })
36 | }
37 | 
38 | def formatAttributes(attributes) {
39 |   return iters.map(attributes, | attribute | {
40 |     var parts = splitHead(attribute.trim(), '=')
41 |     var key = parts[0]
42 |     var value
43 |     if parts.length() > 1 {
44 |       value = is_string(parts[1]) ? unquote(parts[1]) : nil
45 |     }
46 |     return {key: key, value: value}
47 |   })
48 | }
49 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/html.b:
--------------------------------------------------------------------------------
 1 | import iters
 2 | 
 3 | def formatAttributes(attributes) {
 4 |   return iters.reduce(attributes, | attrs, attribute | {
 5 |     if (attribute.value == nil) {
 6 |       return '${attrs} ${attribute.key}'
 7 |     }
 8 |     # var quoteEscape = attribute.value.index_of('\'') != -1
 9 |     # var quote = quoteEscape ? '"' : '\''
10 |     var quote = '"'
11 |     return '${attrs} ${attribute.key}=${quote}${attribute.value}${quote}'
12 |   }, '')
13 | }
14 | 
15 | def html(tree, options) {
16 |   var res = ''
17 |   for node in tree {
18 |     if is_list(node) {
19 |       res += html(node, options)
20 |     } else  if (node.type == 'text') {
21 |       res += node.content
22 |     } else if (node.type == 'comment') {
23 |       res += '<!--${node.content}-->'
24 |     } else  {  
25 |     var isSelfClosing = options.voidTags.contains(node.tagName.lower())
26 |     res += isSelfClosing ? '<${node.tagName}${formatAttributes(node.attributes)}>' : 
27 |       '<${node.tagName}${formatAttributes(node.attributes)}>${html(node.children, options)}</${node.tagName}>'
28 |     }
29 |   }
30 |   return res
31 | }
32 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/index.b:
--------------------------------------------------------------------------------
 1 | import .tags { * }
 2 | import .lexer
 3 | import .parser
 4 | import .format
 5 | import .html
 6 | 
 7 | var parseDefaults = {
 8 |   voidTags: voidTags,
 9 |   closingTags: closingTags,
10 |   childlessTags: childlessTags,
11 |   closingTagAncestorBreakers: closingTagAncestorBreakers,
12 |   includePositions: false
13 | }
14 | 
15 | def decode(str, options) {
16 |   # create options
17 |   if !options options = parseDefaults
18 |   else {
19 |     for key, value in parseDefaults {
20 |       if options.get(key, nil) == nil {
21 |         options.set(key, value)
22 |       }
23 |     }
24 |   }
25 |   
26 |   var tokens = lexer(str, options)
27 |   var nodes = parser(tokens, options)
28 |   return format(nodes, options)
29 | }
30 | 
31 | def encode(ast, options) {
32 |   if !options options = parseDefaults
33 |   return html(ast, options)
34 | }
35 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/lexer.b:
--------------------------------------------------------------------------------
  1 | def feedPosition(position, str, len) {
  2 |   var start = position.index
  3 |   var end = position.index = start + len
  4 |   iter var i = start; i < end; i++ {
  5 |     var char = str[i]
  6 |     if char == '\n' {
  7 |       position.line++
  8 |       position.column = 1
  9 |     } else {
 10 |       position.column++
 11 |     }
 12 |   }
 13 | }
 14 | 
 15 | def jumpPosition(position, str, end) {
 16 |   var len = end - position.index
 17 |   return feedPosition(position, str, len)
 18 | }
 19 | 
 20 | def lexer(str, options) {
 21 |   var state = {
 22 |     str: str,
 23 |     options: options,
 24 |     position: {
 25 |       index: 0,
 26 |       column: 1,
 27 |       line: 1
 28 |     },
 29 |     tokens: []
 30 |   }
 31 |   lex(state)
 32 |   return state.tokens
 33 | }
 34 | 
 35 | def lex(state) {
 36 |   var len = state.str.length()
 37 |   while state.position.index < len {
 38 |     var start = state.position.index
 39 |     lexText(state)
 40 |     if state.position.index == start {
 41 |       var isComment = state.str.index_of('!--', start + 1) > -1
 42 |       if isComment {
 43 |         lexComment(state)
 44 |       } else {
 45 |         var tagName = lexTag(state)
 46 |         if state.get('childlessTags', []).contains(tagName.lower()) {
 47 |           lexSkipTag(tagName, state)
 48 |         }
 49 |       }
 50 |     }
 51 |   }
 52 | }
 53 | 
 54 | var alphanumeric = '/[A-Za-z0-9]/'
 55 | 
 56 | def findTextEnd(str, index) {
 57 |   while true {
 58 |     var textEnd = str.index_of('<', index)
 59 |     if textEnd == -1 {
 60 |       return textEnd
 61 |     }
 62 |     var char = str[textEnd + 1]
 63 |     if char == '/' or char == '!' or char.match(alphanumeric) {
 64 |       return textEnd
 65 |     }
 66 |     index = textEnd + 1
 67 |   }
 68 | }
 69 | 
 70 | def lexText(state) {
 71 |   var type = 'text'
 72 |   var textEnd = findTextEnd(state.str, state.position.index)
 73 |   if textEnd == state.position.index return
 74 |   if textEnd == -1 {
 75 |     textEnd = state.str.length()
 76 |   }
 77 | 
 78 |   var start = state.position.clone()
 79 |   var content = state.str[state.position.index, textEnd]
 80 |   jumpPosition(state.position, state.str, textEnd)
 81 |   var end = state.position.clone()
 82 |   state.tokens.append({
 83 |     type: type, 
 84 |     content: content, 
 85 |     position: {
 86 |       start: start, 
 87 |       end: end,
 88 |     }
 89 |   })
 90 | }
 91 | 
 92 | def lexComment(state) {
 93 |   var start = state.position.clone()
 94 |   feedPosition(state.position, state.str, 4) # "<!--".length()
 95 | 
 96 |   var contentEnd = state.str.index_of('-->', state.position.index)
 97 |   var commentEnd = contentEnd + 3 # "-->".length()
 98 |   if contentEnd == -1 {
 99 |     contentEnd = commentEnd = state.str.length()
100 |   }
101 | 
102 |   var content = state.str[state.position.index, contentEnd]
103 |   jumpPosition(state.position, state.str, commentEnd)
104 |   state.tokens.append({
105 |     type: 'comment',
106 |     content: content,
107 |     position: {
108 |       start: start,
109 |       end: state.position.clone()
110 |     }
111 |   })
112 | }
113 | 
114 | def lexTag(state) {
115 |   {
116 |     var secondChar = state.str[state.position.index + 1]
117 |     var close = secondChar == '/'
118 |     var start = state.position.clone()
119 |     feedPosition(state.position, state.str, close ? 2 : 1)
120 |     state.tokens.append({
121 |       type: 'tag-start', 
122 |       close: close, 
123 |       position: {
124 |         start: start,
125 |       }
126 |     })
127 |   }
128 | 
129 |   var tagName = lexTagName(state)
130 |   lexTagAttributes(state)
131 | 
132 |   {
133 |     var firstChar = state.str[state.position.index]
134 |     var close = firstChar == '/'
135 |     feedPosition(state.position, state.str, close ? 2 : 1)
136 |     var end = state.position.clone()
137 |     state.tokens.append({
138 |       type: 'tag-end', 
139 |       close: close, 
140 |       position: {
141 |         end: end,
142 |       }
143 |     })
144 |   }
145 | 
146 |   return tagName
147 | }
148 | 
149 | # See https:#developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-white-space
150 | var whitespace = '/\s/'
151 | 
152 | def isWhitespaceChar(char) {
153 |   return char.match(whitespace)
154 | }
155 | 
156 | def lexTagName(state) {
157 |   var len = state.str.length()
158 |   var start = state.position.index
159 |   while start < len {
160 |     var char = state.str[start]
161 |     var isTagChar = !(isWhitespaceChar(char) or char == '/' or char == '>')
162 |     if isTagChar break
163 |     start++
164 |   }
165 | 
166 |   var end = start + 1
167 |   while end < len {
168 |     var char = state.str[end]
169 |     var isTagChar = !(isWhitespaceChar(char) or char == '/' or char == '>')
170 |     if !isTagChar break
171 |     end++
172 |   }
173 | 
174 |   jumpPosition(state.position, state.str, end)
175 |   var tagName = state.str[start, end]
176 |   state.tokens.append({
177 |     type: 'tag',
178 |     content: tagName
179 |   })
180 |   return tagName
181 | }
182 | 
183 | def lexTagAttributes(state) {
184 |   var cursor = state.position.index
185 |   var quote = nil # nil, single-, or double-quote
186 |   var wordBegin = cursor # index of word start
187 |   var words = [] # "key", "key=value", "key='value'", etc
188 |   var len = state.str.length()
189 |   while cursor < len {
190 |     var char = state.str[cursor]
191 |     if quote {
192 |       var isQuoteEnd = char == quote
193 |       if isQuoteEnd {
194 |         quote = nil
195 |       }
196 |       cursor++
197 |       continue
198 |     }
199 | 
200 |     var isTagEnd = char == '/' or char == '>'
201 |     if isTagEnd {
202 |       if cursor != wordBegin {
203 |         words.append(state.str[wordBegin, cursor])
204 |       }
205 |       break
206 |     }
207 | 
208 |     var isWordEnd = isWhitespaceChar(char)
209 |     if isWordEnd {
210 |       if cursor != wordBegin {
211 |         words.append(state.str[wordBegin, cursor])
212 |       }
213 |       wordBegin = cursor + 1
214 |       cursor++
215 |       continue
216 |     }
217 | 
218 |     var isQuoteStart = char == '\'' or char == '"'
219 |     if isQuoteStart {
220 |       quote = char
221 |       cursor++
222 |       continue
223 |     }
224 | 
225 |     cursor++
226 |   }
227 |   jumpPosition(state.position, state.str, cursor)
228 | 
229 |   var wLen = words.length()
230 |   var type = 'attribute'
231 |   iter var i = 0; i < wLen; i++ {
232 |     var word = words[i]
233 |     var isNotPair = word.index_of('=') == -1
234 |     if isNotPair and words.length() > i + 1 {
235 |       var secondWord = words[i + 1]
236 |       if secondWord and secondWord.index_of('=') > -1 {
237 |         if secondWord.length() > 1 {
238 |           var newWord = word + secondWord
239 |           state.tokens.append({type: type, content: newWord})
240 |           i += 1
241 |           continue
242 |         }
243 |         var thirdWord = words[i + 2]
244 |         i += 1
245 |         if thirdWord {
246 |           var newWord = word + '=' + thirdWord
247 |           state.tokens.append({type: type, content: newWord})
248 |           i += 1
249 |           continue
250 |         }
251 |       }
252 |     }
253 |     if word.ends_with('=') {
254 |       var secondWord = words[i + 1]
255 |       if secondWord and secondWord.index_of('=') > -1 {
256 |         var newWord = word + secondWord
257 |         state.tokens.append({type: type, content: newWord})
258 |         i += 1
259 |         continue
260 |       }
261 | 
262 |       var newWord = word[0, -1]
263 |       state.tokens.append({type: type, content: newWord})
264 |       continue
265 |     }
266 | 
267 |     state.tokens.append({type: type, content: word})
268 |   }
269 | }
270 | 
271 | def lexSkipTag(tagName, state) {
272 |   var safeTagName = tagName.lower()
273 |   var len = state.str.length()
274 |   var index = state.position.index
275 |   while index < len {
276 |     var nextTag = state.str.index_of('</', index)
277 |     if nextTag == -1 {
278 |       lexText(state)
279 |       break
280 |     }
281 | 
282 |     var tagStartPosition = state.position.clone()
283 |     jumpPosition(tagStartPosition, state.str, nextTag)
284 |     var tagState = {
285 |       str: state.str, 
286 |       position: tagStartPosition, 
287 |       tokens: [],
288 |     }
289 |     var name = lexTag(tagState)
290 |     if safeTagName != name.lower() {
291 |       index = tagState.position.index
292 |       continue
293 |     }
294 | 
295 |     if nextTag != state.position.index {
296 |       var textStart = state.position.clone()
297 |       jumpPosition(state.position, state.str, nextTag)
298 |       state.tokens.append({
299 |         type: 'text',
300 |         content: state.str[textStart.index, nextTag],
301 |         position: {
302 |           start: textStart,
303 |           end: state.position.clone(),
304 |         }
305 |       })
306 |     }
307 | 
308 |     state.tokens.extend(tagState.tokens)
309 |     # state.tokens.append(tagState.tokens)
310 |     jumpPosition(state.position, state.str, tagState.position.index)
311 |     break
312 |   }
313 | }
314 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/parser.b:
--------------------------------------------------------------------------------
  1 | def parser(tokens, options) {
  2 |   var root = {
  3 |     tagName: nil, 
  4 |     children: [],
  5 |   }
  6 |   var state = {
  7 |     tokens: tokens, 
  8 |     options: options, 
  9 |     cursor: 0,
 10 |     stack: [
 11 |       root
 12 |     ],
 13 |   }
 14 |   parse(state)
 15 |   return root.children
 16 | }
 17 | 
 18 | def hasTerminalParent(tagName, stack, terminals) {
 19 |   var tagParents = terminals.get(tagName, nil)
 20 |   if tagParents {
 21 |     var currentIndex = stack.length() - 1
 22 |     while currentIndex >= 0 {
 23 |       var parentTagName = stack[currentIndex].tagName
 24 |       if parentTagName == tagName {
 25 |         break
 26 |       }
 27 |       if tagParents.contains(parentTagName) {
 28 |         return true
 29 |       }
 30 |       currentIndex--
 31 |     }
 32 |   }
 33 |   return false
 34 | }
 35 | 
 36 | def rewindStack(stack, newLength, childrenEndPosition, endPosition) {
 37 |   stack[newLength].position.end = endPosition
 38 |   var len = stack.length()
 39 |   iter var i = newLength + 1; i < len; i++ {
 40 |     stack[i].position.end = childrenEndPosition
 41 |   }
 42 |   stack[newLength,]
 43 | }
 44 | 
 45 | def parse(state) {
 46 |   var nodes = state.stack[state.stack.length() - 1].children
 47 |   var len = state.tokens.length()
 48 |   while state.cursor < len {
 49 |     var token = state.tokens[state.cursor]
 50 |     if token.type != 'tag-start' {
 51 |       nodes.append(token)
 52 |       state.cursor++
 53 |       continue
 54 |     }
 55 | 
 56 |     var tagToken = state.tokens[state.cursor++]
 57 |     state.cursor++
 58 |     var tagName = tagToken.content.lower()
 59 |     if token.close {
 60 |       var index = state.stack.length()
 61 |       var shouldRewind = false
 62 |       while index-- > -1 {
 63 |         if state.stack[index].tagName == tagName {
 64 |           shouldRewind = true
 65 |           break
 66 |         }
 67 |       }
 68 |       while state.cursor < len {
 69 |         var endToken = state.tokens[state.cursor]
 70 |         if endToken.type != 'tag-end' break
 71 |         state.cursor++
 72 |       }
 73 |       if shouldRewind {
 74 |         rewindStack(state.stack, index, token.position.start, state.tokens[state.cursor - 1].position.end)
 75 |         break
 76 |       } else {
 77 |         continue
 78 |       }
 79 |     }
 80 | 
 81 |     var isClosingTag = state.options.closingTags.contains(tagName.lower())
 82 |     var shouldRewindToAutoClose = isClosingTag
 83 |     if shouldRewindToAutoClose {
 84 |       var terminals = state.options.get('closingTagAncestorBreakers')
 85 |       shouldRewindToAutoClose = !hasTerminalParent(tagName.lower(), state.stack, terminals)
 86 |     }
 87 | 
 88 |     if shouldRewindToAutoClose {
 89 |       # rewind the stack to just above the previous
 90 |       # closing tag of the same name
 91 |       var currentIndex = state.stack.length() - 1
 92 |       while currentIndex > 0 {
 93 |         if tagName == state.stack[currentIndex].tagName {
 94 |           rewindStack(state.stack, currentIndex, token.position.start, token.position.start)
 95 |           var previousIndex = currentIndex - 1
 96 |           nodes = state.stack[previousIndex].children
 97 |           break
 98 |         }
 99 |         currentIndex = currentIndex - 1
100 |       }
101 |     }
102 | 
103 |     var attributes = []
104 |     var attrToken
105 |     while state.cursor < len {
106 |       attrToken = state.tokens[state.cursor]
107 |       if attrToken.type == 'tag-end' break
108 |       attributes.append(attrToken.content)
109 |       state.cursor++
110 |     }
111 | 
112 |     state.cursor++
113 |     var children = []
114 |     var position = {
115 |       start: token.position.start,
116 |       end: attrToken.position.end
117 |     }
118 |     var elementNode = {
119 |       type: 'element',
120 |       tagName: tagToken.content,
121 |       attributes: attributes,
122 |       children: children,
123 |       position: position,
124 |     }
125 |     nodes.append(elementNode)
126 | 
127 |     var hasChildren = !(attrToken.close or state.options.voidTags.contains(tagName.lower()))
128 |     if hasChildren {
129 |       var size = state.stack.append({
130 |         tagName: tagName, 
131 |         children: children, 
132 |         position: position,
133 |       })
134 |       var innerState = {
135 |         tokens: state.tokens, 
136 |         options: state.options, 
137 |         cursor: state.cursor, 
138 |         stack: state.stack,
139 |       }
140 |       parse(innerState)
141 |       state.cursor = innerState.cursor
142 |       var rewoundInElement = state.stack.length() == size
143 |       if rewoundInElement {
144 |         elementNode.position.end = state.tokens[state.cursor - 1].position.end
145 |       }
146 |     }
147 |   }
148 | }
149 | 


--------------------------------------------------------------------------------
/.blade/libs/cocoa/tags.b:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Tags which contain arbitary non-parsed content
 3 |  * For example: <script> JavaScript should not be parsed
 4 |  */
 5 | var childlessTags = ['style', 'script', 'template']
 6 | 
 7 | /**
 8 |  * Tags which auto-close because they cannot be nested
 9 |  * For example: <p>Outer<p>Inner is <p>Outer</p><p>Inner</p>
10 |  */
11 | var closingTags = [
12 |   'html', 'head', 'body', 'dt', 'dd', 'li', 'option',
13 |   'thead', 'th', 'tbody', 'tr', 'td', 'tfoot', 'colgroup'
14 | ]
15 | 
16 | /**
17 |  * Closing tags which have ancestor tags which may exist within 
18 |  * them which prevent the closing tag from auto-closing.
19 |  * For example: in <li><ul><li></ul></li>, the top-level <li> 
20 |  * should not auto-close.
21 |  */
22 | var closingTagAncestorBreakers = {
23 |   li: ['ul', 'ol', 'menu'],
24 |   dt: ['dl'],
25 |   dd: ['dl'],
26 |   tbody: ['table'],
27 |   thead: ['table'],
28 |   tfoot: ['table'],
29 |   tr: ['table'],
30 |   td: ['table']
31 | }
32 | 
33 | /**
34 |  * Tags which do not need the closing tag
35 |  * For example: <img> does not need </img>
36 |  */
37 | var voidTags = [
38 |   '!doctype', 'area', 'base', 'br', 'col', 'command',
39 |   'embed', 'hr', 'img', 'input', 'keygen', 'link',
40 |   'meta', 'param', 'source', 'track', 'wbr'
41 | ]
42 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/.gitattributes:
--------------------------------------------------------------------------------
1 | *.b linguist-detectable
2 | *.b linguist-language=Blade
3 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/.gitignore:
--------------------------------------------------------------------------------
 1 | # blade packages directory and files
 2 | .blade/
 3 | *.nyp
 4 | 
 5 | # popular editors
 6 | .vscode/
 7 | .idea/
 8 | .vs/
 9 | 
10 | # c object files (for C extensions)
11 | *.o
12 | *.ko
13 | *.obj
14 | *.elf
15 | 
16 | # log files
17 | *.log
18 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/README.md:
--------------------------------------------------------------------------------
 1 | # drawdown
 2 | 
 3 | Drawdown is a Markdown to HTML converter based on the [drawdown](https://github.com/adamvleggett/drawdown)  JavaScript library.
 4 | 
 5 | ### Supported Features
 6 | 
 7 | - Block quotes
 8 | - Code blocks
 9 | - Links
10 | - Images
11 | - Headings
12 | - Lists (including lettered lists)
13 | - Bold
14 | - Italic
15 | - Strikethrough
16 | - Monospace
17 | - Subscript
18 | - Horizontal rule
19 | - Tables
20 | - Automatic linking
21 | 
22 | ### Unsupported Features
23 | 
24 | - Line blocks
25 | - Definition lists
26 | - Footnotes
27 | - Twitter/Facebook/YouTube embed
28 | - Inline math equations
29 | 
30 | ### Installation
31 | 
32 | You can install this package via the [Nyssa Package Manager](https://nyssa.bladelang.com) with the following command.
33 | 
34 | ```
35 | nyssa install drawdown
36 | ```
37 | 
38 | ### Usage
39 | 
40 | ```
41 | import drawdown
42 | echo drawdown.markdown('# heading')
43 | ```
44 | 
45 | The above will output: `<h1>heading</h1>`.
46 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/app/index.b:
--------------------------------------------------------------------------------
  1 | import iters
  2 | 
  3 | var rx_lt = '/</'
  4 | var rx_gt = '/>/'
  5 | var rx_space = '/\\t|\\r|\uf8ff/u'
  6 | var rx_escape = '/\\\\([\\\\\|`*_{}\[\]()#+\-~])/'
  7 | var rx_hr = '/^([*\-=_] *){3,}$/m'
  8 | var rx_blockquote = '/\\n *&gt; *((.|\\n)*?)(?=(\\n|$){2})/'
  9 | var rx_list = '/\\n( *)(?:[*\-+]|((\d+)|([a-z])|[A-Z])[.)]) +((.|\\n)*?)(?=(\\n|$){2})/'
 10 | var rx_listjoin = '/<\/(ol|ul)>\\n\\n<\1>/'
 11 | var rx_highlight = '/(^|[^A-Za-z\d\\\\])(([*_])|(~)|(\^)|(--)|(\+\+)|`)(\2?)([^<]*?)\2\8(?!\2)(?=\W|_|$)/s'
 12 | var rx_code = '/\\n(((```|~~~).*\\n?((.|\\n)*?)\\n?\\3)|((    .*?\\n)+))/'
 13 | var rx_link = '/((!?)\[(.*?)\]\((.*?)( ".*")?\)|\\\\([\\`*_{}\[\]()#+\-.!~]))/'
 14 | var rx_table = '/\\n(( *\|.*?\| *\\n)+)/'
 15 | var rx_thead = '/^.*\\n( *\|( *\:?-+\:?-+\:? *\|)* *\\n|)/'
 16 | var rx_row = '/.*\\n/'
 17 | var rx_cell = '/\||(.*?[^\\\\])\|/'
 18 | var rx_heading = '/(?=^|>|\\n)([>\s]*?)(#{1,6}) (.*?)( #*)? *(?=\\n|$)/'
 19 | var rx_para = '/(?=^|>|\\n)\s*\\n+([^<]+?)\\n+\s*(?=\\n|<|$)/'
 20 | var rx_stash = '/-\d+\uf8ff/u'
 21 | var rx_weblink = '/((?<!href=")https?:\/\/[^\s\<]+)/'
 22 | var rx_email = '/[0-9a-zA-Z_+]+([-.]{0,1}[0-9a-zA-Z_+])*@([0-9a-zA-Z_]+[-.]+)+[0-9a-zA-Z_]{2,9}/'
 23 | 
 24 | def draw_replace(str, pattern, fn) {
 25 |   var matches = str.matches(pattern)
 26 |   if matches {
 27 |     var str_dup = str[,], index = 0, mc_len = matches[0].length()
 28 | 
 29 |     # align consecutive result sizes
 30 |     iter var i = 1; i < matches.length(); i++ {
 31 |       if matches[i].length() < mc_len {
 32 |         for j in 0..(mc_len - matches[i].length()) {
 33 |           matches[i].insert('', 0)
 34 |         }
 35 |       }
 36 |     }
 37 | 
 38 |     var last_index = -1
 39 |     iter var i = 0; i < mc_len; i++ {
 40 |       var replacement = ''
 41 |       index = str_dup.index_of(matches[0][i], index)
 42 |       if last_index == index {
 43 |         index = str_dup.index_of(matches[0][i], index++)
 44 |       }
 45 |       last_index = index
 46 |       using matches.length() {
 47 |         when 1 replacement = fn(mc_len > i ? matches[0][i] : '', index)
 48 |         when 2 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', index)
 49 |         when 3 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', str)
 50 |         when 4 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', str)
 51 |         when 5 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', str)
 52 |         when 6 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', str)
 53 |         when 7 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', str)
 54 |         when 8 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', matches[7].length() > i ? matches[7][i] : '', str)
 55 |         when 9 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', matches[7].length() > i ? matches[7][i] : '', matches[8].length() > i ? matches[8][i] : '', str)
 56 |         when 10 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', matches[7].length() > i ? matches[7][i] : '', matches[8].length() > i ? matches[8][i] : '', matches[9].length() > i ? matches[9][i] : '', str)
 57 |         when 11 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', matches[7].length() > i ? matches[7][i] : '', matches[8].length() > i ? matches[8][i] : '', matches[9].length() > i ? matches[9][i] : '', matches[10].length() > i ? matches[10][i] : '', str)
 58 |         when 12 replacement = fn(mc_len > i ? matches[0][i] : '', matches[1].length() > i ? matches[1][i] : '', matches[2].length() > i ? matches[2][i] : '', matches[3].length() > i ? matches[3][i] : '', matches[4].length() > i ? matches[4][i] : '', matches[5].length() > i ? matches[5][i] : '', matches[6].length() > i ? matches[6][i] : '', matches[7].length() > i ? matches[7][i] : '', matches[8].length() > i ? matches[8][i] : '', matches[9].length() > i ? matches[9][i] : '', matches[10].length() > i ? matches[10][i] : '', matches[11].length() > i ? matches[11][i] : '', str)
 59 |       }
 60 | 
 61 |       str = str.replace(matches[0][i], replacement, false)
 62 |     }
 63 |   }
 64 |   return str
 65 | }
 66 | 
 67 | def to36(num) {
 68 |   var r = ord(num.upper())
 69 |   if r >= 48 and r <= 57 return r - 48
 70 |   else if r >= 65 and r <= 90 return r - 55
 71 |   return 0/0  # return NaN
 72 | }
 73 | 
 74 | def markdown(src) {
 75 | 
 76 |   def replace(rex, fn) {
 77 |     if is_string(fn) {
 78 |       src = src.replace(rex, fn)
 79 |     } else {
 80 |       src = draw_replace(src, rex, fn)
 81 |     }
 82 |   }
 83 | 
 84 |   def element(tag, content) {
 85 |     return '<' + tag + '>' + content + '</' + tag + '>'
 86 |   }
 87 | 
 88 |   def highlight(src) {
 89 |     return draw_replace(src, rx_highlight, |all, _, p1, emp, sub, sup, small, big, p2, content, _1| {
 90 |       var type = emp ? (p2 ? 'strong' : 'em')
 91 |       : sub ? (p2 ? 's' : 'sub')
 92 |       : sup ? 'sup'
 93 |       : small ? 'small'
 94 |       : big ? 'big'
 95 |       : 'code'
 96 | 
 97 |       # handle cases such as:
 98 |       # ```sh
 99 |       # some command
100 |       # ```
101 |       # which will leave things like:
102 |       # sh
103 |       #   some command
104 |       # in the content
105 |       if type == 'code' and content.index_of('\n') > -1 {
106 |         content = '\n'.join(content.split('\n')[1,]).replace('/`+$/D', '')
107 |       }
108 | 
109 |       return _ + element(type, highlight(content))
110 |     })
111 |   }
112 | 
113 |   def blockquote(src) {
114 |     return draw_replace(src, rx_blockquote, |all, content, _1, _2, _3| {
115 |       return element('blockquote', blockquote(highlight(content.replace('/^ *&gt; */sm', ''))))
116 |     })
117 |   }
118 | 
119 |   def list(src) {
120 |     return draw_replace(src, rx_list, |all, ind, ol, num, low, content, _, _1, _2| {
121 |       var entry = element('li', highlight('</li><li>'.join(iters.map(content.split(
122 |         '/\\n ?${ind}(?:(?:\d+|[a-zA-Z])[.)]|[*\-+]) +/'
123 |       ), list))))
124 |       
125 |       return '\n' + (ol ? ('<ol start="' + (num ? 
126 |           ol + '">' : 
127 |           to36(ol) - 9 + '" style="list-style-type:' + (low ? 'low' : 'upp') + 'er-alpha">') + entry + '</ol>')
128 |         : element('ul', entry))
129 |     })
130 |   }
131 | 
132 |   def unesc(str) {
133 |     # echo str
134 |     return str.replace(rx_escape, '$1')
135 |   }
136 | 
137 |   var stash = {}
138 |   var si = 0
139 | 
140 |   src = '\n' + src + '\n'
141 | 
142 |   src = src.replace(rx_lt, '&lt;')
143 |   src = src.replace(rx_gt, '&gt;')
144 |   replace(rx_space, '  ')
145 | 
146 |   # code
147 |   replace(rx_code, |all, p0, p1, p2, p3, p4, _, _1, _2| {
148 |     stash[si--] = element('pre', element('code', (p3 or p4).replace('/^    /', '')))
149 |     return si + '\uf8ff'
150 |   })
151 | 
152 |   # blockquote
153 |   src = blockquote(src)
154 | 
155 |   # horizontal rule
156 |   src = src.replace(rx_hr, '<hr/>')
157 | 
158 |   # list
159 |   src = list(src)
160 |   replace(rx_listjoin, '')
161 | 
162 |   # link or image
163 |   replace(rx_link, |all, p1, p2, p3, p4, p5, p6| {
164 |     stash[si--] = p4 ? (p2 ? 
165 |       '<img src="' + p4 + '" alt="' + p3 + '"/>' : 
166 |       '<a href="' + p4 + '">' + unesc(highlight(p3)) + '</a>') : 
167 |       p6
168 |     return si + '\uf8ff'
169 |   });
170 | 
171 |   # table
172 |   replace(rx_table, |all, table, _, _1| {
173 |     var sep = table.match(rx_thead)[1]
174 |     return '\n' + element('table',
175 |       draw_replace(table, rx_row, |row, ri| {
176 |         return row == sep ? '' : element('tr', draw_replace(row, rx_cell, |all, cell, ci| {
177 |           return ci > 0 ? element(sep and ri == 0 ? 'th' : 'td', unesc(highlight(cell or ''))) : '|'
178 |         }))
179 |       })
180 |     )
181 |   })
182 |   # table fix
183 |   src = src.replace('<tr>|<td>', '<tr><td>', false)
184 |   src = src.replace('<tr>|<th>', '<tr><th>', false)
185 | 
186 |   # heading
187 |   replace(rx_heading, |all, _, p1, p2, _2| {
188 |     return _ + element('h' + p1.length(), unesc(highlight(p2))) 
189 |   })
190 | 
191 |   # paragraph
192 |   replace(rx_para, |all, content, _| {
193 |     return element('p', unesc(highlight(content))) 
194 |   })
195 | 
196 |   # stash
197 |   replace(rx_stash, |all, _| {  
198 |     # echo (all)
199 |     return stash[to_int(to_number(all))] 
200 |   })
201 | 
202 |   # autolinks
203 |   src = src.replace(rx_weblink, '<a href="$0" target="_blank">$0</a>')
204 |   src = src.replace(rx_email, '<a href="mailto:$0">$0</a>')
205 | 
206 |   return src.trim()
207 | }
208 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/examples/example1.b:
--------------------------------------------------------------------------------
1 | import drawdown
2 | echo drawdown.markdown('# heading')
3 | 


--------------------------------------------------------------------------------
/.blade/libs/drawdown/index.b:
--------------------------------------------------------------------------------
1 | import .app { * }


--------------------------------------------------------------------------------
/.blade/libs/drawdown/nyssa.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "drawdown", 
 3 |   "version": "1.0.1", 
 4 |   "description": "A Markdown to HTML converter.", 
 5 |   "homepage": "https://github.com/mcfriend99/drawdown", 
 6 |   "tags": [
 7 |     "markdown", 
 8 |     "html", 
 9 |     "converter"
10 |   ], 
11 |   "author": "Richard Ore <eqliqandfriends@gmail.com>", 
12 |   "license": "ISC", 
13 |   "sources": [
14 |     "https://nyssa.bladelang.com"
15 |   ], 
16 |   "deps": {}
17 | }


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | *.b linguist-detectable
2 | *.b linguist-language=Blade
3 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Create new Nyssa release
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - 'v*.*.*'
 7 | 
 8 | jobs:
 9 |   build:
10 |     runs-on: ubuntu-20.04
11 |     steps:
12 |       - uses: actions/checkout@v2
13 |       - name: Create ZIP Archive
14 |         run: |
15 |           rm -rf .github
16 |           zip -r9 --symlinks nyssa.zip .
17 |       - name: Generate Artifact
18 |         uses: actions/upload-artifact@v2
19 |         with:
20 |           name: default
21 |           path: nyssa.zip
22 | 
23 |   release:
24 |     name: Create Github Release
25 |     needs: [build]
26 |     runs-on: ubuntu-20.04
27 |     steps:
28 |       - name: Create Release
29 |         id: create_release
30 |         uses: ncipollo/release-action@v1
31 |         with:
32 |           token: ${{ secrets.GITHUB_TOKEN }}
33 |           tag: ${{ github.ref_name }}
34 |           name: ${{ github.ref_name }}
35 |           commit: ${{ github.sha }}
36 |           draft: false
37 |           prerelease: false
38 | 
39 |   publish:
40 |     needs: [release]
41 |     runs-on: ubuntu-20.04
42 |     steps:
43 |       - name: Fetch artifacts
44 |         uses: actions/download-artifact@v1
45 |         with:
46 |           name: default
47 |           path: ./default
48 |       - name: Get release
49 |         id: get_release_info
50 |         uses: leahlundqvist/get-release@v1.3.1
51 |         env:
52 |           GITHUB_TOKEN: ${{ github.token }}
53 |         with:
54 |           tag_name: ${{ github.ref_name }}
55 |       - name: Upload Release Asset
56 |         id: upload-release-asset
57 |         uses: actions/upload-release-asset@v1.0.1
58 |         env:
59 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
60 |         with:
61 |           upload_url: ${{ steps.get_release_info.outputs.upload_url }}
62 |           asset_path: default/nyssa.zip
63 |           asset_name: nyssa-${{ github.ref_name }}.zip
64 |           asset_content_type: application/zip
65 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # blade packages directory and files
 2 | *.nyp
 3 | 
 4 | # popular editors
 5 | .vscode/
 6 | .idea/
 7 | .vs/
 8 | 
 9 | # c object files (for C extensions)
10 | *.o
11 | *.ko
12 | *.obj
13 | *.elf
14 | 
15 | # log files
16 | *.log
17 | 
18 | # nyssa custom
19 | *.DS_Store
20 | storage/
21 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 | 
3 | *TODO*


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Blade Programming Language
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/blade-lang/nyssa/blob/master/LICENSE)
 2 | [![Coverage Status](https://coveralls.io/repos/github/blade-lang/nyssa/badge.svg?branch=main)](https://coveralls.io/github/blade-lang/nyssa?branch=main)
 3 | [![Version](https://img.shields.io/badge/version-0.1.4-green)](https://github.com/blade-lang/nyssa)
 4 | 
 5 | # Nyssa
 6 | 
 7 | Nyssa is the official package manager for the Blade programming language. It is also a self-hostable repository server that allows you to easily manage and distribute packages for your Blade projects.
 8 | 
 9 | #### The CLI
10 | 
11 | ![Nyssa CLI](https://raw.githubusercontent.com/blade-lang/nyssa/main/nyssa-cli.png)
12 | 
13 | #### The browsable repository website.
14 | 
15 | ![Nyssa Repository](https://raw.githubusercontent.com/blade-lang/nyssa/main/nyssa.png)
16 | 
17 | 
18 | ## Features
19 | 
20 | - [x] Create packages.
21 | - [x] Manage application dependencies 
22 |   - [x] Install package
23 |   - [x] Uninstall package
24 |   - [x] Update (Install without specifying a version)
25 |   - [x] Restore package
26 |   - [x] Publish package
27 | - [x] Built-in hostable repository server.
28 | - [x] Publish package to public and private repositories.
29 | - [x] Nyssa repository server public API.
30 | - [x] Nyssa repository server searchable frontend website.
31 | - [x] Manage publisher accounts.
32 |   - [x] Create publisher account
33 |   - [x] Login to publisher account
34 |   - [x] Logout from publisher account
35 | - [x] Custom Post-Installation script support.
36 | - [x] Custom Pre-Uninstallation script support.
37 | - [ ] Generate application/library documentation.
38 | 
39 | 
40 | ## Installation
41 | 
42 | - Clone the repository to the desired host directory using the command below:
43 |   
44 |   ```sh
45 |   git clone https://github.com/blade-lang/nyssa.git
46 |   ```
47 | 
48 | - Add the full path to `nyssa` to path (steps depend on operating system).
49 | 
50 | 
51 | ## Documentation
52 | 
53 | To read the documentation, see the [Getting started](https://nyssa.bladelang.com/docs) guide on the website.
54 | 
55 | 
56 | ## Contributing
57 | 
58 | We welcome contributions from the community. Please see the [CONTRIBUTING.md](./CONTRIBUTING.md) file for more information on how you can help.
59 | 
60 | 
61 | ## License
62 | 
63 | Nyssa is released under the [MIT license](./LICENSE).
64 | 


--------------------------------------------------------------------------------
/app/commands/account.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import io
  3 | import os
  4 | import http
  5 | import json
  6 | import ..setup
  7 | import ..log
  8 | 
  9 | # read the state file
 10 | var state_file = os.join_paths(os.args[1], setup.STATE_FILE)
 11 | var state = json.decode(file(state_file).read().trim() or '{}')
 12 | if !is_dict(state) state = {}
 13 | 
 14 | def parse(parser) {
 15 |   parser.add_command(
 16 |     'account', 
 17 |     'Manages a Nyssa publisher account',
 18 |     {
 19 |       type: args.CHOICE,
 20 |       # choices: ['create', 'login', 'logout'],
 21 |       choices: {
 22 |         create: 'creates a new publisher account',
 23 |         login: 'login to a publisher account',
 24 |         logout: 'log out of a publisher account',
 25 |       }
 26 |     }
 27 |   ).add_option(
 28 |     'repo', 
 29 |     'the repo where the account is located', 
 30 |     {
 31 |       short_name: 'r',
 32 |       type: args.OPTIONAL,
 33 |     }
 34 |   )
 35 | }
 36 | 
 37 | def create(repo, success, error) {
 38 |   # warn about account overwrite
 39 |   if state.get('name', nil) and state.get('key', nil) {
 40 |     var name = state['name']
 41 |     echo 'Account "${name}" currently logged in. If you continue, ${name} will be logged out.'
 42 |     if !['y', 'Y'].contains(io.readline('Do you want to continue? [y/N]').trim())
 43 |       return
 44 |   }
 45 | 
 46 |   var details = {
 47 |     name: io.readline('username:').trim(),
 48 |     email: io.readline('email:').trim(),
 49 |     password: io.readline('password:', true).trim(),
 50 |   }
 51 |   echo '' # because password prompt won't go to a new line.
 52 | 
 53 |   try {
 54 |     log.info('Creating new publisher account at ${repo}.')
 55 |     var res = http.post('${repo}/api/create-publisher', details)
 56 |     var body = json.decode(res.body.to_string())
 57 | 
 58 |     if res.status == 200 {
 59 | 
 60 |       # update the state
 61 |       state['name'] = details.name
 62 |       state['email'] = details.email
 63 |       state['key'] = body.key
 64 |       file(state_file, 'w').write(json.encode(state, false))
 65 | 
 66 |       success(
 67 |         'Account created successfully!\n' +
 68 |         'Publisher Key: ${body.key}',
 69 |         'Save your key somewhere safe cause you\'ll need it to recover '+
 70 |         'your account if you ever forget your password.'
 71 |       )
 72 |     } else {
 73 |       error('Account creation failed:\n  ${body.error}')
 74 |     }
 75 |   } catch Exception e {
 76 |     error('Account creation failed:\n  ${e.message}')
 77 |   }
 78 | }
 79 | 
 80 | def login(repo, success, error) {
 81 |   # warn about account overwrite
 82 |   if state.get('name', nil) and state.get('key', nil) {
 83 |     var name = state['name']
 84 |     echo 'Account "${name}" currently logged in. If you continue, ${name} will be logged out.'
 85 |     if !['y', 'Y'].contains(io.readline('Do you want to continue? [y/N]').trim())
 86 |       return
 87 |   }
 88 | 
 89 |   var details = {
 90 |     username: io.readline('username:').trim(),
 91 |     password: io.readline('password:', true).trim(),
 92 |   }
 93 |   echo '' # because password prompt won't go to a new line.
 94 | 
 95 |   try {
 96 |     log.info('Login in to publisher account at ${repo}.')
 97 |     var res = http.post('${repo}/api/login', details)
 98 |     var body = json.decode(res.body.to_string())
 99 | 
100 |     if res.status == 200 {
101 | 
102 |       # update the state
103 |       state['name'] = body.username
104 |       state['email'] = body.email
105 |       state['key'] = body.key
106 |       
107 |       file(state_file, 'w').write(json.encode(state, false))
108 |       success(
109 |         'Logged in as ${body.username} successfully!\n' +
110 |         'Publisher Key: ${body.key}'
111 |       )
112 |     } else {
113 |       error('Login failed:\n  ${body.error}')
114 |     }
115 |   } catch Exception e {
116 |     error('Login failed:\n  ${e.message}')
117 |   }
118 | }
119 | 
120 | def logout(repo, success, error) {
121 |   if state.get('name', nil)
122 |     state.remove('name')
123 |   if state.get('key', nil)
124 |     state.remove('key')
125 | 
126 |   try {
127 |     if file(state_file, 'w').write(json.encode(state, false))
128 |       success('Logged out of publisher account!')
129 |   } catch Exception e {
130 |     error('Login failed:\n  ${e.message}')
131 |   }
132 | }
133 | 
134 | def run(value, options, success, error) {
135 |   var repo = options.get('repo', setup.DEFAULT_REPOSITORY)
136 | 
137 |   using value {
138 |     when 'login' login(repo, success, error)
139 |     when 'create' create(repo, success, error)
140 |     when 'logout' logout(repo, success, error)
141 |   }
142 | }
143 | 


--------------------------------------------------------------------------------
/app/commands/clean.b:
--------------------------------------------------------------------------------
 1 | import args
 2 | import os
 3 | import ..setup
 4 | import ..log
 5 | 
 6 | def parse(parser) {
 7 |   parser.add_command(
 8 |     'clean', 
 9 |     'Clear Nyssa storage'
10 |   ).add_option(
11 |     'cache',
12 |     'clean packages cache',
13 |     {
14 |       short_name: 'c'
15 |     }
16 |   ).add_option(
17 |     'logs',
18 |     'clean logs',
19 |     {
20 |       short_name: 'l'
21 |     }
22 |   ).add_option(
23 |     'all',
24 |     'clean everything',
25 |     {
26 |       short_name: 'a'
27 |     }
28 |   )
29 | }
30 | 
31 | def run(value, options, success, error) {
32 |   var is_logs = options.get('logs', false),
33 |       is_cache = options.get('cache', false),
34 |       is_all = options.get('all', false)
35 | 
36 |   if !is_logs and !is_all and !is_cache is_all = true
37 | 
38 |   if is_logs or is_all {
39 |     log.info('Cleaning logs...', true)
40 |     os.remove_dir(os.join_paths(os.args[1], setup.LOGS_DIR), true)
41 |     log.init()
42 |   }
43 |   if is_cache or is_all {
44 |     log.info('Cleaning cache...', true)
45 |     os.remove_dir(os.join_paths(os.args[1], setup.CACHE_DIR), true)
46 |     os.create_dir(os.join_paths(os.args[1], setup.CACHE_DIR))
47 |   }
48 | 
49 |   var cleaned = (is_logs and is_cache) or is_all ? (
50 |     'log and cache'
51 |   ) : (
52 |     is_logs ? 'logs' : 'cache'
53 |   )
54 | 
55 |   success('Nyssa ${cleaned} cleaned successfully!')
56 | }
57 | 


--------------------------------------------------------------------------------
/app/commands/doc.b:
--------------------------------------------------------------------------------
 1 | import args
 2 | 
 3 | def parse(parser) {
 4 |   parser.add_command(
 5 |     'doc', 
 6 |     'Generates documentation for the current project'
 7 |   )
 8 | }
 9 | 
10 | def run(value, options, success, error) {
11 |   
12 | }
13 | 


--------------------------------------------------------------------------------
/app/commands/info.b:
--------------------------------------------------------------------------------
 1 | import args
 2 | import hash
 3 | import os
 4 | import colors
 5 | import http
 6 | import json
 7 | import io
 8 | import zip
 9 | import ..setup
10 | import ..log
11 | import ..config { Config }
12 | 
13 | var config_file = os.join_paths(os.cwd(), setup.CONFIG_FILE)
14 | 
15 | def italic(t) {
16 |   return colors.text(t, colors.style.italic)
17 | }
18 | 
19 | def empty() {
20 |   return italic('  None')
21 | }
22 | 
23 | def bold(t) {
24 |   return colors.text('${t} ', colors.style.bold)
25 | }
26 | 
27 | def green(t) {
28 |   return colors.text(t, colors.text_color.green)
29 | }
30 | 
31 | def title(t) {
32 |   return green(bold(t)) + '\n' + green('~' * t.length())
33 | }
34 | 
35 | def info(n, m) {
36 |   if m != nil return bold(' • ${n}:') + (m ? m : italic('None'))
37 |   return ' • ${n}'
38 | }
39 | 
40 | def parse(parser) {
41 |   parser.add_command(
42 |     'info', 
43 |     'Shows current project information'
44 |   )
45 | }
46 | 
47 | def run(value, options, success, error) {
48 |   if !file(config_file).exists() 
49 |     error('Not in a Nyssa project')
50 |   
51 |   var config = json.decode(file(config_file).read())
52 |   if !is_dict(config) or !config.get('name', nil) or !config.get('version', nil)
53 |     error('Not in a Nyssa project')
54 | 
55 |   config = Config.from_dict(config)
56 | 
57 |   try {
58 |     echo ''
59 |       echo title('PACKAGE INFORMATION')
60 |       echo info('Name', config.name)
61 |       echo info('Version', config.version)
62 |       echo info('Description', config.description)
63 |       echo info('Homepage', config.homepage)
64 |       echo info('Author', config.author)
65 |       echo info('License', config.license)
66 |       echo info('Tags', ', '.join(config.tags))
67 |       echo ''
68 |       echo title('DEPENDENCIES')
69 |       if config.deps {
70 |         for name, version in config.deps {
71 |           echo info(name, version)
72 |         }
73 |       } else {
74 |         echo empty()
75 |       }
76 |       echo ''
77 |       echo title('SOURCES')
78 |       if config.sources {
79 |         for source in config.sources {
80 |           echo info(source)
81 |         }
82 |       } else {
83 |         echo empty()
84 |       }
85 |       echo ''
86 |   } catch Exception e {
87 |     error('Failed to retrieve package information for ${value}:\n  ${e.message}')
88 |   }
89 | }
90 | 


--------------------------------------------------------------------------------
/app/commands/init.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import os
  3 | import io
  4 | import iters
  5 | import colors
  6 | import json
  7 | import ..config {
  8 |   Config
  9 | }
 10 | import ..setup
 11 | import ..log
 12 | 
 13 | def parse(parser) {
 14 |   parser.add_command(
 15 |     'init', 
 16 |     'Creates a new package in current directory'
 17 |   ).add_option(
 18 |     'name', 
 19 |     'the name of the package', 
 20 |     {
 21 |       short_name: 'n',
 22 |       type: args.OPTIONAL,
 23 |     }
 24 |   )
 25 | }
 26 | 
 27 | def run(value, options, success, error) {
 28 | 
 29 |   # Declare locations.
 30 |   var here = os.cwd(),
 31 |       test_dir = os.join_paths(here, setup.TEST_DIR),
 32 |       ex_dir = os.join_paths(here, setup.EXAMPLES_DIR),
 33 |       app_dir = os.join_paths(here, setup.APP_DIR)
 34 |   var test_ignore = test_dir + os.path_separator + '.gitignore',
 35 |       ex_ignore = ex_dir + os.path_separator + '.gitignore',
 36 |       index = here + os.path_separator + setup.INDEX_FILE,
 37 |       app_index = app_dir + os.path_separator + setup.INDEX_FILE,
 38 |       readme = here + os.path_separator + setup.README_FILE,
 39 |       config_file = here + os.path_separator + setup.CONFIG_FILE,
 40 |       attr_file = here + os.path_separator + '.gitattributes',
 41 |       ignore_file = here + os.path_separator + '.gitignore'
 42 | 
 43 |   var test_config_file = file(config_file)
 44 |   if test_config_file.exists() and test_config_file.read().trim().length() > 0 {
 45 |     error('Cannot create new package where one exists.')
 46 |     return
 47 |   }
 48 | 
 49 |   var config = get_package_config()
 50 |   config.sources = [setup.DEFAULT_REPOSITORY]
 51 | 
 52 |   if !config.name {
 53 |     error('Package must specify a name.')
 54 |   }
 55 | 
 56 |   log.info('Initializing package ${config.name}')
 57 |   log.info('Creating directories')
 58 | 
 59 |   # Create tests and examples directory
 60 |   if !os.dir_exists(test_dir) os.create_dir(test_dir)
 61 |   if !os.dir_exists(ex_dir) os.create_dir(ex_dir)
 62 | 
 63 |   # Create .gitignore files in tests and examples directory for 
 64 |   # git compartibility.
 65 |   log.info('Creating required git files')
 66 |   var tf = file(test_ignore, 'w+')
 67 |   tf.open(); tf.close()
 68 |   var ef = file(ex_ignore, 'w+')
 69 |   ef.open(); ef.close()
 70 | 
 71 |   # increase Blade visibility by setting the attribute file properties
 72 |   # to allow Github identify it as a Blade project.
 73 |   var test_attr_file = file(attr_file)
 74 |   var attr_content_test = '/\\*\\.b linguist\\-language=Blade/'
 75 |   if !test_attr_file.exists() or !test_attr_file.read().match(attr_content_test) {
 76 |     var start_line = test_attr_file.exists() ? '\n' : ''
 77 |     file(attr_file, 'w+').write(
 78 |       start_line +
 79 |       '*.b linguist-detectable\n' +
 80 |       '*.b linguist-language=Blade\n'
 81 |     )
 82 |   }
 83 | 
 84 |   # create default gitignore file to disable popular editor extensions
 85 |   # and the .blade directory.
 86 |   # 
 87 |   # this will only happen if the file does not exist or does not contain 
 88 |   # the blade default ignore definitions.
 89 |   var test_ingore_file = file(ignore_file)
 90 |   var ignore_start_line = '# blade packages directory and files'
 91 |   if !test_ingore_file.exists() or !test_ingore_file.read().match(
 92 |     '/${ignore_start_line}/'
 93 |   ) {
 94 |     log.info('Initializing Gitignore')
 95 | 
 96 |     var start_line = test_ingore_file.exists() ? '\n' : ''
 97 |     file(ignore_file, 'w+').write(
 98 |       start_line +
 99 |       '${ignore_start_line}\n' +
100 |       '.blade/\n' +
101 |       '*.nyp\n' +   # nyssa package object file
102 |       '\n' +
103 |       '# popular editors\n' +
104 |       '.vscode/\n' +
105 |       '.idea/\n' +
106 |       '.vs/\n' +
107 |       '\n' +
108 |       '# c object files (for C extensions)\n' +
109 |       '*.o\n' +
110 |       '*.ko\n' +
111 |       '*.obj\n' +
112 |       '*.elf\n' +
113 |       '\n' +
114 |       '# log files\n' +
115 |       '*.log\n'
116 |     )
117 |   }
118 | 
119 |   # Create the README.md file if one does not exists.
120 |   if !file(readme).exists() {
121 |     log.info('Generating README.md for project')
122 | 
123 |     file(readme, 'w').write(
124 |       '# ${config.name}\n' + 
125 |       '\n' +
126 |       '${config.description or "_Package description goes here._"}\n' +
127 |       '\n' +
128 |       '### Package Information\n' + 
129 |       '\n' + 
130 |       '- **Name:** ${config.name}\n' +
131 |       '- **Version:** ${config.version}\n' +
132 |       '- **Homepage:** ${config.homepage or "_Homepage goes here._"}\n' +
133 |       '- **Tags:** ${", ".join(config.tags) or "_Tags goes here._"}\n' +
134 |       '- **Author:** ${config.author or "_Author info goes here._"}\n' +
135 |       '- **License:** ${config.license or "_License name or link goes here._"}\n' +
136 |       '\n'
137 |     )
138 |   } else {
139 |     log.info('Existing README.md. Skipping')
140 |   }
141 | 
142 |   # Create the nyssa.json file.
143 |   log.info('Generating Nyssa config file')
144 |   file(config_file, 'w').write(json.encode(config, false))
145 | 
146 |   if !os.dir_exists(app_dir) {
147 |     log.info('Creating application directory')
148 |     os.create_dir(app_dir)
149 |   }
150 | 
151 |   # create the app index file
152 |   var app_index_test_file = file(app_index)
153 |   if !app_index_test_file.exists() or !app_index_test_file.read().trim().length() == 0 {
154 |     log.info('Creating application files')
155 |     file(app_index, 'w+').write("echo 'Welcome to Nyssa. Magic begins here!'")
156 |   }
157 | 
158 |   # create the index file
159 |   var index_test_file = file(index)
160 |   if !index_test_file.exists() or index_test_file.read().trim().length() == 0 {
161 |     log.info('Finalizing package initialization')
162 |     file(index, 'w+').write('import .app { * }')
163 |   }
164 | 
165 |   success('Package ${config.name} created!')
166 | }
167 | 
168 | def _default(t) {
169 |   return colors.text(colors.text('(default: ${t})', colors.text_color.dark_grey), colors.style.italic)
170 | }
171 | 
172 | def get_package_config() {
173 |   var default_name = os.base_name(os.cwd())
174 |   return Config.from_dict({
175 |     name: io.readline('package name ${_default(default_name)}:').trim() or default_name,
176 |     version: io.readline('version ${_default("1.0.0")}:').trim() or '1.0.0',
177 |     description: io.readline('description:').trim(),
178 |     homepage: io.readline('homepage:').trim(),
179 |     tags: iters.map(io.readline('tags:').trim().split(','), |x| {
180 |       return x.trim()
181 |     }),
182 |     author: io.readline('author:').trim(),
183 |     license: io.readline('license ${_default("ISC")}:').trim() or 'ISC',
184 |   })
185 | }
186 | 


--------------------------------------------------------------------------------
/app/commands/install.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import hash
  3 | import os
  4 | import colors
  5 | import http
  6 | import json
  7 | import io
  8 | import zip
  9 | import ..setup
 10 | import ..log
 11 | import ..config { Config }
 12 | import ..util { setup_cli }
 13 | 
 14 | 
 15 | var cache_dir = os.join_paths(os.args[1], setup.CACHE_DIR)
 16 | if !os.dir_exists(cache_dir)
 17 |   os.create_dir(cache_dir)
 18 | 
 19 | var config_file = os.join_paths(os.cwd(), setup.CONFIG_FILE)
 20 | 
 21 | def bold(t) {
 22 |   return colors.text('${t} ', colors.style.bold)
 23 | }
 24 | 
 25 | def green(t) {
 26 |   return colors.text(t, colors.text_color.green)
 27 | }
 28 | 
 29 | def parse(parser) {
 30 |   parser.add_command(
 31 |     'install', 
 32 |     'Installs a Blade package', 
 33 |     {
 34 |       type: args.STRING,
 35 |     }
 36 |   ).add_option(
 37 |     'global', 
 38 |     'installs the package globally', 
 39 |     {
 40 |       short_name: 'g',
 41 |     }
 42 |   ).add_option(
 43 |     'use-cache', 
 44 |     'enables the cache', 
 45 |     {
 46 |       short_name: 'c',
 47 |     }
 48 |   ).add_option(
 49 |     'repo', 
 50 |     'the repository to install from', 
 51 |     {
 52 |       short_name: 'r',
 53 |       type: args.OPTIONAL
 54 |     }
 55 |   )
 56 | }
 57 | 
 58 | /**
 59 |  * @DONE:
 60 |  * - Support for running custom setup script on installation.
 61 |  * @TODO: 
 62 |  * - Add support for copying binary files to bin directory.
 63 |  */
 64 | def configure(config, repo, full_name, name, version, path, is_global, with_cache, progress, error) {
 65 |   log.info('Installing ${full_name}')
 66 | 
 67 |   var blade_exe = os.args[0]
 68 | 
 69 |   var destination
 70 |   if !is_global destination = os.join_paths(os.cwd(), '.blade/libs/${name}')
 71 |   else destination = os.join_paths(os.dir_name(blade_exe), 'vendor/${name}')
 72 | 
 73 |   # create the packages directory if not exists
 74 |   log.info('Creating package directory for ${full_name}')
 75 |   if os.dir_exists(destination)
 76 |     os.remove_dir(destination, true)
 77 |   os.create_dir(destination)
 78 | 
 79 |   # extract
 80 |   log.info('Extracting artefact for ${full_name}')
 81 |   if zip.extract(path, destination) {
 82 | 
 83 |     # add to list of installed packages
 84 |     progress.set(name, version)
 85 | 
 86 |     var package_config_file = os.join_paths(destination, setup.CONFIG_FILE)
 87 |     var package_config = Config.from_dict(json.decode(file(package_config_file).read()))
 88 | 
 89 |     # install dependencies before running post-install in case post-install
 90 |     # depends on a dependency.
 91 |     if package_config.deps {
 92 |       echo ''
 93 |       log.info('Fetching dependencies for ${full_name}...')
 94 |       echo '--------------------------${"-" * full_name.length()}---'
 95 | 
 96 |       for dep, ver in package_config.deps {
 97 |         var dep_full_name = ver ? '${dep}@${ver}' : dep
 98 |         if !progress.contains(dep) {
 99 |           install(config, repo, dep_full_name, dep, ver, is_global, with_cache, progress, error)
100 |         }
101 |       }
102 |     }
103 | 
104 |     # run post install script if it exists
105 |     if package_config.post_install {
106 |       log.info('Running post install for ${full_name}')
107 | 
108 |       # cd into the destination before running post_install so 
109 |       # that post_install will run relative to the package.
110 |       var this_dir = os.cwd()
111 |       os.change_dir(destination)
112 | 
113 |       # run the script
114 |       os.exec('${blade_exe} ${package_config.post_install}')
115 | 
116 |       # return to current directory
117 |       os.change_dir(this_dir)
118 |     }
119 | 
120 |     # create cli if required
121 |     if package_config.cli {
122 |       var cli_path = os.join_paths(destination, package_config.cli)
123 |       log.info('Creating CLI for ${name} at ${cli_path}')
124 |       setup_cli(name, destination, cli_path)
125 |     }
126 |   } else {
127 |     error('${name} installation failed:\n  Failed to extract package source')
128 |   }
129 | }
130 | 
131 | def install(config, repo, full_name, name, version, is_global, with_cache, progress, error) {
132 | 
133 |   if with_cache log.info('Checking local cache for ${full_name}')
134 |   var cache_id = hash.sha1(repo + name + version)
135 |   var cache_path = os.join_paths(cache_dir, '${cache_id}.nyp')
136 | 
137 |   try {
138 | 
139 |     # check local cache first to avoid redownloading all the time...
140 |     if file(cache_path).exists() and with_cache {
141 |       configure(config, repo, full_name, name, nil, cache_path, is_global, with_cache, progress, error)
142 |       return
143 |     }
144 | 
145 |     # fresh install
146 |     log.info('>>> Fetching package metadata for ${full_name}')
147 |     var res = http.get('${repo}/api/get-package/${full_name}')
148 |     var body = json.decode(res.body.to_string())
149 | 
150 |     if res.status == 200 {
151 |       if !progress {
152 |         echo ''
153 |         echo green(bold('PACKAGE FOUND'))
154 |         echo green('-------------')
155 |         echo bold('Name:') + body.name
156 |         echo bold('Version:') + body.version
157 |         echo bold('Description:') + body.description
158 |         echo bold('Homepage:') + body.homepage
159 |         echo bold('Author:') + body.author
160 |         echo bold('License:') + body.license
161 |         echo bold('Publisher:') + body.publisher
162 |         echo ''
163 |       } else {
164 |         log.info('${name} dependency ${body.name}@${body.version} found')
165 |       }
166 | 
167 |       # download source
168 |       log.info('Downloading package source for ${full_name}...')
169 |       var download_url = repo + '/source/' + body.source
170 |       var download_req = http.get(download_url)
171 |       if download_req.status == 200 {
172 |         # save the file to cache
173 |         log.info('Caching download for ${full_name}')
174 |         file(cache_path, 'wb').write(download_req.body)
175 | 
176 |         # do package configuration
177 |         configure(config, repo, full_name, body.name, body.version, cache_path, is_global, with_cache, progress, error)
178 |       } else {
179 |         error('package source not found')
180 |       }
181 |     } else {
182 |       error('${full_name} installation failed:\n  ${body.error}')
183 |     }
184 |   } catch Exception e {
185 |     error('${full_name} installation failed:\n  ${e.message}')
186 |   }
187 | }
188 | 
189 | def run(value, options, success, error) {
190 |   var repo = options.get('repo', setup.DEFAULT_REPOSITORY),
191 |       is_global = options.get('global', false),
192 |       with_cache = options.get('use-cache', false),
193 |       progress = {},
194 |       config_exists = file(config_file).exists()
195 | 
196 |   if !config_exists and !is_global
197 |     error('Not in a Nyssa project')
198 |   
199 |   var config
200 |   if !config_exists and is_global {
201 |     config = Config()
202 |   } else {
203 |     config = json.decode(file(config_file).read())
204 |     if !is_dict(config) or !config.get('name', nil) or !config.get('version', nil)
205 |       error('Not in a Nyssa project')
206 |     config = Config.from_dict(config)
207 |   }
208 | 
209 |   var ns = value.split('@'),
210 |       name = ns[0],
211 |       version = ns.length() > 1 ? ns[1] : nil,
212 |       full_name = version ? '${name}@${version}' : name
213 | 
214 |   var config_check = config.deps.get(name, nil)
215 |   if config_check
216 |     if version == nil or config_check == version
217 |       success('${value} is already installed.')
218 | 
219 |   install(config, repo, full_name, name, version, is_global, with_cache, progress, error)
220 | 
221 |   try {
222 |     if progress.length() >= 1 {
223 |       log.info('Updating dependency state for project')
224 | 
225 |       version = progress[name]
226 | 
227 |       if config.deps.contains(name) and version == nil {
228 |         # do nothing...
229 |       } else {
230 |         config.deps[name] = version
231 |       }
232 | 
233 |       # update sources if not already listed
234 |       if !config.sources.contains(repo) {
235 |         config.sources.append(repo)
236 |       }
237 | 
238 |       if config_exists {
239 |         file(config_file, 'w').write(json.encode(config, false))
240 |       }
241 |     }
242 |   } catch Exception e {
243 |     echo colors.text(
244 |       'Dependency state update failed!\n' + 
245 |       'You can manually fix it by adding the following to the dependency section of you ' + setup.CONFIG_FILE + ' file.\n' +
246 |       '\n\t"${name}": ' + (version ? '"${version}"' : "null") +  '\n\n' +
247 |       'If the section is not empty add a comma (,) and press ENTER before adding the fix.\n', 
248 |       colors.text_color.orange
249 |     )
250 |     error(e.message)
251 |   }
252 | 
253 |   success('${full_name} installed successfully!')
254 | }
255 | 


--------------------------------------------------------------------------------
/app/commands/publish.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import os
  3 | import json
  4 | import http
  5 | import colors
  6 | import zip
  7 | import iters
  8 | import ..setup
  9 | import ..log
 10 | import ..config { Config }
 11 | 
 12 | var storage_dir = os.join_paths(os.args[1], setup.STORAGE_DIR)
 13 | 
 14 | def italics(t) {
 15 |   return colors.text(t, colors.style.italic)
 16 | }
 17 | 
 18 | def parse(parser) {
 19 |   parser.add_command(
 20 |     'publish', 
 21 |     'Publishes a repository'
 22 |   ).add_option(
 23 |     'repo', 
 24 |     'repository url', 
 25 |     {
 26 |       short_name: 'r',
 27 |       type: args.OPTIONAL,
 28 |     }
 29 |   )
 30 | }
 31 | 
 32 | def get_files(root) {
 33 |   var result = []
 34 |   if root {
 35 |     for f in os.read_dir(root) {
 36 |       if f != '.' and f != '..' {
 37 |         var path = os.join_paths(root, f)
 38 |         if os.dir_exists(path) {
 39 |           result.extend(get_files(path))
 40 |         } else {
 41 |           result.append(path)
 42 |         }
 43 |       }
 44 |     }
 45 |   }
 46 |   return result
 47 | }
 48 | 
 49 | def copy_to_tmp(root, dest) {
 50 |   var files = iters.filter(get_files(root), |x| {
 51 |     return x != '.' and x != '..' and 
 52 |       !x.match('/(\\/|\\\\)[.]git\\1/')
 53 |   })
 54 | 
 55 |   for f in files {
 56 |     var dir = os.join_paths(dest, os.dir_name(f).ltrim('.'))
 57 |     if !os.dir_exists(dir) os.create_dir(dir)
 58 |     file(f).copy(os.join_paths(dest, f.ltrim('.')))
 59 |   }
 60 | }
 61 | 
 62 | def run(value, options, success, error) {
 63 |   var repo = options.get('repo', setup.DEFAULT_REPOSITORY),
 64 |       state_file = os.join_paths(os.args[1], setup.STATE_FILE),
 65 |       config_file = os.join_paths(os.cwd(), setup.CONFIG_FILE),
 66 |       readme_file = os.join_paths(os.cwd(), setup.README_FILE),
 67 |       tmp_dest
 68 | 
 69 |   try {
 70 |     log.info('Checking for valid publisher account')
 71 |     var state = json.decode(file(state_file).read().trim()  or '{}')
 72 |     if !state.get('name', nil) or !state.get('key', nil)
 73 |       error(
 74 |         'Publisher account not authenticated.\n' + 
 75 |         'Run "nyssa account create" or "nyssa account login" to get started.'
 76 |       )
 77 | 
 78 |     log.info('Checking for valid Nyssa package')
 79 |     var config = Config.from_dict(json.decode(file(config_file).read()))
 80 |     if !config.name or !config.version
 81 |       error('Invalid Nyssa package.')
 82 | 
 83 |     var source_name = '${state.name}_${config.name}_${config.version}.nyp'
 84 |     tmp_dest = os.join_paths(storage_dir, source_name)
 85 | 
 86 |     log.info('Packaging ${config.name}@${config.version}...')
 87 | 
 88 |     # make a backup that has no git.
 89 |     var tmp_root = os.join_paths(storage_dir, '.tmp')
 90 |     copy_to_tmp('.', tmp_root)
 91 |     var curr_dir = os.cwd()
 92 |     os.change_dir(tmp_root)
 93 | 
 94 |     if zip.compress(os.cwd(), tmp_dest) {
 95 |       os.change_dir(curr_dir)
 96 |       os.remove_dir(tmp_root, true)
 97 |       var client = http.HttpClient()
 98 | 
 99 |       # set authentication headers
100 |       log.info('Authenticating')
101 |       client.headers = {
102 |         'Nyssa-Publisher-Name': state.name,
103 |         'Nyssa-Publisher-Key': state.key,
104 |       }
105 | 
106 |       # make the request
107 |       log.info('Uploading ${config.name}@${config.version} to ${repo}...')
108 |       var res = client.send_request('${repo}/api/create-package', 'POST', {
109 |         name: config.name,
110 |         version: config.version,
111 |         config: json.encode(config),
112 |         source: file(tmp_dest),
113 |         readme: file(readme_file).exists() ? file(readme_file).read() : nil,
114 |       })
115 |       var body = json.decode(res.body.to_string())
116 | 
117 |       # delete the package source file
118 |       log.info('Removing temporary files')
119 |       file(tmp_dest).delete()
120 | 
121 |       if res.status == 200 {
122 |         success('Successfully published ${config.name}@${config.version}!')
123 |       } else {
124 |         error('Publish failed for ${config.name}@${config.version}:\n  ${body.error}')
125 |       }
126 |     } else {
127 | 
128 |       file(tmp_dest).delete()
129 |       error('Packaging failure')
130 |     }
131 |   } catch Exception e {
132 |     error(e.message)
133 |   } finally {
134 |     if tmp_dest file(tmp_dest).delete()
135 |   }
136 | }
137 | 


--------------------------------------------------------------------------------
/app/commands/restore.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import hash
  3 | import os
  4 | import colors
  5 | import http
  6 | import json
  7 | import io
  8 | import zip
  9 | import ..setup
 10 | import ..log
 11 | import ..config { Config }
 12 | import ..util { setup_cli }
 13 | 
 14 | 
 15 | var cache_dir = os.join_paths(os.args[1], setup.CACHE_DIR)
 16 | if !os.dir_exists(cache_dir)
 17 |   os.create_dir(cache_dir)
 18 | 
 19 | var config_file = os.join_paths(os.cwd(), setup.CONFIG_FILE)
 20 | 
 21 | def parse(parser) {
 22 |   parser.add_command(
 23 |     'restore', 
 24 |     'Restores all project dependencies'
 25 |   ).add_option(
 26 |     'no-cache', 
 27 |     'disables the cache', 
 28 |     {
 29 |       short_name: 'x',
 30 |     }
 31 |   )
 32 | }
 33 | 
 34 | def configure(config, repo, full_name, name, version, path, progress, no_cache, error) {
 35 |   log.info('Installing ${full_name}')
 36 | 
 37 |   var blade_exe = os.args[0],
 38 |       destination = os.join_paths(os.cwd(), '.blade/libs/${name}')
 39 | 
 40 |   # create the packages directory if not exists
 41 |   log.info('Creating package directory for ${full_name}')
 42 |   if os.dir_exists(destination)
 43 |     os.remove_dir(destination, true)
 44 |   os.create_dir(destination)
 45 | 
 46 |   # extract
 47 |   log.info('Extracting artefact for ${full_name}')
 48 |   if zip.extract(path, destination) {
 49 |     # add to list of installed packages
 50 |     progress.set(name, version)
 51 | 
 52 |     var package_config_file = os.join_paths(destination, setup.CONFIG_FILE)
 53 |     var package_config = Config.from_dict(json.decode(file(package_config_file).read()))
 54 | 
 55 |     # restore dependencies before running post-install in case post-install
 56 |     # depends on a dependency.
 57 |     if package_config.deps {
 58 |       echo ''
 59 |       log.info('Fetching dependencies for ${full_name}...')
 60 |       echo '--------------------------${"-" * full_name.length()}---'
 61 | 
 62 |       for dep, ver in package_config.deps {
 63 |         var dep_full_name = ver ? '${dep}@${ver}' : dep
 64 |         if !progress.contains(dep) {
 65 |           install(config, repo, dep_full_name, dep, ver, progress, no_cache, error)
 66 |         }
 67 |       }
 68 |     }
 69 | 
 70 |     # run post install script if it exists
 71 |     if package_config.post_install {
 72 |       log.info('Running post install for ${full_name}')
 73 | 
 74 |       # cd into the destination before running post_install so 
 75 |       # that post_install will run relative to the package.
 76 |       var this_dir = os.cwd()
 77 |       os.change_dir(destination)
 78 | 
 79 |       # run the script
 80 |       os.exec('${blade_exe} ${package_config.post_install}')
 81 | 
 82 |       # return to current directory
 83 |       os.change_dir(this_dir)
 84 |     }
 85 | 
 86 |     # create cli if required
 87 |     if package_config.cli {
 88 |       var cli_path = os.join_paths(destination, package_config.cli)
 89 |       log.info('Creating CLI for ${name} at ${cli_path}')
 90 |       setup_cli(name, destination, cli_path)
 91 |     }
 92 | 
 93 |     return true
 94 |   } else {
 95 |     log.debug('${name} installation failed:\n  Failed to extract package source')
 96 |     return false
 97 |   }
 98 | }
 99 | 
100 | def install(config, repo, full_name, name, version, progress, no_cache, error) {
101 |   if !no_cache log.info('Checking local cache for ${full_name}')
102 |   var cache_id = hash.sha1(repo + name + version)
103 |   var cache_path = os.join_paths(cache_dir, '${cache_id}.nyp')
104 | 
105 |   try {
106 | 
107 |     # check local cache first to avoid redownloading all the time...
108 |     if file(cache_path).exists() and !no_cache {
109 |       return configure(config, repo, full_name, name, nil, cache_path, progress, no_cache, error)
110 |     }
111 | 
112 |     # fresh install
113 |     log.info('>>> Fetching package metadata for ${full_name}')
114 |     var res = http.get('${repo}/api/get-package/${full_name}')
115 |     var body = json.decode(res.body.to_string())
116 | 
117 |     if res.status == 200 {
118 |       log.info('${name} dependency ${body.name}@${body.version} found')
119 | 
120 |       # download source
121 |       log.info('Downloading package source for ${full_name}...')
122 |       var download_url = repo + '/source/' + body.source
123 |       var download_req = http.get(download_url)
124 |       if download_req.status == 200 {
125 |         # save the file to cache
126 |         log.info('Caching download for ${full_name}')
127 |         file(cache_path, 'wb').write(download_req.body)
128 | 
129 |         # do package configuration
130 |         return configure(config, repo, full_name, body.name, body.version, cache_path, progress, no_cache, error)
131 |       } else {
132 |         log.debug('${full_name} source not found at ${repo}')
133 |         return false
134 |       }
135 |     } else {
136 |       log.debug('${full_name} not found at ${repo}')
137 |       return false
138 |     }
139 |   } catch Exception e {
140 |     log.debug('${full_name} installation failed:\n  ${e.message}')
141 |     return false
142 |   }
143 | }
144 | 
145 | def run(value, options, success, error) {
146 |   if !file(config_file).exists() 
147 |     error('Not in a Nyssa project')
148 |   
149 |   var config = json.decode(file(config_file).read())
150 |   if !is_dict(config) or !config.get('name', nil) or !config.get('version', nil)
151 |     error('Not in a Nyssa project')
152 | 
153 |   config = Config.from_dict(config)
154 | 
155 |   if config.deps {
156 |     var progress = {}, 
157 |         not_installed = [],
158 |         no_cache = options.get('no-cache', false)
159 | 
160 |     for name, version in config.deps {
161 |       var full_name = version ? '${name}@${version}' : name
162 | 
163 |       # do installation
164 |       var installed = false
165 |       for repo in config.sources {
166 |         if install(config, repo, full_name, name, version, progress, no_cache, error) {
167 |           installed = true
168 |           break
169 |         }
170 |       }
171 | 
172 |       if !installed not_installed.append(full_name)
173 |     }
174 | 
175 |     if not_installed {
176 |       var error_msg = 'Could not install the following packages:'
177 |       for nn in not_installed {
178 |         error_msg += '\n  - ${nn}'
179 |       }
180 |       error(error_msg)
181 |     }
182 |   }
183 | 
184 |   success('Project ${config.name} dependencies successfully restored!')
185 | }
186 | 


--------------------------------------------------------------------------------
/app/commands/serve.b:
--------------------------------------------------------------------------------
 1 | import args
 2 | import os
 3 | import ..server
 4 | import ..setup
 5 | 
 6 | def parse(parser) {
 7 |   parser.add_command(
 8 |     'serve', 
 9 |     'Starts a local Nyssa repository server'
10 |   ).add_option(
11 |     'port', 
12 |     'port of the server (default: ${setup.REPOSITORY_PORT})', 
13 |     {
14 |       short_name: 'p',
15 |       type: args.OPTIONAL,
16 |     }
17 |   ).add_option(
18 |     'host',
19 |     'the host ip (default: ${setup.REPOSITORY_HOST})',
20 |     {
21 |       short_name: 'n',
22 |       type: args.OPTIONAL,
23 |     }
24 |   )
25 | }
26 | 
27 | def run(value, options, success, error) {
28 |   var port = to_number(options.get('port', setup.REPOSITORY_PORT))
29 |   var host = options.get('host', setup.REPOSITORY_HOST)
30 |   server(host, port)
31 | }
32 | 


--------------------------------------------------------------------------------
/app/commands/uninstall.b:
--------------------------------------------------------------------------------
  1 | import args
  2 | import os
  3 | import json
  4 | import ..setup
  5 | import ..log
  6 | import ..config { Config }
  7 | import ..util { remove_cli }
  8 | 
  9 | var blade_exe = os.args[0]
 10 | var libs_dir = os.join_paths(os.cwd(), '.blade/libs')
 11 | var global_dir = os.join_paths(os.dir_name(os.args[0]), 'vendor')
 12 | 
 13 | def parse(parser) {
 14 |   parser.add_command(
 15 |     'uninstall', 
 16 |     'Uninstalls a Blade package', 
 17 |     {
 18 |       type: args.STRING,
 19 |     }
 20 |   ).add_option(
 21 |     'global', 
 22 |     'package is a global package', 
 23 |     {
 24 |       short_name: 'g',
 25 |     }
 26 |   )
 27 | }
 28 | 
 29 | def run(value, options, success, error) {
 30 |   var is_global = options.get('global', false)
 31 |   var package_not_installed = 'package ${value} not installed.'
 32 |   var wrk_dir = is_global ? global_dir : libs_dir
 33 | 
 34 |   if os.dir_exists(wrk_dir) {
 35 |     var package_dir = os.join_paths(wrk_dir, value),
 36 |         package_config_file = os.join_paths(package_dir, setup.CONFIG_FILE),
 37 |         this_config_file = os.join_paths(os.cwd(), setup.CONFIG_FILE),
 38 |         this_config_exists = file(this_config_file).exists()
 39 | 
 40 |     if !file(this_config_file).exists() and !is_global
 41 |       error('Not in a Nyssa package.')
 42 | 
 43 |     var this_config
 44 |     if !this_config_exists and is_global {
 45 |       this_config = Config()
 46 |     } else {
 47 |       this_config = Config.from_dict(json.decode(file(this_config_file).read()))
 48 |       if !this_config.name or !this_config.version
 49 |         error('Not in a Nyssa package.')
 50 |     }
 51 | 
 52 |     if os.dir_exists(package_dir) {
 53 |       try {
 54 |         var pf = file(package_config_file)
 55 |         if pf.exists() {
 56 |           var package_config = Config.from_dict(json.decode(pf.read()))
 57 |           # run pre uninstall script if it exists
 58 |           if package_config.pre_uninstall {
 59 |             log.info('Running pre uninstall for ${value}...')
 60 | 
 61 |             # cd into the destination before running pre_uninstall so 
 62 |             # that pre_uninstall will run relative to the package.
 63 |             var this_dir = os.cwd()
 64 |             os.change_dir(package_dir)
 65 | 
 66 |             # run the script
 67 |             os.exec('${blade_exe} ${package_config.pre_uninstall}')
 68 | 
 69 |             # return to current directory
 70 |             os.change_dir(this_dir)
 71 |           }
 72 | 
 73 |           if package_config.cli {
 74 |             # remove cli script
 75 |             log.info('Removing CLI for ${value}...')
 76 |             remove_cli(value, package_dir)
 77 |           }
 78 |         }
 79 | 
 80 |         log.info('Uninstalling ${value}...')
 81 |         # uninstall the package
 82 |         os.remove_dir(package_dir, true)
 83 | 
 84 |         # remove dependency from config
 85 |         if this_config.deps and this_config.deps.contains(value)
 86 |           this_config.deps.remove(value)
 87 | 
 88 |         if this_config_exists {
 89 |           file(this_config_file, 'w').write(json.encode(this_config, false))
 90 |         }
 91 | 
 92 |         success('${value} uninstalled successfully!')
 93 |       } catch Exception e {
 94 |         error(e.message)
 95 |       }
 96 |     } else {
 97 |       error(package_not_installed)
 98 |     }
 99 |   } else {
100 |     error(package_not_installed)
101 |   }
102 | }
103 | 


--------------------------------------------------------------------------------
/app/config.b:
--------------------------------------------------------------------------------
 1 | import .setup
 2 | 
 3 | class Config {
 4 |   var name
 5 |   var version
 6 |   var description
 7 |   var homepage
 8 |   var tags = []
 9 |   var author
10 |   var license
11 |   var deps = {}
12 |   var post_install
13 |   var pre_uninstall
14 |   var cli
15 | 
16 |   # list of default sources
17 |   var sources = [
18 |     setup.DEFAULT_REPOSITORY
19 |   ]
20 | 
21 |   static from_dict(dict) {
22 |     var c = Config()
23 | 
24 |     c.name = dict.get('name', nil)
25 |     c.version = dict.get('version', '1.0.0')
26 |     c.description = dict.get('description', nil)
27 |     c.homepage = dict.get('homepage', nil)
28 |     c.tags = dict.get('tags', [])
29 |     c.author = dict.get('author', nil)
30 |     c.license = dict.get('license', 'ISC')
31 |     c.deps = dict.get('deps', {})
32 |     c.post_install = dict.get('post_install', nil)
33 |     c.pre_uninstall = dict.get('pre_uninstall', nil)
34 |     c.cli = dict.get('cli', nil)
35 | 
36 |     return c
37 |   }
38 | 
39 |   @to_json() {
40 |     return {
41 |       name: self.name,
42 |       version: self.version,
43 |       description: self.description,
44 |       homepage: self.homepage,
45 |       tags: self.tags,
46 |       author: self.author,
47 |       license: self.license,
48 |       sources: self.sources,
49 |       deps: self.deps,
50 |       post_install: self.post_install,
51 |       pre_uninstall: self.pre_uninstall,
52 |       cli: self.cli,
53 |     }.compact()
54 |   }
55 | }
56 | 


--------------------------------------------------------------------------------
/app/index.b:
--------------------------------------------------------------------------------
 1 | import args
 2 | import io
 3 | import colors
 4 | import os
 5 | import .setup
 6 | import .log
 7 | 
 8 | # initialize storage directory
 9 | var storage_dir = os.join_paths(os.args[1], setup.STORAGE_DIR)
10 | if !os.dir_exists(storage_dir)
11 |   os.create_dir(storage_dir)
12 | 
13 | # ensure config file exists...
14 | var config_file = os.join_paths(os.args[1], setup.CONFIG_FILE)
15 | if !file(config_file).exists()
16 |   file(config_file, 'w').write('{}')
17 | 
18 | # ensure the state file exists
19 | var state_file = os.join_paths(os.args[1], setup.STATE_FILE)
20 | if !file(state_file).exists()
21 |   file(state_file, 'w').write('{}')
22 | 
23 | # import commands...
24 | import .commands.account
25 | import .commands.clean
26 | import .commands.info
27 | import .commands.init
28 | import .commands.install
29 | import .commands.restore
30 | # import .commands.doc
31 | import .commands.uninstall
32 | # import .commands.update
33 | import .commands.publish
34 | import .commands.serve
35 | 
36 | # Import options...
37 | import .options.version
38 | 
39 | var parser = args.Parser('nyssa', true)
40 | 
41 | var commands = {
42 |   account: account,
43 |   clean: clean,
44 |   # doc: doc,
45 |   info: info,
46 |   init: init,
47 |   install: install,
48 |   publish: publish,
49 |   restore: restore,
50 |   serve: serve,
51 |   uninstall: uninstall,
52 |   # update: update,
53 | }
54 | 
55 | var options = {
56 |   version: version,
57 | }
58 | 
59 | for cmd in commands {
60 |   cmd.parse(parser)
61 | }
62 | for o in options {
63 |   o.parse(parser)
64 | }
65 | 
66 | def success(msg, info) {
67 |   io.stderr.write(colors.text(
68 |     colors.text(log.info(msg, true) + '\n', colors.text_color.green),
69 |     colors.style.bold
70 |   ))
71 |   if info {
72 |     io.stderr.write(colors.text(
73 |       colors.text('\n' + info + '\n', colors.text_color.blue),
74 |       colors.style.italic
75 |     ))
76 |   }
77 |   os.exit(0)
78 | }
79 | 
80 | def error(msg) {
81 |   io.stderr.write(colors.text(log.error(msg, true) + '\n', colors.text_color.red))
82 |   os.exit(1)
83 | }
84 | 
85 | var opts = parser.parse()
86 | 
87 | if opts.options or opts.command {
88 |   var command = opts.command
89 |   opts = opts.options
90 | 
91 |   if command {
92 |     commands[command.name].run(command.value, opts, success, error)
93 |   } else if opts {
94 |     var key = opts.keys()[0]
95 |     options[key].get(opts[key])
96 |   }
97 | }
98 | 


--------------------------------------------------------------------------------
/app/log.b:
--------------------------------------------------------------------------------
 1 | import io
 2 | import date
 3 | import os
 4 | import .setup
 5 | 
 6 | var logs_dir = os.join_paths(os.args[1], setup.LOGS_DIR)
 7 | 
 8 | var _logfile
 9 | def init() {
10 |   if !os.dir_exists(logs_dir)
11 |     os.create_dir(logs_dir)
12 |     
13 |   var time = date.localtime()
14 |   _logfile = file(
15 |     '${logs_dir}/${time.year}-${to_string(time.month).lpad(2,'0')}-${to_string(time.day).lpad(2,'0')}.log',
16 |     'a+'
17 |   )
18 | }
19 | init()
20 | 
21 | def _write(type, mes, no_console) {
22 |   var time = date.localtime()
23 |   var message = '${time.year}-${to_string(time.month).lpad(2,'0')}-${to_string(time.day).lpad(2,'0')} ' + 
24 |                 '${to_string(time.hour).lpad(2,'0')}:${to_string(time.minute).lpad(2,'0')}:${to_string(time.seconds).lpad(2,'0')}' +
25 |                 '.${to_string(time.microseconds).lpad(6,'0')} ${type} ${mes}\n'
26 |   if !no_console print(mes + '\n')
27 |   _logfile.write(message)
28 |   return mes
29 | }
30 | 
31 | def info(message, no_console) {
32 |   return _write('INFO', message, no_console)
33 | }
34 | 
35 | def debug(message, no_console) {
36 |   return _write('DEBUG', message, no_console)
37 | }
38 | 
39 | def warn(message, no_console) {
40 |   return _write('WARN', message, no_console)
41 | }
42 | 
43 | def error(message, no_console) {
44 |   return _write('ERROR', message, no_console)
45 | }
46 | 


--------------------------------------------------------------------------------
/app/options/version.b:
--------------------------------------------------------------------------------
 1 | import os
 2 | import ..setup
 3 | 
 4 | def parse(parser) {
 5 |   parser.add_option(
 6 |     'version', 
 7 |     'Show Nyssa version', 
 8 |     {
 9 |       short_name: 'v'
10 |     }
11 |   )
12 | }
13 | 
14 | def get(value) {
15 |   echo 'Nyssa ${setup.NYSSA_VERSION}'
16 |   echo os.exec('${os.args[0]} -v')
17 | }
18 | 


--------------------------------------------------------------------------------
/app/package.b:
--------------------------------------------------------------------------------
 1 | import date
 2 | import .config
 3 | 
 4 | class Package {
 5 |   var publisher
 6 |   var name
 7 |   var version
 8 |   var source
 9 |   var readme
10 |   var config
11 |   var downloads = 0
12 |   var active = true
13 |   var created_at
14 |   var deleted_at
15 | 
16 |   Package(publisher, name, version, source, config, readme, created_at) {
17 |     self.publisher = publisher
18 |     self.name = name
19 |     self.version = version
20 |     self.source = source
21 |     self.config = config
22 |     self.readme = readme
23 |     self.created_at = created_at ? created_at : date()
24 |   }
25 | 
26 |   static from_dict(dict) {
27 |     var package = Package(dict.publisher, dict.name, dict.version, dict.source, dict.config, dict.readme, dict.get('created_at', date().format('c')))
28 |     package.downloads = dict.get('downloads', 0)
29 |     package.active = dict.get('active', true)
30 |     package.deleted_at = dict.get('deleted_at', nil)
31 |     return package
32 |   }
33 | 
34 |   @to_json() {
35 |     return {
36 |       name: self.name,
37 |       publisher: self.publisher,
38 |       version: self.version,
39 |       source: self.source,
40 |       config: self.config,
41 |       readme: self.readme,
42 |       downloads: self.downloads,
43 |       active: self.active,
44 |       created_at: self.created_at,
45 |       deleted_at: self.deleted_at,
46 |     }
47 |   }
48 | }
49 | 
50 | def package(publisher, name, version, config, readme, source) {
51 |   return Package.from_dict({
52 |     name: name,
53 |     publisher: publisher,
54 |     version: version,
55 |     config: config,
56 |     source: source,
57 |     readme: readme,
58 |   })
59 | }
60 | 


--------------------------------------------------------------------------------
/app/publisher.b:
--------------------------------------------------------------------------------
 1 | import date
 2 | import .config
 3 | 
 4 | class Publisher {
 5 |   var username
 6 |   var email
 7 |   var password
 8 |   var key
 9 |   var active = true
10 |   var created_at
11 |   var deleted_at
12 | 
13 |   Publisher(username, email, password, key, created_at) {
14 |     self.username = username
15 |     self.email = email
16 |     self.password = password
17 |     self.key = key
18 |     self.created_at = created_at ? created_at : date()
19 |   }
20 | 
21 |   static from_dict(dict) {
22 |     var package = Publisher(dict.username, dict.email, dict.password, dict.key, dict.get('created_at', date().format('c')))
23 |     package.active = dict.get('active', true)
24 |     package.deleted_at = dict.get('deleted_at', nil)
25 |     return package
26 |   }
27 | 
28 |   @to_json() {
29 |     return {
30 |       username: self.username,
31 |       email: self.email,
32 |       key: self.key,
33 |       active: self.active,
34 |       created_at: self.created_at,
35 |       deleted_at: self.deleted_at,
36 |     }
37 |   }
38 | }
39 | 
40 | def publisher(username, email, password, key) {
41 |   return Publisher(username, email, password, key)
42 | }
43 | 


--------------------------------------------------------------------------------
/app/server/api.b:
--------------------------------------------------------------------------------
  1 | # API BACKEND
  2 | 
  3 | import hash
  4 | import json
  5 | import bcrypt
  6 | import os
  7 | import http.status
  8 | import .template
  9 | import .db
 10 | import .util
 11 | import .errors
 12 | import ..setup
 13 | import ..log
 14 | import ..package
 15 | import ..publisher
 16 | 
 17 | var uploads_dir = os.join_paths(os.args[1], setup.SOURCES_DIR)
 18 | if !os.dir_exists(uploads_dir)
 19 |   os.create_dir(uploads_dir)
 20 | 
 21 | # API
 22 | def create_publisher(req, res) {
 23 |   /* Expected request format:
 24 |     {
 25 |       "name": string,
 26 |       "email": string,
 27 |       "password": string
 28 |     } */
 29 |   if !req.body or !is_dict(req.body)
 30 |     return res.fail(status.BAD_REQUEST)
 31 | 
 32 |   var name = req.body.get('name', nil),
 33 |       email = req.body.get('email', nil),
 34 |       password = req.body.get('password', nil)
 35 | 
 36 |   if !name or !email or !password
 37 |     return res.fail(status.BAD_REQUEST)
 38 | 
 39 |   # ensure name is in a valid format
 40 |   # 1. publisher name can only contain alphanumeric and underscores
 41 |   # 2. publisher name must start with an alphabeth
 42 |   if !name.match('/^[a-zA-Z][a-zA-Z0-9_]+$/')
 43 |     return res.fail(status.BAD_REQUEST, 'invalid publisher name')
 44 | 
 45 |   # ensure that name is not taken
 46 |   var test = db.get_publisher(name)
 47 |   if test return res.fail(status.CONFLICT, 'publisher already exists')
 48 | 
 49 |   # generate key
 50 |   var key = util.generate_publisher_key(name)
 51 | 
 52 |   log.info('Creating publisher ${name}')
 53 |   var pub = publisher(name, email, bcrypt.hash(password, 5), key)
 54 |   if db.create_publisher(pub) == 0
 55 |     return res.fail(status.SERVICE_UNAVAILABLE, 'something went wrong')
 56 | 
 57 |   return res.json(pub)
 58 | }
 59 | 
 60 | def create_package(req, res) {
 61 |   /* Expected request format:
 62 |     {
 63 |       "name": string,
 64 |       "version": string,
 65 |       "source": file,
 66 |       "config": string,
 67 |       "readme": string
 68 |     } */
 69 |   if !req.body or !is_dict(req.body)
 70 |     return res.fail(status.BAD_REQUEST)
 71 | 
 72 |   var publisher
 73 |   if publisher = util.validate_auth_data(req, res) {
 74 |     var name = req.body.get('name', nil),
 75 |       version = req.body.get('version', nil),
 76 |       config = req.body.get('config', nil),
 77 |       readme = req.body.get('readme', nil),
 78 |       source = req.files.get('source', nil)
 79 | 
 80 |     if !name or !version or !config or !source
 81 |       return res.fail(status.BAD_REQUEST)
 82 | 
 83 |     # disallow creating a package named blade to avoid cli destruction
 84 |     # when doing a global installation.
 85 |     if name.lower() == 'blade'
 86 |       return res.fail(status.BAD_REQUEST)
 87 | 
 88 |     config = json.decode(config)
 89 |     # Verify config first
 90 |     if !is_dict(config) or !config.get('name', nil) or !config.get('version', nil)
 91 |       return res.fail(status.BAD_REQUEST)
 92 |     if config.name != name or config.version != version
 93 |       return res.fail(status.BAD_REQUEST)
 94 | 
 95 |     # then avoid conflicts
 96 |     var test_pkg = db.get_package(name)
 97 |     if test_pkg {
 98 |       # now ensure that another publisher isn't publishing it
 99 |       if test_pkg.publisher != publisher.username
100 |         return res.fail(status.CONFLICT, 'Package ${name} already exists in this repository')
101 | 
102 |       # check if package version already exist
103 |       if db.get_package(name, version)
104 |         return res.fail(status.CONFLICT, 'Package ${name} already published version ${version}')
105 |     }
106 | 
107 |     # write the file next
108 |     var file_name = '${publisher.username}_${name}_${microtime()}.nyp'
109 |     var file_path = os.join_paths(uploads_dir, file_name)
110 |     if !file(file_path, 'wb').write(source.content)
111 |       return res.fail(status.UNPROCESSABLE_ENTITY)  # consider using UNSUPPORTED_MEDIA_TYPE
112 | 
113 |     var pkg = package(publisher.username, name, version, config, readme, file_name)
114 | 
115 |     # then write to db
116 |     if db.create_package(pkg) == 0
117 |       return res.fail(status.SERVICE_UNAVAILABLE, 'something went wrong')
118 | 
119 |     # return the package
120 |     return res.json(pkg)
121 |   }
122 | }
123 | 
124 | def get_package(req, res) {
125 |   var r = req.params.get('name', '').split('@')
126 |   var name = r[0],
127 |       version = r.length() > 1 ? r[1] : nil
128 | 
129 |   if !name return res.fail(status.BAD_REQUEST)
130 | 
131 |   # fetch the package
132 |   var pack = db.get_package(name, version)
133 |   if !pack return res.fail(status.NOT_FOUND)
134 | 
135 |   db.update_package_download_count(pack.name, pack.version)
136 | 
137 |   pack.tags = json.decode(pack.tags)
138 |   pack.deps = json.decode(pack.deps)
139 |   pack.remove('config')
140 | 
141 |   return res.json(pack)
142 | }
143 | 
144 | def all_package(req, res) {
145 |   # fetch all the package
146 |   var packs = db.get_packages()
147 | 
148 |   for pack in packs {
149 |     pack.tags = json.decode(pack.tags)
150 |     pack.deps = json.decode(pack.deps)
151 |     pack.remove('config')
152 |   }
153 | 
154 |   return res.json(packs)
155 | }
156 | 
157 | def login(req, res) {
158 |   /* Expected request format:
159 |   {
160 |     "username": string,
161 |     "password": string
162 |   } */
163 |   if !req.body or !is_dict(req.body)
164 |     return res.fail(status.BAD_REQUEST)
165 | 
166 |   var name = req.body.get('username', nil),
167 |       password = req.body.get('password', nil)
168 | 
169 |   if !name or !password
170 |     return res.fail(status.BAD_REQUEST)
171 | 
172 |   var pub = db.get_publisher(name)
173 | 
174 |   # authenticate
175 |   if !pub or !bcrypt.compare(password, pub.password)
176 |     return res.fail(status.FORBIDDEN)
177 | 
178 | 
179 |   # transform for return to remove the non-returning fields
180 |   pub = publisher.Publisher.from_dict(pub)
181 | 
182 |   return res.json(pub)
183 | }
184 | 


--------------------------------------------------------------------------------
/app/server/db.b:
--------------------------------------------------------------------------------
  1 | import sqlite
  2 | import os
  3 | import json
  4 | import math
  5 | import ..log
  6 | import ..setup
  7 | 
  8 | var db_file = os.join_paths(os.args[1], setup.DATABASE_FILE)
  9 | var db_dir = os.dir_name(db_file)
 10 | 
 11 | if !os.dir_exists(db_dir)
 12 |   os.create_dir(db_dir)
 13 | 
 14 | var db = sqlite.open(db_file)
 15 | 
 16 | def create_tables() {
 17 |   # create the publishers table
 18 |   db.exec('CREATE TABLE IF NOT EXISTS publishers (' +
 19 |       'id INTEGER PRIMARY KEY,' +
 20 |       'username TEXT NOT NULL,' +
 21 |       'email TEXT NOT NULL,' +
 22 |       'password TEXT NOT NULL,' +
 23 |       'key TEXT NOT NULL,' +
 24 |       'active BOOLEAN DEFAULT TRUE,' +
 25 |       'created_at DATETIME DEFAULT CURRENT_TIMESTAMP,' +
 26 |       'deleted_at DATETIME NULL' +
 27 |     ');')
 28 | 
 29 |   # Create the packages table
 30 |   db.exec('CREATE TABLE IF NOT EXISTS packages (' +
 31 |       'id INTEGER PRIMARY KEY,' +
 32 |       'publisher TEXT NOT NULL,' +
 33 |       'name TEXT NOT NULL,' +
 34 |       'version TEXT NOT NULL,' +
 35 |       'source TEXT NOT NULL,' +
 36 |       'config TEXT NOT NULL,' +
 37 |       'readme TEXT NULL,' +
 38 | 
 39 |       # extracted columns start
 40 |       'description TEXT GENERATED ALWAYS AS (json_extract(config, \'$.description\')) VIRTUAL,' +
 41 |       'homepage TEXT GENERATED ALWAYS AS (json_extract(config, \'$.homepage\')) VIRTUAL,' +
 42 |       'author TEXT GENERATED ALWAYS AS (json_extract(config, \'$.author\')) VIRTUAL,' +
 43 |       'license TEXT GENERATED ALWAYS AS (json_extract(config, \'$.license\')) VIRTUAL,' +
 44 |       'tags TEXT GENERATED ALWAYS AS (json_extract(config, \'$.tags\')) VIRTUAL,' +
 45 |       'deps TEXT GENERATED ALWAYS AS (json_extract(config, \'$.deps\')) VIRTUAL,' +
 46 |       # extracted columns end
 47 | 
 48 |       'downloads INTEGER DEFAULT 0,' +
 49 |       'active BOOLEAN DEFAULT TRUE,' +
 50 |       'created_at DATETIME DEFAULT CURRENT_TIMESTAMP,' +
 51 |       'deleted_at DATETIME NULL' +
 52 |     ');')
 53 | 
 54 |     # create the sessions table
 55 |     db.exec('CREATE TABLE IF NOT EXISTS sessions (' +
 56 |         'id INTEGER PRIMARY KEY,' +
 57 |         'key TEXT NOT NULL,' +
 58 |         'data TEXT DEFAULT \'{}\',' +
 59 |         'created_at DATETIME DEFAULT CURRENT_TIMESTAMP' +
 60 |       ');')
 61 | }
 62 | 
 63 | # PUBLISHERS
 64 | 
 65 | def get_publishers() {
 66 |   return db.query('SELECT * FROM publishers;')
 67 | }
 68 | 
 69 | def get_publisher(name, key) {
 70 |   var res
 71 |   if !key {
 72 |     res = db.fetch('SELECT * FROM publishers WHERE username = ? ORDER BY id DESC LIMIT 1;', [name])
 73 |   } else {
 74 |     res = db.fetch('SELECT * FROM publishers WHERE username = ? AND key = ? ORDER BY id DESC LIMIT 1;', [name, key])
 75 |   }
 76 | 
 77 |   if res return res[0]
 78 |   return nil
 79 | }
 80 | 
 81 | def check_publisher(name) {
 82 |   var res = db.fetch('SELECT * FROM publishers WHERE username = ? OR email = ? ORDER BY id DESC LIMIT 1;', [name, name])
 83 | 
 84 |   if res return res[0]
 85 |   return nil
 86 | }
 87 | 
 88 | def create_publisher(publisher) {
 89 |   if db.exec('INSERT INTO publishers (username, email, password, key) VALUES (?, ?, ?, ?);', [
 90 |     publisher.username, 
 91 |     publisher.email,
 92 |     publisher.password,
 93 |     publisher.key
 94 |   ])
 95 |     return db.last_insert_id()
 96 |   return 0
 97 | }
 98 | 
 99 | def delete_publisher(name) {
100 |   return db.exec('DELETE FROM publishers WHERE username = ?;', [name])
101 | }
102 | 
103 | def get_publishers_count() {
104 |   var res = db.fetch('SELECT COUNT(*) as count FROM publishers;')
105 |   if res return res[0].count or 0
106 |   return 0
107 | }
108 | 
109 | # PACKAGES
110 | 
111 | def get_packages() {
112 |   return db.fetch('SELECT * FROM packages WHERE deleted_at IS NULL;')
113 | }
114 | 
115 | def get_top_packages(order) {
116 |   if !order order = 'download DESC'
117 |   return db.fetch("SELECT id, name, publisher, description, sum(downloads) as download, replace(created_at, '-', '/') as date_created FROM packages WHERE deleted_at IS NULL GROUP BY name ORDER BY ${order} LIMIT 4;")
118 | }
119 | 
120 | def get_package(name, version) {
121 |   var res
122 |   if !version {
123 |     res = db.fetch('SELECT * FROM packages WHERE name = ? and deleted_at IS NULL ORDER BY id DESC LIMIT 1;', [name])
124 |   } else {
125 |     res = db.fetch('SELECT * FROM packages WHERE name = ? and version = ? ORDER BY id DESC LIMIT 1;', [name, version])
126 |   }
127 | 
128 |   if res return res[0]
129 |   return nil
130 | }
131 | 
132 | def get_package_for_view(name, version) {
133 |   var res
134 |   if !version {
135 |     res = db.fetch('SELECT * FROM packages WHERE name = ? ORDER BY id DESC LIMIT 1;', [name])
136 |     if res {
137 |       res[0].download = db.fetch('SELECT SUM(downloads) as downloads FROM packages WHERE name = ?', [name])[0].downloads
138 |     }
139 |   } else {
140 |     res = db.fetch('SELECT *, downloads as download FROM packages WHERE name = ? and version = ? ORDER BY id DESC LIMIT 1;', [name, version])
141 |   }
142 | 
143 |   if res return res[0]
144 |   return nil
145 | }
146 | 
147 | def get_package_versions(name) {
148 |   return db.fetch('SELECT id, version FROM packages WHERE name = ? and deleted_at IS NULL ORDER BY id DESC', [name])
149 | }
150 | 
151 | def search_package(query, page, order) {
152 |   if !page page = 1
153 |   if !order order = 'downloads'
154 |   var per_page = setup.PACKAGES_PER_PAGE or 10
155 | 
156 |   var lower_limit = (page - 1) * per_page # 10 per page
157 | 
158 |   var count = db.fetch('SELECT count(*) as count FROM (SELECT * FROM packages WHERE (name LIKE :query OR description LIKE :query OR publisher LIKE :query OR tags LIKE :query) AND deleted_at IS NULL GROUP BY name);', {':query': query})
159 |   if !count count = 0
160 |   else count = count[0].count
161 | 
162 |   var result = db.fetch('SELECT *, sum(downloads) as download FROM (SELECT * FROM packages WHERE (name LIKE :query OR description LIKE :query OR publisher LIKE :query OR tags LIKE :query) AND deleted_at IS NULL ORDER BY id DESC) GROUP BY name ORDER BY ${order} LIMIT ${lower_limit}, ${per_page};', {':query': query})
163 |   var start = per_page * (page -1)
164 | 
165 |   return {
166 |     packages: result,
167 |     page: page,
168 |     pages: math.ceil(count / per_page),
169 |     start: start,
170 |     end: start + result.length(),
171 |     total: count,
172 |   }
173 | }
174 | 
175 | def get_user_packages(username, page) {
176 |   if !page page = 1
177 |   var per_page = setup.PACKAGES_PER_PAGE or 10
178 | 
179 |   var lower_limit = (page - 1) * per_page # 10 per page
180 | 
181 |   var count = db.fetch('SELECT count(*) as count FROM (SELECT * FROM packages WHERE publisher = :username GROUP BY name);', {':username': username})
182 |   if !count count = 0
183 |   else count = count[0].count
184 | 
185 |   var result = db.fetch('SELECT * FROM (SELECT * FROM packages WHERE publisher = :username ORDER BY id DESC) GROUP BY name LIMIT ${lower_limit}, ${per_page};', {':username': username})
186 |   var start = per_page * (page -1)
187 | 
188 |   return {
189 |     packages: result,
190 |     page: page,
191 |     pages: math.ceil(count / per_page),
192 |     start: start,
193 |     end: start + result.length(),
194 |     total: count,
195 |   }
196 | }
197 | 
198 | def create_package(package) {
199 |   if db.exec('INSERT INTO packages (publisher, name, version, source, config, readme) VALUES (?, ?, ?, ?, ?, ?);', [
200 |     package.publisher,
201 |     package.name,
202 |     package.version,
203 |     package.source,
204 |     json.encode(package.config),
205 |     package.readme
206 |   ]) return db.last_insert_id()
207 |   return 0
208 | }
209 | 
210 | def delete_package(name) {
211 |   return db.exec('DELETE FROM packages WHERE name = ?;', [name])
212 | }
213 | 
214 | def update_package_download_count(name, version) {
215 |   return db.exec('UPDATE packages SET downloads = downloads + 1 WHERE name = ? and version = ?;', [name, version])
216 | }
217 | 
218 | def get_all_packages_count() {
219 |   var res = db.fetch('SELECT COUNT(*) as count FROM packages;')
220 |   if res return res[0].count or 0
221 |   return 0
222 | }
223 | 
224 | def get_packages_count() {
225 |   var res = db.fetch('SELECT COUNT(DISTINCT name) as count FROM packages;')
226 |   if res return res[0].count or 0
227 |   return 0
228 | }
229 | 
230 | def get_all_download_count(name) {
231 |   var res
232 |   if name {
233 |     res = db.fetch('SELECT SUM(downloads) as count FROM packages WHERE name = ?', [name])
234 |   } else {
235 |     res = db.fetch('SELECT SUM(downloads) as count FROM packages')
236 |   }
237 |   if res return res[0].count or 0
238 |   return 0
239 | }
240 | 
241 | def revert_package(name, version) {
242 |   return db.exec('UPDATE packages SET deleted_at=CURRENT_TIMESTAMP WHERE name = ? and id > ?;', [name, version])
243 | }
244 | 
245 | def archive_package(name) {
246 |   return db.exec('UPDATE packages SET deleted_at=CURRENT_TIMESTAMP WHERE name = ?;', [name])
247 | }
248 | 
249 | # SESSIONS
250 | 
251 | def get_session(key) {
252 |   var res = db.fetch('SELECT data FROM sessions WHERE key = ? ORDER BY id DESC LIMIT 1;', [key])
253 |   if res return json.decode(res[0].data)
254 |   return false
255 | }
256 | 
257 | def create_session(key) {
258 |   if db.exec('INSERT INTO sessions (key) VALUES (?);', [key])
259 |     return db.last_insert_id()
260 |   return 0
261 | }
262 | 
263 | def update_session(key, value) {
264 |   if db.exec('UPDATE sessions SET data = ? WHERE key = ?;', [value, key])
265 |     return true
266 |   return false
267 | }
268 | 
269 | def delete_session(key) {
270 |   return db.exec('DELETE FROM sessions WHERE key = ?;', [key])
271 | }
272 | 
273 | 
274 | # create tables if not exists...
275 | create_tables()
276 | 


--------------------------------------------------------------------------------
/app/server/errors.b:
--------------------------------------------------------------------------------
 1 | import http.status
 2 | import json
 3 | import .template
 4 | import ..log
 5 | 
 6 | def _error(s, req, res) {
 7 |   res.status = s
 8 |   res.headers['Content-Type'] = 'text/plain'
 9 |   res.write('${s} - ${status.map[s]}')
10 | }
11 | 
12 | def not_found(req, res) {
13 |   res.status = 404
14 |   res.write(template('404', {
15 |     show_login: !res.session.contains('user')
16 |   }))
17 | }
18 | 
19 | def server_error(err, req, res) {
20 |   res.body = bytes(0)
21 |   _error(500, req, res)
22 | 
23 |   var error = 'Error: ${err.message}\nTrace:\n${err.stacktrace}'
24 | 
25 |   log.error(error)
26 | }
27 | 


--------------------------------------------------------------------------------
/app/server/index.b:
--------------------------------------------------------------------------------
 1 | import http
 2 | import .router
 3 | import ..log
 4 | 
 5 | def server(host, port) {
 6 |   
 7 |   var server = http.server(port, host)
 8 |   server.on_receive(router)
 9 |   server.on_error(|err, _| {
10 |     log.error('Error: ${err.message}\nTrace:\n${err.stacktrace}')
11 |   })
12 | 
13 |   var host_name = host == '0.0.0.0' ? 'localhost' : host
14 |   log.info('Nyssa repository server started.') 
15 |   log.info('Repository URL: http://${host_name}:${port}')
16 |   server.listen()
17 | }
18 | 


--------------------------------------------------------------------------------
/app/server/router.b:
--------------------------------------------------------------------------------
  1 | import json
  2 | import hash
  3 | import http.status
  4 | import .errors
  5 | import .db
  6 | import .routes { routes }
  7 | import ..log
  8 | import ..setup
  9 | 
 10 | def _log_request(req, res) {
 11 |   log.info('RepositoryAccess: ${req.ip} - "${req.method} ${req.request_uri} ' +
 12 |       '${req.http_version}" ${res.status} ${res.status < 400 ? res.body.length() : '-'}')
 13 | }
 14 | 
 15 | def _get_uri_route_data(route, path) {
 16 |   var result = {}
 17 | 
 18 |   var name_pattern = '([a-zA-Z_][a-zA-Z0-9_]+)'
 19 |   var regex = route.
 20 |     # * in routes match anything or nothing after.
 21 |     replace('/[*]/', '(.*)').
 22 |     # + in routes match something after.
 23 |     replace('/[+]/', '(.+)').
 24 |     # convert {id} pattern to matching ids for path
 25 |     replace('/\\{${name_pattern}\\}/', '(?P<$1>[^/]+)')
 26 | 
 27 |   var matches = path.matches('~^${regex}$~i')
 28 |   if matches {
 29 |     for k, v in matches {
 30 |       result[k] = v[0]
 31 |     }
 32 |   }
 33 | 
 34 |   return result
 35 | }
 36 | 
 37 | def _start_session() {
 38 |   var key = hash.sha1(to_string(microtime()) + rand(111111111, 999999999))
 39 |   if db.create_session(key) > 0 {
 40 |     return key
 41 |   }
 42 |   return nil
 43 | }
 44 | 
 45 | def _setup_session(req, res) {
 46 |   res.session = {}
 47 |   res.session_key = nil
 48 |   if req.cookies.contains(setup.SESSION_NAME) {
 49 |     res.session_key = req.cookies[setup.SESSION_NAME]
 50 |     var ses = db.get_session(res.session_key)
 51 |     if is_dict(ses) {
 52 |       res.session.extend(ses)
 53 |     } else {
 54 |       res.session_key = _start_session()
 55 |       res.set_cookie(setup.SESSION_NAME, res.session_key)
 56 |     }
 57 |   } else {
 58 |     res.session_key = _start_session()
 59 |     res.set_cookie(setup.SESSION_NAME, res.session_key)
 60 |   }
 61 | 
 62 |   # bind '.clear_session()' to response
 63 |   res.clear_session = || {
 64 |     res.session = {}
 65 | 
 66 |     # just for simplicity
 67 |     return nil
 68 |   }
 69 | }
 70 | 
 71 | def router(req, res) {
 72 |   try {
 73 |     var view = errors.not_found
 74 | 
 75 |     # Check exact matchs first...
 76 |     if routes.contains(req.path) {
 77 |       var data = routes[req.path]
 78 |       if data[0].upper() == req.method.upper()
 79 |         view = data[1]
 80 |     } else {
 81 |       for route, data in routes {
 82 |         var route_data = _get_uri_route_data(route, req.path)
 83 |         if route_data {
 84 |           if data[0].upper() == req.method.upper() {
 85 |             view = data[1]
 86 |             req.params = route_data
 87 |           }
 88 |         }
 89 |       }
 90 |     }
 91 | 
 92 |     # setup session
 93 |     _setup_session(req, res)
 94 | 
 95 |     # bind '.json()' to response
 96 |     res.json = | v | {
 97 |       res.headers['Content-Type'] = 'application/json'
 98 |       res.write(json.encode(v))
 99 | 
100 |       # just for simplicity
101 |       return nil
102 |     }
103 | 
104 |     # bind the '.fail()' to response
105 |     res.fail = | code, v | {
106 |       res.status = code
107 |       res.headers['Content-Type'] = 'application/json'
108 |       if !v v = status.map[code]
109 |       res.json({error: v})
110 | 
111 |       # just for simplicity
112 |       return nil
113 |     }
114 | 
115 |     view(req, res)
116 | 
117 |     # update session
118 |     if res.session_key {
119 |       db.update_session(res.session_key, json.encode(res.session))
120 |     }
121 |   } catch Exception e {
122 |     errors.server_error(e, req, res)
123 |   }
124 | 
125 |   # Log every request before exiting the client session.
126 |   _log_request(req, res)
127 | }
128 | 


--------------------------------------------------------------------------------
/app/server/routes.b:
--------------------------------------------------------------------------------
 1 | import .api
 2 | import .views
 3 | import .statics
 4 | 
 5 | var routes = {
 6 |   # api endpoints
 7 |   '/static/*': ['GET', statics.static_handler],
 8 |   '/source/*': ['GET', statics.source_handler],
 9 |   '/api/packages': ['GET', api.all_package],
10 |   '/api/create-package': ['POST', api.create_package],
11 |   '/api/get-package/{name}': ['GET', api.get_package],
12 |   '/api/create-publisher': ['POST', api.create_publisher],
13 |   '/api/login': ['POST', api.login],
14 | 
15 |   # frontend website pages
16 |   '/': ['GET', views.home],
17 |   '/404': ['GET', views.error_page],
18 |   '/login': ['GET', views.login],
19 |   '/auth': ['POST', views.authenticate],
20 |   '/account': ['GET', views.account],
21 |   '/search': ['GET', views.search],
22 |   '/view/{id}': ['GET', views.view],
23 |   '/revert': ['POST', views.revert],
24 |   '/archive/{name}': ['GET', views.archive],
25 |   '/logout': ['GET', views.logout],
26 |   '/docs': ['GET', views.doc],
27 |   '/docs/*': ['GET', views.doc],
28 | }
29 | 


--------------------------------------------------------------------------------
/app/server/statics.b:
--------------------------------------------------------------------------------
 1 | import os
 2 | import mime
 3 | import .errors
 4 | import ..setup
 5 | import ..log
 6 | 
 7 | var static_files_directory = os.join_paths(os.args[1], setup.STATIC_DIR)
 8 | var source_files_directory = os.join_paths(os.args[1], setup.SOURCES_DIR)
 9 | 
10 | # if static files directory does not exist, create it.
11 | if !os.dir_exists(static_files_directory)
12 |   os.create_dir(static_files_directory)
13 | 
14 | def static_handler(req, res) {
15 |   var static_path = req.path.replace('/^\\/static\\//', '')
16 |   var reader = file(os.join_paths(static_files_directory, static_path), 'rb')
17 |   
18 |   if reader.exists() {
19 |     res.headers['Content-Type'] = mime.detect_from_name(static_path)
20 |     res.write(reader.read())
21 |   } else {
22 |     errors.not_found(req, res)
23 |   }
24 | }
25 | 
26 | def source_handler(req, res) {
27 |   var source_path = req.path.replace('/^\\/source\\//', '')
28 |   var reader = file(os.join_paths(source_files_directory, source_path), 'rb')
29 |   
30 |   if reader.exists() {
31 |     res.headers['Content-Type'] = 'application/octet-stream'
32 |     var content = reader.read()
33 |     res.write(content)
34 |     content.dispose()
35 |   } else {
36 |     errors.not_found(req, res)
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/app/server/template.b:
--------------------------------------------------------------------------------
  1 | import os
  2 | import json
  3 | import iters
  4 | import cocoa
  5 | import drawdown
  6 | import ..setup
  7 | import ..log
  8 | import .util
  9 | 
 10 | var templates_directory = os.join_paths(os.args[1], setup.TEMPLATES_DIR)
 11 | 
 12 | # create templates directory if missing.
 13 | if !os.dir_exists(templates_directory)
 14 |   os.create_dir(templates_directory)
 15 | 
 16 | var functions = {
 17 |   length: | t | {
 18 |     return t.length()
 19 |   },
 20 |   plus_one: | t | {
 21 |     return t + 1
 22 |   },
 23 |   format_number: | t | {
 24 |     return util.format_number(t)
 25 |   },
 26 |   strip_line: | t | {
 27 |     return t.replace('\n', '\\n')
 28 |   },
 29 |   sort_name: | t | {
 30 |     return t == 'name'
 31 |   },
 32 |   sort_download: | t | {
 33 |     return t == 'downloads'
 34 |   },
 35 |   sort_created: | t | {
 36 |     return t == 'created_at'
 37 |   },
 38 |   br: | t | {
 39 |     return t.replace('\n', '<br>')
 40 |   },
 41 |   draw: | t | {
 42 |     try {
 43 |       return drawdown.markdown(t)
 44 |     } catch Exception e {
 45 |       log.error(e.message)
 46 |       log.error(e.stacktrace)
 47 |       return t
 48 |     }
 49 |   },
 50 |   can_revert: | versions | {
 51 |     return versions.length() > 1
 52 |   },
 53 |   no_ext: | t | {
 54 |     return t.split('.')[0]
 55 |   },
 56 |   file_title: | t | {
 57 |     var x = t.split('.')[0].replace('-', ' ')
 58 |     return x[0].upper() + x[1,]
 59 |   },
 60 |   eq: |t, v| {
 61 |     return t == v
 62 |   }
 63 | }
 64 | 
 65 | def get_attrs(attrs) {
 66 |   return iters.reduce(attrs, | dict, attr | {
 67 |     dict.set(attr.key, attr.value)
 68 |     return dict
 69 |   }, {})
 70 | }
 71 | 
 72 | def strip(txt) {
 73 |   # remove comments and surrounding white space
 74 |   return txt.trim().replace('/(?=<!--)([\s\S]*?)-->\\n*/m', '')
 75 | }
 76 | 
 77 | def strip_attr(element, ...) {
 78 |   var attrs = __args__
 79 |   element.attributes = iters.filter(element.attributes, | el | {
 80 |     return !attrs.contains(el.key)
 81 |   })
 82 | }
 83 | 
 84 | def extract_var(variables, _var) {
 85 |   var var_split = _var.split('|')
 86 |   if var_split {
 87 |     var _vars = var_split[0].split('.')
 88 |     var real_var
 89 | 
 90 |     if variables.contains(_vars[0]) {
 91 |       if _vars.length() > 1 {
 92 |         var final_var = variables[_vars[0]]
 93 |         iter var i = 1; i < _vars.length(); i++ {
 94 |           if is_dict(final_var) {
 95 |             final_var = final_var[_vars[i].matches('/^\d+$/') ? to_number(_vars[i]) : _vars[i]]
 96 |           } else if (is_list(final_var) or is_string(final_var)) and _vars[i].matches('/^\d+$/') {
 97 |             final_var = final_var[to_number(_vars[i])]
 98 |           } else {
 99 |             die Exception('could not resolve ${_var} at ${_vars[i]}')
100 |           }
101 |         }
102 | 
103 |         real_var = final_var
104 |       } else {
105 |         real_var = variables[_vars[0]]
106 |       }
107 | 
108 |       if var_split.length() > 1 {
109 |         iter var i = 1; i < var_split.length(); i++ {
110 |           var fn = var_split[i].split('=')
111 |           if functions.contains(fn[0]) {
112 |             if fn.length() == 1 {
113 |               real_var = functions[fn[0]](real_var)
114 |             } else {
115 |               real_var = functions[fn[0]](real_var, extract_var(variables, fn[1]))
116 |             }
117 |           }
118 |         }
119 |       }
120 | 
121 |       return real_var
122 |     }
123 |   }
124 | 
125 |   return ''
126 | }
127 | 
128 | def replace_vars(content, variables) {
129 |   # replace variables: {var_name}
130 |   # 
131 |   # NOTE: This must come last as previous actions could generate or 
132 |   # contain variables as well.
133 |   var var_vars = content.matches('~(?<![{])\{(?P<variable>([a-zA-Z_][a-zA-Z0-9_\-|=]*(\.[a-zA-Z0-9_\-|=]+)*))\}~')
134 |   if var_vars {
135 |     # var_vars = json.decode(json.encode(var_vars))
136 |     for _var in var_vars.variable {
137 |       content = content.replace('{${_var}}', to_string(extract_var(variables, _var)))
138 |     }
139 |   }
140 |   
141 |   # strip variable escapes
142 |   return content.replace('~\\{\\{~', '{')
143 | }
144 | 
145 | def process(path, element, variables) {
146 |   if !element return nil
147 | 
148 |   if is_string(element) {
149 |     return replace_vars(element, variables)
150 |   }
151 | 
152 |   if is_list(element) {
153 |     return iters.map(element, | el | {
154 |       return process(path, el, variables)
155 |     }).compact()
156 |   }
157 | 
158 |   def error(message) {
159 |     die Exception('${message} at ${path}[${element.position.start.line},${element.position.start.column}]')
160 |   }
161 |   
162 |   if element.type == 'text' {
163 |     # replace variables: {var_name}
164 |     element.content = process(path, element.content, variables)
165 |     return element
166 |   } else {
167 |     var attrs = get_attrs(element.attributes)
168 | 
169 |     if element {
170 |       # process special elements
171 | 
172 |       using element.tagName {
173 |         # include tags
174 |         when 'include' {
175 |           if !attrs or !attrs.contains('path')
176 |             error('missing "path" attribute for include tag')
177 |   
178 |           var includePath = os.join_paths(templates_directory, attrs.path)
179 |           if !includePath.match('/[.][a-zA-Z]+$/') includePath += '.html'
180 |           var fl = file(includePath)
181 |           if fl.exists() {
182 |             element = process(includePath, cocoa.decode(strip(fl.read()), {includePositions: true}), variables)
183 |           } else {
184 |             error('file "${attrs.path}" not found')
185 |           }
186 |         }
187 |       }
188 |     }
189 | 
190 |     # process directives
191 | 
192 |     if attrs.contains('ny-if') {
193 |       # if tag
194 |       var _var = extract_var(variables, attrs.get('ny-if'))
195 |       if _var {
196 |         strip_attr(element, 'ny-if')
197 |         element = process(path, element, variables)
198 |       } else {
199 |         element = nil
200 |       }
201 |     } else if attrs.contains('ny-not') {
202 |       # if not tag
203 |       var _var = extract_var(variables, attrs.get('ny-not'))
204 |       if !_var {
205 |         strip_attr(element, 'ny-not')
206 |         element = process(path, element, variables)
207 |       } else {
208 |         element = nil
209 |       }
210 |     } else if attrs.contains('ny-for') {
211 |       # for tag
212 |       if !attrs or !attrs.contains('ny-key')
213 |         error('missing "ny-key" attribute for `for` tag')
214 |       
215 |       var data = extract_var(variables, attrs.get('ny-for')),
216 |           key_name = attrs.get('ny-key'),
217 |           value_name = attrs.get('ny-value', nil)
218 | 
219 |       strip_attr(element, 'ny-for', 'ny-key', 'ny-value')
220 |       var for_vars = variables.clone()
221 | 
222 |       var result = []
223 |       for key, value in data {
224 |         for_vars.set('${key_name}', value_name ? key : value)
225 |         if value_name for_vars.set('${value_name}', value)
226 |         result.append(process(path, json.decode(json.encode(element)), for_vars))
227 |       }
228 |       return result
229 |       /* return iters.map(data, |value, key| {
230 |         for_vars.set('${key_name}', value_name ? key : value)
231 |         if value_name for_vars.set('${value_name}', value)
232 |         return process(path, json.decode(json.encode(element)), for_vars)
233 |       }) */
234 |     }
235 |     
236 |     if element and element.contains('children') and element.children {
237 |       element.children = process(path, element.children, variables)
238 |     }
239 | 
240 |     # replace attribute variables...
241 |     if element and !is_list(element) {
242 |       for attr in element.attributes {
243 |         if attr.value {
244 |           # replace variables: {var_name}
245 |           attr.value = process(path, attr.value, variables)
246 |         }
247 |       }
248 |     }
249 | 
250 |     return element
251 |   }
252 | }
253 | 
254 | def template(name, variables) {
255 |   if !is_string(name)
256 |     die Exception('template name expected')
257 | 
258 |   var path = os.join_paths(templates_directory, name)
259 |   if !path.ends_with('.html') path += '.html'
260 | 
261 |   if variables != nil and !is_dict(variables)
262 |     die Exception('variables must be passed to templates as a dictionary')
263 |   if variables == nil variables = {}
264 | 
265 |   var template_file = file(path)
266 |   if template_file.exists() {
267 |     var file_content = strip(template_file.read())
268 |     # return file_content
269 | 
270 |     return cocoa.encode(
271 |       process(
272 |         path,
273 |         cocoa.decode(file_content, {includePositions: true}),
274 |         variables
275 |       )
276 |     )
277 |   }
278 | 
279 |   die Exception('template ${name} not found')
280 | }
281 | 


--------------------------------------------------------------------------------
/app/server/util.b:
--------------------------------------------------------------------------------
 1 | import hash
 2 | import http.status
 3 | import .db
 4 | import ..log
 5 | 
 6 | def generate_publisher_key(name) {
 7 |   var table = bytes(0)
 8 |   iter var i = 0; i < 64; i++ {
 9 |     table.append(rand(0, 255))
10 |   }
11 | 
12 |   var mcbytes = to_string(microtime()).to_bytes()
13 |   table.extend(mcbytes)
14 |   mcbytes.dispose()
15 |   var name_bytes = name.to_bytes()
16 |   table.extend(name_bytes)
17 |   name_bytes.dispose()
18 | 
19 |   var h = hash.sha1(table)
20 |   table.dispose()
21 | 
22 |   return h
23 | }
24 | 
25 | def validate_auth_data(req, res) {
26 |   if !req.headers return res.fail(status.UNAUTHORIZED)
27 | 
28 |   var key = req.headers.get('Nyssa-Publisher-Key', nil)
29 |   if !key return res.fail(status.UNAUTHORIZED)
30 | 
31 |   var name = req.headers.get('Nyssa-Publisher-Name', nil)
32 |   if !name return res.fail(status.UNAUTHORIZED)
33 | 
34 |   var publisher = db.get_publisher(name, key)
35 |   if !publisher return res.fail(status.UNAUTHORIZED)
36 |   
37 |   log.info('Publisher "${publisher.username}" authenticated!')
38 |   return publisher
39 | }
40 | 
41 | def format_number(number) {
42 |   var parts = to_string(number).split('.')
43 |   parts[0] = parts[0].replace('/\B(?=(\d{3})+(?!\d))/', ',')
44 |   return '.'.join(parts)
45 | }
46 | 


--------------------------------------------------------------------------------
/app/server/views.b:
--------------------------------------------------------------------------------
  1 | # FROTEND WEB PAGES
  2 | import json
  3 | import bcrypt
  4 | import os
  5 | import .template
  6 | import .db
  7 | import .util
  8 | import ..setup
  9 | 
 10 | var doc_files = [
 11 |   'installing-nyssa.md',
 12 |   'creating-projects.md',
 13 |   'publishing-packages.md',
 14 |   'managing-dependencies.md',
 15 |   'package-layout.md',
 16 |   'install-and-uninstall-actions.md',
 17 |   'getting-project-info.md',
 18 |   'hosting-a-private-repository.md',
 19 |   'publishers-account.md',
 20 |   'cleaning-cache-and-logs.md',
 21 |   'commands.md'
 22 | ]
 23 | 
 24 | var nyssa_version = '0.0.0'
 25 | var docs_dir = os.join_paths(os.args[1], setup.DOCS_DIR)
 26 | var config_file = os.join_paths(os.args[1], setup.CONFIG_FILE)
 27 | if (config_file = file(config_file)) and config_file.exists() {
 28 |   var conf = json.decode(config_file.read())
 29 |   if is_dict(conf) {
 30 |     nyssa_version = conf.get('version', '0.0.0')
 31 |   }
 32 | }
 33 | 
 34 | def error_page(req, res) {
 35 |   res.write(template('404'))
 36 | }
 37 | 
 38 | def home(req, res) {
 39 |   res.write(template('home', {
 40 |     publishers: db.get_publishers_count(),
 41 |     packages: db.get_packages_count(),
 42 |     downloads: db.get_all_download_count(),
 43 |     top_packages: db.get_top_packages(),
 44 |     latest_packages: db.get_top_packages('created_at DESC'),
 45 |     show_login: !res.session.contains('user'),
 46 |     nyssa_version: nyssa_version,
 47 |   }))
 48 | }
 49 | 
 50 | def search(req, res) {
 51 |   if !req.queries.contains('q') {
 52 |     # redirect to home
 53 |     res.redirect('/')
 54 |     return
 55 |   }
 56 | 
 57 |   var query = req.queries.q
 58 |   var page = to_number(req.queries.get('page', '1'))
 59 |   var sort = req.queries.get('sort', nil) ? req.queries.sort : 'download'
 60 |   var real_sort = sort == 'name' ? '${sort} ASC' : '${sort} DESC'
 61 | 
 62 |   var result = db.search_package('%${query}%', page, real_sort)
 63 |   for pack in result.packages {
 64 |     pack.tags = json.decode(pack.tags)
 65 |   }
 66 | 
 67 |   var pg = 1..(result.pages + 1)
 68 |   if result.pages > 11 and page >= 6 {
 69 |     var start = page - 5, end = page + 5 + 1
 70 |     if end > result.pages end = result.pages
 71 |     pg = start..end
 72 |   }
 73 | 
 74 |   var pagination = []
 75 |   for x in pg {
 76 |     if x == page pagination.append({page: x, active: true})
 77 |     else pagination.append({page: x, active: false})
 78 |   }
 79 | 
 80 |   res.write(template('search', {
 81 |     query: query,
 82 |     result: result,
 83 |     pages: pagination,
 84 |     sort: sort,
 85 |     show_login: !res.session.contains('user'),
 86 |   }))
 87 | }
 88 | 
 89 | def view(req, res) {
 90 |   var id = req.params.id
 91 |   var name = id, version
 92 |   if id.match('@') {
 93 |     var id_split = id.split('@')
 94 |     name = id_split[0]; version = id_split[1]
 95 |   }
 96 |   var package = db.get_package_for_view(name, version)
 97 | 
 98 |   if package {
 99 |     package.deps = json.decode(package.deps)
100 |     package.tags = json.decode(package.tags)
101 |     package['versions'] = db.get_package_versions(name)
102 |   } else {
103 |     # redirect to not found
104 |     res.redirect('/404')
105 |     return
106 |   }
107 |   res.write(template('view', {
108 |     package: package,
109 |     name: req.params.id,
110 |     version: version,
111 |     show_login: !res.session.contains('user'),
112 |   }))
113 | }
114 | 
115 | def authenticate(req, res) {
116 |   if res.session.contains('user') {
117 |     res.redirect('/account')
118 |     return
119 |   }
120 | 
121 |   if req.body and is_dict(req.body) {
122 |     var name = req.body.get('username', nil),
123 |       password = req.body.get('password', nil)
124 | 
125 |     if name and password {
126 |       var pub = db.get_publisher(name)
127 | 
128 |       # authenticate
129 |       if pub and bcrypt.compare(password, pub.password) {
130 |         res.session['user'] = pub
131 |         res.redirect('/account')
132 |         return
133 |       }
134 |     }
135 |   }
136 | 
137 |   res.redirect('/login?error=1')
138 | }
139 | 
140 | def login(req, res) {
141 |   if res.session.contains('user') {
142 |     res.redirect('/account')
143 |     return
144 |   }
145 | 
146 |   res.write(template('login', {
147 |     show_login: true,
148 |     error: req.queries.get('error', nil)
149 |   }))
150 | }
151 | 
152 | def account(req, res) {
153 |   if !res.session.contains('user') {
154 |     res.redirect('/login')
155 |     return
156 |   }
157 | 
158 |   var page = to_number(req.queries.get('page', '1'))
159 |   var result = db.get_user_packages(res.session['user'].username, page)
160 |   for pack in result.packages {
161 |     pack.tags = json.decode(pack.tags)
162 |     pack.versions = db.get_package_versions(pack.name)
163 |     pack.downloads = db.get_all_download_count(pack.name)
164 |   }
165 | 
166 |   var pg = 1..(result.pages + 1)
167 |   if result.pages > 11 and page >= 6 {
168 |     var start = page - 5, end = page + 5 + 1
169 |     if end > result.pages end = result.pages
170 |     pg = start..end
171 |   }
172 | 
173 |   var pagination = []
174 |   for x in pg {
175 |     if x == page pagination.append({page: x, active: true})
176 |     else pagination.append({page: x, active: false})
177 |   }
178 | 
179 |   res.write(template('account', {
180 |     result: result,
181 |     pages: pagination,
182 |     show_login: false,
183 |     user: res.session['user'],
184 |     message: res.session.remove('message')
185 |   }))
186 | }
187 | 
188 | def revert(req, res) {
189 |   if !res.session.contains('user') {
190 |     res.redirect('/login')
191 |     return
192 |   }
193 |   
194 |   if req.body and is_dict(req.body) {
195 |     var name = req.body.get('name', nil),
196 |       version = req.body.get('version', nil)
197 | 
198 |     if name and version {
199 |       var package = db.get_package(name, version)
200 |       if package and package.publisher == res.session['user'].username {
201 |         if db.revert_package(name, package.id) {
202 |           # create flash message
203 |           res.session['message'] = 'Package <strong>${name}</strong> successfully reverted to version <strong>${version}</strong>'
204 |         }
205 |         res.redirect('/account')
206 |         return
207 |       }
208 |     }
209 |   }
210 | 
211 |   res.redirect('/login')
212 | }
213 | 
214 | def archive(req, res) {
215 |   if !res.session.contains('user') {
216 |     res.redirect('/login')
217 |     return
218 |   }
219 |   
220 |   if req.params {
221 |     var name = req.params.name
222 |     var package = db.get_package(name)
223 |     if package and package.publisher == res.session['user'].username {
224 |       if db.archive_package(name) {
225 |         # create flash message
226 |         res.session['message'] = 'Package <strong>${name}</strong> successfully archived.'
227 |       }
228 |       res.redirect('/account')
229 |       return
230 |     }
231 |   }
232 | 
233 |   res.redirect('/login')
234 | }
235 | 
236 | def logout(req, res) {
237 |   res.clear_session()
238 |   res.redirect('/')
239 | }
240 | 
241 | def doc(req, res) {
242 |   var uri = req.path.replace('~^/docs/?~', '').trim('/')
243 |   if uri == '' uri = 'installing-nyssa'
244 |   
245 |   var doc_file
246 |   if !doc_files.contains('${uri}.md') or 
247 |     !os.dir_exists(docs_dir) or
248 |     !file(doc_file = os.join_paths(docs_dir, '${uri}.md')).exists() {
249 |     res.redirect('/404')
250 |     return
251 |   }
252 | 
253 |   res.write(template('doc', {
254 |     uri: uri,
255 |     content: file(doc_file).read(),
256 |     doc_files: doc_files,
257 |     show_login: !res.session.contains('user'),
258 |   }))
259 | }
260 | 


--------------------------------------------------------------------------------
/app/setup.b:
--------------------------------------------------------------------------------
 1 | # general
 2 | var NYSSA_VERSION = '0.1.0'
 3 | 
 4 | # directories
 5 | var APP_DIR = 'app'
 6 | var TEST_DIR = 'tests'
 7 | var EXAMPLES_DIR = 'examples'
 8 | var STATIC_DIR = 'public'
 9 | var TEMPLATES_DIR = 'templates'
10 | var STORAGE_DIR = 'storage'
11 | var DOCS_DIR = 'docs'
12 | var LOGS_DIR = '${STORAGE_DIR}/logs'
13 | var SOURCES_DIR = '${STORAGE_DIR}/sources'
14 | var DATABASE_DIR = '${STORAGE_DIR}/db'
15 | var CACHE_DIR = '${STORAGE_DIR}/cache'
16 | 
17 | # files
18 | var INDEX_FILE = 'index.b'
19 | var README_FILE = 'README.md'
20 | var CONFIG_FILE = 'nyssa.json'
21 | var DATABASE_FILE = '${DATABASE_DIR}/nyssa.db'
22 | var STATE_FILE = '${STORAGE_DIR}/config.json'
23 | 
24 | # repository
25 | var REPOSITORY_HOST = '127.0.0.1'
26 | var REPOSITORY_PORT = 3000
27 | 
28 | var DEFAULT_REPOSITORY = 'https://nyssa.bladelang.com'
29 | 
30 | # frontend
31 | var PACKAGES_PER_PAGE = 10
32 | var SESSION_NAME = 'NYSSA-SESSION-ID'
33 | 


--------------------------------------------------------------------------------
/app/util.b:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | def setup_cli(name, base_path, cli_path) {
 4 |   var is_windows = os.platform == 'windows'
 5 |   var path = os.join_paths(base_path, '../../', name) + (is_windows ? '.cmd' : '')
 6 | 
 7 |   var cmd
 8 |   if !is_windows {
 9 |     cmd = '#!/bin/bash\n' +
10 |       '\n' +
11 |       'if [[ ! $(command -v blade) ]]; then\n' +
12 |       '  echo "Blade is not installed or not in path."\n' +
13 |       '  exit 1\n' +
14 |       'fi\n' +
15 |       '\n'+ 
16 |       'BLADE_EXE=`which blade`\n' +
17 |       '\n' +
18 |       'exec "$BLADE_EXE" "${cli_path}" "$@"\n'
19 |   } else {
20 | 
21 |     cmd = '@ECHO OFF\r\n' +
22 |       'SETLOCAL\r\n' +
23 |       '\r\n' +
24 |       '@REM Find Blade executable\r\n' +
25 |       'for %%i in (blade.exe) do SET "BLADE_EXE=%%~$PATH:i"\r\n' +
26 |       '\r\n' +
27 |       'if defined BLADE_EXE (\r\n' +
28 |       '    GOTO :RUN\r\n' +
29 |       ') else (\r\n' +
30 |       '    GOTO :ERROR\r\n' +
31 |       ')\r\n' +
32 |       '\r\n' +
33 |       ':ERROR\r\n' +
34 |       'SET msgboxTitle=${name}\r\n' +
35 |       'SET msgboxBody=Blade is not installed or not in path.\r\n' +
36 |       'SET tmpmsgbox=%temp%\~tmpmsgbox.vbs\r\n' +
37 |       'IF EXIST "%tmpmsgbox%" DEL /F /Q "%tmpmsgbox%"\r\n' +
38 |       'ECHO msgbox "%msgboxBody%",0,"%msgboxTitle%">"%tmpmsgbox%"\r\n' +
39 |       'WSCRIPT "%tmpmsgbox%"\r\n' +
40 |       'EXIT /B 1\r\n' +
41 |       '\r\n' +
42 |       ':RUN\r\n' +
43 |       '\r\n' +
44 |       '"%BLADE_EXE%" "${cli_path}" %*\r\n' +
45 |       'EXIT /B 0\r\n'
46 |   }
47 | 
48 | 
49 |   file(path, 'w').write(cmd)
50 |   if !is_windows {
51 |     os.chmod(path, 0c744) # u+x
52 |   }
53 | }
54 | 
55 | def remove_cli(name, base_path) {
56 |   var is_windows = os.platform == 'windows'
57 |   var path = os.join_paths(base_path, '../../', name) + (is_windows ? '.cmd' : '')
58 |   var fh = file(path)
59 |   if fh.exists()
60 |     fh.delete()
61 | }
62 | 


--------------------------------------------------------------------------------
/docs/cleaning-cache-and-logs.md:
--------------------------------------------------------------------------------
1 | # Cleaning cache and log files
2 | 
3 | - To clean all cache and log file, run the command `nyssa clean`.
4 | - To clean log files only pass the `--logs` flag (or `-l` for short). For example, `nyssa clean --logs`
5 | - To clean cache files only pass the `--cache` flag (or `-c` for short). For example, `nyssa clean --cache`.
6 | - You can pass the `--all` flag (or `-a` for short) to clean everything. This is the same as simply running `nyssa clean`.
7 | 


--------------------------------------------------------------------------------
/docs/commands.md:
--------------------------------------------------------------------------------
 1 | # Commands
 2 | 
 3 | Usage: `nyssa` [ [-h] | [-v] ] [COMMAND]
 4 | 
 5 | ### OPTIONS
 6 | -  `-h`, `--help`                Show this help message and exit
 7 | -  `-v`, `--version`             Show Nyssa version
 8 | 
 9 | ### COMMANDS
10 | - **account** <_choice_>          Manages a Nyssa publisher account
11 |   -  `create`                    creates a new publisher account
12 |   -  `login`                     login to a publisher account
13 |   -  `logout`                    log out of a publisher account
14 |   -  *`-r`*, *`--repo`* <_value_>        the repo where the account is located
15 | - **clean**                     Clear Nyssa storage
16 |   -  *`-c`*, *`--cache`*               clean packages cache
17 |   -  *`-l`*, *`--logs`*                clean logs
18 |   -  *`-a`*, *`--all`*                 clean everything
19 | - **info**                      Shows current project information
20 | - **init**                      Creates a new package in current directory
21 |   -  *`-n`*, *`--name`* <_value_>        the name of the package
22 | - **install** <_value_>           Installs a Blade package
23 |   -  *`-g`*, *`--global`*              installs the package globally
24 |   -  *`-c`*, *`--use-cache`*           enables the cache
25 |   -  *`-r`*, *`--repo`* <*value*>        the repository to install from
26 | - **publish**                   Publishes a repository
27 |   -  *`-r`*, *`--repo`* <*value*>        repository url
28 | - **restore**                   Restores all project dependencies
29 |   -  *`-x`*, *`--no-cache`*            disables the cache
30 | - **serve**                     Starts a local Nyssa repository server
31 |   -  *`-p`*, *`--port`* <*value*>        port of the server (default: 3000)
32 |   -  *`-n`*, *`--host`* <*value*>        the host ip (default: 127.0.0.1)
33 | - **uninstall** <*value*>         Uninstalls a Blade package
34 |   -  *`-g`*, *`--global`*              package is a global package


--------------------------------------------------------------------------------
/docs/creating-projects.md:
--------------------------------------------------------------------------------
 1 | # Creating Projects
 2 | 
 3 | Nyssa projecs are typical Blade  applications
 4 | 
 5 | ### To create a new project
 6 | 
 7 | 1. Create a new directory for your project and open a terminal/command window in the directory and run the `nyssa init` command.
 8 | 2. Fill in the responses to the prompted questions. `name` and `version` are required so nyssa will suggest an appropriate value for you. You can leave them blank to allow nyssa use the default values or replace them with other values of your choice.
 9 |   
10 |   See [Package layout](/docs/package-layout) for the structure of the command output.
11 | 
12 |   > The default `name` will be the name of current directory and the default version will be `1.0.0`. It is conventional to keep the version name semantic.
13 | 
14 | ### Converting an existing project
15 | 
16 | To convert an existing application or library into a Nyssa application, all you need to do is to follow the same process for creating a new package. **If the application already contain a file named `nyssa.json`, you may need to delete it** because nyssa does not reinitialize existing projects.
17 | 
18 | _When converting an existing application, your existing directory and files matching those that nyssa creates will not be overwritten_.
19 | 
20 | ### Where to write code
21 | 
22 | Your code can go into any Blade (`.b`) file in the created/generated directories and files. However, by default and by convention, your code should go into the `app` directory.
23 | 
24 | ### Running your application
25 | 
26 | To run your application, run the command `blade .` from the root of the application.
27 | 
28 | When you create a new nyssa project, nyssa creates a simple Hello World like application for you as well. If you run `blade .` from the root of your new nyssa project, you'll be greeted by the message `Welcome to Nyssa. Magic begins here!`. To modify this, you can open the file at `app/index.b` to change what the application does.
29 | 
30 | 


--------------------------------------------------------------------------------
/docs/getting-project-info.md:
--------------------------------------------------------------------------------
 1 | # Getting project information
 2 | 
 3 | Nyssa provides the `info` command to allow you print a user-friendly description of the current application. Run the `nyssa info` command from the root of your application or package to get information about the project without opening the `nyssa.json` file.
 4 | 
 5 | For example,
 6 | 
 7 | ```
 8 | nyssa info
 9 | ```
10 | 
11 | You get an output similar to this.
12 | 
13 | ```
14 | PACKAGE INFORMATION 
15 | ~~~~~~~~~~~~~~~~~~~
16 |  • Name: pg
17 |  • Version: 1.0.0
18 |  • Description: None
19 |  • Homepage: None
20 |  • Author: None
21 |  • License: ISC
22 |  • Tags: None
23 | 
24 | DEPENDENCIES 
25 | ~~~~~~~~~~~~
26 |  • sample: 1.0.0
27 |  • test: 1.0.0
28 | 
29 | SOURCES 
30 | ~~~~~~~
31 |  • https://nyssa.bladelang.com
32 | ```
33 | 


--------------------------------------------------------------------------------
/docs/hosting-a-private-repository.md:
--------------------------------------------------------------------------------
 1 | # Hosting a private repository
 2 | 
 3 | Nyssa is a self-hostable repository.
 4 | 
 5 | This means that you can install and configure your own private or custom instance of [nyssa.bladelang.com](https://nyssa.bladelang.com) that people can publish to and install packages from. In fact, [nyssa.bladelang.com](https://nyssa.bladelang.com) is essentially just another private repository that is accessible to everyone in the Blade community and hosted on the public web.
 6 | 
 7 | ### Starting the respository server
 8 | 
 9 | Once you have Nyssa installed on a device, you can start the repository server by running the command `nyssa serve`. This starts a local repository server that listens to the port `3000`. You should see a log similar to the following:
10 | 
11 | ```
12 | $ nyssa serve
13 | Nyssa repository server started.
14 | Repository URL: http://127.0.0.1:3000
15 | ```
16 | 
17 | You can visit `http://127.0.0.1:3000` in your browser to see your own clone of this website. 
18 | 
19 | Replace IP address with the address/domain of the server if you are trying to access it outside of the server. In fact, if you'll be accessing it ourside the local machine, it is advisable to change the configured host from `127.0.0.1` to `0.0.0.0`.
20 | 
21 | ### Customizing your installation
22 | 
23 | You fully customize your own repository setup by modifying the `app/setup.b` file. For exmple, you can change the host and port number by modifying the value of `REPOSITORY_HOST` and `REPOSITORY_PORT` respectively in the file `app/setup.b`.
24 | 
25 | ### Production considerations
26 | 
27 | - While the built-in server can be used as is on production, it is not advisable to do so unless you are not exposing it on the internet (such as internal use on in an organization). Especially if you are trying to run on `https` as the server only supports plain `http`.
28 | - Consider running behind a reverse-proxy such as `apache` or `lightspeed` or `nginx` or run it behind a `VPN`.
29 | 
30 | 


--------------------------------------------------------------------------------
/docs/install-and-uninstall-actions.md:
--------------------------------------------------------------------------------
 1 | # Install and Uninstall actions
 2 | 
 3 | Nyssa provides two installation hook (`post_install` and `cli`) and one uninstallation hook (`pre_uninstall`) that allows package and library authors to customize the installation and uninstallation experience and do many things such as downloading and building extra dependencies that may be written in other programming languages.
 4 | 
 5 | ### `post_install`
 6 | 
 7 | The `post_install` configuration allows package authors to specify a Blade script that should be run after the package has been extracted into its destination directory. To specify a script to run after installation, add the `post_install` option to the `nyssa.json` file.
 8 | 
 9 | ```
10 | ...
11 | "post_install": "my_cli_script.b"
12 | ```
13 | 
14 | The _<scirpt_name>_ must be a path or filename relative to the root of the package.
15 | 
16 | ### `pre_uninstall`
17 | 
18 | The `pre_uninstall` configuration is much like the `post_install` configuration, except that it runs just before a package is uninstalled. You can add it to the `nyssa.json` file in the same way as the `post_install` option.
19 | 
20 | ```
21 | ...
22 | "pre_uninstall": "my_cli_script.b"
23 | ```
24 | 
25 | ### `cli`
26 | 
27 | The `cli` installation hook allows package authors to specify a script that serves as the CLI entry point to the application. When the _CLI_ script is specified, a CLI entry will be created at `.blade` for local installations or at the root of Blade for global installations. This files will be automatically removed during uninstallation.
28 | 
29 | For example, the testing framework `qi` specifies a CLI entry point. For this reason, when you install `qi` locally, you can run the Qi command by simply running the command `.blade/qi` (or `.blade\qi` for Windows) to run your tests. This is made possible because during installation, Nyssa will automatically create the corresponding command-line entry file for you.
30 | 
31 | For applications installated globally, the application will become available on the user terminal **via the name** of the application provided that Blade has been added to path during installation.
32 | 
33 | For example,
34 | 
35 | ```
36 | "cli": "my_cli_script.b"
37 | ```
38 | 


--------------------------------------------------------------------------------
/docs/installing-nyssa.md:
--------------------------------------------------------------------------------
 1 | # Installing Nyssa
 2 | 
 3 | Setting up Nyssa is a very straight forward process that involves three easy steps.
 4 | 
 5 | 1. Download the Nyssa package manager from [the official Nyssa website](https://nyssa.bladelang.com) or from [the Github repository releases page](https://github.com/blade-lang/nyssa/releases). It is recommended to download from the Nyssa website as the website will only have the most stable release for download.
 6 | 2. Extract the downloaded `.zip` file to a choice location on your device.
 7 | 3. Add the location of the extracted package to your system environment path to make the `nyssa` command available system-wide.
 8 | 
 9 | Various operating systems provides different mechanisms for adding a path to the environment so the steps may vary for your specific operating system.
10 | 
11 | Here's a few links for different operating systems showing how to do this.
12 | 
13 | | Operating systems | Instruction Link |
14 | |------------------|------------------|
15 | | Linux, macOS | [https://opensource.com/article/17/6/set-path-linux](https://opensource.com/article/17/6/set-path-linux) |
16 | | Windows | [https://www.wikihow.com/Change-the-PATH-Environment-Variable-on-Windows](https://www.wikihow.com/Change-the-PATH-Environment-Variable-on-Windows) |
17 | 
18 | 
19 | ### Testing your installation
20 | 
21 | If you followed all the steps and successfully added the download directory to system path, open a new terminal session (may be required) and run the command `nyssa --version`.
22 | 
23 | You should see an output similar to the below.
24 | 
25 | ```
26 | Nyssa 0.1.0
27 | Blade 0.0.75 (running on BladeVM 0.0.8)
28 | ```
29 | 
30 | You can also run the `nyssa` command without any arguments to see the full help information.
31 | 
32 | ```
33 | Usage: nyssa [ [-h] | [-v] ] [COMMAND]
34 | 
35 | OPTIONS:
36 |   -h, --help                Show this help message and exit
37 |   -v, --version             Show Nyssa version
38 | 
39 | COMMANDS:
40 |   account <choice>          Manages a Nyssa publisher account
41 |     create                    creates a new publisher account
42 |     login                     login to a publisher account
43 |     logout                    log out of a publisher account
44 |     -r, --repo <value>        the repo where the account is located
45 |   clean                     Clear Nyssa storage
46 |     -c, --cache               clean packages cache
47 |     -l, --logs                clean logs
48 |     -a, --all                 clean everything
49 |   info                      Shows current project information
50 |   init                      Creates a new package in current directory
51 |     -n, --name <value>        the name of the package
52 |   install <value>           Installs a Blade package
53 |     -g, --global              installs the package globally
54 |     -c, --use-cache           enables the cache
55 |     -r, --repo <value>        the repository to install from
56 |   publish                   Publishes a repository
57 |     -r, --repo <value>        repository url
58 |   restore                   Restores all project dependencies
59 |     -x, --no-cache            disables the cache
60 |   serve                     Starts a local Nyssa repository server
61 |     -p, --port <value>        port of the server (default: 3000)
62 |     -n, --host <value>        the host ip (default: 127.0.0.1)
63 |   uninstall <value>         Uninstalls a Blade package
64 |     -g, --global              package is a global package
65 | ```
66 | 
67 | If you can see this, then you're all good.
68 | 


--------------------------------------------------------------------------------
/docs/managing-dependencies.md:
--------------------------------------------------------------------------------
 1 | # Managing dependencies
 2 | 
 3 | As a package manager, one of the core responsibilities of nyssa is to help you manage dependencies for your application. In Blade, there are three (3) scopes of libraries that exist.
 4 | 
 5 | - **Builtin libraries**: This libraries are the Blade core libraries from which all other libraries are built on and are not meant to be managed by any third party application. Managing or modifying this packages yourself can break your installation and/or make your installation incompartible with other installations.
 6 | - **Global libraries**: This are packages located in Blade's global packages directory (typically `$BLADE_INSTALL_DIR/vendor`) and are available to all applications in Blade and can be imported in the same way as the core libraries, but not part of the core packages.
 7 | - **Local libraries**: This are packages located in your application, package or library's local packages directory (typically `$APPLICATION_DIR/.blade/libs`) and are available to all modules in your application and can be imported in the same way as the core libraries.
 8 | 
 9 | Nyssa lets you install both global and local libraries for your application. The default behavior is to install a package locally.
10 | 
11 | ### Installing a package
12 | 
13 | To install a package locally into your application, open a terminal at the root of your application and run
14 | 
15 | ```
16 | nyssa install <package_name>
17 | ```
18 | 
19 | This will create the path `.blade/libs` in your current directory if it doesn't exist already and download the package into that directory. This will also update the `nyssa.json` file with the installed dependency uder the `deps` section.
20 | 
21 | > **NOTE:** nyssa does not install a local package outside of a nyssa project.
22 | 
23 | If you want to install a specific version of a package, you have you specify the version in the install command using the `@` separator like below.
24 | 
25 | ```
26 | nyssa install <package_name>@<package_version>
27 | ```
28 | 
29 | For example,
30 | 
31 | ```
32 | nyssa install packgist@1.1.3
33 | ```
34 | 
35 | To install a package globally and make it available to all applications, you need to add the `--global` flag (or `-g` for short) to the command. For example:
36 | 
37 | ```
38 | nyssa install --global <package_name>
39 | ```
40 | 
41 | > **NOTE:** You can install a package globally from any directory on your device. A `nyssa.json` file will only be updated if it is ran inside a nyssa project.
42 | 
43 | You can also choose to install a package from another repository other than [nyssa.bladelang.com](https://nyssa.bladelang.com) by specifying the `--repo` flag (or `-r` for short) like below.
44 | 
45 | ```
46 | nyssa install --repo <repo_url> <package_name>
47 | ```
48 | 
49 | The new repo will be added as a source into the `nyssa.json` script. This allows nyssa to easily restore the dependency later on.
50 | 
51 | > When installing packages, by default nyssa does not use the cache. You can instruct nyssa to check if a version of the package and version has been previously downloaded and use that download copy again by specifying the `--use-cache` flag (`-c` for short). This helps avoid unnecessary bandwidth costs.
52 | 
53 | ### Uninstalling packages
54 | 
55 | To uninstall or remove a dependency from a project, you need to run the `nyssa uninstall` command like
56 | 
57 | ```
58 | nyssa uninstall <package_name>
59 | ```
60 | 
61 | To uninstall a package that was installed globally, you need to specify the `--global` flag.
62 | 
63 | ```
64 | nyssa uninstall --global <package_name>
65 | ```
66 | 
67 | ### Upgrading packages
68 | 
69 | To upgrade Nyssa packages whether globally installed or locally installed, you only need to reinstall it. Nyssa will install the latest version of that package and replace the current one with it.
70 | 
71 | ### Restoring packages
72 | 
73 | When nyssa creates a project, it includes a `.gitignore` file that tells it to ignore the `.blade` directory. This keeps source control light and easy to manage. To restore back all your packages when you move or copy your code across locations or devices, you can run the command
74 | 
75 | ```
76 | nyssa restore
77 | ```
78 | 
79 | This is also useful if you ever mistakenly delete the `.blade` directory or compress the project with archivers that ignore hidden file on Unix machines or somehow end up with a corrupted library. You can also use restore to reinstall all packages.
80 | 
81 | > Unlike package installation, restore uses a cache by default. Sometimes, this isn't exactly what you want. You can ask nyssa to not use any cached version by specifying the `--no-cache` flag (or `-x` for short).
82 | 
83 | 


--------------------------------------------------------------------------------
/docs/package-layout.md:
--------------------------------------------------------------------------------
 1 | # Package layout
 2 | 
 3 | This document describes the technical details of a Nyssa package.
 4 | 
 5 | ### Layout
 6 | 
 7 | The default layout for Nyssa package when generated by `nyssa init` is as 
 8 | follows:
 9 | 
10 | - `.blade`: The default Blade pacakges directory which contains 
11 |   installed packages and will only be available when at least one 
12 |   or more package is installed.
13 | - `app`: The directory contains the main application/package code.
14 | - `examples`: Examples accompanying your package goes here and _may_
15 |   be shown to users under the `Examples` section of the Nyssa website.
16 | - `index.b`: The default Blade package index file.
17 | - `README.md`: The README.md file will be contain the main documentation 
18 |   for your package.
19 |   > **NOTE:**
20 |   > If your packages adheres to Blade standard multiline comment 
21 |   > documentation format as shown in the Blade standard library 
22 |   > documentation, your package documentation _may_ be expanded to include
23 |   > such documentations.
24 | - `nyssa.json`: The Nyssa package configuration script.
25 | - `tests`: This directory contains unit, integration and all types 
26 |   of tests for your package.
27 | 
28 | **!Important**
29 | 
30 | You can create a Nyssa package without having to run `nyssa init`. Essentially,
31 | the only files required are the `index.b` and the `nyssa.json` files and they
32 | can be manually created without losing Nyssa's ability to install, uninstall
33 | and configure packages.
34 | 
35 | 
36 | ### `nyssa.json`
37 | 
38 | The `nyssa.json` file is pretty intuitive and is very similar to NodeJS NPM
39 | package.json files. A typical sample of a complete `nyssa.json` file looks like this:
40 | 
41 | ```json
42 | {
43 |   "name": "sample", 
44 |   "version": "0.1.0", 
45 |   "description": "An example package", 
46 |   "homepage": "", 
47 |   "tags": [
48 |     "tag1",
49 |     "tag2",
50 |     "tag3"
51 |   ], 
52 |   "author": "Package Author <someone@example.com>", 
53 |   "license": "MIT", 
54 |   "sources": [
55 |     "nyssa.bladelang.com"
56 |   ],
57 |   "deps": {
58 |     "dependecny1": "1.0.0",
59 |     "dependecny2": "1.0.0",
60 |     "dependecny3": "1.0.0"
61 |   },
62 |   "post_install": "post-install-script.b",
63 |   "pre_uninstall": "pre-uninstall-script.b"
64 | }
65 | ```
66 | 
67 | 
68 | 
69 | 


--------------------------------------------------------------------------------
/docs/publishers-account.md:
--------------------------------------------------------------------------------
 1 | # Publishers account
 2 | 
 3 | Nyssa allows you to publish packages to the default repository ([nyssa.bladelang.com](https://nyssa.bladelang.com)) as well as private hosted repositories through the use of publisher accounts.
 4 | 
 5 | Publisher accounts are account created by package authors to allow them publish nyssa package to repositories. A nyssa instance can only publish to one repository at a time and as such, you can only be authenticated to one Nyssa repository at a time.
 6 | 
 7 | ### Creating publisher accounts
 8 | 
 9 | Publisher accounts can only be created through the nyssa CLI and never from the repository web application. 
10 | 
11 | To create a new publisher account on the default repository [nyssa.bladelang.com](https://nyssa.bladelang.com), run the command `nyssa account create`. This will bring up a new prompt asking you for your `username`, `email` and `password` all of which are required to create a new account.
12 | 
13 | Upon successful account creation, you'll be given your issued **Publisher's Key**. This key in conjuction with your username allows you to publish packages.
14 | 
15 | > Save your publisher's key in a secure and safe location because you'll need it to recover your account should you ever forget your account password.
16 | 
17 | To create an account in another repository or a private repository, use the `--repo` flag to point to another repository. For example
18 | 
19 | ```
20 | nyssa account --repo https://myprivatenyssa.com create
21 | ```
22 | 
23 | > You can use the short form `-r` instead of the long `--repo`.
24 | 
25 | ### Login to publisher account
26 | 
27 | If you've created a publisher account, you can always login on the same or other devices using the command `nyssa account login`. This will prompt you for your `username` and `password`. Upon successful login, your key will be registered against the current machine.
28 | 
29 | Just like creating a new account, you can use the `-r` or `--repo` to login to another repository different from the [nyssa.bladelang.com](https://nyssa.bladelang.com).
30 | 
31 | > You can also login to your publisher account on your repository's website [login](/login) page.
32 | 
33 | 
34 | ### Loging out of an account
35 | 
36 | When you try to sign into another account when you are already signed in to an account, nyssa asks if you want to logout of the former account. simply enter `y` and nyssa automatically logs out the former account signed in.
37 | 
38 | To explicitly sign out of all accounts, run the command `nyssa account logout`.
39 | 
40 | 


--------------------------------------------------------------------------------
/docs/publishing-packages.md:
--------------------------------------------------------------------------------
 1 | # Publishing packages
 2 | 
 3 | Nyssa packages are simply nyssa projects published on a Nyssa repository. This document highlights the steps and guides to publishing a package to a repository.
 4 | 
 5 | ### Package name guidelines
 6 | 
 7 | Before publishing a package, there are a few things you should consider when choosing a package name.
 8 | 
 9 | 1. It must be unique. Package names are unique throughout a repository irrespective of who publishes them. 
10 |   
11 |   It is advisable to first search the repository you want to publish to (such as [nyssa.bladelang.com](nyssa.bladelang.com)) for any package already using the name you want to choose. 
12 |   
13 |   > It is also highly possible but not conventional to have the same package published under different names in different repositories.
14 | 2. It should be descriptive.
15 | 3. It should not infringe on a someone else's trademarks nor be misleading.
16 | 
17 | Also, a good package names should be useable as a good variable names.
18 | 
19 | ### The README.md file
20 | 
21 | One of the files generated by nyssa during `nyssa init` is the `README.md` file. Before publishing a package, do your best to communicate as much information and/or documentation as you can in this file because this is the file that will be shown to people who come to browse your package on repositories.
22 | 
23 | > The file is a Markdown file and should be treated as such. You can check Github's guide on [Markdown](https://guides.github.com/features/mastering-markdown/#what) to help you write more appealing READMEs.
24 | 
25 | ### Semantic versioning
26 | 
27 | Everytime you publish a new package or an update to an existing package, nyssa _requires_ that the package version changes as well. Following the semantic versioning when changing/updating this version helps keep the ecosystem clean and predictable as well as easy to navigate for other developers.
28 | 
29 | When introducing a breaking change to a package, it's recommended that you increment the major version of the package.
30 | 
31 | ### Publishing to a repository
32 | 
33 | Before you can publish an application, you must have created and be logged in to a publisher account. See [this guide](/docs/publishers-account) on how to do that.
34 | 
35 | Once you are logged in to your publisher account, simply run the command `nyssa publish` from the root of your package and nyssa will take care of the rest.
36 | 
37 | ### Testing your package
38 | 
39 | One very important first things to do after publishing a package is testing that the package actually works and is importable in other applications without causing a crash or undesired side-effects.
40 | 
41 | To test your application after publising to a repository,
42 | 
43 | - Create a new directory outside of your project (e.g. `sample`) and open a new terminal session in the directory. This can be done on Unix devices like this:
44 | 
45 | ```
46 | mkdir sample
47 | cd sample
48 | ```
49 | 
50 | - Create a new nyssa application in the directory by running `nyssa init`.
51 | - Run the command `nyssa install <package_name>`.
52 | - Open the file at `app/index.b` and insert code to import your package before every code in the file. E.g.
53 | 
54 | ```
55 | import <package_name>
56 | echo 'Welcome to Nyssa. Magic begins here!'
57 | ```
58 | 
59 | - Run the application (`blade .`)
60 | 
61 | If all goes well without crashing, then your package can be imported without crashing the user's application. From here on, you can write more tests.
62 | 
63 | > In this example, the package_name was `my_package`.
64 | 


--------------------------------------------------------------------------------
/examples/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/examples/.gitignore


--------------------------------------------------------------------------------
/index.b:
--------------------------------------------------------------------------------
1 | import .app { * }


--------------------------------------------------------------------------------
/nyssa:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | if [[ ! $(command -v blade) ]]; then
 4 |   echo "Blade is not installed or not in path."
 5 |   exit 1
 6 | fi
 7 | 
 8 | NYSSA_DIR=`dirname $0`
 9 | BLADE_EXE=`which blade`
10 | 
11 | exec $BLADE_EXE $NYSSA_DIR "$@"
12 | 


--------------------------------------------------------------------------------
/nyssa-cli.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/nyssa-cli.png


--------------------------------------------------------------------------------
/nyssa.cmd:
--------------------------------------------------------------------------------
 1 | @ECHO OFF
 2 | SETLOCAL
 3 | SET "NYSSA_DIR=%~dp0"
 4 | 
 5 | @REM Find Blade executable
 6 | for %%i in (blade.exe) do SET "BLADE_EXE=%%~$PATH:i"
 7 | 
 8 | if defined BLADE_EXE (
 9 |     GOTO :RUN
10 | ) else (
11 |     GOTO :ERROR
12 | )
13 | 
14 | :ERROR
15 | SET msgboxTitle=Nyssa
16 | SET msgboxBody=Blade is not installed or not in path.
17 | SET tmpmsgbox=%temp%\~tmpmsgbox.vbs
18 | IF EXIST "%tmpmsgbox%" DEL /F /Q "%tmpmsgbox%"
19 | ECHO msgbox "%msgboxBody%",0,"%msgboxTitle%">"%tmpmsgbox%"
20 | WSCRIPT "%tmpmsgbox%"
21 | EXIT /B 1
22 | 
23 | :RUN
24 | 
25 | :: @TODO: Remove the executable name and script path from the commands 
26 | :: passed to the running script.
27 | 
28 | %BLADE_EXE% %NYSSA_DIR% %*
29 | EXIT /B 0
30 | 


--------------------------------------------------------------------------------
/nyssa.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "nyssa", 
 3 |   "version": "0.1.9", 
 4 |   "description": "A package manager and repository for the Blade programming language.", 
 5 |   "homepage": "", 
 6 |   "tags": [
 7 |     "nyssa", 
 8 |     "blade", 
 9 |     "package-manager",
10 |     "tools"
11 |   ], 
12 |   "author": "Richard Ore <eqliqandfriends@gmail.com>", 
13 |   "license": "MIT", 
14 |   "sources": [
15 |     "https://nyssa.bladelang.com"
16 |   ], 
17 |   "deps": {
18 |     "drawdown": "1.0.1"
19 |   }
20 | }


--------------------------------------------------------------------------------
/nyssa.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/nyssa.png


--------------------------------------------------------------------------------
/public/css/style.css:
--------------------------------------------------------------------------------
  1 | * {
  2 |   box-sizing: border-box;
  3 | }
  4 | 
  5 | body.no-term-color .navbar, body.no-term-color .footer {
  6 |   background-color: transparent !important;
  7 | }
  8 | 
  9 | body.has-head-color .navbar {
 10 |   border-bottom: 1px solid rgba(0, 0, 0, .05);
 11 | }
 12 | 
 13 | body.no-foot-color .footer {
 14 |   background-color: transparent !important;
 15 | }
 16 | 
 17 | a {
 18 |   color: #10907c;
 19 | }
 20 | 
 21 | a:hover {
 22 |   color: #11c1a6;
 23 | }
 24 | 
 25 | input:focus {
 26 |   box-shadow: none !important;
 27 | }
 28 | 
 29 | pre {
 30 |   white-space: pre-wrap;
 31 |   border-radius: .25rem;
 32 | }
 33 | 
 34 | .columns {
 35 |   margin: 0;
 36 | }
 37 | 
 38 | .divide {
 39 |   border-bottom: 1px solid rgba(0, 0, 0, .05);
 40 | }
 41 | 
 42 | .hero {
 43 |   border-bottom: 1px solid #d0f2ed;
 44 |   position: relative;
 45 | }
 46 | 
 47 | .hero::before, .stats::before {    
 48 |   content: "";
 49 |   background-image: url(../images/hero-bg-1.png);
 50 |   position: absolute;
 51 |   top: 0px;
 52 |   right: 0px;
 53 |   bottom: 0px;
 54 |   left: 0px;
 55 |   opacity: 0.25;
 56 | }
 57 | 
 58 | .hero .control.has-icons-left .input:focus~.icon, .navi .control.has-icons-left .input:focus~.icon {
 59 |   color: #04d1b3;
 60 | }
 61 | 
 62 | .navbar-item, .navbar-link {
 63 |   color: #7d7d7d;
 64 |   font-weight: 500;
 65 | }
 66 | 
 67 | .navbar a.navbar-item:hover, .navbar a.navbar-item:focus {
 68 |   background-color: #0000;
 69 |   color: #4e4e4e;
 70 | }
 71 | 
 72 | .fill-image img {
 73 |   max-width: 100%;
 74 | }
 75 | 
 76 | .vertical-middle {
 77 |   vertical-align: middle;
 78 | }
 79 | 
 80 | .px-12 {
 81 |   padding-left: 6rem !important;
 82 |   padding-right: 6rem !important;
 83 | }
 84 | 
 85 | .py-12 {
 86 |   padding-top: 6rem !important;
 87 |   padding-bottom: 6rem !important;
 88 | }
 89 | 
 90 | .stats {
 91 |   position: relative;
 92 | }
 93 | 
 94 | .stats .media+.media {
 95 |   border-top: 0;
 96 |   margin-top: 0;
 97 |   padding-top: 0;
 98 | }
 99 | 
100 | .tile.is-child {
101 |   margin: 1rem !important;
102 |   padding: 1rem;
103 |   box-shadow: 0 0 10px rgb(0, 0, 0, .1);
104 |   border-radius: 0.5em;
105 |   border: 1px solid rgba(0, 0, 0, .05);
106 | }
107 | 
108 | .tile.is-child .title {
109 |   font-size: 1.25rem;
110 | }
111 | 
112 | .tile.is-child .subtitle {
113 |   font-size: .95rem;
114 |   margin-bottom: 0.75rem;
115 | }
116 | 
117 | .tile.is-child .content {
118 |   font-size: .9rem;
119 | }
120 | 
121 | .tile .timestamp {
122 |   font-size: .95rem;
123 |   border-bottom: 1px solid rgba(0, 0, 0, .1);
124 |   margin-bottom: 0.25rem;
125 |   padding-bottom: 0.25rem;
126 |   color: #999;
127 | }
128 | 
129 | .line-top {
130 |   border-top: 2px solid rgba(0, 0, 0, .05);
131 | }
132 | 
133 | footer nav a {
134 |   margin: 0 1em;
135 | }
136 | 
137 | footer nav a:first-of-type {
138 |   margin-left: 0;
139 | }
140 | 
141 | footer nav a:last-of-type{
142 |   margin-right: 0;
143 |   border-right: 0;
144 | }
145 | 
146 | footer nav span {
147 |   border-right: 1px solid rgba(0, 0, 0, .1);
148 | }
149 | 
150 | .search-item {
151 |   padding-bottom: 1rem;
152 |   padding-top: 1rem;
153 |   border-top: 1px solid rgb(0, 0, 0, .1);
154 | }
155 | 
156 | .search-item:first-of-type {
157 |   border-top: 0;
158 | }
159 | 
160 | .search-item .title {
161 |   font-size: 1.5rem;
162 | }
163 | 
164 | .search-item .subtitle {
165 |   font-size: 1rem;
166 |   color: #999;
167 |   margin-bottom: .95rem;
168 | }
169 | 
170 | .tabs li.is-active a {
171 |   border-bottom-color: #00d1b2;
172 |   color: #0fa08a;
173 | }
174 | 
175 | pre.has-icon {
176 |   position: relative;
177 |   display: flex;
178 |   overflow: initial;
179 | }
180 | 
181 | pre.has-icon .code {
182 |   flex: 1;
183 | }
184 | 
185 | pre.has-icon .icon {
186 |   position: relative;
187 |   cursor: pointer;
188 | }
189 | 
190 | .offscreen {
191 |   position: fixed;
192 |   top: -10000em;
193 | }
194 | 
195 | #copy-command {
196 |   position: relative;
197 |   transition: all 0.5s ease-out;
198 | }
199 | 
200 | #copy-command::after {
201 |   position: absolute;
202 |   content: attr(data-tip);
203 |   bottom: -2.5em;
204 |   padding: 0.25em 0.5em;
205 |   background: #04d1b2;
206 |   color: #fff;
207 |   border-radius: 0.25em;
208 |   display: none;
209 |   transition: display 1s;
210 | }
211 | 
212 | #copy-command::before {
213 |   content: "";
214 |   border-left: 8px solid #0000;
215 |   border-right: 8px solid #0000;
216 |   position: absolute;
217 |   bottom: -0.65em;
218 |   width: 8px;
219 |   height: 8px;
220 |   border-bottom: 8px solid #04d1b2;
221 |   display: none;
222 |   transition: display 1s;
223 | }
224 | 
225 | #copy-command.open {
226 |   color: #04d1b2;
227 | }
228 | 
229 | #copy-command.open::before, #copy-command.open::after {
230 |   display: inline;
231 | }
232 | 
233 | .field-label {
234 |   text-align: inherit;
235 |   margin-right: 0;
236 | }
237 | 
238 | .notification.clean {
239 |   border-radius: 0;
240 |   padding: .5em;
241 |   text-align: center;
242 | }
243 | 
244 | .title code {
245 |   font-size: 60%;
246 | }
247 | 
248 | .is-relative {
249 |   position: relative;
250 | }
251 | 
252 | .is-absolute {
253 |   position: absolute;
254 | }
255 | 
256 | .hero .buttons {
257 |   bottom: -2em;
258 |   display: block;
259 |   width: 100%;
260 |   left: 0;
261 |   right: 0;
262 | }
263 | 
264 | .hero .buttons .button .icon-text span {
265 |   line-height: 1.5;
266 | }
267 | 
268 | .content.doc h3 {
269 |   border-bottom: 1px solid rgba(0, 0, 0, .1);
270 |   padding-bottom: .5em;
271 | }
272 | 
273 | .content.doc h1 {
274 |   border-bottom: 4px solid #0000001a;
275 |   padding-bottom: .5rem;
276 | }
277 | 
278 | .content.doc blockquote {
279 |   margin-top: .5em;
280 |   border-color: #ffe08a;
281 |   color: #946c00;
282 |   background-color: #fffaeb;
283 | }
284 | 
285 | .content.doc blockquote strong {
286 |   color: inherit;
287 | }
288 | 
289 | .content.doc p {
290 |   margin: 1em 0;
291 | }
292 | 
293 | .menu-list a.is-active {
294 |   background-color: #10907c;
295 | }
296 | 
297 | .is-mobile {
298 |   display: none !important;
299 | }
300 | 
301 | @media (max-width: 60em) {
302 |   .navbar-menu {
303 |     display: block;
304 |     background-color: #ebfffc!important;
305 |   }
306 |   .hero .buttons {
307 |     display: flex;
308 |     justify-content: center;
309 |   }
310 |   .px-12 {
311 |     padding-left: 1.5em !important;
312 |     padding-right: 1.5em !important;
313 |   }
314 |   .px-6 {
315 |     padding-left: 1em !important;
316 |     padding-right: 1em !important;
317 |   }
318 |   .px-12 .px-6 {
319 |     padding-left: 0 !important;
320 |     padding-right: 0 !important;
321 |   }
322 |   .stats .media+.media {
323 |     padding-top: 2em;
324 |   }
325 |   .tile.is-child {
326 |     margin-left: 0.25em !important;
327 |     margin-right: 0.25em !important;
328 |   }
329 |   .f-logo, .navbar-end {
330 |     display: none;
331 |   }
332 |   .navbar-menu {
333 |     box-shadow: none;
334 |   }
335 |   .navbar-item {
336 |     display: inline-flex;
337 |   }
338 | 
339 |   .is-mobile {
340 |     display: inline-flex !important;
341 |   }
342 | }
343 | 
344 | @media (max-width: 43em) {
345 |   .hero .buttons {
346 |     display: flex;
347 |     bottom: -4em;
348 |   }
349 | 
350 |   .is-mobile {
351 |     display:  inline-flex !important;
352 |   }
353 | }
354 | 


--------------------------------------------------------------------------------
/public/images/android-chrome-192x192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/android-chrome-192x192.png


--------------------------------------------------------------------------------
/public/images/android-chrome-512x512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/android-chrome-512x512.png


--------------------------------------------------------------------------------
/public/images/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/apple-touch-icon.png


--------------------------------------------------------------------------------
/public/images/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/favicon-16x16.png


--------------------------------------------------------------------------------
/public/images/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/favicon-32x32.png


--------------------------------------------------------------------------------
/public/images/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/favicon.ico


--------------------------------------------------------------------------------
/public/images/hero-bg-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/hero-bg-1.png


--------------------------------------------------------------------------------
/public/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/public/images/logo.png


--------------------------------------------------------------------------------
/public/images/svg/github.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 496 512" width="16px"><!--! Font Awesome Pro 6.2.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path fill="currentColor" d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg>


--------------------------------------------------------------------------------
/public/site.webmanifest:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "Nyssa",
 3 |   "short_name": "nyssa",
 4 |   "icons": [
 5 |     {
 6 |       "src": "/static/images/android-chrome-192x192.png",
 7 |       "sizes": "192x192",
 8 |       "type": "image/png"
 9 |     },
10 |     {
11 |       "src": "/static/images/android-chrome-512x512.png",
12 |       "sizes": "512x512",
13 |       "type": "image/png"
14 |     }
15 |   ],
16 |   "theme_color": "#00d1b2",
17 |   "background_color": "#ebfffc",
18 |   "display": "standalone"
19 | }
20 | 


--------------------------------------------------------------------------------
/templates/404.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <include path="inc/meta.html" />
 5 |   <title>404 - Nyssa Package Manager</title>
 6 | </head>
 7 | <body class="no-term-color">
 8 |   <include path="inc/header.html" />
 9 | 
10 |   <section class="columns is-justify-content-center py-6 my-6">
11 |     <div class="column is-half">
12 |       <div class="content has-text-centered">
13 |         <div class="title is-size-1">404</div>
14 |         <div class="subtitle">The page you are looking for cannot be found.</div>
15 |       </div>
16 |     </div>
17 |   </section>
18 | 
19 |   <include path="inc/footer.html" />
20 | </body>
21 | </html>


--------------------------------------------------------------------------------
/templates/account.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |   <include path="inc/meta.html" />
  5 |   <title>@{user.username} - Nyssa Package Manager</title>
  6 | </head>
  7 | <body class="has-head-color no-foot-color">
  8 |   <include path="inc/header.html" />
  9 | 
 10 |   <section class="container py-6">
 11 |     <div class="columns is-justify-content-center">
 12 |       <div class="column is-one-quarter">
 13 |         <div class="mb-4">
 14 |           <a class="button is-warning is-light" href="/logout">Log Out</a>
 15 |         </div>
 16 |         <article class="message is-info">
 17 |           <div class="message-header">
 18 |             <p>About: Revert to version</p>
 19 |           </div>
 20 |           <div class="message-body">
 21 |             When you revert a package to another version, all versions higher than that version will 
 22 |             become unavailable in search results and that version will be the default for new installations, 
 23 |             but users who have installed them or wrote applications depending on them will still be able 
 24 |             to download it.<br/><br/>
 25 |             However, this means you won't be able to upload new versions of the application to replace the 
 26 |             reverted versions.
 27 |           </div>
 28 |         </article>
 29 |       </div>
 30 |       <div class="column is-three-quarters pl-6">
 31 |         <div class="title">My Packages</div>
 32 |         <div class="notification is-primary" ny-if="message">
 33 |           <button class="delete"></button>
 34 |           {message}
 35 |         </div>
 36 |         <div class="mb-4" ny-if="result.packages">
 37 |           Showing result {result.start|plus_one} to {result.end} of {result.total} (page {result.page} of {result.pages})
 38 |         </div>
 39 |         <div class="search-result">
 40 |           <div class="search-item" ny-for="result.packages" ny-key="package">
 41 |             <div class="title">
 42 |               <a href="/view/{package.name}">
 43 |                 {package.name}
 44 |                 <code ny-if="package.deleted_at"><small> - Archived</small></code>
 45 |               </a>
 46 |             </div>
 47 |             <div class="subtitle">
 48 |               Latest Version: <span>{package.version}</span>, Last Published: <span>{package.created_at}</span>, Total Downloads: <span>{package.downloads|format_number}</span>
 49 |             </div>
 50 |             <div class="content">
 51 |               <div class="tags mb-2">
 52 |                 <a href="/search?q={v.version}" class="tag is-light" ny-for="package.versions" ny-key="v">v{v.version}</a>
 53 |               </div>
 54 |               <div>
 55 |                 <span ny-if="package.description">
 56 |                   {package.description|strip_line}
 57 |                 </span>
 58 |                 <em ny-not="package.description">No description.</em>
 59 |               </div>
 60 |               <div class="tags mt-4" ny-if="package.tags">
 61 |                 <a href="/search?q={tag}" class="tag is-light" ny-for="package.tags" ny-key="tag">{tag}</a>
 62 |               </div>
 63 |               <div class="mt-2" ny-if="package.versions|can_revert">
 64 |                 <form class="revert-form field is-horizontal" method="post" action="/revert">
 65 |                   <input type="hidden" name="name" value="{package.name}" />
 66 |                   <div class="field-label is-small">
 67 |                     <label class="label">Revert to version:</label>
 68 |                   </div>
 69 |                   <div class="field-body is-narrow">
 70 |                     <div class="field has-addons">
 71 |                       <div class="control">
 72 |                         <div class="select is-small">
 73 |                           <select name="version" class="input">
 74 |                             <option value="{v.version}" ny-for="package.versions" ny-key="v">{v.version}</option>
 75 |                           </select>
 76 |                         </div>
 77 |                       </div>
 78 |                       <div class="control">
 79 |                         <button class="button is-warning is-small">Revert</button>
 80 |                       </div>
 81 |                       <div class="control">
 82 |                         <a class="button is-danger is-small" href="/archive/{package.name}" ny-not="package.deleted_at">Archive</a>
 83 |                       </div>
 84 |                     </div>
 85 |                   </div>
 86 |                 </form>
 87 |               </div>
 88 |               <div class="mt-2" ny-not="package.versions|can_revert">
 89 |                 <a class="button is-danger is-small" href="/archive/{package.name}" ny-not="package.deleted_at">Archive</a>
 90 |               </div>
 91 |             </div>
 92 |           </div>
 93 |           <div class="has-text-centered" ny-not="result.packages">
 94 |             No package found matching the term "{query}"
 95 |           </div>
 96 |         </div>
 97 |         <nav class="pagination mt-6" role="navigation" aria-label="pagination" ny-if="result.packages">
 98 |           <ul class="pagination-list">
 99 |             <li ny-for="pages" ny-key="p">
100 |               <a ny-if="p.active" class="pagination-link is-current" aria-label="Goto page {p.page}">{p.page}</a>
101 |               <a ny-not="p.active" href="/search?q={query}&page={p.page}" class="pagination-link" aria-label="Goto page {p.page}">{p.page}</a>
102 |             </li>
103 |           </ul>
104 |         </nav>
105 |       </div>
106 |     </div>
107 |   </section>
108 | 
109 |   <include path="inc/footer.html" />
110 | 
111 |   <script>
112 |     function revertFormSubmit(event) {
113 |       event.preventDefault();
114 |     }
115 |     document.addEventListener('DOMContentLoaded', function() {
116 |       document.querySelectorAll('form.revert-form').forEach(function(el) {
117 |         el.addEventListener('submit', function(e) {
118 |           e.preventDefault()
119 |           e.stopPropagation()
120 | 
121 |           if(confirm('Are you sure you want to revert the package "' +el.name.value+ '" to version "' +el.version.value+ '"')) {
122 |             el.submit()
123 |           }
124 |         })
125 |       })
126 | 
127 |       var ex = document.querySelector('.notification .delete')
128 |       if(ex) {
129 |         ex.addEventListener('click', function() {
130 |           var el = document.querySelector('.notification')
131 |           el.parentElement.removeChild(el)
132 |         })
133 |       }
134 |     })
135 |   </script>
136 | </body>
137 | </html>


--------------------------------------------------------------------------------
/templates/doc.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <include path="inc/meta.html" />
 5 |   <title>{uri|file_title} - Nyssa Package Manager</title>
 6 | </head>
 7 | <body class="has-head-color no-foot-color">
 8 |   <include path="inc/header.html" />
 9 | 
10 |   <section class="container py-6">
11 |     <div class="columns is-justify-content-center">
12 |       <div class="column is-one-quarter">
13 |         <aside class="menu">
14 |           <p class="menu-label">
15 |             Docs
16 |           </p>
17 |           <ul class="menu-list">
18 |             <li ny-for="doc_files" ny-key="f">
19 |               <a class="is-active" ny-if="f|no_ext|eq=uri" href="/docs/{f|no_ext}">{f|file_title}</a>
20 |               <a ny-not="f|no_ext|eq=uri" href="/docs/{f|no_ext}">{f|file_title}</a>
21 |             </li>
22 |           </ul>
23 |         </aside>
24 |       </div>
25 |       <div class="column is-three-quarters pl-6">
26 |         <div class="content doc">{content|draw}</div>
27 |       </div>
28 |     </div>
29 |   </section>
30 | 
31 |   <include path="inc/footer.html" />
32 | </body>
33 | </html>


--------------------------------------------------------------------------------
/templates/home.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en" class="has-background-primary-light">
  3 | <head>
  4 |   <include path="inc/meta.html" />
  5 |   <title>Nyssa Package Manager</title>
  6 | </head>
  7 | <body class="">
  8 |   <include path="inc/header.html" />
  9 | 
 10 |   <div class="notification is-warning clean">
 11 |     <strong>Nyssa support Blade v0.0.77 and above.</strong>
 12 |   </div>
 13 | 
 14 |   <section class="hero has-background-primary-light is-halfheight is-reletive">
 15 |     <div class="hero-body">
 16 |       <div class="container is-max-desktop has-text-centered">
 17 |         <include path="inc/logo.html" />
 18 |         <div class="subtitle">The official Blade language package manager</div>
 19 | 
 20 |         <div class="my-6">
 21 |           <include path="inc/search-bar.html" />
 22 |         </div>
 23 |       </div>
 24 |     </div>
 25 |     <div class="container buttons are-large has-text-centered is-absolute">
 26 |       <a class="button is-danger px-6" href="https://github.com/blade-lang/nyssa/releases/download/v{nyssa_version}/nyssa-v{nyssa_version}.zip" target="_blank">
 27 |         <span class="icon-text">
 28 |           <span class="icon">
 29 |             <i class="fas fa-download"></i>
 30 |           </span>
 31 |           <span>Download</span>
 32 |         </span>
 33 |       </a>
 34 |       <a class="button is-link px-6" href="/docs">
 35 |         <span class="icon-text">
 36 |           <span class="icon">
 37 |             <i class="fas fa-book"></i>
 38 |           </span>
 39 |           <span>Get Started</span>
 40 |         </span>
 41 |       </a>
 42 |     </div>
 43 |   </section>
 44 | 
 45 |   <section class="px-12 py-12 has-background-white">
 46 |     <div class="container is-max-desktop">
 47 |       <div class="px-6 has-text-centered">
 48 |         <h3 class="is-size-3 mb-4 has-text-primary">What is Nyssa?</h3>
 49 |         <h1 class="is-size-1 mb-6 has-text-weight-bold">An extension to Blade package management</h1>
 50 |         <p class="is-size-5">
 51 |           Nyssa is a simple abstraction on top of Blade's built-in package management facilities to provide a managed system of creating and consuming packages as well as manage their dependencies. Nyssa also provides you with a self-hostable package repository that can be used privately in organisations at large. 
 52 |           <!-- <br><br>
 53 |           This website/domain is a community powered public and general-purpose instance of Nyssa. -->
 54 |         </p>
 55 |       </div>
 56 |     </div>
 57 |   </section>
 58 | 
 59 |   <section class="px-12 py-12 has-background-primary has-text-white">
 60 |     <div class="level stats">
 61 |       <article class="media">
 62 |         <figure class="media-left">
 63 |           <p class="image">
 64 |             <i class="fa-solid fa-users" style="font-size: 64px;"></i>
 65 |           </p>
 66 |         </figure>
 67 |         <div class="media-content">
 68 |           <p class="heading is-size-6">Authors</p>
 69 |           <p class="title is-size-3 has-text-white">{publishers|format_number}</p>
 70 |         </div>
 71 |       </article>
 72 |       <article class="media">
 73 |         <figure class="media-left">
 74 |           <p class="image">
 75 |             <i class="fa-solid fa-cubes" style="font-size: 64px;"></i>
 76 |           </p>
 77 |         </figure>
 78 |         <div class="media-content">
 79 |           <p class="heading is-size-6">Total Packages</p>
 80 |           <p class="title is-size-3 has-text-white">{packages|format_number}</p>
 81 |         </div>
 82 |       </article>
 83 |       <article class="media">
 84 |         <figure class="media-left">
 85 |           <p class="image">
 86 |             <i class="fa fa-download" style="font-size: 64px;"></i>
 87 |           </p>
 88 |         </figure>
 89 |         <div class="media-content">
 90 |           <p class="heading is-size-6">Downloads</p>
 91 |           <p class="title is-size-3 has-text-white">{downloads|format_number}</p>
 92 |         </div>
 93 |       </article>
 94 |     </div>
 95 |   </section>
 96 |   
 97 |   <section class="py-12 has-background-white">
 98 |     <div class="px-12 pt-4">
 99 |       <div class="container">
100 |         <div class="px-6">
101 |           <h3 class="is-size-4 mb-4 has-text-primary has-text-centered">
102 |             Top Packages
103 |           </h3>
104 |           <div>
105 |             <div class="tile is-parent">
106 |               <div class="tile is-child" ny-for="top_packages" ny-key="package">
107 |                 <div class="title">
108 |                   <a href="/view/{package.name}">{package.name}</a>
109 |                 </div>
110 |                 <div class="subtitle">
111 |                   <a href="/search?q={package.publisher}">@{package.publisher}</a>
112 |                 </div>
113 |                 <div class="content">
114 |                   <span ny-if="package.description">{package.description}</span>
115 |                   <em ny-not="package.description">No description given.</em>
116 |                 </div>
117 |               </div>
118 |               <div class="has-text-centered" style="width: 100%;" ny-not="top_packages">
119 |                 <em>No packages found in this repository.</em>
120 |               </div>
121 |             </div>
122 |           </div>
123 |         </div>
124 |       </div>
125 |   
126 |       <div class="container pt-6 pb-4">
127 |         <div class="px-6">
128 |           <h3 class="is-size-4 mb-4 has-text-primary has-text-centered">
129 |             Latest Packages
130 |           </h3>
131 |           <div>
132 |             <div class="tile is-parent">
133 |               <div class="tile is-child" ny-for="latest_packages" ny-key="package">
134 |                 <div class="timestamp">
135 |                   <small>{package.date_created}</small>
136 |                 </div>
137 |                 <div class="title">
138 |                   <a href="/view/{package.name}">{package.name}</a>
139 |                 </div>
140 |                 <div class="subtitle">
141 |                   <a href="/search?q={package.publisher}">@{package.publisher}</a>
142 |                 </div>
143 |                 <div class="content">
144 |                   <span ny-if="package.description">{package.description}</span>
145 |                   <em ny-not="package.description">No description given.</em>
146 |                 </div>
147 |               </div>
148 |               <div class="has-text-centered" style="width: 100%;" ny-not="latest_packages">
149 |                 <em>No packages found in this repository.</em>
150 |               </div>
151 |             </div>
152 |           </div>
153 |         </div>
154 |       </div>
155 |     </div>
156 |   </section>
157 | 
158 |   <include path="inc/footer.html" />
159 | </body>
160 | </html>


--------------------------------------------------------------------------------
/templates/inc/footer.html:
--------------------------------------------------------------------------------
 1 | <footer class="footer">
 2 |   <div class="content">
 3 |     <div class="columns">
 4 |       <div class="column is-one-quarter has-text-right f-logo">
 5 |         <img src="/static/images/logo.png" width="56px" class="vertical-middle" />
 6 |       </div>
 7 |       <div class="column is-three-quarter">
 8 |         <nav>
 9 |           <a href="https://bladelang.com">Blade</a>
10 |           <span></span>
11 |           <a href="https://github.com/blade-lang/blade/blob/main/CODE_OF_CONDUCT.md">Code of Conduct</a>
12 |           <span></span>
13 |           <a href="https://github.com/blade-lang/nyssa/blob/main/LICENSE">License</a>
14 |           <span></span>
15 |           <a href="https://github.com/blade-lang/nyssa/issues/new">Bug Report</a>
16 |         </nav>
17 |         <p>
18 |           <strong>Nyssa</strong> by <a href="https://github.com/blade-lang">Blade Contributors</a>. The source code is licensed
19 |           <a href="http://opensource.org/licenses/mit-license.php" target="_blank">MIT</a>. The website content
20 |           is licensed <a href="http://creativecommons.org/licenses/by-nc-sa/4.0/" target="_blank">CC BY NC SA 4.0</a>.
21 |         </p>
22 |       </div>
23 |     </div>
24 |   </div>
25 | </footer>


--------------------------------------------------------------------------------
/templates/inc/header.html:
--------------------------------------------------------------------------------
 1 | <nav class="navbar has-background-primary-light">
 2 |   <div class="container">
 3 |     <div id="navMenu" class="navbar-menu">
 4 |       <div class="navbar-start">
 5 |         <a class="navbar-item" href="/">
 6 |           Home
 7 |         </a>
 8 |         <a class="navbar-item" href="/docs">
 9 |           Getting Started
10 |         </a>
11 |         <a class="navbar-item is-mobile" href="/login" ny-if="show_login">Login</a>
12 |         <a class="navbar-item is-link  is-mobile" href="/account" ny-not="show_login">
13 |           <span class="icon-text">
14 |             <span class="icon">
15 |               <i class="fas fa-user"></i>
16 |             </span>
17 |             <span>My Account</span>
18 |           </span>
19 |         </a>
20 |         <a class="navbar-item is-dark is-mobile" href="https://github.com/blade-lang/nyssa" target="_blank">
21 |           <span class="icon-text">
22 |             <span class="icon">
23 |               <i class="fa-brands fa-github"></i>
24 |             </span>
25 |             <span>Github</span>
26 |           </span>
27 |         </a>
28 |       </div>
29 | 
30 |       <div class="navbar-end">
31 |         <div class="navbar-item">
32 |           <div class="buttons">
33 |             <a class="button" href="/login" ny-if="show_login">Login</a>
34 |             <a class="button is-link" href="/account" ny-not="show_login">
35 |               <span class="icon-text">
36 |                 <span class="icon">
37 |                   <i class="fas fa-user"></i>
38 |                 </span>
39 |                 <span>My Account</span>
40 |               </span>
41 |             </a>
42 |             <a class="button is-dark" href="https://github.com/blade-lang/nyssa" target="_blank">
43 |               <span class="icon-text">
44 |                 <span class="icon">
45 |                   <i class="fa-brands fa-github"></i>
46 |                 </span>
47 |                 <span>Github</span>
48 |               </span>
49 |             </a>
50 |           </div>
51 |         </div>
52 |       </div>
53 |     </div>
54 |   </div>
55 | </nav>


--------------------------------------------------------------------------------
/templates/inc/logo.html:
--------------------------------------------------------------------------------
1 | <h1 class="title is-size-1 mt-6 has-text-primary is-spaced">
2 |   <img src="/static/images/logo.png" width="56px" class="vertical-middle" alt="Nyssa logo" />
3 |   <span class="vertical-middle has-text-weight-bold">Nyssa</span>
4 | </h1>


--------------------------------------------------------------------------------
/templates/inc/meta.html:
--------------------------------------------------------------------------------
 1 | <meta charset="UTF-8">
 2 | <meta http-equiv="X-UA-Compatible" content="IE=edge">
 3 | <meta name="viewport" content="width=device-width, initial-scale=1.0">
 4 | <link rel="stylesheet" href="/static/css/bulma.min.css">
 5 | <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6.2.1/css/all.min.css">
 6 | <link rel="stylesheet" href="/static/css/style.css">
 7 | <link rel="apple-touch-icon" sizes="180x180" href="/images/apple-touch-icon.png">
 8 | <link rel="icon" type="image/png" sizes="32x32" href="/static/images/favicon-32x32.png">
 9 | <link rel="icon" type="image/png" sizes="16x16" href="/static/images/favicon-16x16.png">
10 | <link rel="manifest" href="/static/site.webmanifest">


--------------------------------------------------------------------------------
/templates/inc/search-bar.html:
--------------------------------------------------------------------------------
 1 | <form action="/search" name="searchform">
 2 |   <div class="field has-addons columns">
 3 |     <div class="control column p-0 has-icons-left">
 4 |       <input type="text" placeholder="Search..." name="q" class="input is-primary px-5 py-5 pl-6" value="{query}" />
 5 |       <span class="icon is-left mt-1 ml-1">
 6 |         <i class="fa-solid fa-magnifying-glass"></i>
 7 |       </span>
 8 |     </div>
 9 |     <input type="hidden" name="sort" />
10 |     <div class="control">
11 |       <button class="button is-primary px-6 py-5 has-text-weight-bold">Search</button>
12 |     </div>
13 |   </div>
14 | </form>


--------------------------------------------------------------------------------
/templates/login.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <include path="inc/meta.html" />
 5 |   <title>Login - Nyssa Package Manager</title>
 6 | </head>
 7 | <body class="no-term-color">
 8 |   <include path="inc/header.html" />
 9 | 
10 |   <section class="columns is-justify-content-center">
11 |     <form class="column is-one-quarter py-4 my-2" method="POST" action="/auth">
12 |       <div class="has-text-centered mb-6">
13 |         <include path="inc/logo.html" />
14 |       </div>
15 | 
16 |       <article class="message is-danger" ny-if="error">
17 |         <div class="message-body"><small>Invalid Credentials</small></div>
18 |       </article>
19 | 
20 |       <div class="field">
21 |         <p class="control has-icons-left">
22 |           <input class="input" type="text" placeholder="Username" name="username">
23 |           <span class="icon is-small is-left">
24 |             <i class="fas fa-user"></i>
25 |           </span>
26 |         </p>
27 |       </div>
28 |       <div class="field">
29 |         <p class="control has-icons-left">
30 |           <input class="input" type="password" placeholder="Password" name="password">
31 |           <span class="icon is-small is-left">
32 |             <i class="fas fa-lock"></i>
33 |           </span>
34 |         </p>
35 |       </div>
36 |       <div class="control">
37 |         <button class="button is-primary is-fullwidth" type="submit">Login to Publisher account</button>
38 |       </div>
39 |       <div class="control mt-4">
40 |         <a href="/recover">I forgot my password</a>
41 |       </div>
42 |       <div class="box mt-4">
43 |         <small>To create an account, run the following command from your local installation:</small>
44 |         <br>
45 |         <code>nyssa account create</code>
46 |       </div>
47 |     </form>
48 |   </section>
49 | 
50 |   <include path="inc/footer.html" />
51 | </body>
52 | </html>


--------------------------------------------------------------------------------
/templates/search.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |   <include path="inc/meta.html" />
  5 |   <title>{query} - Nyssa Package Manager</title>
  6 | </head>
  7 | <body class="">
  8 |   <include path="inc/header.html" />
  9 |   <div class="has-background-primary-light px-6 pb-5 divide navi">
 10 |     <include path="inc/search-bar.html" />
 11 |   </div>
 12 |   
 13 |   <section class="py-6">
 14 |     <div class="container">
 15 |       <div class="columns">
 16 |         <form class="column is-one-quarter" name="sortform">
 17 |           <div class="content">
 18 |             <div class="title">Sort by</div>
 19 |           </div>
 20 |           <div class="control">
 21 |             <div>
 22 |               <label class="radio">
 23 |                 <input type="radio" name="order" value="name" ny-if="sort|sort_name" checked>
 24 |                 <input type="radio" name="order" value="name" ny-not="sort|sort_name">
 25 |                 Name
 26 |               </label>
 27 |             </div>
 28 |             <div>
 29 |               <label class="radio">
 30 |                 <input type="radio" name="order" value="downloads" ny-if="sort|sort_download" checked>
 31 |                 <input type="radio" name="order" value="downloads" ny-not="sort|sort_download">
 32 |                 Downloads
 33 |               </label>
 34 |             </div>
 35 |             <div>
 36 |               <label class="radio">
 37 |                 <input type="radio" name="order" value="created_at" ny-if="sort|sort_created" checked>
 38 |                 <input type="radio" name="order" value="created_at" ny-not="sort|sort_created">
 39 |                 Date Created
 40 |               </label>
 41 |             </div>
 42 |           </div>
 43 |         </form>
 44 |         <div class="column is-three-quarters">
 45 |           <div class="mb-4" ny-if="result.packages">
 46 |             Showing result {result.start|plus_one} to {result.end} of {result.total} (page {result.page} of {result.pages})
 47 |           </div>
 48 |           <div class="search-result">
 49 |             <div class="search-item" ny-for="result.packages" ny-key="package">
 50 |               <div class="title">
 51 |                 <a href="/view/{package.name}">{package.name}</a>
 52 |               </div>
 53 |               <div class="subtitle">
 54 |                 <a href="/search?q={package.publisher}">@{package.publisher}</a> published <span>{package.version}</span> at <span>{package.created_at}</span> with <span>{package.download|format_number}</span> downloads
 55 |               </div>
 56 |               <div class="content">
 57 |                 <div>
 58 |                   <span ny-if="package.description">
 59 |                     {package.description|strip_line}
 60 |                   </span>
 61 |                   <em ny-not="package.description">No description.</em>
 62 |                 </div>
 63 |                 <div class="tags mt-4" ny-if="package.tags">
 64 |                   <a href="/search?q={tag}" class="tag is-light" ny-for="package.tags" ny-key="tag">{tag}</a>
 65 |                 </div>
 66 |               </div>
 67 |             </div>
 68 |             <div class="has-text-centered" ny-not="result.packages">
 69 |               No package found matching the term "{query}"
 70 |             </div>
 71 |           </div>
 72 |           <nav class="pagination mt-6" role="navigation" aria-label="pagination" ny-if="result.packages">
 73 |             <ul class="pagination-list">
 74 |               <li ny-for="pages" ny-key="p">
 75 |                 <a ny-if="p.active" class="pagination-link is-current" aria-label="Goto page {p.page}">{p.page}</a>
 76 |                 <a ny-not="p.active" href="/search?q={query}&page={p.page}" class="pagination-link" aria-label="Goto page {p.page}">{p.page}</a>
 77 |               </li>
 78 |             </ul>
 79 |           </nav>
 80 |         </div>
 81 |       </div>
 82 |     </div>
 83 |   </section>
 84 | 
 85 |   <include path="inc/footer.html" />
 86 | 
 87 |   <script>
 88 |     document.addEventListener('DOMContentLoaded', function() {
 89 |       var rad = document.sortform.order;
 90 |       var prev = null;
 91 |       for (var i = 0; i < rad.length; i++) {
 92 |         rad[i].addEventListener('change', function() {
 93 |           if (this !== prev) {
 94 |             prev = this;
 95 |           }
 96 |           document.searchform.sort.value = this.value
 97 |           document.searchform.submit()
 98 |         });
 99 |       }
100 |     })
101 |   </script>
102 | </body>
103 | </html>


--------------------------------------------------------------------------------
/templates/view.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |   <include path="inc/meta.html" />
  5 |   <title>{name} - Nyssa Package Manager</title>
  6 | </head>
  7 | <body class="">
  8 |   <include path="inc/header.html" />
  9 |   <div class="has-background-primary-light px-6 pb-5 divide navi">
 10 |     <include path="inc/search-bar.html" />
 11 |   </div>
 12 |   <div class="notification is-warning is-small clean" ny-if="package.deleted_at">This package or version is archived.</div>
 13 |   
 14 |   <section class="py-6">
 15 |     <div class="container">
 16 |       <div class="columns">
 17 |         <div class="column is-two-third pr-6">
 18 |           <div class="content" ny-if="package">
 19 |             <div class="title mb-2">{package.name}</div>
 20 |             <div>
 21 |               <div class="tags">
 22 |                 <span class="tag has-text-weight-bold">{package.version}</span> 
 23 |                 <a class="tag has-text-weight-bold" href="/search?q={package.publisher}">@{package.publisher}</a>
 24 |                 <span class="tag has-text-weight-bold">{package.created_at}</span>
 25 |               </div>
 26 |             </div>
 27 |             <div class="tabs main-tab">
 28 |               <ul class="ml-0 pl-0">
 29 |                 <li class="is-active" tab-id="readme"><a>ReadMe</a></li>
 30 |                 <li tab-id="dependencies"><a>Dependencies</a></li>
 31 |                 <li tab-id="versions" ny-not="version"><a>Versions</a></li>
 32 |               </ul>
 33 |             </div>
 34 |             <div id="readme-content">{package.readme|draw}</div>
 35 |             <div ny-not="version" id="versions-content" class="is-hidden">
 36 |               <ul ny-if="package.versions">
 37 |                 <li ny-for="package.versions" ny-key="name" ny-value="ver">
 38 |                   <a href="/view/{package.name}@{ver.version}">{package.name} - {ver.version}</a>
 39 |                 </li>
 40 |               </ul>
 41 |               <ul ny-not="package.versions">
 42 |                 <li>
 43 |                   <a href="/view/{package.name}@{package.version}">{package.name} - {package.version}</a>
 44 |                 </li>
 45 |               </ul>
 46 |             </div>
 47 |             <div id="dependencies-content" class="is-hidden">
 48 |               <ul ny-if="package.deps">
 49 |                 <li ny-for="package.deps" ny-key="name" ny-value="version">
 50 |                   <a href="/view/{name}@{version}">{name} - {version}</a>
 51 |                 </li>
 52 |               </ul>
 53 |               <em ny-not="package.deps">Package has no dependencies.</em>
 54 |             </div>
 55 |           </div>
 56 |         </div>
 57 |         <div class="column is-one-third">
 58 |           <div class="content">
 59 |             <div class="title is-4">Install</div>
 60 |             <pre class="has-icon">
 61 |               <span class="code" id="install-command" ny-not="version">nyssa install {package.name}</span>
 62 |               <span class="code" id="install-command" ny-if="version">nyssa install {package.name}@{package.version}</span>
 63 |               <span data-tip="Copied!" class="icon" id="copy-command">
 64 |                 <i class="far fa-copy"></i>
 65 |               </span>
 66 |             </pre>
 67 |             <div class="title is-4 mt-6">Details</div>
 68 |             <div ny-if="package.description">{package.description|strip_line}</div>
 69 |             <div ny-not="package.description"><em>No Description.</em></div>
 70 |             <div class="tags mt-4" ny-if="package.tags">
 71 |               <a href="/search?q={tag}" class="tag is-light" ny-for="package.tags" ny-key="tag">{tag}</a>
 72 |             </div>
 73 |             <div class="title is-5 mb-2 mt-5" ny-if="package.homepage">Homepage</div>
 74 |             <div ny-if="package.homepage">
 75 |               <a target="_blank" href="{package.homepage}">{package.homepage}</a>
 76 |             </div>
 77 |             <div class="mt-4"><strong>License:</strong> <span>{package.license}</span></div>
 78 |             <div class="mt-4"><strong>Downloads:</strong> <span>{package.download}</span></div>
 79 |           </div>
 80 |         </div>
 81 |       </div>
 82 |     </div>
 83 |   </section>
 84 | 
 85 |   <include path="inc/footer.html" />
 86 | 
 87 |   <script>
 88 |     document.addEventListener('DOMContentLoaded', function() {
 89 |       var tabLinks = document.querySelectorAll('.main-tab li')
 90 |       tabLinks.forEach(function(link) {
 91 |         link.addEventListener('click', function() {
 92 |           var tab = document.getElementById(link.getAttribute('tab-id') + '-content')
 93 | 
 94 |           // clear state
 95 |           tabLinks.forEach(function(tl) {
 96 |             tl.classList.remove('is-active')
 97 |             document.getElementById(tl.getAttribute('tab-id') + '-content').classList.add('is-hidden')
 98 |           })
 99 | 
100 |           // set current state
101 |           link.classList.add('is-active')
102 |           tab.classList.remove('is-hidden')
103 |         })
104 |       })
105 | 
106 |       var installCommand = document.getElementById('install-command').innerText
107 | 
108 |       function notifyCopied() {
109 |         var el = document.getElementById('copy-command')
110 |         el.classList.add('open')
111 |         setTimeout(function() {
112 |           el.classList.remove('open')
113 |         }, 1500)
114 |       }
115 | 
116 |       function copyInstallCommand() {
117 |         if(navigator.clipboard) {
118 |           navigator.clipboard.writeText(installCommand)
119 |           notifyCopied()
120 |         } else {
121 |           var textArea = document.createElement("textarea")
122 |           textArea.value = installCommand
123 |           textArea.style.opacity = 0
124 |           document.body.appendChild(textArea)
125 |           textArea.focus()
126 |           textArea.select()
127 | 
128 |           try {
129 |             var successful = document.execCommand('copy')
130 |             if(successful) {
131 |               notifyCopied()
132 |             }
133 |           } catch (err) {
134 |           }
135 | 
136 |           document.body.removeChild(textArea);
137 |         }
138 |       }
139 | 
140 |       document.getElementById('copy-command').addEventListener('click', copyInstallCommand)
141 |     })
142 |   </script>
143 | </body>
144 | </html>


--------------------------------------------------------------------------------
/tests/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade-lang/nyssa/7f7ae7b7f8607f20b73b97ddf0b761580395f3da/tests/.gitignore


--------------------------------------------------------------------------------