Clearning by Lint

src/mol-model/structure/query/queries/atom-set.ts

@@ -1,9 +1,13 @@
-/*
+/**
+ * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Koya Sakuma
+ * Adapted from MolQL implemtation of atom-set.ts
+ *
  * Copyright (c) 2017 MolQL contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  */
-
 /*
 import Environment from '../environment'
 import Expression from '../expression'
@@ -19,9 +23,9 @@ import { StructureQuery } from '../query';
 import { StructureSelection } from '../selection';
 import { getCurrentStructureProperties, UnitTypeProperties } from './filters';
 import { QueryContext } from '../context';
-//import { none } from './generators';
+// import { none } from './generators';
-//import { HashSet } from '../../../../mol-data/generic';
+// import { HashSet } from '../../../../mol-data/generic';
-//import { Structure } from '../../structure';
+// import { Structure } from '../../structure';
 
 
 /*
@@ -72,44 +76,44 @@ export function pick(env: Environment, selection: Selection, pred: Expression<bo
 
 
 
-//xport function merge(queries: ArrayLike<StructureQuery>): S
+// xport function merge(queries: ArrayLike<StructureQuery>): S
 
-//export function atomCount(env: Environment) {
+// export function atomCount(env: Environment) {
 //    return AtomSet.count(env.slots.atomSet);
-//}
+// }
 
-//export function atomCount(query : StructureSelection) : StructureQuery {
+// export function atomCount(query : StructureSelection) : StructureQuery {
-export function atomCount(ctx:QueryContext) {
+export function atomCount(ctx: QueryContext) {
-    return (ctx:any) => {
+    return (ctx: any) => {
-	const x : number  = StructureSelection.structureCount(ctx);
+        const x: number = StructureSelection.structureCount(ctx);
-        return x
+        return x;
     };
 }
 
-//export function countQuery(env: Environment, query: Expression<AtomSelection>) {
+// export function countQuery(env: Environment, query: Expression<AtomSelection>) {
 //    const sel = query(Environment(Context.ofAtomSet(env.context, env.slots.atomSet)))
 //    return AtomSelection.atomSets(sel).length;
-//}
+// }
 
-export function countQuery(ctx:QueryContext,query: StructureQuery){
+export function countQuery(ctx: QueryContext, query: StructureQuery) {
-    return (ctx:any) => {
+    return (ctx: any) => {
         const sel = query(ctx);
-	const x : number  = StructureSelection.structureCount(sel);
+        const x: number = StructureSelection.structureCount(sel);
-        return x
+        return x;
     };
 }
 
 
-export function propertySet(ctx:QueryContext, prop: UnitTypeProperties) {
+export function propertySet(ctx: QueryContext, prop: UnitTypeProperties) {
     const set = new Set();
-    const x = getCurrentStructureProperties(ctx, prop, set)
+    const x = getCurrentStructureProperties(ctx, prop, set);
-    return x
+    return x;
 }
 
 /*
 unction getSelectionProperties(ctx: QueryContext, query: StructureQuery, props: UnitTypeProperties) {
 
-  
+
 
     const sel = query(ctx);
     ctx.pushCurrentElement();

src/mol-plugin-state/transforms/model.ts

@@ -786,7 +786,7 @@ const StructureSelectionFromScript = PluginStateTransform.BuiltIn({
     from: SO.Molecule.Structure,
     to: SO.Molecule.Structure,
     params: () => ({
-        script: PD.Script({ language: 'pymol', expression: 'all' }),
+        script: PD.Script({ language: 'rasmol', expression: 'all' }),
         label: PD.Optional(PD.Text(''))
     })
 })({

src/mol-script/runtime/query/table.ts

@@ -359,32 +359,32 @@ const symbols = [
 
     // ============= ATOM SET ================
 
-//    D(MolScript.structureQuery.combinator.merge, (ctx, xs) => Queries.combinators.merge(xs as any)(ctx)),
+    //    D(MolScript.structureQuery.combinator.merge, (ctx, xs) => Queries.combinators.merge(xs as any)(ctx)),
-    D(MolScript.structureQuery.atomSet.atomCount,     
+    D(MolScript.structureQuery.atomSet.atomCount,
-      function structureQuery_atomset_atomCount(ctx, xs) {
+        function structureQuery_atomset_atomCount(ctx, xs) {
-	  console.log("From atomCount");
+	  console.log('From atomCount');
-	  console.log(Queries.atomset.atomCount(ctx))
+	  console.log(Queries.atomset.atomCount(ctx));
-	  return Queries.atomset.atomCount(ctx)
+	  return Queries.atomset.atomCount(ctx);
-      }),
+        }),
 
 
-    D(MolScript.structureQuery.atomSet.countQuery,     
+    D(MolScript.structureQuery.atomSet.countQuery,
-      function structureQuery_atomset_countQuery(ctx, xs) {
+        function structureQuery_atomset_countQuery(ctx, xs) {
-	  console.log("From countQuery");
+	  console.log('From countQuery');
-	  console.log(Queries.atomset.countQuery(ctx,xs[0](ctx) as any))
+	  console.log(Queries.atomset.countQuery(ctx, xs[0](ctx) as any));
-	  return Queries.atomset.countQuery(ctx,xs[0](ctx) as any)
+	  return Queries.atomset.countQuery(ctx, xs[0](ctx) as any);
-      }),
+        }),
 
-//    env, v[0](env)
+    //    env, v[0](env)
 
-    D(MolScript.structureQuery.atomSet.propertySet,     
+    D(MolScript.structureQuery.atomSet.propertySet,
-      function structureQuery_atomset_propertySet(ctx, xs) { return Queries.atomset.propertySet(ctx, xs[0] as any)}),
+        function structureQuery_atomset_propertySet(ctx, xs) { return Queries.atomset.propertySet(ctx, xs[0] as any); }),
-//    D(MolScript.structureQuery.filter.withSameAtomProperties, (ctx, xs) => Queries.filters.withSameAtomProperties(xs[0] as any, xs['source'] as any, xs['property'] as any)(ctx)),
+    //    D(MolScript.structureQuery.filter.withSameAtomProperties, (ctx, xs) => Queries.filters.withSameAtomProperties(xs[0] as any, xs['source'] as any, xs['property'] as any)(ctx)),
-    
+
+
+    //    Symbol(MolQL.structure.atomSet.propertySet)((env, v) => StructureRuntime.AtomSet.propertySet(env, v[0])),
 
-//    Symbol(MolQL.structure.atomSet.propertySet)((env, v) => StructureRuntime.AtomSet.propertySet(env, v[0])),
 
-    
     // ============= BOND PROPERTIES ================
     D(MolScript.structureQuery.bondProperty.order, (ctx, xs) => ctx.atomicBond.order),
     D(MolScript.structureQuery.bondProperty.flags, (ctx, xs) => ctx.atomicBond.type),

src/mol-script/transpile.ts

@@ -16,7 +16,7 @@ export function parse(lang: string, str: string) {
         const query = transpiler[lang](str);
 
         console.log(str);
-	console.log(query);
+        console.log(query);
         //	console.log(util.inspect(query, {depth: 20, color: true}))
         console.log('\n');
 

src/mol-script/transpilers/helper.ts

@@ -195,7 +195,7 @@ export function testExpr(property: any, args: any) {
 
 export function invertExpr(selection: Expression) {
     return B.struct.generator.queryInSelection({
-        0: selection, query: B.struct.generator.all(), 'in-complement': true}
+        0: selection, query: B.struct.generator.all(), 'in-complement': true }
     );
 }
 

src/mol-script/transpilers/pymol/operators.ts

@@ -235,7 +235,7 @@ export const operators: OperatorList = [
         '@desc': 'Expands selection to complete molecules.',
         '@examples': ['BYMOLECULE resi 20-30'],
         name: 'bymolecule',
-	isUnsupported: true, //structure-query.atom-property.topology.connected-component-key' is not implemented
+        isUnsupported: true, // structure-query.atom-property.topology.connected-component-key' is not implemented
         abbr: ['bymol', 'bm.'],
         type: h.prefix,
         rule: h.prefixOp(/BYMOLECULE|bymol|bm\./i),
@@ -262,7 +262,7 @@ export const operators: OperatorList = [
         '@desc': 'Expands selection to complete segments.',
         '@examples': ['BYSEGMENT resn CYS'],
         name: 'bysegment',
-        abbr: ['bysegi', 'byseg', 'bs.'],        
+        abbr: ['bysegi', 'byseg', 'bs.'],
         type: h.prefix,
         rule: h.prefixOp(/BYSEGMENT|bysegi|byseg|bs\./i),
         map: (op: string, selection: Expression) => {
@@ -297,12 +297,12 @@ export const operators: OperatorList = [
         '@desc': 'All rings of size ≤ 7 which have at least one atom in s1.',
         '@examples': ['BYRING resn HEM'],
         name: 'byring',
-	//isUnsupported: true, // structure-query.atom-set.atom-count' is not implemented.
+        // isUnsupported: true, // structure-query.atom-set.atom-count' is not implemented.
         type: h.prefix,
         rule: h.prefixOp(/BYRING/i),
         map: (op: string, selection: Expression) => {
             return h.asAtoms(
-		B.struct.modifier.intersectBy({
+                B.struct.modifier.intersectBy({
                     '0': B.struct.filter.pick({
                         '0': B.struct.generator.rings(),
                         test: B.core.logic.and([

src/mol-script/transpilers/vmd/operators.ts

@@ -43,7 +43,7 @@ export const operators: OperatorList = [
         rule: h.prefixOp(/EXWITHIN\s+([-+]?[0-9]*\.?[0-9]+)\s+OF/i, 1).map((x: any) => parseFloat(x)),
         map: (radius: number, target: Expression) => {
             return B.struct.modifier.exceptBy({
-                '0':  B.struct.modifier.includeSurroundings({ 0: target, radius }),
+                '0': B.struct.modifier.includeSurroundings({ 0: target, radius }),
                 by: target
             });
         }

src/mol-script/transpilers/vmd/parser.ts

@@ -179,7 +179,7 @@ const lang = P.MonadicParser.createLanguage({
 	    return B.struct.generator.atomGroups({ [h.testLevel(property)]: test });
 	    //  h.testLevel is not working for unknown reason, so relaced it by hardcoded 'atom-test'
             //	    console.log(h.testLevel(property));
-	    //return B.struct.generator.atomGroups({ 'atom-test': test });
+	    // return B.struct.generator.atomGroups({ 'atom-test': test });
         });
     },