text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```javascript
module.exports = function(grunt) {
grunt.config.set('sass', {
dev: {
options: {
implementation: require('node-sass'),
// style: 'compressed',
},
files: [{
expand: true,
cwd: 'assets/styles/',
src: ['importer.scss'],
dest: '.tmp/public/styles/',
ext: '.css'
}]
}
});
grunt.loadNpmTasks('grunt-sass');
};
``` | /content/code_sandbox/tasks/config/sass.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 99 |
```javascript
/**
* Compiles LESS files into CSS.
*
* ---------------------------------------------------------------
*
* Only the `assets/styles/importer.less` is compiled.
* This allows you to control the ordering yourself, i.e. import your
* dependencies, mixins, variables, resets, etc. before other stylesheets)
*
* For usage docs see:
* path_to_url
*/
module.exports = function(grunt) {
grunt.config.set('less', {
dev: {
files: [{
expand: true,
cwd: 'assets/styles/',
src: ['importer.less'],
dest: '.tmp/public/styles/',
ext: '.css'
}]
}
});
grunt.loadNpmTasks('grunt-contrib-less');
};
``` | /content/code_sandbox/tasks/config/less.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 154 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('linkAssetsBuildProd', [
'sails-linker:prodJsRelative',
'sails-linker:prodStylesRelative',
'sails-linker:devTpl',
'sails-linker:prodJsRelativePug',
'sails-linker:prodStylesRelativePug',
'sails-linker:devTplPug'
]);
};
``` | /content/code_sandbox/tasks/register/linkAssetsBuildProd.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 93 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('linkAssets', [
'sails-linker:devJs',
'sails-linker:devStyles',
'sails-linker:devTpl',
'sails-linker:devJsPug',
'sails-linker:devStylesPug',
'sails-linker:devTplPug'
]);
};
``` | /content/code_sandbox/tasks/register/linkAssets.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 87 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('linkAssetsBuild', [
'sails-linker:devJsRelative',
'sails-linker:devStylesRelative',
'sails-linker:devTpl',
'sails-linker:devJsRelativePug',
'sails-linker:devStylesRelativePug',
'sails-linker:devTplPug'
]);
};
``` | /content/code_sandbox/tasks/register/linkAssetsBuild.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 92 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('syncAssets', [
'jst:dev',
'pug:dev',
'less:dev',
'sass:dev',
'sync:dev',
'coffee:dev'
]);
};
``` | /content/code_sandbox/tasks/register/syncAssets.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 65 |
```javascript
module.exports = function(grunt) {
grunt.registerTask('default', [
'wiredep',
'compileAssets',
'linkAssets',
'watch'
]);
};
``` | /content/code_sandbox/tasks/register/default.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 39 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('prod', [
'compileAssets',
'concat',
'uglify',
'cssmin',
'sails-linker:prodJs',
'sails-linker:prodStyles',
'sails-linker:devTpl',
'sails-linker:prodJsPug',
'sails-linker:prodStylesPug',
'sails-linker:devTplPug'
]);
};
``` | /content/code_sandbox/tasks/register/prod.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 108 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('buildProd', [
'compileAssets',
'concat',
'uglify',
'cssmin',
'linkAssetsBuildProd',
'clean:build',
'copy:build'
]);
};
``` | /content/code_sandbox/tasks/register/buildProd.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 65 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('compileAssets', [
'clean:dev',
'jst:dev',
'pug:dev',
'less:dev',
'sass:dev',
'copy:dev',
'coffee:dev'
]);
};
``` | /content/code_sandbox/tasks/register/compileAssets.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 72 |
```javascript
/**
* Autoinsert script tags (or other filebased tags) in an html file.
*
* ---------------------------------------------------------------
*
* Automatically inject <script> tags for javascript files and <link> tags
* for css files. Also automatically links an output file containing precompiled
* templates using a <script> tag.
*
* For usage docs see:
* path_to_url
*
*/
module.exports = function(grunt) {
grunt.config.set('sails-linker', {
devJs: {
options: {
startTag: '<!--SCRIPTS-->',
endTag: '<!--SCRIPTS END-->',
fileTmpl: '<script src="%s"></script>',
appRoot: '.tmp/public'
},
files: {
'.tmp/public/**/*.html': require('../pipeline').jsFilesToInject,
'views/**/*.html': require('../pipeline').jsFilesToInject,
'views/**/*.ejs': require('../pipeline').jsFilesToInject
}
},
devJsRelative: {
options: {
startTag: '<!--SCRIPTS-->',
endTag: '<!--SCRIPTS END-->',
fileTmpl: '<script src="%s"></script>',
appRoot: '.tmp/public',
relative: true
},
files: {
'.tmp/public/**/*.html': require('../pipeline').jsFilesToInject,
'views/**/*.html': require('../pipeline').jsFilesToInject,
'views/**/*.ejs': require('../pipeline').jsFilesToInject
}
},
prodJs: {
options: {
startTag: '<!--SCRIPTS-->',
endTag: '<!--SCRIPTS END-->',
fileTmpl: '<script src="%s"></script>',
appRoot: '.tmp/public'
},
files: {
'.tmp/public/**/*.html': ['.tmp/public/min/production.min.js'],
'views/**/*.html': ['.tmp/public/min/production.min.js'],
'views/**/*.ejs': ['.tmp/public/min/production.min.js']
}
},
prodJsRelative: {
options: {
startTag: '<!--SCRIPTS-->',
endTag: '<!--SCRIPTS END-->',
fileTmpl: '<script src="%s"></script>',
appRoot: '.tmp/public',
relative: true
},
files: {
'.tmp/public/**/*.html': ['.tmp/public/min/production.min.js'],
'views/**/*.html': ['.tmp/public/min/production.min.js'],
'views/**/*.ejs': ['.tmp/public/min/production.min.js']
}
},
devStyles: {
options: {
startTag: '<!--STYLES-->',
endTag: '<!--STYLES END-->',
fileTmpl: '<link rel="stylesheet" href="%s">',
appRoot: '.tmp/public'
},
files: {
'.tmp/public/**/*.html': require('../pipeline').cssFilesToInject,
'views/**/*.html': require('../pipeline').cssFilesToInject,
'views/**/*.ejs': require('../pipeline').cssFilesToInject
}
},
devStylesRelative: {
options: {
startTag: '<!--STYLES-->',
endTag: '<!--STYLES END-->',
fileTmpl: '<link rel="stylesheet" href="%s">',
appRoot: '.tmp/public',
relative: true
},
files: {
'.tmp/public/**/*.html': require('../pipeline').cssFilesToInject,
'views/**/*.html': require('../pipeline').cssFilesToInject,
'views/**/*.ejs': require('../pipeline').cssFilesToInject
}
},
prodStyles: {
options: {
startTag: '<!--STYLES-->',
endTag: '<!--STYLES END-->',
fileTmpl: '<link rel="stylesheet" href="%s">',
appRoot: '.tmp/public'
},
files: {
'.tmp/public/index.html': ['.tmp/public/min/production.min.css'],
'views/**/*.html': ['.tmp/public/min/production.min.css'],
'views/**/*.ejs': ['.tmp/public/min/production.min.css']
}
},
prodStylesRelative: {
options: {
startTag: '<!--STYLES-->',
endTag: '<!--STYLES END-->',
fileTmpl: '<link rel="stylesheet" href="%s">',
appRoot: '.tmp/public',
relative: true
},
files: {
'.tmp/public/index.html': ['.tmp/public/min/production.min.css'],
'views/**/*.html': ['.tmp/public/min/production.min.css'],
'views/**/*.ejs': ['.tmp/public/min/production.min.css']
}
},
// Bring in JST template object
devTpl: {
options: {
startTag: '<!--TEMPLATES-->',
endTag: '<!--TEMPLATES END-->',
fileTmpl: '<script type="text/javascript" src="%s"></script>',
appRoot: '.tmp/public'
},
files: {
'.tmp/public/index.html': ['.tmp/public/jst.js'],
'views/**/*.html': ['.tmp/public/jst.js'],
'views/**/*.ejs': ['.tmp/public/jst.js']
}
},
devJsPug: {
options: {
startTag: '// SCRIPTS',
endTag: '// SCRIPTS END',
fileTmpl: 'script(src="%s")',
appRoot: '.tmp/public'
},
files: {
'views/**/*.pug': require('../pipeline').jsFilesToInject
}
},
devJsRelativePug: {
options: {
startTag: '// SCRIPTS',
endTag: '// SCRIPTS END',
fileTmpl: 'script(src="%s")',
appRoot: '.tmp/public',
relative: true
},
files: {
'views/**/*.pug': require('../pipeline').jsFilesToInject
}
},
prodJsPug: {
options: {
startTag: '// SCRIPTS',
endTag: '// SCRIPTS END',
fileTmpl: 'script(src="%s")',
appRoot: '.tmp/public'
},
files: {
'views/**/*.pug': ['.tmp/public/min/production.min.js']
}
},
prodJsRelativePug: {
options: {
startTag: '// SCRIPTS',
endTag: '// SCRIPTS END',
fileTmpl: 'script(src="%s")',
appRoot: '.tmp/public',
relative: true
},
files: {
'views/**/*.pug': ['.tmp/public/min/production.min.js']
}
},
devStylesPug: {
options: {
startTag: '// STYLES',
endTag: '// STYLES END',
fileTmpl: 'link(rel="stylesheet", href="%s")',
appRoot: '.tmp/public'
},
files: {
'views/**/*.pug': require('../pipeline').cssFilesToInject
}
},
devStylesRelativePug: {
options: {
startTag: '// STYLES',
endTag: '// STYLES END',
fileTmpl: 'link(rel="stylesheet", href="%s")',
appRoot: '.tmp/public',
relative: true
},
files: {
'views/**/*.pug': require('../pipeline').cssFilesToInject
}
},
prodStylesPug: {
options: {
startTag: '// STYLES',
endTag: '// STYLES END',
fileTmpl: 'link(rel="stylesheet", href="%s")',
appRoot: '.tmp/public'
},
files: {
'views/**/*.pug': ['.tmp/public/min/production.min.css']
}
},
prodStylesRelativePug: {
options: {
startTag: '// STYLES',
endTag: '// STYLES END',
fileTmpl: 'link(rel="stylesheet", href="%s")',
appRoot: '.tmp/public',
relative: true
},
files: {
'views/**/*.pug': ['.tmp/public/min/production.min.css']
}
},
// Bring in JST template object
devTplPug: {
options: {
startTag: '// TEMPLATES',
endTag: '// TEMPLATES END',
fileTmpl: 'script(type="text/javascript", src="%s")',
appRoot: '.tmp/public'
},
files: {
'views/**/*.pug': ['.tmp/public/jst.js']
}
}
});
grunt.loadNpmTasks('grunt-sails-linker');
};
``` | /content/code_sandbox/tasks/config/sails-linker.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 1,946 |
```javascript
module.exports = function (grunt) {
grunt.registerTask('build', [
'compileAssets',
'linkAssetsBuild',
'clean:build',
'copy:build'
]);
};
``` | /content/code_sandbox/tasks/register/build.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 47 |
```javascript
'use strict';
const { driver } = require('db-migrate').getInstance().config.getCurrent().settings;
const sql = {
// PostgreSQL
pg: {
up: (
// Add `availability` column (if doesn't exist) to `version` table
'ALTER TABLE version ADD COLUMN IF NOT EXISTS availability TIMESTAMPTZ;'
),
down: (
// Drop `availability` column (if exists) from `version` table
'ALTER TABLE version DROP COLUMN IF EXISTS availability;'
)
}
};
const { up } = driver && sql[driver];
const { down } = driver && sql[driver];
exports.up = db => up ? db.runSql(up) : null;
exports.down = db => down ? db.runSql(down) : null;
``` | /content/code_sandbox/migrations/20190930000000-availability-migration.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 167 |
```javascript
'use strict';
const { driver } = require('db-migrate').getInstance().config.getCurrent().settings;
const sql = {
// PostgreSQL
pg: {
up: (
// Add `id` column (if doesn't exist) to `asset` table
'ALTER TABLE asset ADD COLUMN IF NOT EXISTS id TEXT;' +
// Populate `id` column in `asset` table with default data if empty
'UPDATE asset SET id = CONCAT(version, \'_\', platform, \'_\', REPLACE(filetype, \'.\', \'\')) WHERE id IS NULL;' +
// Drop primary key constraint (if exists) from `asset` table
'ALTER TABLE asset DROP CONSTRAINT IF EXISTS asset_pkey;' +
// Add primary key constraint on `id` column in `asset` table
'ALTER TABLE asset ADD PRIMARY KEY (id);'
),
down: (
// Drop `id` column (if exists) from `asset` table
'ALTER TABLE asset DROP COLUMN IF EXISTS id;' +
// Drop primary key constraint (if exists) from `asset` table
'ALTER TABLE asset DROP CONSTRAINT IF EXISTS asset_pkey;' +
// Add primary key constraint on `name` column in `asset` table
'ALTER TABLE asset ADD PRIMARY KEY (name);'
)
}
};
const { up } = driver && sql[driver];
const { down } = driver && sql[driver];
exports.up = db => up ? db.runSql(up) : null;
exports.down = db => down ? db.runSql(down) : null;
``` | /content/code_sandbox/migrations/20190930000000-asset-migration.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 333 |
```javascript
'use strict';
const { driver } = require('db-migrate').getInstance().config.getCurrent().settings;
const sql = {
// PostgreSQL
pg: {
up: (
// Create `flavor` table (if doesn't exist)
'CREATE TABLE IF NOT EXISTS flavor (name TEXT PRIMARY KEY, "createdAt" TIMESTAMPTZ, "updatedAt" TIMESTAMPTZ);' +
// Add `id` column (if doesn't exist) to `version` table
'ALTER TABLE version ADD COLUMN IF NOT EXISTS id TEXT;' +
// Add `flavor` column (if doesn't exist) to `version` table
'ALTER TABLE version ADD COLUMN IF NOT EXISTS flavor TEXT;' +
// Drop primary key constraint (if exists) from `version` table
'ALTER TABLE version DROP CONSTRAINT IF EXISTS version_pkey;' +
// Populate `id` column in `version` table with default data if empty
'UPDATE version SET id = CONCAT(name, \'_\', COALESCE(flavor, \'default\')) WHERE id IS NULL;' +
// Add primary key constraint on `id` column in `version` table
'ALTER TABLE version ADD PRIMARY KEY (id);'
),
down: (
// Drop `flavor` table (if exists)
'DROP TABLE IF EXISTS flavor;' +
// Drop `id` column (if exists) from `version` table
'ALTER TABLE version DROP COLUMN IF EXISTS id;' +
// Drop `flavor` column (if exists) from `version` table
'ALTER TABLE version DROP COLUMN IF EXISTS flavor;' +
// Drop primary key constraint (if exists) from `version` table
'ALTER TABLE version DROP CONSTRAINT IF EXISTS version_pkey;' +
// Add primary key constraint on `name` column in `version` table
'ALTER TABLE version ADD PRIMARY KEY (name);' +
// Depopulate default data from `version` column in `asset` table
'UPDATE asset SET version = REPLACE(version, \'_default\', \'\') WHERE version LIKE \'%_default\';'
)
}
};
const { up } = driver && sql[driver];
const { down } = driver && sql[driver];
exports.up = db => up ? db.runSql(up) : null;
exports.down = db => down ? db.runSql(down) : null;
``` | /content/code_sandbox/migrations/20190930000000-flavor-migration.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 507 |
```javascript
/**
* Flavor Service
*/
const FlavorService = {};
/**
* Deletes a flavor from the database.
* @param {Object} flavor The flavors record object from sails
* @param {Object} req Optional: The request object
* @returns {Promise} Resolved once the flavor is destroyed
*/
FlavorService.destroy = (flavor, req) => {
if (!flavor) {
throw new Error('You must pass a flavor');
}
return Flavor
.destroy(flavor.name)
.then(() => {
if (sails.hooks.pubsub) {
Flavor.publish(
[flavor.name], {
verb: 'destroyed',
previous: flavor
}, !req._sails.config.blueprints.mirror && req
);
if (req && req.isSocket) {
Flavor.unsubscribe(req, flavor);
Flavor.retire(flavor);
}
}
});
};
module.exports = FlavorService;
``` | /content/code_sandbox/api/services/FlavorService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 207 |
```javascript
/**
* Version Service
*/
var _ = require('lodash');
var semver = require('semver');
var VersionService = {};
// Normalize version name
VersionService.normalizeName = function(name) {
if (name[0] == 'v') name = name.slice(1);
return name;
};
// Compare two versions
VersionService.compare = function(v1, v2) {
if (semver.gt(v1.tag, v2.tag)) {
return -1;
}
if (semver.lt(v1.tag, v2.tag)) {
return 1;
}
return 0;
};
/**
* Deletes a version from the database.
* @param {Object} version The versions record object from sails
* @param {Object} req Optional: The request object
* @returns {Promise} Resolved once the version is destroyed
*/
VersionService.destroy = (version, req) => {
if (!version) {
throw new Error('You must pass a version');
}
return Version
.destroy(version.id)
.then(() => {
if (sails.hooks.pubsub) {
Version.publish(
[version.id], {
verb: 'destroyed',
previous: version
}, !req._sails.config.blueprints.mirror && req
);
if (req && req.isSocket) {
Version.unsubscribe(req, version);
Version.retire(version);
}
}
});
};
module.exports = VersionService;
``` | /content/code_sandbox/api/services/VersionService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 321 |
```javascript
/**
* Platform Service
*/
var _ = require('lodash');
var useragent = require('express-useragent');
var PlatformService = {
LINUX: 'linux',
LINUX_32: 'linux_32',
LINUX_64: 'linux_64',
OSX: 'osx',
OSX_32: 'osx_32',
OSX_64: 'osx_64',
OSX_ARM64: 'osx_arm64',
WINDOWS: 'windows',
WINDOWS_32: 'windows_32',
WINDOWS_64: 'windows_64',
};
/**
* Reduce a platfrom ID to its type
* (ex. windows_64 to windows)
* @param {String} platform Platform ID
* @return {String} Platform type name
*/
PlatformService.toType = function(platform) {
return _.head(platform.split('_'));
};
/**
* Detect the user's platform from a request object
* @param {Object} req An express request object
* @return {String} String representation of the detected platform
*/
PlatformService.detectFromRequest = function(req) {
var source = req.headers['user-agent'];
var ua = useragent.parse(source);
if (ua.isWindows) return [this.WINDOWS_32, this.WINDOWS_64];
if (ua.isMac) return [this.OSX_64, this.OSX_ARM64]; // this.OSX_ARM64 until a bug with arm64 useragent is fixed
if (ua.isLinux64) return [this.LINUX_64, this.LINUX_32];
if (ua.isLinux) return [this.LINUX_32];
};
/**
* Detect and normalize the platformID from platform name input string.
* Used to handle unnormalized inputs from user agents.
* @param {Object} platformName An Asset object
* @param {Boolean} strictMatch Whether to only match to the current arch
* If false, 32 bit will be added for 64 bit
* @return {String} Full platform ID
*/
PlatformService.detect = function(platformName, strictMatch) {
var name = platformName.toLowerCase();
var prefix = '';
var suffixes = [];
// Detect prefix: osx, widnows or linux
if (_.includes(name, 'win')) {
prefix = this.WINDOWS;
}
if (
_.includes(name, 'linux') ||
_.includes(name, 'ubuntu')
) {
prefix = this.LINUX;
}
if (
_.includes(name, 'mac') ||
_.includes(name, 'osx') ||
name.indexOf('darwin') >= 0
) {
prefix = this.OSX;
}
// Detect architecture
if (
prefix === this.OSX ||
// _.includes(name, 'x64') ||
// _.includes(name, 'amd64') ||
_.includes(name, '64')
) {
if (_.includes(name, 'arm64')) {
suffixes.unshift('arm64');
} else {
suffixes.push('64');
}
if (!strictMatch && prefix !== this.OSX) {
suffixes.unshift('32');
}
} else {
suffixes.unshift('32');
}
var result = [];
_.forEach(suffixes, function(suffix) {
result.push(prefix + '_' + suffix);
});
return result;
};
PlatformService.sanitize = function(platforms) {
var self = this;
return _.map(platforms, function(platform) {
switch (platform) {
case self.OSX:
case self.OSX_32:
platform = self.OSX_64;
break;
default:
}
return platform;
});
}
module.exports = PlatformService;
``` | /content/code_sandbox/api/services/PlatformService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 802 |
```javascript
/**
* Windows Release Service
*/
var _ = require('lodash');
var semver = require('semver');
var stripBom = require('strip-bom');
var ChannelService = require('./ChannelService');
var WindowsReleaseService = {};
// Ordered list of supported pre-release channels
var PRERELEASE_CHANNEL_MAGINITUDE = 1000;
var PRERELEASE_CHANNELS = _(ChannelService.availableChannels)
.without('stable')
.reverse()
.value();
// RELEASES parsing
var releaseRegex = /^([0-9a-fA-F]{40})\s+(\S+)\s+(\d+)[\r]*$/;
/**
* Hash a prerelease
* @param {String} s [description]
* @return {String} [description]
*/
function hashPrerelease(s) {
if (_.isString(s[0])) {
return (_.indexOf(PRERELEASE_CHANNELS, s[0]) + 1) * PRERELEASE_CHANNEL_MAGINITUDE + (s[1] || 0);
} else {
return s[0];
}
}
// Map a semver version to a windows version
WindowsReleaseService.normVersion = function(tag) {
var parts = new semver.SemVer(tag);
var prerelease = '';
if (parts.prerelease && parts.prerelease.length > 0) {
prerelease = hashPrerelease(parts.prerelease);
}
return [
parts.major,
parts.minor,
parts.patch
].join('.') + (prerelease ? '.' + prerelease : '');
};
// Map a windows version to a semver
WindowsReleaseService.toSemver = function(tag) {
var parts = tag.split('.');
var version = parts.slice(0, 3).join('.');
var prerelease = Number(parts[3]);
// semver == windows version
if (!prerelease) return version;
var channelId = Math.floor(prerelease / CHANNEL_MAGINITUDE);
var channel = CHANNELS[channelId - 1];
var count = prerelease - (channelId * CHANNEL_MAGINITUDE);
return version + '-' + channel + '.' + count;
};
// Parse RELEASES file
// path_to_url#L19
WindowsReleaseService.parse = function(content) {
return _.chain(stripBom(content))
.replace('\r\n', '\n')
.split('\n')
.map(function(line) {
var parts = releaseRegex.exec(line);
if (!parts) return null;
var filename = parts[2];
var isDelta = filename.indexOf('-full.nupkg') == -1;
var filenameParts = filename
.replace('.nupkg', '')
.replace('-delta', '')
.replace('-full', '')
.split(/\.|-/)
.reverse();
var version = _.chain(filenameParts)
.filter(function(x) {
return /^\d+$/.exec(x);
})
.reverse()
.value()
.join('.');
return {
sha: parts[1],
filename: filename,
size: Number(parts[3]),
isDelta: isDelta,
version: version,
semver: this.toSemver(version)
};
})
.compact()
.value();
};
// Generate a RELEASES file
WindowsReleaseService.generate = function(assets) {
return _.map(assets, function(asset) {
return [
asset.hash,
asset.name.replace('-ia32', ''),
asset.size
].join(' ');
})
.join('\n');
};
module.exports = WindowsReleaseService;
``` | /content/code_sandbox/api/services/WindowsReleaseService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 769 |
```javascript
/**
* Platform Service
*/
var _ = require('lodash');
var ChannelService = {
availableChannels: sails.config.channels
};
/**
* Retrieves all available channels given the most restrictive one
* @param {String} channel Channel name
* @return {Array} Applicable channel names ordered by desc. stability
*/
ChannelService.getApplicableChannels = function(channel) {
var channelIndex = ChannelService.availableChannels.indexOf(channel);
if (channelIndex === -1) {
return ChannelService.availableChannels[ChannelService.availableChannels.length - 1];
}
return ChannelService.availableChannels.slice(
0,
channelIndex + 1
);
};
module.exports = ChannelService;
``` | /content/code_sandbox/api/services/ChannelService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 147 |
```javascript
/**
* A simple service for making reusable helper functions globaly available yet
* namespaced
*/
var _ = require('lodash');
var semver = require('semver');
var UtilityService = {};
UtilityService.getTruthyObject = function(object) {
return _.pickBy(object, _.identity);
};
/**
* Compare version objects using semantic versioning.
* Pass to Array.sort for a descending array
* @param {Object} v1 Version object one
* @param {Object} v2 Version object two
* @return {-1|0|1} Whether one is is less than or greater
*/
UtilityService.compareVersion = function(v1, v2) {
return -semver.compare(v1.name, v2.name);
};
module.exports = UtilityService;
``` | /content/code_sandbox/api/services/UtilityService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 164 |
```javascript
/**
* Simple Authentication Service
*
* Currently supported methods:
* - static
* - LDAP
*/
var _ = require('lodash');
var LdapAuth = require('ldapauth-fork');
var AuthService = {};
AuthService.authenticate = function(req, options, cb) {
var username, password;
if (!options) {
throw new Error('Authentication requires options');
}
username = req.param('username');
password = req.param('password');
if (!username || !password) {
return cb({
message: options.badRequestMessage || 'Missing credentials',
code: 400
});
}
if (_.has(options, 'static')) {
if (_.has(options, 'ldap')) {
var originalCb = cb;
cb = function(err, user) {
if (err) {
return AuthService._authenticateLDAP(
username,
password,
options.ldap,
function(secondErr, user) {
if (secondErr) {
return originalCb(err);
}
originalCb(null, user);
}
);
}
originalCb(null, user);
};
}
AuthService._authenticateStatic(username, password, options.static, cb);
} else if (_.has(options, 'ldap')) {
AuthService._authenticateLDAP(username, password, options.ldap, cb);
} else {
throw new Error('Authentication options incomplete.');
}
};
AuthService._authenticateStatic = function(username, password, options, cb) {
if (!options) {
throw new Error('LDAP authentication requires options');
}
if (
username !== options.username ||
password !== options.password
) {
return cb({
message: 'Invalid username/password',
code: 401
});
} else {
return cb(
null, {
username: username
}
);
}
};
/**
* LDAP authentication
*
* The LDAP authentication strategy authenticates requests based on the
* credentials submitted through an HTML-based login form.
*
* Applications may supply a `verify` callback which accepts `user` object
* and then calls the `done` callback supplying a `user`, which should be set
* to `false` if user is not allowed to authenticate. If an exception occured,
* `err` should be set.
*
* Options:
* - `server` options for ldapauth, see path_to_url
* - `usernameField` field name where the username is found, defaults to _username_
* - `passwordField` field name where the password is found, defaults to _password_
* - `passReqToCallback` when `true`, `req` is the first argument to the verify callback (default: `false`)
*
* Options can be also given as function that accepts a callback end calls it
* with error and options arguments. Notice that the callback is executed on
* every authenticate call.
*
* Example:
*
* AuthService._authenticateLDAP(
* 'myusername',
* 'mypassword',
* sails.config.auth,
* function(err, user) {
* if (err) return;
* console.log('User ' + user.username + ' has been authenticated');
* }
* ));
*/
AuthService._authenticateLDAP = function(username, password, options, cb) {
var ldap;
if (!options) {
throw new Error('LDAP authentication requires options');
}
/**
* AD possible messages
* path_to_url
*/
var messages = {
'530': options.invalidLogonHours || 'Not Permitted to login at this time',
'531': options.invalidWorkstation || 'Not permited to logon at this workstation',
'532': options.passwordExpired || 'Password expired',
'533': options.accountDisabled || 'Account disabled',
'534': options.accountDisabled || 'Account disabled',
'701': options.accountExpired || 'Account expired',
'773': options.passwordMustChange || 'User must reset password',
'775': options.accountLockedOut || 'User account locked',
default: options.invalidCredentials || 'Invalid username/password'
};
ldap = new LdapAuth(options.server);
ldap.authenticate(username, password, function(err, user) {
ldap.close(function() {}); // We don't care about the closing
if (err) {
// Invalid credentials / user not found are not errors but login failures
if (
err.name === 'InvalidCredentialsError' ||
err.name === 'NoSuchObjectError' ||
(typeof err === 'string' && err.match(/no such user/i))
) {
var message = options.invalidCredentials || 'Invalid username/password';
if (err.message) {
var ldapComment = err.message.match(/data ([0-9a-fA-F]*), v[0-9a-fA-F]*/);
if (ldapComment && ldapComment[1]) {
message = messages[ldapComment[1]] || messages['default'];
}
}
return cb({
message: message,
code: 401
});
}
if (err.name === 'ConstraintViolationError') {
return cb({
message: options.constraintViolation || 'Exceeded password retry limit, account locked',
code: 401
});
}
// Other errors are (most likely) real errors
return cb(err);
}
if (!user) return cb({
message: options.userNotFound || 'Invalid username/password',
code: 401
});
// Check that the user is a member of the allowed user group
if (
options.group &&
(!user.memberOf || user.memberOf.indexOf(options.group) === -1)
) {
return cb({
message: options.userNotAuthorized || 'Your account is not authorized.',
code: 401
});
}
_.set(user, 'username', _.get(user, options.usernameField));
return cb(null, user);
});
};
module.exports = AuthService;
``` | /content/code_sandbox/api/services/AuthService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 1,266 |
```javascript
var jwt = require('jsonwebtoken');
module.exports.issueToken = function(payload, options) {
var token = jwt.sign(payload, process.env.TOKEN_SECRET || sails.config.jwt.token_secret, options);
return token;
};
module.exports.verifyToken = function(token, callback) {
return jwt.verify(token, process.env.TOKEN_SECRET || sails.config.jwt.token_secret, {}, callback);
};
``` | /content/code_sandbox/api/services/AuthToken.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 79 |
```javascript
/**
* Channel.js
*
* @description :: Various release channel (ex. stable & dev)
* @docs :: path_to_url#!documentation/models
*/
module.exports = {
primaryKey: 'name',
attributes: {
name: {
type: 'string',
unique: true,
required: true
}
},
};
``` | /content/code_sandbox/api/models/Channel.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 73 |
```javascript
/**
* File Service
*
* Handles uploads & downloads of versions
*/
var mime = require('mime');
var fsx = require('fs-extra');
var crypto = require('crypto');
var Promise = require('bluebird');
var SkipperDisk = require('skipper-disk');
var AssetService = {};
AssetService.serveFile = function (req, res, asset) {
// Stream the file to the user
fsx.createReadStream(asset.fd)
.on('error', function (err) {
res.serverError('An error occurred while accessing asset.', err);
sails.log.error('Unable to access asset:', asset.fd);
})
.on('open', function () {
// Send file properties in header
res.setHeader(
'Content-Disposition', 'attachment; filename*=UTF-8\'\'' + encodeURIComponent(asset.name)
);
res.setHeader('Content-Length', asset.size);
res.setHeader('Content-Type', mime.getType(asset.fd));
})
.on('end', async function complete() {
// After we have sent the file, log analytics, failures experienced at
// this point should only be handled internally (do not use the res
// object).
//
// Atomically increment the download count for analytics purposes
//
// Warning: not all adapters support queries (such as sails-disk).
var datastore = Asset.getDatastore();
if (_.isFunction(datastore.sendNativeQuery) && datastore.config.adapter !== 'sails-disk') {
try {
await datastore.sendNativeQuery(
'UPDATE asset SET download_count = download_count + 1 WHERE id = $1;', [asset.id])
.intercept(function (err) {
});
// Early exit if the query was successful.
return;
} catch (err) {
sails.log.error(
'An error occurred while logging asset download', err
);
}
}
// Attempt to update the download count through the fallback mechanism.
// Note that this may be lossy since it is not atomic.
asset.download_count++;
Asset.update({
id: asset.id
}, asset)
.exec(function (err) {
if (err) {
sails.log.error(
'An error occurred while logging asset download', err
);
}
});
})
// Pipe to user
.pipe(res);
};
/**
* Asyncronously generates a SHA1 hash from a file
* Identical to:
* path_to_url#L161
* @param {String} fd File descriptor of file to hash
* @return {String} Promise which is resolved with the hash once complete
*/
AssetService.getHash = function (fd, type = "sha1", encoding = "hex") {
return new Promise(function (resolve, reject) {
var hash = crypto.createHash(type);
hash.setEncoding(encoding);
fsx
.createReadStream(fd)
.on("error", function (err) {
reject(err);
})
.on("end", function () {
hash.end();
resolve(hash.read());
})
// Pipe to hash generator
.pipe(hash, { end: false });
});
};
/**
* Deletes an asset from the database.
* Warning: this will NOT remove fd from the file system.
* @param {Record} asset The asset's record object from sails
* @param {Object} req Optional: The request object
* @returns {Promise} Resolved once the asset is destroyed
*/
AssetService.destroy = function (asset, req) {
if (!asset) {
throw new Error('You must pass an asset');
}
return Asset.destroy(asset.id)
.then(function destroyedRecord() {
if (sails.hooks.pubsub) {
Asset.publish(
[asset.id],
{
verb: 'destroyed',
previous: asset
},
!req._sails.config.blueprints.mirror && req
);
if (req && req.isSocket) {
Asset.unsubscribe(req, record);
Asset.retire(record);
}
}
});
};
/**
* Deletes an asset's file from the filesystem.
* Warning: this will NOT remove the reference to the fd in the database.
* @param {Object} asset The asset object who's file we would like deleted
* @returns {Promise} Resolved once the file is deleted
*/
AssetService.deleteFile = function (asset) {
if (!asset) {
throw new Error('You must pass an asset');
}
if (!asset.fd) {
throw new Error('The provided asset does not have a file descriptor');
}
var fileAdapter = SkipperDisk();
var fileAdapterRmAsync = Promise.promisify(fileAdapter.rm);
return fileAdapterRmAsync(asset.fd);
};
module.exports = AssetService;
``` | /content/code_sandbox/api/services/AssetService.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 1,027 |
```javascript
/**
* Asset.js
*
* @description :: A software asset that can be used to install the app (ex. .exe, .dmg, .deb, etc.)
* @docs :: path_to_url#!documentation/models
*/
module.exports = {
primaryKey: 'id',
attributes: {
id: {
type: 'string',
unique: true,
required: true
},
name: {
type: 'string',
required: true
},
platform: {
type: 'string',
isIn: ['linux_32', 'linux_64', 'osx_64', 'osx_arm64', 'windows_32', 'windows_64'],
required: true
},
filetype: {
type: 'string',
required: true
},
hash: {
type: 'string'
},
size: {
type: 'number',
required: true,
columnType: 'integer'
},
download_count: {
type: 'number',
defaultsTo: 0,
columnType: 'integer'
},
version: {
model: 'version',
required: true
},
// File descriptor for the asset
fd: {
type: 'string',
required: true
}
}
};
``` | /content/code_sandbox/api/models/Asset.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 280 |
```javascript
/**
* Flavor.js
*
* @description :: Represents a release flavor (ex. default)
* @docs :: path_to_url#!documentation/models
*/
module.exports = {
primaryKey: 'name',
attributes: {
name: {
type: 'string',
unique: true,
required: true
}
},
};
``` | /content/code_sandbox/api/models/Flavor.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 72 |
```javascript
/**
* Version.js
*
* @description :: Represents a release version, which has a flavor, contains assets and is a member of a channel
* @docs :: path_to_url#!documentation/models
*/
module.exports = {
primaryKey: 'id',
attributes: {
id: {
type: 'string',
unique: true,
required: true
},
name: {
type: 'string',
required: true
},
assets: {
collection: 'asset',
via: 'version'
},
channel: {
model: 'channel',
required: true
},
availability: {
type: 'string'
},
flavor: {
model: 'flavor',
},
notes: {
type: 'string'
}
},
beforeCreate: (version, proceed) => {
const { name, flavor } = version;
version.id = `${name}_${flavor}`;
return proceed();
},
afterCreate: (version, proceed) => {
const { availability, createdAt, id } = version;
if (!availability || new Date(availability) < new Date(createdAt)) {
return Version
.update(id, { availability: createdAt })
.exec(proceed);
}
return proceed();
}
};
``` | /content/code_sandbox/api/models/Version.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 277 |
```javascript
/**
* 403 (Forbidden) Handler
*
* Usage:
* return res.forbidden();
* return res.forbidden(err);
* return res.forbidden(err, 'some/specific/forbidden/view');
*
* e.g.:
* ```
* return res.forbidden('Access denied.');
* ```
*/
module.exports = function forbidden (data, options) {
// Get access to `req`, `res`, & `sails`
var req = this.req;
var res = this.res;
var sails = req._sails;
// Set status code
res.status(403);
// Log error to console
if (data !== undefined) {
sails.log.verbose('Sending 403 ("Forbidden") response: \n',data);
}
else sails.log.verbose('Sending 403 ("Forbidden") response');
// Only include errors in response if application environment
// is not set to 'production'. In production, we shouldn't
// send back any identifying information about errors.
if (sails.config.environment === 'production') {
data = undefined;
}
// If the user-agent wants JSON, always respond with JSON
if (req.wantsJSON) {
return res.json(data);
}
// If second argument is a string, we take that to mean it refers to a view.
// If it was omitted, use an empty object (`{}`)
options = (typeof options === 'string') ? { view: options } : options || {};
// If a view was provided in options, serve it.
// Otherwise try to guess an appropriate view, or if that doesn't
// work, just send JSON.
if (options.view) {
return res.view(options.view, { data: data });
}
// If no second argument provided, try to serve the default view,
// but fall back to sending JSON(P) if any errors occur.
else return res.view('403', { data: data }, function (err, html) {
// If a view error occured, fall back to JSON(P).
if (err) {
//
// Additionally:
// If the view was missing, ignore the error but provide a verbose log.
if (err.code === 'E_VIEW_FAILED') {
sails.log.verbose('res.forbidden() :: Could not locate view for error page (sending JSON instead). Details: ',err);
}
// Otherwise, if this was a more serious error, log to the console with the details.
else {
sails.log.warn('res.forbidden() :: When attempting to render error page view, an error occured (sending JSON instead). Details: ', err);
}
return res.json(data);
}
return res.send(html);
});
};
``` | /content/code_sandbox/api/responses/forbidden.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 584 |
```javascript
/**
* 500 (Server Error) Response
*
* Usage:
* return res.serverError();
* return res.serverError(err);
* return res.serverError(err, 'some/specific/error/view');
*
* NOTE:
* If something throws in a policy or controller, or an internal
* error is encountered, Sails will call `res.serverError()`
* automatically.
*/
module.exports = function serverError(data, options) {
// Get access to `req`, `res`, & `sails`
var req = this.req;
var res = this.res;
var sails = req._sails;
// Set status code
res.status(500);
// Log error to console
if (data !== undefined) {
sails.log.error('Sending 500 ("Server Error") response: \n', data);
} else {
sails.log.error('Sending empty 500 ("Server Error") response');
}
// Only include errors in response if application environment
// is not set to 'production'. In production, we shouldn't
// send back any identifying information about errors.
if (sails.config.environment === 'production') {
data = undefined;
}
// If the user-agent wants JSON, always respond with JSON
if (req.wantsJSON) {
return res.json(data);
}
// If second argument is a string, we take that to mean it refers to a view.
// If it was omitted, use an empty object (`{}`)
options = (typeof options === 'string') ? {
view: options
} : options || {};
// If a view was provided in options, serve it.
// Otherwise try to guess an appropriate view, or if that doesn't
// work, just send JSON.
if (options.view) {
return res.view(options.view, {
data: data
});
}
// If no second argument provided, try to serve the default view,
// but fall back to sending JSON(P) if any errors occur.
else return res.view('500', {
data: data
}, function(err, html) {
// If a view error occured, fall back to JSON(P).
if (err) {
//
// Additionally:
// If the view was missing, ignore the error but provide a verbose log.
if (err.code === 'E_VIEW_FAILED') {
sails.log.verbose('res.serverError() :: Could not locate view for error page (sending JSON instead). Details: ', err);
}
// Otherwise, if this was a more serious error, log to the console with the details.
else {
sails.log.warn('res.serverError() :: When attempting to render error page view, an error occured (sending JSON instead). Details: ', err);
}
return res.json(data);
}
return res.send(html);
});
};
``` | /content/code_sandbox/api/responses/serverError.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 614 |
```javascript
/**
* 200 (OK) Response
*
* Usage:
* return res.ok();
* return res.ok(data);
* return res.ok(data, 'auth/login');
*
* @param {Object} data
* @param {String|Object} options
* - pass string to render specified view
*/
module.exports = function sendOK (data, options) {
// Get access to `req`, `res`, & `sails`
var req = this.req;
var res = this.res;
var sails = req._sails;
sails.log.silly('res.ok() :: Sending 200 ("OK") response');
// Set status code
res.status(200);
// If appropriate, serve data as JSON(P)
if (req.wantsJSON) {
return res.json(data);
}
// If second argument is a string, we take that to mean it refers to a view.
// If it was omitted, use an empty object (`{}`)
options = (typeof options === 'string') ? { view: options } : options || {};
// If a view was provided in options, serve it.
// Otherwise try to guess an appropriate view, or if that doesn't
// work, just send JSON.
if (options.view) {
return res.view(options.view, { data: data });
}
// If no second argument provided, try to serve the implied view,
// but fall back to sending JSON(P) if no view can be inferred.
else return res.guessView({ data: data }, function couldNotGuessView () {
return res.json(data);
});
};
``` | /content/code_sandbox/api/responses/ok.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 348 |
```javascript
/**
* 404 (Not Found) Handler
*
* Usage:
* return res.notFound();
* return res.notFound(err);
* return res.notFound(err, 'some/specific/notfound/view');
*
* e.g.:
* ```
* return res.notFound();
* ```
*
* NOTE:
* If a request doesn't match any explicit routes (i.e. `config/routes.js`)
* or route blueprints (i.e. "shadow routes", Sails will call `res.notFound()`
* automatically.
*/
module.exports = function notFound (data, options) {
// Get access to `req`, `res`, & `sails`
var req = this.req;
var res = this.res;
var sails = req._sails;
// Set status code
res.status(404);
// Log error to console
if (data !== undefined) {
sails.log.verbose('Sending 404 ("Not Found") response: \n',data);
}
else sails.log.verbose('Sending 404 ("Not Found") response');
// Only include errors in response if application environment
// is not set to 'production'. In production, we shouldn't
// send back any identifying information about errors.
if (sails.config.environment === 'production') {
data = undefined;
}
// If the user-agent wants JSON, always respond with JSON
if (req.wantsJSON) {
return res.json(data);
}
// If second argument is a string, we take that to mean it refers to a view.
// If it was omitted, use an empty object (`{}`)
options = (typeof options === 'string') ? { view: options } : options || {};
// If a view was provided in options, serve it.
// Otherwise try to guess an appropriate view, or if that doesn't
// work, just send JSON.
if (options.view) {
return res.view(options.view, { data: data });
}
// If no second argument provided, try to serve the default view,
// but fall back to sending JSON(P) if any errors occur.
else return res.view('homepage', {}, function (err, html) {
// If a view error occured, fall back to JSON(P).
if (err) {
//
// Additionally:
// If the view was missing, ignore the error but provide a verbose log.
if (err.code === 'E_VIEW_FAILED') {
sails.log.verbose('res.notFound() :: Could not locate view for error page (sending JSON instead). Details: ',err);
}
// Otherwise, if this was a more serious error, log to the console with the details.
else {
sails.log.warn('res.notFound() :: When attempting to render error page view, an error occured (sending JSON instead). Details: ', err);
}
return res.json(data);
}
return res.send(html);
});
};
``` | /content/code_sandbox/api/responses/notFound.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 629 |
```javascript
/**
* Sets no-cache header in response.
*/
module.exports = function (req, res, next) {
sails.log.info("Applying disable cache policy");
res.header('Cache-Control', 'private, no-cache, no-store, must-revalidate');
res.header('Expires', '-1');
res.header('Pragma', 'no-cache');
next();
};
``` | /content/code_sandbox/api/policies/noCache.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 77 |
```javascript
/**
* 400 (Bad Request) Handler
*
* Usage:
* return res.badRequest();
* return res.badRequest(data);
* return res.badRequest(data, 'some/specific/badRequest/view');
*
* e.g.:
* ```
* return res.badRequest(
* 'Please choose a valid `password` (6-12 characters)',
* 'trial/signup'
* );
* ```
*/
module.exports = function badRequest(data, options) {
// Get access to `req`, `res`, & `sails`
var req = this.req;
var res = this.res;
var sails = req._sails;
// Set status code
res.status(400);
// Log error to console
if (data !== undefined) {
sails.log.verbose('Sending 400 ("Bad Request") response: \n',data);
}
else sails.log.verbose('Sending 400 ("Bad Request") response');
// Only include errors in response if application environment
// is not set to 'production'. In production, we shouldn't
// send back any identifying information about errors.
if (sails.config.environment === 'production') {
data = undefined;
}
// If the user-agent wants JSON, always respond with JSON
if (req.wantsJSON) {
return res.json(data);
}
// If second argument is a string, we take that to mean it refers to a view.
// If it was omitted, use an empty object (`{}`)
options = (typeof options === 'string') ? { view: options } : options || {};
// If a view was provided in options, serve it.
// Otherwise try to guess an appropriate view, or if that doesn't
// work, just send JSON.
if (options.view) {
return res.view(options.view, { data: data });
}
// If no second argument provided, try to serve the implied view,
// but fall back to sending JSON(P) if no view can be inferred.
else return res.guessView({ data: data }, function couldNotGuessView () {
return res.json(data);
});
};
``` | /content/code_sandbox/api/responses/badRequest.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 458 |
```javascript
/**
* authToken
*
* @module :: Policy
* @description :: Ensure that the user is authenticated with an authToken
* @docs :: path_to_url#!/documentation/concepts/Policies
*
*/
module.exports = function(req, res, next) {
var token;
if (req.headers && req.headers.authorization) {
var parts = req.headers.authorization.split(' ');
if (parts.length == 2) {
var scheme = parts[0],
credentials = parts[1];
if (/^Bearer$/i.test(scheme)) {
token = credentials;
}
} else {
return res.forbidden('Wrong authorization format.');
}
} else if (req.param('token')) {
token = req.param('token');
// We delete the token from param to not mess with blueprints
delete req.query.token;
} else {
return res.forbidden('No authorization header found.');
}
AuthToken.verifyToken(token, function(err, decodedToken) {
if (err) return res.forbidden('Invalid Token.');
req.token = decodedToken.sub;
next();
});
};
``` | /content/code_sandbox/api/policies/authToken.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 238 |
```javascript
/**
* Authentication Controller
*
*/
var AuthController = {
login: function(req, res) {
AuthService.authenticate(
req,
sails.config.auth,
function(err, user) {
if (err) {
return res.status(err.code || 401).send(err.message || 'Incorrect credentials');
}
if (!user) {
// If there is no error passed then we should have a user object
return res.serverError('Could not retrieve user');
}
return res.json({
user: user.username,
token: AuthToken.issueToken({
sub: user.username
})
});
});
}
// Logout is handled client-side
};
module.exports = AuthController;
``` | /content/code_sandbox/api/controllers/AuthController.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 150 |
```javascript
/**
* AssetController
*
* @description :: Server-side logic for managing assets
* @help :: See path_to_url#!/documentation/concepts/Controllers
*/
var _ = require('lodash');
var path = require('path');
var actionUtil = require('sails/lib/hooks/blueprints/actionUtil');
var Promise = require('bluebird');
module.exports = {
/**
* Download a release artifact
*
* Note: if a filename is specified, nothing but the filetype is used.
* This is because Squirrel.Windows does a poor job of parsing the filename,
* and so we must fake the filenames of x32 and x64 versions to be the same.
*
* (GET /download/latest/:platform?': 'AssetController.download')
* (GET /download/:version/:platform?/:filename?': 'AssetController.download')
* (GET /download/channel/:channel/:platform?': 'AssetController.download')
* (GET /download/flavor/:flavor/latest/:platform?': 'AssetController.download')
* (GET /download/flavor/:flavor/:version/:platform?/:filename?': 'AssetController.download')
* (GET /download/flavor/:flavor/channel/:channel/:platform?': 'AssetController.download')
*/
download: function(req, res) {
var channel = req.params.channel;
var version = req.params.version || undefined;
var filename = req.params.filename;
var filetype = req.query.filetype;
const flavor = req.params.flavor || 'default';
// We accept multiple platforms (x64 implies x32)
var platforms;
var platform = req.param('platform');
if (platform) {
platforms = [platform];
}
// Normalize filetype by prepending with period
if (_.isString(filetype) && filetype[0] !== '.') {
filetype = '.' + filetype;
} else if (filename) {
filetype = filename.substr(filename.lastIndexOf('.'));
}
// Detect platform from useragent
if (!platforms) {
platforms = PlatformService.detectFromRequest(req);
if (!platforms) {
return res.serverError(
'No platform specified and detecting one was unsuccessful.'
);
}
} else {
platforms = PlatformService.sanitize(platforms);
}
if (!version) {
channel = channel || 'stable';
}
new Promise(function(resolve, reject) {
var assetOptions = UtilityService.getTruthyObject({
platform: platforms,
filetype: filetype
});
sails.log.debug('Asset requested with options', assetOptions);
if (version || channel) {
Version
.find(UtilityService.getTruthyObject({
name: version,
channel: channel,
flavor
}))
.sort([{
createdAt: 'desc'
}])
// the latest version maybe has no assets, for example
// the moment between creating a version and uploading assets,
// so find more than 1 version and use the one containing assets.
.limit(10)
.populate('assets', assetOptions)
.then(function(versions) {
if (!versions || !versions.length) {
return resolve();
}
// sort versions by `name` instead of `createdAt`,
// an lower version could be deleted then be created again,
// thus it has newer `createdAt`.
versions = versions.sort(UtilityService.compareVersion);
var version;
for (var i = 0; i < versions.length; i++) {
version = versions[i];
if (version.assets && version.assets.length) {
break;
}
}
if (!version.assets || !version.assets.length) {
return resolve();
}
// Sorting filename in ascending order prioritizes other files
// over zip archives is both are available and matched.
return resolve(_.orderBy(
version.assets, ['filetype', 'createdAt'], ['asc', 'desc']
)[0]);
})
.catch(reject);
} else {
Asset
.find(assetOptions)
.sort([{
createdAt: 'desc'
}])
.limit(1)
.then(resolve)
.catch(reject);
}
})
.then(function(asset) {
if (!asset || !asset.fd) {
let noneFoundMessage = `The ${flavor} flavor has no download available`;
if (platforms) {
if (platforms.length > 1) {
noneFoundMessage += ' for platforms ' + platforms.toString();
} else {
noneFoundMessage += ' for platform ' + platforms[0];
}
}
noneFoundMessage += version ? ' for version ' + version : '';
noneFoundMessage += channel ? ' (' + channel + ') ' : '';
noneFoundMessage += filename ? ' with filename ' + filename : '';
noneFoundMessage += filetype ? ' with filetype ' + filetype : '';
return res.notFound(noneFoundMessage);
}
// Serve asset & log analytics
return AssetService.serveFile(req, res, asset);
})
// Catch any unhandled errors
.catch(res.negotiate);
},
create: function(req, res) {
// Create data object (monolithic combination of all parameters)
// Omit the blacklisted params (like JSONP callback param, etc.)
var data = actionUtil.parseValues(req);
if (!data.version) {
return res.badRequest('A version is required.');
}
if (_.isString(data.version)) {
// Only a id was provided, normalize
data.version = {
id: data.version
};
} else if (data.version && data.version.id) {
// Valid request, but we only want the id
data.version = {
id: data.version.id
};
} else {
return res.badRequest('Invalid version provided.');
}
// Check that the version exists (or its `_default` flavor equivalent)
Version
.find({
id: [data.version.id, `${data.version.id}_default`]
})
.then(versions => {
if (!versions || !versions.length) {
return res.notFound('The specified `version` does not exist');
}
data.version.id = versions[versions.length - 1].id;
// Set upload request timeout to 10 minutes
req.setTimeout(10 * 60 * 1000);
req.file('file').upload(sails.config.files,
function whenDone(err, uploadedFiles) {
if (err) {
return res.negotiate(err);
}
// If an unexpected number of files were uploaded, respond with an
// error.
if (uploadedFiles.length !== 1) {
return res.badRequest('No file was uploaded');
}
var uploadedFile = uploadedFiles[0];
if (uploadedFile.filename === 'RELEASES') {
return res.badRequest(
'The RELEASES file should not be uploaded since the release server will generate at request time');
}
var fileExt = path.extname(uploadedFile.filename);
sails.log.debug('Creating asset with name', data.name || uploadedFile.filename);
var hashPromise;
if (fileExt === '.nupkg') {
// Calculate the hash of the file, as it is necessary for windows
// files
hashPromise = AssetService.getHash(uploadedFile.fd);
} else if (fileExt === '.exe' || fileExt === '.zip') {
hashPromise = AssetService.getHash(
uploadedFile.fd,
"sha512",
"base64"
);
} else {
hashPromise = Promise.resolve('');
}
hashPromise
.then(function(fileHash) {
var newAsset = _.merge({
name: uploadedFile.filename,
hash: fileHash,
filetype: fileExt,
fd: uploadedFile.fd,
size: uploadedFile.size
}, data);
// Due to an API change in Sails/Waterline, the primary key values must be specified directly.=
newAsset.version = newAsset.version.id;
const delta = newAsset.name && newAsset.name.toLowerCase().includes('-delta') ? 'delta_' : '';
newAsset.id = `${newAsset.version}_${newAsset.platform}_${delta}${newAsset.filetype.replace(/\./g, '')}`;
// Create new instance of model using data from params
Asset
.create(newAsset)
.exec(function created(err, newInstance) {
// Differentiate between waterline-originated validation errors
// and serious underlying issues. Respond with badRequest if a
// validation error is encountered, w/ validation info.
if (err) return res.negotiate(err);
// If we have the pubsub hook, use the model class's publish
// method to notify all subscribers about the created item.
if (req._sails.hooks.pubsub) {
if (req.isSocket) {
Asset.subscribe(req, newInstance);
Asset.introduce(newInstance);
}
Asset.publish([newInstance.id], {
verb: 'created',
id: newInstance.id,
data: newInstance
}, !req.options.mirror && req);
}
// Send JSONP-friendly response if it's supported
res.ok(newInstance);
});
})
.catch(res.negotiate);
});
});
},
destroy: function(req, res) {
var pk = actionUtil.requirePk(req);
var query = Asset.findOne(pk);
query.populate('version');
query
.then(function foundRecord(record) {
if (!record) return res.notFound(
'No record found with the specified `name`.'
);
// Delete the file & remove from db
return Promise.join(
AssetService.destroy(record, req),
AssetService.deleteFile(record),
function() {})
.then(function success() {
res.ok(record);
});
})
.error(res.negotiate);
}
};
``` | /content/code_sandbox/api/controllers/AssetController.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 2,124 |
```javascript
/**
* ChannelController
*
* @description :: Server-side logic for managing Channels
* @help :: See path_to_url#!/documentation/concepts/Controllers
*/
module.exports = {
/**
* Returns a list of channel names sorted by their priority
*
* ( GET /channels/sorted )
*/
list: function (req, res) {
res.send(ChannelService.availableChannels);
},
};
``` | /content/code_sandbox/api/controllers/ChannelController.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 88 |
```javascript
/**
* FlavorController
*
* @description :: Server-side logic for managing Flavors
* @help :: See path_to_url#!/documentation/concepts/Controllers
*/
const actionUtil = require('sails/lib/hooks/blueprints/actionUtil');
const Promise = require('bluebird');
const destroyAssetAndFile = (asset, req) => AssetService
.destroy(asset, req)
.then(AssetService.deleteFile(asset))
.then(() => sails.log.info('Destroyed asset:', asset));
const destroyAssetsAndFiles = (version, req) => version.assets
.map(asset => destroyAssetAndFile(asset, req));
const destroyVersion = (version, req) => VersionService
.destroy(version, req)
.then(() => sails.log.info('Destroyed version:', version));
const destroyVersionAssetsAndFiles = (version, req) => Promise
.all(destroyAssetsAndFiles(version, req))
.then(destroyVersion(version, req));
const destroyFlavor = (flavor, req) => FlavorService
.destroy(flavor, req)
.then(() => sails.log.info('Destroyed flavor:', flavor));
module.exports = {
/**
* Overloaded blueprint function
* Changes:
* - Delete all associated versions, assets & their files
* @param {Object} req Incoming request object
* @param {Object} res Outgoing response object
*/
destroy: (req, res) => {
const pk = actionUtil.requirePk(req);
if (pk === 'default') {
res.serverError('Default flavor cannot be deleted.');
} else {
Flavor
.findOne(pk)
.exec((err, flavor) => {
if (err) {
res.serverError(err);
} else if (!flavor) {
res.notFound('No flavor found with the specified `name`.');
} else {
Version
.find({ flavor: flavor.name })
.populate('assets')
.exec((err, versions) => {
if (err) {
res.serverError(err);
} else {
Promise
.map(versions, version => destroyVersionAssetsAndFiles(version, req))
.then(destroyFlavor(flavor, req))
.then(res.ok(flavor.name))
.error(res.negotiate);
}
});
}
});
}
}
};
``` | /content/code_sandbox/api/controllers/FlavorController.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 507 |
```shell
#!/usr/bin/env bash
# Use this script to test if a given TCP host/port are available
# OSX doesn't have the timeout command but it can be installed using homebrew.
# Check if the gtimeout command exists and, if needed, tell the user how to
# install it.
timeout_cmd="timeout"
if [ $(uname -s) = "Darwin" ]; then
timeout_cmd="gtimeout"
if ! which $timeout_cmd 2>&1 >/dev/null; then
echo "Can't find the command 'gtimeout'. Run 'brew install coreutils' to install it."
exit 1
fi
fi
cmdname=$(basename $0)
echoerr() { if [[ $QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }
usage()
{
cat << USAGE >&2
Usage:
$cmdname host:port [-s] [-t timeout] [-- command args]
-h HOST | --host=HOST Host or IP under test
-p PORT | --port=PORT TCP port under test
Alternatively, you specify the host and port as host:port
-s | --strict Only execute subcommand if the test succeeds
-q | --quiet Don\'t output any status messages
-t TIMEOUT | --timeout=TIMEOUT
Timeout in seconds, zero for no timeout
-- COMMAND ARGS Execute command with args after the test finishes
USAGE
exit 1
}
wait_for()
{
if [[ $TIMEOUT -gt 0 ]]; then
echoerr "$cmdname: waiting $TIMEOUT seconds for $HOST:$PORT"
else
echoerr "$cmdname: waiting for $HOST:$PORT without a timeout"
fi
start_ts=$(date +%s)
while :
do
(echo > /dev/tcp/$HOST/$PORT) >/dev/null 2>&1
result=$?
if [[ $result -eq 0 ]]; then
end_ts=$(date +%s)
echoerr "$cmdname: $HOST:$PORT is available after $((end_ts - start_ts)) seconds"
break
fi
sleep 1
done
return $result
}
wait_for_wrapper()
{
# In order to support SIGINT during timeout: path_to_url
if [[ $QUIET -eq 1 ]]; then
$timeout_cmd $TIMEOUT $0 --quiet --child --host=$HOST --port=$PORT --timeout=$TIMEOUT &
else
$timeout_cmd $TIMEOUT $0 --child --host=$HOST --port=$PORT --timeout=$TIMEOUT &
fi
PID=$!
trap "kill -INT -$PID" INT
wait $PID
RESULT=$?
if [[ $RESULT -ne 0 ]]; then
echoerr "$cmdname: timeout occurred after waiting $TIMEOUT seconds for $HOST:$PORT"
fi
return $RESULT
}
# process arguments
while [[ $# -gt 0 ]]
do
case "$1" in
*:* )
hostport=(${1//:/ })
HOST=${hostport[0]}
PORT=${hostport[1]}
shift 1
;;
--child)
CHILD=1
shift 1
;;
-q | --quiet)
QUIET=1
shift 1
;;
-s | --strict)
STRICT=1
shift 1
;;
-h)
HOST="$2"
if [[ $HOST == "" ]]; then break; fi
shift 2
;;
--host=*)
HOST="${1#*=}"
shift 1
;;
-p)
PORT="$2"
if [[ $PORT == "" ]]; then break; fi
shift 2
;;
--port=*)
PORT="${1#*=}"
shift 1
;;
-t)
TIMEOUT="$2"
if [[ $TIMEOUT == "" ]]; then break; fi
shift 2
;;
--timeout=*)
TIMEOUT="${1#*=}"
shift 1
;;
--)
shift
CLI="$@"
break
;;
--help)
usage
;;
*)
echoerr "Unknown argument: $1"
usage
;;
esac
done
if [[ "$HOST" == "" || "$PORT" == "" ]]; then
echoerr "Error: you need to provide a host and port to test."
usage
fi
TIMEOUT=${TIMEOUT:-15}
STRICT=${STRICT:-0}
CHILD=${CHILD:-0}
QUIET=${QUIET:-0}
if [[ $CHILD -gt 0 ]]; then
wait_for
RESULT=$?
exit $RESULT
else
if [[ $TIMEOUT -gt 0 ]]; then
wait_for_wrapper
RESULT=$?
else
wait_for
RESULT=$?
fi
fi
if [[ $CLI != "" ]]; then
if [[ $RESULT -ne 0 && $STRICT -eq 1 ]]; then
echoerr "$cmdname: strict mode, refusing to execute subprocess"
exit $RESULT
fi
exec $CLI
else
exit $RESULT
fi
``` | /content/code_sandbox/scripts/wait.sh | shell | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 1,139 |
```javascript
/**
* VersionController
*
* @description :: Server-side logic for handling version requests
* @help :: See path_to_url#!/documentation/concepts/Controllers
*/
var actionUtil = require('sails/lib/hooks/blueprints/actionUtil');
var url = require('url');
var Promise = require('bluebird');
var semver = require('semver');
var compareVersions = require('compare-versions');
const availabilityFilter = () => ({ '<=': (new Date()).toISOString() });
module.exports = {
/**
* Set availability date of specified version
*
* (PUT /version/availability/:version/:timestamp)
*/
availability: (req, res) => {
const { version, timestamp } = req.params;
if (!version) return res.badRequest('Requires `version` parameter');
if (!timestamp) return res.badRequest('Requires `timestamp` parameter');
const availability = new Date(parseInt(timestamp, 10));
if (isNaN(availability) || availability.getTime().toString() !== timestamp) {
return res.badRequest('Parameter `timestamp` must be a valid unix timestamp in milliseconds');
}
Version
.findOne(version)
.then(foundVersion => {
if (!foundVersion) return res.notFound('The specified `version` does not exist');
if (availability < new Date(foundVersion.createdAt)) {
return res.badRequest(
'Parameter `timestamp` must be greater than or equal to the version creation date'
);
}
return Version
.update(version, { availability })
.then(([updatedVersion]) => {
Version.publish([version.id], {
verb: 'updated',
id: version.id,
data: updatedVersion,
previous: version
}, req);
res.send(updatedVersion);
});
})
.catch(res.negotiate);
},
/**
* Redirect the update request to the appropriate endpoint
* (GET /update)
*/
redirect: function(req, res) {
var platform = req.param('platform');
var version = req.param('version');
if (!version) {
return res.badRequest('Requires "version" parameter');
}
if (!platform) {
return res.badRequest('Requires "platform" parameter');
}
return res.redirect('/update/' + platform + '/' + version);
},
/**
* Sorts versions and returns pages of them sorted by sermver
*
* ( GET /versions/sorted )
*/
list: function (req, res) {
Version
.find()
.then(versions => {
var count = versions.length;
var page = req.param('page') || req.query.page || 0;
var start = page * sails.config.views.pageSize;
var end = start + sails.config.views.pageSize;
var items = versions
.sort(function (a, b) {
return -compareVersions(a.name, b.name);
})
.slice(start, end);
const response = {
total: count,
offset: start,
page: page,
items: items
}
return Promise.all([
// load channels
new Promise(function (resolve, reject) {
Promise.all(items.map(function (version) {
return Channel.findOne({
name: version.channel
})
}))
.then(resolve)
.catch(reject)
}),
// load assets
new Promise(function (resolve, reject) {
Promise.all(items.map(function (version) {
return Asset.find({
version: version.id
})
}))
.then(resolve)
.catch(reject)
}),
// load flavors
new Promise((resolve, reject) => Promise
.map(items, version => Flavor.findOne(version.flavor))
.then(resolve)
.catch(reject)
)
])
.then(function (results) {
response.items = response.items.map(function (item, index) {
return {
id: item.id,
channel: results[0][index],
assets: results[1][index].map(function (asset) {
return {
id: asset.id,
name: asset.name,
platform: asset.platform,
filetype: asset.filetype,
hash: asset.hash,
size: asset.size,
download_count: asset.download_count,
fd: asset.fd,
createdAt: asset.createdAt,
updatedAt: asset.updatedAt
}
}),
flavor: results[2][index],
name: item.name,
notes: item.notes,
createdAt: item.createdAt,
updatedAt: item.updatedAt,
availability: item.availability
}
})
return response
})
})
.then(response => {
res.send(response);
})
.catch(res.negotiate);
},
/**
* Serves auto-updates: Status and Squirrel.Mac
*
* Assumes stable channel & default flavor unless specified
*
* (GET /update/:platform/:version/:channel)
* (GET /update/flavor/:flavor/:platform/:version/:channel?)
*/
general: function(req, res) {
var platform = req.param('platform');
var version = req.param('version');
var channel = req.param('channel') || 'stable';
const flavor = req.params.flavor || 'default';
if (!version) {
return res.badRequest('Requires `version` parameter');
}
if (!platform) {
return res.badRequest('Requires `platform` parameter');
}
var platforms = PlatformService.detect(platform, true);
sails.log.debug('Update Search Query', {
platform: platforms,
version: version,
channel: channel,
flavor
});
// Get specified version object, it's time will be used for the general
// cutoff.
Version
.findOne({
name: version,
flavor
})
.then(function(currentVersion) {
var applicableChannels, createdAtFilter;
applicableChannels = ChannelService.getApplicableChannels(channel);
sails.log.debug('Applicable Channels', applicableChannels);
if (currentVersion) {
createdAtFilter = {
'>': currentVersion.createdAt
};
} else {
sails.log.debug('The specified `version` does not exist');
}
sails.log.debug('Time Filter', createdAtFilter);
return Version
.find(UtilityService.getTruthyObject({
channel: applicableChannels,
createdAt: createdAtFilter,
availability: availabilityFilter(),
flavor
}))
.populate('assets', {
platform: platforms
})
.then(function(newerVersions) {
// Sort versions which were added after the current one by semver in
// descending order.
newerVersions.sort(UtilityService.compareVersion);
var latestVersion;
sails.log.debug('Newer Versions', newerVersions);
// Generate the combined release notes for the newer versions while simultaneously filtering out
// inapplicable versions and finding the latest version.
var releaseNotes = _.reduce(
newerVersions,
function(prevNotes, newVersion) {
// Filter out assets that are not zip files since we only
// support zip files for auto-updates.
newVersion.assets = _.filter(newVersion.assets, function(asset) {
return asset.filetype === '.zip';
});
// If one of the assets for this verison apply to our desired
// platform then we will skip this version
if (!newVersion.assets.length) {
return prevNotes;
}
// If this is the first version we've found that is newer than
// the current version, then we will use it as the latest.
if (!latestVersion && semver.lt(version, newVersion.name)) {
latestVersion = newVersion;
}
// Skip if no notes available for this version
if (!newVersion.notes || !newVersion.notes.length) {
return prevNotes;
}
// If not the first changenote, prefix with new line
var newChangeNote = !prevNotes.length ? '' : '\n';
// Add the version name and notes
newChangeNote += '## ' + newVersion.name + '\n' + newVersion.notes;
// Add the new changenote to the previous ones
return prevNotes + newChangeNote;
},
'');
var currentVersionName = _.get(currentVersion, 'name');
sails.log.debug('Version candidate', latestVersion);
sails.log.debug('Current version', currentVersionName);
if (!latestVersion || latestVersion.name === currentVersionName) {
sails.log.debug('Version candidate denied');
return res.status(204).send('No updates.');
}
sails.log.debug('Version candidate accepted');
return res.ok({
url: url.resolve(
sails.config.appUrl,
`/download/flavor/${flavor}/${latestVersion.name}/` +
latestVersion.assets[0].platform + '?filetype=zip'
),
name: latestVersion.name,
notes: releaseNotes,
pub_date: new Date(latestVersion.availability).toISOString()
});
});
})
.catch(res.negotiate);
},
/**
* Serves auto-updates: Squirrel.Windows: serve RELEASES from latest version
* Currently, it will only serve a full.nupkg of the latest release with a
* normalized filename (for pre-release)
*
* (GET /update/:platform/:version/:channel/RELEASES)
* (GET /update/flavor/:flavor/:platform/:version/:channel/RELEASES)
*/
windows: function(req, res) {
var platform = req.param('platform');
var version = req.param('version');
var channel = req.param('channel') || 'stable';
const flavor = req.params.flavor || 'default';
if (!version) {
return res.badRequest('Requires `version` parameter');
}
if (!platform) {
return res.badRequest('Requires `platform` parameter');
}
var platforms = PlatformService.detect(platform, true);
sails.log.debug('Windows Update Search Query', {
platform: platforms,
version: version,
channel: channel,
flavor
});
// Get specified version object, it's time will be used for the general
// cutoff.
Version
.findOne({
name: version,
flavor
})
.then(function(currentVersion) {
var applicableChannels, createdAtFilter;
applicableChannels = ChannelService.getApplicableChannels(channel);
sails.log.debug('Applicable Channels', applicableChannels);
if (currentVersion) {
createdAtFilter = {
'>=': currentVersion.createdAt
};
} else {
sails.log.debug('The specified `version` does not exist');
}
sails.log.debug('Time Filter', createdAtFilter);
return Version
.find(UtilityService.getTruthyObject({
channel: applicableChannels,
createdAt: createdAtFilter,
availability: availabilityFilter(),
flavor
}))
.populate('assets', {
platform: platforms
})
.then(function(newerVersions) {
// Sort versions which were added after the current one by semver in
// descending order.
newerVersions.sort(UtilityService.compareVersion);
var latestVersion = _.find(
newerVersions,
function(newVersion) {
_.remove(newVersion.assets, function(o) {
return o.filetype !== '.nupkg' || !o.hash;
});
// Make sure the last version is a version with full asset
// so RELEASES contains at least one full asset (which is mandatory for Squirrel.Windows)
let v = _.filter(
newVersion.assets,
function(o) {
return _.includes(o.name.toLowerCase(), '-full');
}
);
return v.length && semver.lte(
version, newVersion.name
);
});
if (!latestVersion) {
sails.log.debug('Version not found');
return res.status(500).send('Version not found');
}
// Add Delta assets from other versions
var deltaAssets = _.reduce(
newerVersions,
function(assets, newVersion) {
return assets.concat(
_.filter(
newVersion.assets,
function(asset) {
return asset.filetype === '.nupkg'
&& _.includes(asset.name.toLowerCase(), '-delta')
&& semver.lte(version, newVersion.name)
&& semver.gt(latestVersion.name, newVersion.name);
}));
}, []);
Array.prototype.unshift.apply(latestVersion.assets, deltaAssets);
sails.log.debug('Latest Windows Version', latestVersion);
// Change asset name to use full download link
const assets = _.map(latestVersion.assets, function(asset) {
asset.name = url.resolve(
sails.config.appUrl,
`/download/flavor/${flavor}/${latestVersion.name}/${asset.platform}/` +
asset.name
);
return asset;
});
var output = WindowsReleaseService.generate(assets);
res.header('Content-Length', output.length);
res.attachment('RELEASES');
return res.send(output);
});
})
.catch(res.negotiate);
},
/**
* Get electron-updater win yml for a specific channel
* (GET /update/:platform/latest.yml)
* (GET /update/:platform/:channel.yml)
* (GET /update/:platform/:channel/latest.yml)
* (GET /update/flavor/:flavor/:platform/latest.yml)
* (GET /update/flavor/:flavor/:platform/:channel.yml)
* (GET /update/flavor/:flavor/:platform/:channel/latest.yml)
*/
electronUpdaterWin: function(req, res) {
var platform = req.param('platform');
var channel = req.param('channel') || 'stable';
const flavor = req.params.flavor || 'default';
if (!platform) {
return res.badRequest('Requires `platform` parameter');
}
var platforms = PlatformService.detect(platform, true);
sails.log.debug('NSIS electron-updater Search Query', {
platform: platforms,
channel: channel,
flavor
});
var applicableChannels = ChannelService.getApplicableChannels(channel);
sails.log.debug('Applicable Channels', applicableChannels);
// Get latest version that has a windows asset
Version
.find({
channel: applicableChannels,
availability: availabilityFilter(),
flavor
})
.populate('assets')
.then(function(versions) {
// TODO: Implement method to get latest version with available asset
var sortedVersions = versions.sort(UtilityService.compareVersion);
var latestVersion = null;
var asset = null;
for (var i = 0; i < sortedVersions.length; i++) {
var currentVersion = sortedVersions[i];
if (currentVersion.assets) {
for (var j = 0; j < currentVersion.assets.length; j++) {
var currentAsset = currentVersion.assets[j];
// Find the first asset that is a exe file and matches the desired platform.
// Note that only exe files are supported for win autoupdates through this API (not nupkg).
// Nupkg files are supported through the Squirrel.Windows API.
if (currentAsset.filetype === '.exe' && _.includes(platforms, currentAsset.platform)) {
latestVersion = currentVersion;
asset = currentAsset;
break;
}
}
if (latestVersion) {
break;
}
}
}
if (latestVersion) {
var downloadPath = url.resolve(
"",
`/download/flavor/${flavor}/${latestVersion.name}/${asset.platform}/` +
asset.name
);
const sha512 = asset.hash ? asset.hash : null;
var latestYml = "version: " + latestVersion.name
+ "\nfiles:"
+ "\n - url: " + downloadPath
+ "\n sha512: " + sha512
+ "\n size: " + asset.size
+ "\nreleaseDate: " + latestVersion.updatedAt
+ "\npath: " + downloadPath
+ "\nsha512: " + sha512
+ "\nsize: " + asset.size;
res.send(latestYml);
} else {
res.notFound();
}
});
},
/**
* Get electron-updater mac yml for a specific channel
* (GET /update/:platform/latest-mac.yml)
* (GET /update/:platform/:channel-mac.yml)
* (GET /update/:platform/:channel/latest-mac.yml)
* (GET /update/flavor/:flavor/:platform/latest-mac.yml)
* (GET /update/flavor/:flavor/:platform/:channel-mac.yml)
* (GET /update/flavor/:flavor/:platform/:channel/latest-mac.yml)
*/
electronUpdaterMac: function(req, res) {
var platform = req.param('platform');
var channel = req.param('channel') || 'stable';
const flavor = req.params.flavor || 'default';
if (!platform) {
return res.badRequest('Requires `platform` parameter');
}
var platforms = PlatformService.detect(platform, true);
sails.log.debug('Mac electron-updater Search Query', {
platform: platforms,
channel: channel,
flavor
});
var applicableChannels = ChannelService.getApplicableChannels(channel);
sails.log.debug('Applicable Channels', applicableChannels);
// Get latest version that has a mac asset
Version
.find({
channel: applicableChannels,
availability: availabilityFilter(),
flavor
})
.populate('assets')
.then(function(versions) {
// TODO: Implement method to get latest version with available asset
var sortedVersions = versions.sort(UtilityService.compareVersion);
var latestVersion = null;
var asset = null;
for (var i = 0; i < sortedVersions.length; i++) {
var currentVersion = sortedVersions[i];
if (currentVersion.assets) {
for (var j = 0; j < currentVersion.assets.length; j++) {
var currentAsset = currentVersion.assets[j];
// Find the first asset that is a zip file and matches the desired platform.
// Note that only zip files are supported for mac autoupdates.
if (currentAsset.filetype === '.zip' && _.includes(platforms, currentAsset.platform)) {
latestVersion = currentVersion;
asset = currentAsset;
break;
}
}
if (latestVersion) {
break;
}
}
}
if (latestVersion) {
var downloadPath = url.resolve(
"",
`/download/flavor/${flavor}/${latestVersion.name}/${asset.platform}/` +
asset.name
);
const sha512 = asset.hash ? asset.hash : null;
var latestYml = "version: " + latestVersion.name
+ "\nfiles:"
+ "\n - url: " + downloadPath
+ "\n sha512: " + sha512
+ "\n size: " + asset.size
+ "\nreleaseDate: " + latestVersion.updatedAt
+ "\npath: " + downloadPath
+ "\nsha512: " + sha512
+ "\nsize: " + asset.size;
res.send(latestYml);
} else {
res.notFound();
}
});
},
/**
* Get release notes for a specific version
* (GET /notes/:version/:flavor?)
*/
releaseNotes: function(req, res) {
var version = req.params.version;
const flavor = req.params.flavor || 'default';
Version
.findOne({
name: version,
availability: availabilityFilter(),
flavor
})
.then(function(currentVersion) {
if (!currentVersion) {
return res.notFound('The specified version does not exist');
}
return res.format({
'application/json': function() {
res.send({
'notes': currentVersion.notes,
'pub_date': new Date(currentVersion.availability).toISOString()
});
},
'default': function() {
res.send(currentVersion.notes);
}
});
})
.catch(res.negotiate);
},
/**
* Overloaded blueprint function
* Changes:
* - Delete all associated assets & their files
*/
destroy: function(req, res) {
var pk = actionUtil.requirePk(req);
var query = Version.findOne(pk);
query.populate('assets');
query.exec(function foundRecord(err, record) {
if (err) return res.serverError(err);
if (!record) return res.notFound(
'No record found with the specified `name`.'
);
var deletePromises = _.map(record.assets, function(asset) {
return Promise.join(
AssetService.destroy(asset, req),
AssetService.deleteFile(asset),
function() {
sails.log.info('Destroyed asset: ', asset);
});
});
Promise.all(deletePromises)
.then(function allDeleted() {
return Version.destroy(pk)
.then(function destroyedRecord() {
if (sails.hooks.pubsub) {
Version.publish(
[pk], {
verb: 'destroyed',
previous: record
}, !req._sails.config.blueprints.mirror && req
);
if (req.isSocket) {
Version.unsubscribe(req, record);
Version.retire(record);
}
}
sails.log.info('Destroyed version: ', record);
return res.ok(record);
});
})
.error(res.negotiate);
});
}
};
``` | /content/code_sandbox/api/controllers/VersionController.js | javascript | 2016-02-28T10:06:53 | 2024-08-15T05:19:37 | electron-release-server | ArekSredzki/electron-release-server | 2,072 | 4,630 |
```java
package presenter;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
/**
* Date: 25.02.2016
* Time: 13:36
*
* @author Savin Mikhail
*/
public class PresenterWithoutEmptyConstructor<V extends MvpView> extends MvpPresenter<V> {
public PresenterWithoutEmptyConstructor(String s) {/*do nothing*/}
private PresenterWithoutEmptyConstructor() {/*do nothing*/}
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/PresenterWithoutEmptyConstructor.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 98 |
```java
package com.arellomobile.mvp.compiler.view;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import params.EmptyParams;
public class EmptyParamsView implements MvpView, EmptyParams {
@InjectPresenter(factory = MockPresenterFactory.class, presenterId = "Test", type = PresenterType.LOCAL)
public MvpPresenter<MvpView> mInjectViewStatePresenter;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/EmptyParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 135 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import presenter.PositiveParamsViewPresenter;
/**
* Date: 25.02.2016
* Time: 14:50
*
* @author Savin Mikhail
*/
public class InjectPresenterTypeBehaviorView implements MvpView {
@InjectPresenter(tag = "", type = PresenterType.LOCAL)
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mTagLocalPresenter;
@InjectPresenter(factory = MockPresenterFactory.class, type = PresenterType.LOCAL)
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mFactoryLocalPresenter;
@InjectPresenter(presenterId = "", type = PresenterType.LOCAL)
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mPresenterIdLocalPresenter;
@InjectPresenter(tag = "")
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mTagLocalPresenter2;
@InjectPresenter(factory = MockPresenterFactory.class)
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mFactoryLocalPresenter2;
@InjectPresenter(presenterId = "")
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mPresenterIdLocalPresenter2;
@InjectPresenter(tag = "", factory = MockPresenterFactory.class)
private PositiveParamsViewPresenter<InjectPresenterTypeBehaviorView> mFactoryTagPresenter;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterTypeBehaviorView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 305 |
```java
package view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 26.02.2016
* Time: 17:58
*
* @author Savin Mikhail
*/
public interface WithoutGenerateViewAnnotationView extends MvpView {
}
``` | /content/code_sandbox/moxy/src/test/resources/view/WithoutGenerateViewAnnotationView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 57 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.TestViewPresenter;
/**
* Date: 25.02.2016
* Time: 12:50
*
* @author Savin Mikhail
*/
public class InjectPresenterWithIncorrectViewView implements MvpView {
@InjectPresenter
public TestViewPresenter mTestViewPresenter;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterWithIncorrectViewView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 94 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.CounterTestView;
/**
* Date: 15.03.2016
* Time: 13:32
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStateForClassPresenter extends MvpPresenter<CounterTestView> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/InjectViewStateForClassPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 87 |
```java
package view;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:13
*
* @author Savin Mikhail
*/
public interface ViewStateParentStrategyTagView {
@StateStrategyType(AddToEndSingleStrategy.class)
void method1();
@StateStrategyType(value = AddToEndSingleStrategy.class, tag = "Test2")
void method2();
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateParentStrategyTagView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 124 |
```java
package view;
import com.arellomobile.mvp.GenerateViewState;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:09
*
* @author Savin Mikhail
*/
@GenerateViewState
public interface ViewStateChildWithIncorrectStrategyTagView extends ViewStateParentView, ViewStateParentStrategyTagView {
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateChildWithIncorrectStrategyTagView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 111 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.view.CounterTestView;
import com.arellomobile.mvp.view.TestViewChild2;
import presenter.WithViewGenericPresenter;
/**
* Date: 04.03.2016
* Time: 11:27
*
* @author Savin Mikhail
*/
public class InjectPresenterWithGenericViewIncorrect extends TestViewChild2<MvpView> {
@InjectPresenter
WithViewGenericPresenter<CounterTestView, InjectPresenterWithGenericViewIncorrect> mPresenter;
public void testEvent() {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterWithGenericViewIncorrect.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 136 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 25.02.2016
* Time: 9:21
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface Params1 {
String mockParams1(String presenterId);
}
``` | /content/code_sandbox/moxy/src/test/resources/params/Params1.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 77 |
```java
package view;
import com.arellomobile.mvp.GenerateViewState;
import com.arellomobile.mvp.MvpView;
/**
* Date: 26.02.2016
* Time: 11:49
*
* @author Savin Mikhail
*/
public interface ViewStateForGenericView<T> extends MvpView {
void testEvent(T ter);
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateForGenericView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 74 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 24.02.2016
* Time: 10:06
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface EmptyParams {
}
``` | /content/code_sandbox/moxy/src/test/resources/params/EmptyParams.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 69 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 24.02.2016
* Time: 10:11
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface SeveralMethodParams {
void method1();
void method2();
}
``` | /content/code_sandbox/moxy/src/test/resources/params/SeveralMethodParams.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 78 |
```java
package view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 26.02.2016
* Time: 11:36
*
* @author Savin Mikhail
*/
public interface PositiveViewStateView extends MvpView {
void method();
}
``` | /content/code_sandbox/moxy/src/test/resources/view/PositiveViewStateView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 58 |
```java
package view;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:13
*
* @author Savin Mikhail
*/
public interface ViewStateParent2View {
@StateStrategyType(SingleStateStrategy.class)
void method1();
@StateStrategyType(value = AddToEndSingleStrategy.class, tag = "Test2")
void method2();
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateParent2View.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 122 |
```java
package presenter;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.view.CounterTestView;
import com.arellomobile.mvp.view.TestView;
import com.arellomobile.mvp.view.TestViewChild;
import view.PositiveParamsView;
/**
* Date: 04.03.2016
* Time: 11:27
*
* @author Savin Mikhail
*/
public class WithViewGenericPresenter<T extends CounterTestView, S extends CounterTestView> extends WithViewGenericPresenter2<T, S> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/WithViewGenericPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 125 |
```java
package view;
import com.arellomobile.mvp.GenerateViewState;
/**
* Date: 26.02.2016
* Time: 11:08
*
* @author Savin Mikhail
*/
@GenerateViewState
public interface ViewStateForNotView {
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateForNotView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 55 |
```java
package view;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
/**
* Date: 25.02.2016
* Time: 11:39
*
* @author Savin Mikhail
*/
public class InjectPresenterAnnotationInsideNotMvpViewClass {
@InjectPresenter
public MvpPresenter<MvpView> mObject;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterAnnotationInsideNotMvpViewClass.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 94 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 24.02.2016
* Time: 18:17
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface IncorrectParametersParams {
void method1(Integer i);
}
``` | /content/code_sandbox/moxy/src/test/resources/params/IncorrectParametersParams.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 76 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.params.MockParams;
import com.arellomobile.mvp.params.MockParams2;
import params.Params1;
import params.Params2;
/**
* Date: 24.02.2016
* Time: 18:52
*
* @author Savin Mikhail
*/
public class SeveralParamsView implements MvpView, Params1, Params2 {
@Override
public String mockParams1(final String presenterId) {
return null;
}
@Override
public String mockParams2(final String presenterId) {
return null;
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/SeveralParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 134 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
/**
* Date: 25.02.2016
* Time: 11:39
*
* @author Savin Mikhail
*/
public class ObjectInjectPresenterView implements MvpView {
@InjectPresenter
public Object mObject;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ObjectInjectPresenterView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 76 |
```java
package view;
import com.arellomobile.mvp.GenerateViewState;
import com.arellomobile.mvp.MvpView;
/**
* Date: 26.02.2016
* Time: 11:33
*
* @author Savin Mikhail
*/
@GenerateViewState
public class ViewStateForClassView implements MvpView {
public void showProgress() {
}
public void hideProgress() {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateForClassView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 86 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import params.IncorrectParametersParams;
/**
* Date: 24.02.2016
* Time: 18:19
*
* @author Savin Mikhail
*/
public class IncorrectParametersParamsView implements MvpView, IncorrectParametersParams {
@InjectPresenter(factory = MockPresenterFactory.class, presenterId = "Test", type = PresenterType.LOCAL)
public InjectViewStatePresenter mInjectViewStatePresenter;
@Override
public void method1(final Integer i) {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/IncorrectParametersParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 160 |
```java
package view;
import com.arellomobile.mvp.factory.MockPresenterFactory2;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.TestViewPresenter;
import com.arellomobile.mvp.view.TestView;
import params.Params1;
/**
* Date: 25.02.2016
* Time: 13:48
*
* @author Savin Mikhail
*/
public class InjectPresenterWithIncorrectParamsView implements TestView, Params1 {
@InjectPresenter(factory = MockPresenterFactory2.class, presenterId = "Test", type = PresenterType.LOCAL)
public TestViewPresenter mPresenter;
@Override
public void testEvent() {
}
@Override
public String mockParams1(final String presenterId) {
return null;
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterWithIncorrectParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 175 |
```java
package view;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import params.Params1;
import presenter.PositiveParamsViewPresenter;
/**
* Date: 25.02.2016
* Time: 11:19
*
* @author Savin Mikhail
*/
public class PositiveParamsView implements MvpView, Params1 {
@InjectPresenter(factory = MockPresenterFactory.class, presenterId = "Test", type = PresenterType.LOCAL)
public PositiveParamsViewPresenter<PositiveParamsView> mInjectViewStatePresenter;
@Override
public String mockParams1(final String presenterId) {
return null;
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/PositiveParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 174 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 24.02.2016
* Time: 18:17
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface IncorrectCountOfParametersParams {
void method1(String s1, String s2);
}
``` | /content/code_sandbox/moxy/src/test/resources/params/IncorrectCountOfParametersParams.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 83 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:08
*
* @author Savin Mikhail
*/
public interface ViewStateParentView extends MvpView {
@StateStrategyType(value = AddToEndSingleStrategy.class)
void method1();
@StateStrategyType(value = AddToEndSingleStrategy.class, tag = "Test")
void method2();
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateParentView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 123 |
```java
package view;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:09
*
* @author Savin Mikhail
*/
public interface ViewStateChildWithIncorrectStrategyClassView extends ViewStateParentView, ViewStateParentStrategyClassView {
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateChildWithIncorrectStrategyClassView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 97 |
```java
package view;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.02.2016
* Time: 12:13
*
* @author Savin Mikhail
*/
public interface ViewStateParentStrategyClassView {
@StateStrategyType(SingleStateStrategy.class)
void method1();
@StateStrategyType(value = AddToEndSingleStrategy.class, tag = "Test")
void method2();
}
``` | /content/code_sandbox/moxy/src/test/resources/view/ViewStateParentStrategyClassView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 122 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.view.CounterTestView;
import com.arellomobile.mvp.view.TestView;
import com.arellomobile.mvp.view.TestViewChild2;
import presenter.WithViewGenericPresenter;
/**
* Date: 04.03.2016
* Time: 11:27
*
* @author Savin Mikhail
*/
public class InjectPresenterWithGenericView extends CounterTestView {
@InjectPresenter
WithViewGenericPresenter<InjectPresenterWithGenericView, CounterTestView> mPresenter;
public void testEvent() {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterWithGenericView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 141 |
```java
package view;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import view.ViewStateForGenericView;
/**
* Date: 15.03.2016
* Time: 13:44
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStateForGenericViewPresenter extends MvpPresenter<ViewStateForGenericView<Object>> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/InjectViewStateForGenericViewPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 86 |
```java
package params;
import com.arellomobile.mvp.ParamsProvider;
import com.arellomobile.mvp.factory.MockPresenterFactory;
/**
* Date: 25.02.2016
* Time: 9:21
*
* @author Savin Mikhail
*/
@ParamsProvider(MockPresenterFactory.class)
public interface Params2 {
String mockParams2(String presenterId);
}
``` | /content/code_sandbox/moxy/src/test/resources/params/Params2.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 77 |
```java
package presenter;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.view.CounterTestView;
import com.arellomobile.mvp.view.TestView;
import com.arellomobile.mvp.view.TestViewChild;
import view.PositiveParamsView;
/**
* Date: 04.03.2016
* Time: 11:27
*
* @author Savin Mikhail
*/
public class WithViewGenericPresenter2<T extends TestView, S extends CounterTestView> extends MvpPresenter<T> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/WithViewGenericPresenter2.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 121 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.presenter.InjectPresenter;
import presenter.PresenterWithoutEmptyConstructor;
/**
* Date: 10.02.2016
* Time: 13:22
*
* @author Savin Mikhail
*/
public class InjectPresenterWithoutEmptyConstructorView implements MvpView {
@InjectPresenter
public PresenterWithoutEmptyConstructor<InjectPresenterWithoutEmptyConstructorView> your_sha256_hashuctor;
}
``` | /content/code_sandbox/moxy/src/test/resources/view/InjectPresenterWithoutEmptyConstructorView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 100 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
public class SeveralMethodParamsView implements MvpView, params.SeveralMethodParams {
@InjectPresenter(factory = MockPresenterFactory.class, presenterId = "Test", type = PresenterType.LOCAL)
public InjectViewStatePresenter mInjectViewStatePresenter;
@Override
public void method1() {
}
@Override
public void method2() {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/SeveralMethodParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 135 |
```java
package view;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.factory.MockPresenterFactory;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import params.IncorrectCountOfParametersParams;
import params.IncorrectParametersParams;
/**
* Date: 24.02.2016
* Time: 18:19
*
* @author Savin Mikhail
*/
public class IncorrectCountOfParametersParamsView implements MvpView, IncorrectCountOfParametersParams {
@InjectPresenter(factory = MockPresenterFactory.class, presenterId = "Test", type = PresenterType.LOCAL)
public InjectViewStatePresenter mInjectViewStatePresenter;
@Override
public void method1(final String s1, String s2) {
}
}
``` | /content/code_sandbox/moxy/src/test/resources/view/IncorrectCountOfParametersParamsView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 178 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import view.PositiveViewStateView;
/**
* Date: 26.02.2016
* Time: 17:38
*
* @author Savin Mikhail
*/
@InjectViewState
public class PositiveViewStateProviderForNotPresenter {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/PositiveViewStateProviderForNotPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 73 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import view.WithoutGenerateViewAnnotationView;
/**
* Date: 26.02.2016
* Time: 17:56
*
* @author Savin Mikhail
*/
@InjectViewState
public class ViewStateProviderForViewWithoutGenerateViewAnnotationPresenter extends MvpPresenter<WithoutGenerateViewAnnotationView> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/ViewStateProviderForViewWithoutGenerateViewAnnotationPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 90 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import view.ViewStateChildWithIncorrectStrategyClassView;
/**
* Date: 15.03.2016
* Time: 14:47
*
* @author Savin Mikhail
*/
@InjectViewState
public class ViewStateChildWithIncorrectStrategyClassPresenter extends MvpPresenter<ViewStateChildWithIncorrectStrategyClassView> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/ViewStateChildWithIncorrectStrategyClassPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 92 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.CounterTestView;
/**
* Date: 15.03.2016
* Time: 13:32
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStateForGenericPresenter<T extends CounterTestView> extends MvpPresenter<T> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/InjectViewStateForGenericPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 90 |
```java
package presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import view.PositiveViewStateView;
/**
* Date: 26.02.2016
* Time: 17:38
*
* @author Savin Mikhail
*/
@InjectViewState
public class PositiveViewStateProviderPresenter extends MvpPresenter<PositiveViewStateView> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/PositiveViewStateProviderPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 80 |
```java
package presenter;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.MvpView;
/**
* Date: 10.02.2016
* Time: 13:24
*
* @author Savin Mikhail
*/
public class PositiveParamsViewPresenter<V extends MvpView> extends MvpPresenter<V> {
}
``` | /content/code_sandbox/moxy/src/test/resources/presenter/PositiveParamsViewPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 75 |
```java
package com.arellomobile.mvp.tests;
import android.os.Bundle;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.view.DelegateLocalPresenterTestView;
import com.arellomobile.mvp.view.TestView;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Date: 10.02.2016
* Time: 13:19
*
* @author Savin Mikhail
*/
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class MvpDelegateTest {
private DelegateLocalPresenterTestView mTestView = new DelegateLocalPresenterTestView();
private MvpDelegate<? extends TestView> mMvpDelegate = new MvpDelegate<>(mTestView);
@Before
public void init() {
mMvpDelegate.onCreate(Mockito.mock(Bundle.class));
mMvpDelegate.onAttach();
}
@After
public void reset() {
mMvpDelegate.onDetach();
mMvpDelegate.onDestroy();
}
@Test
public void localPresenterTest() {
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/tests/MvpDelegateTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 257 |
```java
package com.arellomobile.mvp.compiler;
import java.io.IOException;
import java.util.regex.Pattern;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableTable;
import org.junit.Test;
import javax.tools.Diagnostic;
import static org.junit.Assert.fail;
/**
* Date: 26.02.2016
* Time: 17:38
*
* @author Savin Mikhail
*/
public class ViewStateProviderClassTest extends CompilerTest {
@Test
public void positiveViewStateProvider() {
try {
assertCompilationResultIs(ImmutableTable.<Diagnostic.Kind, Integer, Pattern>of(), ImmutableList.of(getString("com/arellomobile/mvp/presenter/PositiveViewStateProviderPresenter$$ViewStateProvider.java")));
} catch (IOException e) {
fail(e.getLocalizedMessage());
}
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/compiler/ViewStateProviderClassTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 170 |
```java
package com.arellomobile.mvp.tests;
import java.lang.reflect.Field;
import android.os.Bundle;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.NoViewStatePresenter;
import com.arellomobile.mvp.view.DelegateLocalPresenterTestView;
import com.arellomobile.mvp.view.TestView;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
/**
* Date: 09.02.2016
* Time: 12:37
*
* @author Savin Mikhail
*/
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class LocalPresenterTest {
@Mock
TestView mTestView;
DelegateLocalPresenterTestView mDelegateLocalPresenterTestView = new DelegateLocalPresenterTestView();
DelegateLocalPresenterTestView mDelegateLocalPresenter2TestView = new DelegateLocalPresenterTestView();
MvpDelegate<? extends TestView> mTestViewMvpDelegate = new MvpDelegate<>(mDelegateLocalPresenterTestView);
MvpDelegate<? extends TestView> mTestViewMvpDelegate2 = new MvpDelegate<>(mDelegateLocalPresenter2TestView);
@Before
public void setup() {
mTestView = mock(TestView.class);
mTestViewMvpDelegate.onCreate(null);
mTestViewMvpDelegate.onAttach();
mTestViewMvpDelegate2.onCreate(null);
mTestViewMvpDelegate2.onAttach();
}
@After
public void reset() {
mTestViewMvpDelegate.onDetach();
mTestViewMvpDelegate.onDestroy();
mTestViewMvpDelegate2.onDetach();
mTestViewMvpDelegate2.onDestroy();
}
@Test
public void checkWithInjectViewState() {
InjectViewStatePresenter injectViewStatePresenter = new InjectViewStatePresenter();
injectViewStatePresenter.attachView(mTestView);
try {
Field mViewState = MvpPresenter.class.getDeclaredField("mViewState");
mViewState.setAccessible(true);
assertTrue("ViewState is null for InjectViewStatePresenter", mViewState.get(injectViewStatePresenter) != null);
} catch (IllegalAccessException | NoSuchFieldException e) {
assertFalse(e.getLocalizedMessage(), true);
}
}
@Test
public void checkWithoutViewState() {
NoViewStatePresenter noViewStatePresenter = new NoViewStatePresenter();
noViewStatePresenter.attachView(mTestView);
try {
Field mViewState = MvpPresenter.class.getDeclaredField("mViewState");
mViewState.setAccessible(true);
assertTrue("ViewState is not null for NoViewStatePresenter", mViewState.get(noViewStatePresenter) == null);
} catch (IllegalAccessException | NoSuchFieldException e) {
assertFalse(e.getLocalizedMessage(), true);
}
}
@Test
public void checkDelegatePresenter() {
assertTrue("Presenter is null for delegate", mDelegateLocalPresenterTestView.mInjectViewStatePresenter != null);
}
@Test
public void checkLocalPresenters() {
assertNotEquals("Local Presenters for two different view is equal", mDelegateLocalPresenterTestView.mInjectViewStatePresenter.hashCode(), mDelegateLocalPresenter2TestView.mInjectViewStatePresenter.hashCode());
}
@Test
public void checkSaveState() {
int hashCode = mDelegateLocalPresenterTestView.mInjectViewStatePresenter.hashCode();
Bundle bundle = new Bundle();
mTestViewMvpDelegate.onSaveInstanceState(bundle);
mTestViewMvpDelegate.onDetach();
mTestViewMvpDelegate.onDestroy();
mTestViewMvpDelegate.onCreate(bundle);
mTestViewMvpDelegate.onAttach();
//TODO: should be passed! Or change test
//assertTrue("Local presenter has different hashCode after recreate", hashCode == mDelegateLocalPresenterTestView.mInjectViewStatePresenter.hashCode());
mTestViewMvpDelegate.onDetach();
mTestViewMvpDelegate.onDestroy();
mTestViewMvpDelegate.onCreate();
mTestViewMvpDelegate.onAttach();
assertFalse("Local presenter has same hashCode after creating new view", hashCode == mDelegateLocalPresenterTestView.mInjectViewStatePresenter.hashCode());
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/tests/LocalPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 934 |
```java
package com.arellomobile.mvp.compiler;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
@SupportedAnnotationTypes(value = {"*"})
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public final class ErrorProcessor extends AbstractProcessor {
Messager messager;
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
this.messager = processingEnv.getMessager();
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
for (Element element : roundEnv.getRootElements()) {
if (element.getSimpleName().toString().equals("InjectPresenterTypeBehaviorView")) {
for (Element element1 : element.getEnclosedElements()) {
System.out.println("EnclosedElements: " + element1.getSimpleName());
ImmutableList<String> of = ImmutableList.of("mPresenterIdLocalPresenter", "mTagLocalPresenter", "mFactoryLocalPresenter", "mFactoryTagPresenter");
if (of.contains(element1.getSimpleName().toString())) {
messager.printMessage(Diagnostic.Kind.ERROR, "expected error!", element1);
}
}
}
}
return true;
}
@Override
public Set<String> getSupportedAnnotationTypes() {
return ImmutableSet.of("*");
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/compiler/ErrorProcessor.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 389 |
```java
package com.arellomobile.mvp.compiler;
import java.io.IOException;
import java.util.regex.Pattern;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableTable;
import com.google.common.truth.Truth;
import com.google.testing.compile.JavaFileObjects;
import org.junit.Test;
import javax.tools.Diagnostic;
import static org.junit.Assert.fail;
/**
* Date: 26.02.2016
* Time: 10:50
*
* @author Savin Mikhail
*/
public class ViewStateClassTest extends CompilerTest {
@Test
public void viewStateForClassView_throw() {
try {
getThat(JavaFileObjects.forResource("view/CounterTestView.java"), JavaFileObjects.forResource("presenter/InjectViewStateForClassPresenter.java")).failsToCompile();
fail();
} catch (RuntimeException e) {
Truth.assertThat(e.getLocalizedMessage().contains("must be INTERFACE, or not mark it as"));
}
}
@Test
public void positiveViewState() {
try {
assertCompilationResultIs(ImmutableTable.<Diagnostic.Kind, Integer, Pattern>of(), ImmutableList.of(getString("com/arellomobile/mvp/view/PositiveViewStateView$$State.java")));
} catch (IOException e) {
fail(e.getLocalizedMessage());
}
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/compiler/ViewStateClassTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 272 |
```java
package com.arellomobile.mvp.memory_leak_test;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;
import android.os.Bundle;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.memory_leak_test.resources.TestViewImplementation;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import static org.junit.Assert.assertTrue;
/**
* Date: 29.12.2016
* Time: 14:29
*
* @author Yuri Shmakov
*/
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class MemoryLeakTest {
@Test
public void test() {
TestViewImplementation viewImplementation = new TestViewImplementation();
viewImplementation.delegate = new MvpDelegate<>(viewImplementation);
viewImplementation.delegate.onCreate(new Bundle());
viewImplementation.delegate.onDestroy();
WeakReference viewImplementationReference = new WeakReference(viewImplementation);
WeakReference presenterReference = new WeakReference(viewImplementation.presenter);
/**
* Remove local reference to this object. Test will been failed if reference to the implemented view or
* to presenter was being saved in Moxy
*/
//noinspection UnusedAssignment
viewImplementation = null;
long delay = 0;
while (delay < TimeUnit.SECONDS.toMillis(2)) {
System.gc();
if (viewImplementationReference.get() == null && presenterReference.get() == null) {
return;
}
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
delay += 100;
}
assertTrue(false);
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/memory_leak_test/MemoryLeakTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 366 |
```java
package com.arellomobile.mvp.memory_leak_test.resources;
import com.arellomobile.mvp.MvpView;
/**
* Date: 29.12.2016
* Time: 14:31
*
* @author Yuri Shmakov
*/
public interface TestView extends MvpView {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/memory_leak_test/resources/TestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 65 |
```java
package com.arellomobile.mvp.memory_leak_test.resources;
import com.arellomobile.mvp.MvpPresenter;
/**
* Date: 29.12.2016
* Time: 14:32
*
* @author Yuri Shmakov
*/
public class TestPresenter extends MvpPresenter<TestView> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/memory_leak_test/resources/TestPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 68 |
```java
package com.arellomobile.mvp.compiler;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Table;
import com.google.common.io.Files;
import com.google.common.io.Resources;
import com.google.common.truth.Truth;
import com.google.testing.compile.CompileTester;
import com.google.testing.compile.JavaSourcesSubjectFactory;
import org.junit.Before;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;
import javax.annotation.processing.Processor;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* Date: 25.02.2016
* Time: 11:40
*
* @author Savin Mikhail
*/
public abstract class CompilerTest {
private JavaCompiler javac;
private DiagnosticCollector<JavaFileObject> diagnosticCollector;
private StandardJavaFileManager fileManager;
private File tmpDir;
@Before
public void setUp() {
javac = ToolProvider.getSystemJavaCompiler();
diagnosticCollector = new DiagnosticCollector<>();
fileManager = javac.getStandardFileManager(diagnosticCollector, null, null);
tmpDir = Files.createTempDir();
}
protected CompileTester getThat(final JavaFileObject... target) {
return getThat(Collections.singletonList(new MvpCompiler()), target);
}
protected CompileTester getThat(Collection<? extends Processor> processors, final JavaFileObject... target) {
return Truth.assert_().about(JavaSourcesSubjectFactory.javaSources())
.that(Arrays.asList(target))
.processedWith(processors);
}
protected String getString(String filePath) throws IOException {
URL resource = Resources.getResource(filePath);
Scanner scanner = new Scanner(new ByteArrayInputStream(Resources.toByteArray(resource)));
StringBuilder stringBuilder = new StringBuilder();
while (scanner.hasNextLine()) {
stringBuilder.append(scanner.nextLine());
stringBuilder.append("\n");
}
return stringBuilder.toString();
}
protected void assertCompilationResultIs(Table<Diagnostic.Kind, Integer, Pattern> expectedDiagnostics, Collection<String> resources) throws IOException {
assertCompilationResultIs(expectedDiagnostics, resources, MvpCompiler.class);
}
//For more info see path_to_url
protected void assertCompilationResultIs(Table<Diagnostic.Kind, Integer, Pattern> expectedDiagnostics, Collection<String> resources, final Class<? extends Processor> processor) throws IOException {
StringWriter compilerOut = new StringWriter();
List<String> options = ImmutableList.of(
"-sourcepath", tmpDir.getPath(),
"-d", tmpDir.getPath(),
"-processor", processor.getName(),
"-Xlint");
javac.getTask(compilerOut, fileManager, diagnosticCollector, options, null, null);
// This doesn't compile anything but communicates the paths to the JavaFileManager.
// Convert the strings containing the source code of the test classes into files that we
// can feed to the compiler.
List<String> classNames = Lists.newArrayList();
List<JavaFileObject> sourceFiles = Lists.newArrayList();
for (String source : resources) {
ClassName className = ClassName.extractFromSource(source);
File dir = new File(tmpDir, className.sourceDirectoryName());
dir.mkdirs();
assertTrue(dir.isDirectory()); // True if we just made it, or it was already there.
String sourceName = className.simpleName + ".java";
Files.write(source, new File(dir, sourceName), Charset.forName("UTF-8"));
classNames.add(className.fullName());
JavaFileObject sourceFile = fileManager.getJavaFileForInput(
StandardLocation.SOURCE_PATH, className.fullName(), JavaFileObject.Kind.SOURCE);
sourceFiles.add(sourceFile);
}
assertEquals(classNames.size(), sourceFiles.size());
// Compile the classes.
JavaCompiler.CompilationTask javacTask = javac.getTask(
compilerOut, fileManager, diagnosticCollector, options, classNames, sourceFiles);
boolean compiledOk = javacTask.call();
// Check that there were no compilation errors unless we were expecting there to be.
// We ignore "notes", typically debugging output from the annotation processor
// when that is enabled.
Table<Diagnostic.Kind, Integer, String> diagnostics = HashBasedTable.create();
for (Diagnostic<?> diagnostic : diagnosticCollector.getDiagnostics()) {
boolean ignore = (diagnostic.getKind() == Diagnostic.Kind.NOTE
|| (diagnostic.getKind() == Diagnostic.Kind.WARNING
&& diagnostic.getMessage(null).contains(
"No processor claimed any of these annotations")));
if (!ignore) {
diagnostics.put(
diagnostic.getKind(), (int) diagnostic.getLineNumber(), diagnostic.getMessage(null));
}
}
assertEquals(diagnostics.containsRow(Diagnostic.Kind.ERROR), !compiledOk);
assertEquals("Diagnostic kinds should match: " + diagnostics,
expectedDiagnostics.rowKeySet(), diagnostics.rowKeySet());
for (Table.Cell<Diagnostic.Kind, Integer, Pattern> expectedDiagnostic :
expectedDiagnostics.cellSet()) {
boolean match = false;
for (Table.Cell<Diagnostic.Kind, Integer, String> diagnostic : diagnostics.cellSet()) {
if (expectedDiagnostic.getValue().matcher(diagnostic.getValue()).find()) {
int expectedLine = expectedDiagnostic.getColumnKey();
if (expectedLine != 0) {
int actualLine = diagnostic.getColumnKey();
if (actualLine != expectedLine) {
fail("Diagnostic matched pattern but on line " + actualLine
+ " not line " + expectedLine + ": " + diagnostic.getValue());
}
}
match = true;
break;
}
}
assertTrue("Diagnostics should contain " + expectedDiagnostic + ": " + diagnostics, match);
}
}
private static class ClassName {
final String packageName; // Package name with trailing dot. May be empty but not null.
final String simpleName;
private ClassName(String packageName, String simpleName) {
this.packageName = packageName;
this.simpleName = simpleName;
}
// Extract the package and simple name of the top-level class defined in the given string,
// which is a Java sourceUnit unit.
static ClassName extractFromSource(String sourceUnit) {
String pkg;
if (sourceUnit.contains("package ")) {
// (?s) means that . matches everything including \n
pkg = sourceUnit.replaceAll("(?s).*?package ([a-z.]+);.*", "$1") + ".";
} else {
pkg = "";
}
String cls = sourceUnit.replaceAll("(?s).*?(class|interface|enum) ([A-Za-z0-9_$]+).*", "$2");
assertTrue(cls, cls.matches("[A-Za-z0-9_$]+"));
return new ClassName(pkg, cls);
}
String fullName() {
return packageName + simpleName;
}
String sourceDirectoryName() {
return packageName.replace('.', '/');
}
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/compiler/CompilerTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 1,566 |
```java
package com.arellomobile.mvp.memory_leak_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
/**
* Date: 29.12.2016
* Time: 14:33
*
* @author Yuri Shmakov
*/
public class TestViewImplementation implements TestView {
@InjectPresenter
public TestPresenter presenter;
public MvpDelegate<TestViewImplementation> delegate;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/memory_leak_test/resources/TestViewImplementation.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 95 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.ProvidePresenter;
/**
* Date: 30.12.2016
* Time: 12:39
*
* @author Yuri Shmakov
*/
public class TwoLocalProvidedView implements TestView {
@InjectPresenter
public TestPresenter oneLocalPresenter;
@InjectPresenter
public TestPresenter secondLocalPresenter;
public MvpDelegate<TwoLocalProvidedView> delegate;
@ProvidePresenter
TestPresenter provideLocalPresenter() {
return new TestPresenter();
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/TwoLocalProvidedView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 145 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpView;
/**
* Date: 30.12.2016
* Time: 10:11
*
* @author Yuri Shmakov
*/
public interface TestView extends MvpView {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/TestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 65 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpPresenter;
/**
* Date: 30.12.2016
* Time: 10:10
*
* @author Yuri Shmakov
*/
public class TestPresenter extends MvpPresenter<TestView> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/TestPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 68 |
```java
package com.arellomobile.mvp.provide_methods_test;
import android.os.Bundle;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.provide_methods_test.resources.LocalProvidedView;
import com.arellomobile.mvp.provide_methods_test.resources.TwoLocalProvidedView;
import com.arellomobile.mvp.provide_methods_test.resources.TwoWeakWithSamePresenterIdView;
import com.arellomobile.mvp.provide_methods_test.resources.WeakProvidedView;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Date: 30.12.2016
* Time: 11:18
*
* @author Yuri Shmakov
*/
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class ProvideMethodsTest {
@Test
public void testLocalIsProvided() {
LocalProvidedView view = new LocalProvidedView();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
Assert.assertNotNull(view.oneLocalPresenter);
Assert.assertSame(view.oneLocalPresenter, view.oneLocalProvidedPresenter);
}
@Test
public void testTwoLocalUseDifferentProvided() {
TwoLocalProvidedView view = new TwoLocalProvidedView();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
Assert.assertNotSame(view.oneLocalPresenter, view.secondLocalPresenter);
}
@Test
public void testWeakPresenterWithHardcodedTag() {
WeakProvidedView view = new WeakProvidedView();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
Assert.assertNotNull(view.weakPresenter);
Assert.assertSame(view.weakPresenter, view.weakProvidedPresenter);
}
@Test
public void testTwoWeakPresenterWithSamePresenterIdTest() {
TwoWeakWithSamePresenterIdView view = new TwoWeakWithSamePresenterIdView();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
Assert.assertNotNull(view.oneWeakPresenter);
Assert.assertNotNull(view.secondWeakPresenter);
Assert.assertSame(view.oneWeakPresenter, view.secondWeakPresenter);
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/ProvideMethodsTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 483 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.ProvidePresenter;
/**
* Date: 30.12.2016
* Time: 12:05
*
* @author Yuri Shmakov
*/
public class WeakProvidedView implements TestView {
@InjectPresenter(type = PresenterType.WEAK, tag = "weakPresenter")
public TestPresenter weakPresenter;
public TestPresenter weakProvidedPresenter;
public MvpDelegate<WeakProvidedView> delegate;
@ProvidePresenter(type = PresenterType.WEAK, tag = "weakPresenter")
public TestPresenter provideWeakPresenter() {
weakProvidedPresenter = new TestPresenter();
return weakProvidedPresenter;
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/WeakProvidedView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 190 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.ProvidePresenter;
import com.arellomobile.mvp.presenter.ProvidePresenterTag;
/**
* Date: 30.12.2016
* Time: 12:05
*
* @author Yuri Shmakov
*/
public class TwoWeakWithSamePresenterIdView implements TestView {
@InjectPresenter(type = PresenterType.WEAK, presenterId = "weakPresenter")
public TestPresenter oneWeakPresenter;
@InjectPresenter(type = PresenterType.WEAK, presenterId = "weakPresenter")
public TestPresenter secondWeakPresenter;
public MvpDelegate<TwoWeakWithSamePresenterIdView> delegate;
@ProvidePresenterTag(presenterClass = TestPresenter.class, type = PresenterType.WEAK, presenterId = "weakPresenter")
public String providePresenterTag() {
return "weakPresenterTag";
}
@ProvidePresenter(type = PresenterType.WEAK, presenterId = "weakPresenter")
public TestPresenter provideTestPresenter() {
return new TestPresenter();
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/TwoWeakWithSamePresenterIdView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 261 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.ProvidePresenter;
import com.arellomobile.mvp.presenter.ProvidePresenterTag;
/**
* Date: 30.12.2016
* Time: 12:05
*
* @author Yuri Shmakov
*/
public class TwoWeakWithDiffPresenterIdView implements TestView {
@InjectPresenter(type = PresenterType.WEAK, presenterId = "oneWeakPresenter")
public TestPresenter oneWeakPresenter;
@InjectPresenter(type = PresenterType.WEAK, presenterId = "secondWeakPresenter")
public TestPresenter secondWeakPresenter;
public MvpDelegate<TwoWeakWithDiffPresenterIdView> delegate;
@ProvidePresenterTag(presenterClass = TestPresenter.class, type = PresenterType.WEAK, presenterId = "oneWeakPresenter")
public String provideOnePresenterTag() {
return "oneWeakPresenterTag";
}
@ProvidePresenterTag(presenterClass = TestPresenter.class, type = PresenterType.WEAK, presenterId = "secondWeakPresenter")
public String provideSecondPresenterTag() {
return "secondWeakPresenterTag";
}
@ProvidePresenter(type = PresenterType.WEAK, presenterId = "oneWeakPresenter")
public TestPresenter provideOneTestPresenter() {
return new TestPresenter();
}
@ProvidePresenter(type = PresenterType.WEAK, presenterId = "secondWeakPresenter")
public TestPresenter provideSecondTestPresenter() {
return new TestPresenter();
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/TwoWeakWithDiffPresenterIdView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 352 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.