Use remix-plugin module API

pull/7/head
Omkara 6 years ago
parent ce54f4b2c6
commit bd15208c7b
  1. 116
      remix-resolve/src/resolve.ts
  2. 17
      remix-resolve/tests/test.ts

@ -1,19 +1,16 @@
import axios from 'axios'
import { Api, PluginProfile } from 'remix-plugin'
import { Api, ModuleProfile, API } from 'remix-plugin'
export interface RemixResolve extends Api {
type: 'remix-resolve'
events: {}
resolve: any
resolve: Function
}
export const RemixResolveProfile: PluginProfile<RemixResolve> = {
export const RemixResolveProfile: ModuleProfile<RemixResolve> = {
type: 'remix-resolve',
methods: ['resolve'],
events: [],
notifications: [],
url: ''
methods: ['resolve']
}
@ -33,6 +30,111 @@ interface Handler {
handle(match: any): any;
}
export class RemixResolveApi implements API<RemixResolve> {
public readonly type = 'remix-resolve'
previouslyHandled: PreviouslyHandledImports
constructor() {
this.previouslyHandled = {}
}
/**
* Handle an import statement based on github
* @params root The root of the github import statement
* @params filePath path of the file in github
*/
handleGithubCall(root: string, filePath: string) {
return
}
/**
* Handle an import statement based on http
* @params url The url of the import statement
* @params cleanURL
*/
handleHttp(url: string, cleanURL: string) {
return
}
/**
* Handle an import statement based on https
* @params url The url of the import statement
* @params cleanURL
*/
handleHttps(url: string, cleanURL: string) {
return
}
handleSwarm(url: string, cleanURL: string) {
return
}
/**
* Handle an import statement based on IPFS
* @params url The url of the IPFS import statement
*/
async handleIPFS(url: string) {
// replace ipfs:// with /ipfs/
url = url.replace(/^ipfs:\/\/?/, 'ipfs/')
try {
const req = 'https://gateway.ipfs.io/' + url
// If you don't find greeter.sol on ipfs gateway use local
// const req = 'http://localhost:8080/' + url
const response = await axios.get(req)
return response.data
} catch (e) {
throw e
}
}
handleLocal(root: string, filePath: string) {
return
}
getHandlers(): Handler[] {
return [
{
type: 'github',
match: (url) => { return /^(https?:\/\/)?(www.)?github.com\/([^/]*\/[^/]*)\/(.*)/.exec(url) },
handle: (match) => this.handleGithubCall(match[3], match[4])
},
{
type: 'http',
match: (url) => { return /^(http?:\/\/?(.*))$/.exec(url) },
handle: (match) => this.handleHttp(match[1], match[2])
},
{
type: 'https',
match: (url) => { return /^(https?:\/\/?(.*))$/.exec(url) },
handle: (match) => this.handleHttps(match[1], match[2])
},
{
type: 'swarm',
match: (url) => { return /^(bzz-raw?:\/\/?(.*))$/.exec(url) },
handle: (match) => this.handleSwarm(match[1], match[2])
},
{
type: 'ipfs',
match: (url) => { return /^(ipfs:\/\/?.+)/.exec(url) },
handle: (match) => this.handleIPFS(match[1])
}
]
}
public async resolve(filePath: string, customHandlers?: Handler[]): Promise<Imported> {
var imported: Imported = this.previouslyHandled[filePath]
if(imported) {
return imported
}
const builtinHandlers: Handler[] = this.getHandlers()
const handlers: Handler[] = customHandlers ? [...builtinHandlers, ...customHandlers] : [...builtinHandlers]
const matchedHandler = handlers.filter(handler => handler.match(filePath))
const handler: Handler = matchedHandler[0]
const match = handler.match(filePath)
const content: string = await handler.handle(match)
imported = {
content,
cleanURL: filePath,
type: handler.type
}
this.previouslyHandled[filePath] = imported
return imported
}
}
export class ImportResolver {
previouslyHandled: PreviouslyHandledImports
constructor() {

@ -1,4 +1,4 @@
import { RemixResolve, ImportResolver } from '../src'
import { RemixResolve, ImportResolver, RemixResolveApi } from '../src'
import * as fs from 'fs'
import * as path from 'path'
import * as assert from 'assert'
@ -10,10 +10,10 @@ const RemixResolveProfile: PluginProfile<RemixResolve> = {
url: ''
}
interface IAppManager {
modules: {},
plugins: {
'remix-resolve': RemixResolve
}
modules: {
remixResolve: RemixResolve
},
plugins: {}
}
describe('testRunner', () => {
@ -72,14 +72,13 @@ describe('testRunner', () => {
// AppManager tests
describe('test with AppManager', () => {
let app: AppManager<IAppManager>
let api: Plugin<RemixResolve>
let api: RemixResolveApi
before(() => {
api = new Plugin(RemixResolveProfile)
api = new RemixResolveApi()
app = new AppManager({
plugins: [{ json: RemixResolveProfile, api }]
modules: [{ json: RemixResolveProfile, api }]
})
app.activate(api.type)
})
it('Plugin should be added to app', () => {
assert.equal(typeof(app.calls[api.type].resolve), 'function')

Loading…
Cancel
Save