pinstripe 0.11.0 → 0.12.0

package/cli.js

@@ -2,10 +2,9 @@
 
 import { spawn } from 'child_process';
 
-import { importAll } from './lib/import_all.js';
 import { project } from './lib/project.js';
 import { Command } from './lib/command.js';
-import { Environment } from './lib/environment.js';
+import { createEnvironment } from './lib/environment.js';
 
 (async () => {
     const { entryPath, localPinstripePath, exists } = await project;
@@ -18,12 +17,12 @@ import { Environment } from './lib/environment.js';
             stdio: 'inherit'
         });
     } else {
-        await importAll();
         if(entryPath){
-            await import(entryPath);
-            await importAll();
+            import(entryPath);
         }
 
+        const { runCommand, resetEnvironment } = await createEnvironment();
+
         if(exists){
             Command.unregister('generate-project');
         } else {
@@ -34,8 +33,7 @@ import { Environment } from './lib/environment.js';
                 }
             });
         }
-
-        const { runCommand, resetEnvironment } = Environment.new();
+        
         try {
             await runCommand(...args);
         } catch(e) {

package/lib/async_path_builder.js

@@ -15,6 +15,10 @@ export const AsyncPathBuilder = Base.extend().include({
         return new this.constructor(this._startObject, [...this._path, args ]);
     },
 
+    get toString(){
+        return this.__getMissing('toString');
+    },
+
     then(...args){
         return unwrap(this._startObject, [...this._path]).then(...args);
     }

package/lib/async_path_builder.test.js

@@ -25,3 +25,14 @@ test('AsyncPathBuilder (2)', async () => {
     expect(await foo.bar().baz()).toBe("boo");
     expect(await foo.bar().baz().length).toBe(3);
 });
+
+test('AsyncPathBuilder (3)', async () => {
+    const foo = AsyncPathBuilder.new({
+        toString(){
+            return "hello world";
+        }
+    });
+    
+    expect(await foo.toString()).toBe("hello world");
+});
+

package/lib/base.js

@@ -117,17 +117,21 @@ const assignProps = (target, ...sources) => {
                 return;
             }
             const descriptor = { ...Object.getOwnPropertyDescriptor(source, name) };
-            const { get } = descriptor;
+            const { get, set } = descriptor;
+            const { get: targetGet, set: targetSet } = (Object.getOwnPropertyDescriptor(target, name) || {});
             if(get){
                 descriptor.get = function(...args){
                     return get.call(this.__proxy || this, ...args);
                 };
+            } else if(targetGet) {
+                descriptor.get = targetGet;
             }
-            const { set } = descriptor;
             if(set){
                 descriptor.set = function(...args){
                     set.call(this.__proxy || this, ...args);
                 };
+            } else if(targetSet){
+                descriptor.set = targetSet;
             }
             Object.defineProperty(target, name, descriptor);
         });

package/lib/base.test.js

@@ -78,3 +78,21 @@ test(`Base - can produce dynamic keys`, () => {
 
     expect(Object.keys(fixture)).toEqual(['foo', 'bar']);
 });
+
+test(`Base - getters and setters with same name can be defined independently`, () => {
+    const fixture = Base.extend().include({
+        meta(){
+            this.prototype.assignProps({
+                get foo(){
+                    return 'bar';
+                }
+            });
+        },
+
+        set foo(value){
+            
+        }
+    }).new();
+
+    expect(fixture.foo).toEqual('bar');
+})

package/lib/commands/{generate_widget.js → generate_node_wrapper.js}

@@ -6,23 +6,23 @@ export default async ({
 }) => {
     const name = snakeify(extractArg(''));
     if(name == ''){
-        console.error('A widget name must be given.');
+        console.error('A node wrapper name must be given.');
         process.exit();
     }
 
     await inProjectRootDir(async () => {
 
-        await generateFile(`lib/widgets/_importer.js`, { skipIfExists: true }, () => {
+        await generateFile(`lib/node_wrappers/_importer.js`, { skipIfExists: true }, () => {
             line();
-            line(`export { widgetImporter as default } from 'pinstripe';`);
+            line(`export { nodeWrapperImporter as default } from 'pinstripe';`);
             line();
         });
 
-        await generateFile(`lib/widgets/${name}.client.js`, () => {
+        await generateFile(`lib/node_wrappers/${name}.client.js`, () => {
             line();
             line(`export default {`);
             indent(() => {
-                line(`initialize(...args){`);
+                line(`initialize(){`);
                     indent(() => {
                         line(`this.constructor.parent.prototype.initialize.call(this, ...args);`);
                     });

package/lib/commands/list_node_wrappers.js

@@ -0,0 +1,14 @@
+
+import chalk from 'chalk';
+
+import { NodeWrapper } from '../node_wrapper.js';
+
+export default () => {
+    console.log('');
+    console.log('The following node wrappers are available:');
+    console.log('');
+    Object.keys(NodeWrapper.classes).sort().forEach(nodeWrapperName => {
+        console.log(`  * ${chalk.green(nodeWrapperName)}`);
+    });
+    console.log('');
+};

package/lib/css.js

@@ -0,0 +1,101 @@
+
+import { Base } from './base.js';
+
+export const Css = Base.extend().include({
+    
+    meta(){
+        this.assignProps({
+            render(...rules){
+                return this.new(compileRules(deepMerge({}, ...rules)));
+            }
+        });
+    },
+
+    initialize(value){
+        this.value = value;
+    },
+
+    toString(){
+        return this.value;
+    },
+
+    toResponseArray(status = 200, headers = {}){
+        return [status, {'content-type': 'text/css', ...headers}, [this.value.trim()]];
+    }
+});
+
+const compileRules = (rules, path = [], out = []) => {
+    const props = {};
+
+    Object.keys(rules).forEach(name => {
+        const value = rules[name];
+        if(typeof value == 'object') return;
+        props[name] = value;
+    });
+
+    if(path.length && Object.keys(props).length){
+        out.push(compileRule(path, props));
+    }
+
+    Object.keys(rules).forEach(name => {
+        const value = rules[name];
+        if(typeof value != 'object') return;
+        compileRules(value, [ ...path, name ], out);
+    });
+
+    if(!path.length) return out.join('\n');
+};
+
+const compileRule = (path, props) => {
+    const atRules = [];
+    let selector = '';
+    path.forEach((segment, i) => {
+        if(segment.match(/^@/)){
+            atRules.push(segment);
+        } else {
+            segment = segment.match(/&/) ? segment : `${i ? '& ' : '&'}${segment}`.replace(/,\s*/g, ', & ');
+            selector = selector.split(/,\s*/).map(selector => segment.replace(/&/g, selector)).join(', ');
+        }
+    });
+
+    const out = [];
+    const indent = [];
+
+    atRules.forEach(rule => {
+        out.push(`${indent.join('')}${rule} {`);
+        indent.push('    ');
+    });
+
+    out.push(`${indent.join('')}${selector} {`);
+    indent.push('    ');
+    Object.keys(props).forEach(name => {
+        const value = props[name];
+        out.push(`${indent.join('')}${normaliseName(name)}: ${name == 'content' ? `'${value}'` : value};`);
+    })
+    indent.pop();
+    out.push(`${indent.join('')}}`);
+
+    atRules.forEach(() => {
+        indent.pop();
+        out.push(`${indent.join('')}}`);
+    });
+
+    return out.join('\n');
+};
+
+const normaliseName = name => name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+
+const deepMerge = (destination = {}, ...sources) => {
+    sources.forEach(source => {
+        Object.keys(source).forEach(key => {
+            const value = source[key];
+            if(typeof value == 'object') {
+                destination[key] = deepMerge(typeof destination[key] == 'object' ? destination[key] : {}, value);
+            } else {
+                destination[key] = source[key];
+            }
+        });
+    });
+    return destination;
+};
+

package/lib/database/adapter.js

@@ -0,0 +1,23 @@
+
+import { Base } from "../base.js";
+import { Registrable } from '../registrable.js';
+
+export const Adapter = Base.extend().include({
+    meta(){
+        this.include(Registrable);
+    },
+
+    initialize(config){
+        this.config = config;
+    }
+});
+
+export const createAdapterDeligator = namespace => name => {
+    return function(...args){
+        const { methods } = this._adapter;
+        if(methods && methods[namespace] && methods[namespace][name]){
+            return this._adapter.methods[namespace][name].call(this, ...args);
+        }
+        throw new Error(`Adapter method '${namespace}.${name}' does not exist.`)
+    }
+};