cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tommy-carlos williams <to...@devgeeks.org>
Subject Re: adding platforms to npm for dependency sanity
Date Tue, 03 Jun 2014 23:17:39 GMT
+1

On 4 June 2014 at 9:17:09, Brian LeRoux (b@brian.io) wrote:

…and use package.json to achieve a frictionless env swap on a per project  
basis, eventually making the CLI a thin shell that calls into node_modules  
ala Grunt, Gulp, etc.  


On Tue, Jun 3, 2014 at 4:07 PM, tommy-carlos williams <tommy@devgeeks.org>  
wrote:  

> You can’t have version x of a plugin for iOS and version y of that same  
> plugin for Android, so multiple platform versions seems like a complexity  
> for complexity’s sake.  
>  
> It’s true that different apps need to support different platform versions,  
> but I would suspect that the greatest majority of those would want the same  
> version of iOS and Android in app x.  
>  
>  
>  
> On 4 June 2014 at 9:04:42, Brian LeRoux (b@brian.io) wrote:  
>  
> That is the thing: you do not EVER want to have disparate versions of  
> platforms. Plugins negate this potential fantasy.  
>  
> You want version locked deps. You want to use package.json to do that b/c  
> that is what the runtime we use has standardized itself on.  
>  
>  
> On Tue, Jun 3, 2014 at 1:12 PM, Terence M. Bandoian <terence@tmbsw.com>  
> wrote:  
>  
> > A typical use case might be:  
> >  
> > -project1  
> > -project1-ios  
> > -project1-android  
> > -project1-windows  
> > ...  
> > -projectN  
> > -projectN-ios  
> > -projectN-android  
> > -projectN-windows  
> >  
> > with a different platform version for each sub-project.  
> >  
> > Would CLI be installed globally? Locally for each sub-project? Would a  
> > project-platform have to be re-built if a plugin were added?  
> >  
> > -Terence  
> >  
> >  
> > On 6/3/2014 1:47 PM, Michal Mocny wrote:  
> >  
> >> Okay, so I think that implies:  
> >>  
> >> (a) CLI versions tied to very specific platform versions ==> to switch  
> >> platform versions you must switching CLI versions ==> switching one  
> >> platform version switches all platform versions.  
> >> - Andrew pointed out this is currently the case, and is a problem that  
> >> leads to users not updating CLI as often as they otherwise would  
> >> - I think this basically implies platforms cannot be independently  
> >> versioned (sure the semver numbers may differ, but for all practical  
> >> purposes, you would use platforms from the same release date, based on  
> CLI  
> >> version).  
> >>  
> >> (b) Require apps to depend on specific CLI version, assuming you mean  
> with  
> >> a local package.json:  
> >> - Now all cordova projects must be node projects, which they currently  
> are  
> >> not.  
> >> - Currently the cordova-cli creates apps, so we have a globally  
> installed  
> >> bootstrapping cordova-cli, and a locally installed specific version  
> >> cordova-cli, a-la grunt/gulp. (this idea was thrown around before).  
> >> - Quite a dramatic change for cordova workflow, surely larger than the  
> >> current proposal.  
> >> - Or we drop cordova-cli entirely and just publish grunt/gulp plugins to  
> >> "add cordova" to your existing web app. Thats an even more radical  
> >> departure and significant work.  
> >>  
> >> -Michal  
> >>  
> >>  
> >> On Tue, Jun 3, 2014 at 1:58 PM, Brian LeRoux <b@brian.io> wrote:  
> >>  
> >> No, at least not how I'd see it done.  
> >>>  
> >>> 1.) Updating is important. Staying current: encouraged.  
> >>> 2.) I'd make my App depend on a specific CLI version. I'd call into  
> that  
> >>> using npm scripts.  
> >>>  
> >>>  
> >>>  
> >>>  
> >>> On Tue, Jun 3, 2014 at 10:48 AM, Michal Mocny <mmocny@chromium.org>  
> >>> wrote:  
> >>>  
> >>> Thinking it through, if cordova platforms are deps of the CLI, to  
> >>>>  
> >>> install a  
> >>>  
> >>>> specific version you wouldn't just do:  
> >>>>  
> >>>>> npm install -g cordova-ios@3.4.1  
> >>>>>  
> >>>> you would actually need to:  
> >>>>  
> >>>>> cd $(npm config get prefix)/lib/node_modules/cordova  
> >>>>> npm install --save cordova-ios@3.4.1  
> >>>>>  
> >>>> ..and then remember to do that again whenever you `npm update -g`  
> >>>> ..and its harder to have multiple platform versions for different  
> >>>>  
> >>> projects  
> >>>  
> >>>> (questionable if this is useful for devs outside of cordova  
> >>>> contributors,  
> >>>> but may be useful at last test upgrades when we ship new platform  
> >>>> versions).  
> >>>>  
> >>>> -Michal  
> >>>>  
> >>>>  
> >>>> On Tue, Jun 3, 2014 at 1:28 PM, Brian LeRoux <b@brian.io> wrote:  
> >>>>  
> >>>> NIH: not invented here  
> >>>>>  
> >>>>>  
> >>>>>  
> >>>>> On Tue, Jun 3, 2014 at 10:17 AM, Andrew Grieve <agrieve@chromium.org  
> >  
> >>>>> wrote:  
> >>>>>  
> >>>>> On Tue, Jun 3, 2014 at 12:19 PM, Brian LeRoux <b@brian.io> wrote:  
> >>>>>>  
> >>>>>> Actually that was >0 LOC which is a fine argument if you ask me.  
> >>>>>>>  
> >>>>>> And  
> >>>  
> >>>> we  
> >>>>  
> >>>>> both know there is much more to it than just that. lazy_load…for  
> >>>>>>>  
> >>>>>> example.  
> >>>>>  
> >>>>>>  
> >>>>>> If you're concerned about code, there is a tonne of much  
> >>>>>>  
> >>>>> lower-hanging  
> >>>  
> >>>> fruit.  
> >>>>>>  
> >>>>>>  
> >>>>>> Bundling platforms is bundling a dep that we require to operate. We  
> >>>>>>>  
> >>>>>> do  
> >>>>  
> >>>>> not  
> >>>>>>  
> >>>>>>> require plugins to operate. You cannot build a project without  
> >>>>>>>  
> >>>>>> having a  
> >>>>  
> >>>>> platform and, indeed, you probably want more than one.  
> >>>>>>>  
> >>>>>>> I don't require blackberry to create an iOS project. But I do  
> >>>>>> require  
> >>>>>>  
> >>>>> some  
> >>>>>  
> >>>>>> plugins. We use "npm cache add" to download plugins, I don't see how  
> >>>>>> platforms would not work just as easily.  
> >>>>>>  
> >>>>>>  
> >>>>>> Agree that we need discreet versioning: hence why I'm advocating we  
> >>>>>>>  
> >>>>>> use  
> >>>>  
> >>>>> well understood, maintained, and effectively standard system for  
> >>>>>>>  
> >>>>>> doing  
> >>>>  
> >>>>> this. We do not need NIH dependencies that is what package.json is  
> >>>>>>>  
> >>>>>> for!  
> >>>>  
> >>>>> I don't know what NIH dependencies are. Googling suggests you're  
> >>>>>>  
> >>>>> talking  
> >>>>  
> >>>>> about drugs...  
> >>>>>>  
> >>>>>> We *are* using npm for downloading, we're just not making the user  
> >>>>>>  
> >>>>> type  
> >>>  
> >>>> it  
> >>>>>  
> >>>>>> directly.  
> >>>>>>  
> >>>>>> Mark's approach also avoids the "what-if" cases where what's in your  
> >>>>>> node_modules might not match what's in your platforms/  
> >>>>>>  
> >>>>>> Does what Mark has implemented not address a use-case of yours? Or  
> >>>>>>  
> >>>>> are  
> >>>  
> >>>> we  
> >>>>  
> >>>>> going back & forth over personal preference?  
> >>>>>>  
> >>>>>>  
> >>>>>>  
> >>>>>>  
> >>>>>>  
> >>>>>>  
> >>>>>>  
> >>>>>>>  
> >>>>>>>  
> >>>>>>> On Tue, Jun 3, 2014 at 9:07 AM, Andrew Grieve <  
> >>>>>>>  
> >>>>>> agrieve@chromium.org>  
> >>>  
> >>>> wrote:  
> >>>>>>>  
> >>>>>>> On Tue, Jun 3, 2014 at 11:34 AM, Brian LeRoux <b@brian.io>  
> >>>>>>>>  
> >>>>>>> wrote:  
> >>>  
> >>>> Andrew, you misunderstand. I am talking about bundling  
> >>>>>>>>>  
> >>>>>>>> platforms  
> >>>  
> >>>> directly  
> >>>>>>>  
> >>>>>>>> as dependencies of the CLI.  
> >>>>>>>>>  
> >>>>>>>>> A trivial example:  
> >>>>>>>>>  
> >>>>>>>>> CLI  
> >>>>>>>>> '-ios  
> >>>>>>>>>  
> >>>>>>>>> Wherein, CLI declares the precise version of the platform it  
> >>>>>>>>>  
> >>>>>>>> uses.  
> >>>>  
> >>>>> We  
> >>>>>  
> >>>>>> could  
> >>>>>>>>  
> >>>>>>>>> wildcard. I don't know that we want or need to do that.  
> >>>>>>>>>  
> >>>>>>>>> It would have identical semantics to today except the download  
> >>>>>>>>>  
> >>>>>>>> penalty  
> >>>>>>  
> >>>>>>> happens up front. (We can remove lazy_load logic. We don't have  
> >>>>>>>>>  
> >>>>>>>> to  
> >>>>  
> >>>>> maintain  
> >>>>>>>>  
> >>>>>>>>> our own dependency manifests and caches. LESS code: good  
> >>>>>>>>>  
> >>>>>>>> thing.)  
> >>>  
> >>>> Let me paste the code for doing our own caching for you:  
> >>>>>>>>  
> >>>>>>>> cordova_npm: function lazy_load_npm(platform) {  
> >>>>>>>> if (!(platform in platforms)) {  
> >>>>>>>> return Q.reject(new Error('Cordova library "' +  
> >>>>>>>>  
> >>>>>>> platform  
> >>>>  
> >>>>> +  
> >>>>>  
> >>>>>> '"  
> >>>>>>  
> >>>>>>> not recognized.'));  
> >>>>>>>> }  
> >>>>>>>> var pkg = 'cordova-' + platform + '@' +  
> >>>>>>>> platforms[platform].version;  
> >>>>>>>> return Q.nfcall( npm.load, {cache:  
> >>>>>>>>  
> >>>>>>> path.join(util.libDirectory,  
> >>>>>  
> >>>>>> 'npm_cache') })  
> >>>>>>>> .then(function() {  
> >>>>>>>> return Q.ninvoke(npm.commands, 'cache', ['add',  
> >>>>>>>>  
> >>>>>>> pkg]);  
> >>>  
> >>>> }).then(function(info) {  
> >>>>>>>> var pkgDir = path.resolve(npm.cache, info.name,  
> >>>>>>>>  
> >>>>>>> info.version,  
> >>>>>>>  
> >>>>>>>> 'package');  
> >>>>>>>> return pkgDir;  
> >>>>>>>> });  
> >>>>>>>> },  
> >>>>>>>>  
> >>>>>>>> There's really no "amount of code" argument here.  
> >>>>>>>>  
> >>>>>>>>  
> >>>>>>>>  
> >>>>>>>> Adding platforms at a specific version would mean having a  
> >>>>>>>>>  
> >>>>>>>> specific  
> >>>>  
> >>>>> version  
> >>>>>>>>  
> >>>>>>>>> of the CLI. Yes: this is way better! Explicit dependencies is  
> >>>>>>>>>  
> >>>>>>>> the  
> >>>  
> >>>> best  
> >>>>>>  
> >>>>>>> way  
> >>>>>>>>  
> >>>>>>>>> to work w/ the small modules thing.  
> >>>>>>>>>  
> >>>>>>>>> Bundling platforms with CLI would be like bundling all of the  
> >>>>>>>>  
> >>>>>>> plugins  
> >>>>  
> >>>>> with  
> >>>>>>>  
> >>>>>>>> CLI, or like bundling every npm module with npm.  
> >>>>>>>>  
> >>>>>>>> Devs need to be able to try out platforms at different versions.  
> >>>>>>>>  
> >>>>>>> We  
> >>>  
> >>>> should  
> >>>>>>>  
> >>>>>>>> not do anything that keeps users clinging to old versions of CLI  
> >>>>>>>>  
> >>>>>>> (e.g.  
> >>>>>  
> >>>>>> they  
> >>>>>>>  
> >>>>>>>> do this now because they don't want to update to new platforms)  
> >>>>>>>>  
> >>>>>>>>  
> >>>>>>>>  
> >>>>>>>>  
> >>>>>>>>>  
> >>>>>>>>>  
> >>>>>>>>> On Mon, Jun 2, 2014 at 7:34 PM, Michal Mocny <  
> >>>>>>>>>  
> >>>>>>>> mmocny@chromium.org>  
> >>>>  
> >>>>> wrote:  
> >>>>>>>>  
> >>>>>>>>> On Mon, Jun 2, 2014 at 10:14 PM, Andrew Grieve <  
> >>>>>>>>>>  
> >>>>>>>>> agrieve@chromium.org  
> >>>>>>  
> >>>>>>> wrote:  
> >>>>>>>>>>  
> >>>>>>>>>> Here's both flows as I understand them:  
> >>>>>>>>>>>  
> >>>>>>>>>>> Direct NPM flow:  
> >>>>>>>>>>> # Downloads platform source into node_modules  
> >>>>>>>>>>> npm install cordova-ios@3.4.0 --save  
> >>>>>>>>>>> # Runs the create script and installs plugins to create  
> >>>>>>>>>>>  
> >>>>>>>>>> platforms/ios  
> >>>>>>>  
> >>>>>>>> cordova platform add ios --path=node_modules/cordova-ios  
> >>>>>>>>>>>  
> >>>>>>>>>>> To be fair, I think with Brian's suggestion, platform add FOO  
> >>>>>>>>>>  
> >>>>>>>>> would  
> >>>>>  
> >>>>>> by  
> >>>>>>>  
> >>>>>>>> default look in node_modules so you wouldn't be explicit  
> >>>>>>>>>>  
> >>>>>>>>> about  
> >>>  
> >>>> it,  
> >>>>>  
> >>>>>> and  
> >>>>>>>  
> >>>>>>>> also  
> >>>>>>>>>  
> >>>>>>>>>> the default cordova project package.json would depend on all  
> >>>>>>>>>>  
> >>>>>>>>> the  
> >>>>  
> >>>>> latest  
> >>>>>>>  
> >>>>>>>> versions of each platform, so the flows would actually be:  
> >>>>>>>>>>  
> >>>>>>>>>>> cordova create Foo && cd Foo  
> >>>>>>>>>>> npm install  
> >>>>>>>>>>> npm install cordova-ios@3.4 --save  
> >>>>>>>>>>> cordova platform add android  
> >>>>>>>>>>> cordova platform add ios  
> >>>>>>>>>>> # crazy idea? use npm post-install hooks to auto-run  
> >>>>>>>>>>>  
> >>>>>>>>>> create/upgrade  
> >>>>>>  
> >>>>>>> so  
> >>>>>>>>  
> >>>>>>>>> you usually don't need above two lines?  
> >>>>>>>>>>  
> >>>>>>>>>> Compared to:  
> >>>>>>>>>>  
> >>>>>>>>>>> cordova create Foo && cd Foo  
> >>>>>>>>>>> cordova platform add android  
> >>>>>>>>>>> cordova platform add ios@3.4  
> >>>>>>>>>>>  
> >>>>>>>>>> I think #2 is enough better that its not worth changing.  
> >>>>>>>>>>  
> >>>>>>>>>>  
> >>>>>>>>>> Cordova-to-npm flow (as Mark's implemented):  
> >>>>>>>>>>> # Runs "npm cache add cordova-ios", then runs create script  
> >>>>>>>>>>>  
> >>>>>>>>>> from  
> >>>>>  
> >>>>>> ~/cache/cordova-ios/bin/create  
> >>>>>>>>>>> cordova platform add ios@3.4.0  
> >>>>>>>>>>>  
> >>>>>>>>>>> - In both flows: we use npm to do all of the heavy lifting  
> >>>>>>>>>>> - In both flows: the npm module is cached in your home  
> >>>>>>>>>>>  
> >>>>>>>>>> directory  
> >>>>>  
> >>>>>> - In both flows?: we store the plugins & platforms  
> >>>>>>>>>>>  
> >>>>>>>>>> explicitly  
> >>>  
> >>>> within  
> >>>>>>>  
> >>>>>>>> config.xml (Gorkem's added this)  
> >>>>>>>>>>> - In flow #1, we have a package.json & a node_modules, in  
> >>>>>>>>>>>  
> >>>>>>>>>> #2  
> >>>  
> >>>> we  
> >>>>  
> >>>>> don't.  
> >>>>>>>>  
> >>>>>>>>> Why put the onus on the user to fetch the platform source  
> >>>>>>>>>>>  
> >>>>>>>>>> when  
> >>>>  
> >>>>> it's  
> >>>>>>  
> >>>>>>> as  
> >>>>>>>>  
> >>>>>>>>> easy  
> >>>>>>>>>>  
> >>>>>>>>>>> as running "npm cache add" under-the-hood?  
> >>>>>>>>>>>  
> >>>>>>>>>>>  
> >>>>>>>>>>> In regards to the idea of using require() on platform  
> >>>>>>>>>>>  
> >>>>>>>>>> scripts  
> >>>  
> >>>> instead  
> >>>>>>>  
> >>>>>>>> of  
> >>>>>>>>>  
> >>>>>>>>>> subshelling: I think this is tangental to the debate of how  
> >>>>>>>>>>>  
> >>>>>>>>>> to  
> >>>>  
> >>>>> fetch  
> >>>>>>>  
> >>>>>>>> the  
> >>>>>>>>>  
> >>>>>>>>>> platform.  
> >>>>>>>>>>> In regards to using "npm install" directly when using the  
> >>>>>>>>>>>  
> >>>>>>>>>> plugman  
> >>>>>  
> >>>>>> workflow:  
> >>>>>>>>>>  
> >>>>>>>>>>> Sounds good to me.  
> >>>>>>>>>>>  
> >>>>>>>>>>>  
> >>>>>>>>>>>  
> >>>>>>>>>>>  
> >>>>>>>>>>> On Mon, Jun 2, 2014 at 6:05 PM, Brian LeRoux <b@brian.io>  
> >>>>>>>>>>>  
> >>>>>>>>>> wrote:  
> >>>>>  
> >>>>>> Eventually, yes. (Sort of how Grunt works now.)  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>  
> >>>>>>>>>>>> On Mon, Jun 2, 2014 at 5:52 PM, Terence M. Bandoian <  
> >>>>>>>>>>>>  
> >>>>>>>>>>> terence@tmbsw.com  
> >>>>>>>>>  
> >>>>>>>>>> wrote:  
> >>>>>>>>>>>>  
> >>>>>>>>>>>> Can multiple versions of a platform be installed  
> >>>>>>>>>>>>>  
> >>>>>>>>>>>> side-by-side?  
> >>>>>>  
> >>>>>>> -Terence  
> >>>>>>>>>>>>>  
> >>>>>>>>>>>>>  
> >>>>>>>>>>>>>  
> >>>>>>>>>>>>> On 6/2/2014 3:04 PM, Michal Mocny wrote:  
> >>>>>>>>>>>>>  
> >>>>>>>>>>>>> >From original email: "Ideal future CLI uses platforms  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> just  
> >>>>>  
> >>>>>> like  
> >>>>>>>  
> >>>>>>>> other  
> >>>>>>>>>>  
> >>>>>>>>>>> deps.  
> >>>>>>>>>>>>>> We lose lazy loading but network and disk is cheap so  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> it  
> >>>  
> >>>> wasn't  
> >>>>>>>  
> >>>>>>>> really  
> >>>>>>>>>>  
> >>>>>>>>>>> important anyhow."  
> >>>>>>>>>>>>>> Made me think Brian is proposing adding platforms to  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> cli  
> >>>  
> >>>> package.json  
> >>>>>>>>>>  
> >>>>>>>>>>> dependencies, and you would have a single global  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> install  
> >>>  
> >>>> cordova-platforms.  
> >>>>>>>>>>>>>> Then you can override the version with an explicit  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> install  
> >>>>>  
> >>>>>> as  
> >>>>>>>  
> >>>>>>>> he  
> >>>>>>>>  
> >>>>>>>>> mentions  
> >>>>>>>>>>>>>> "npm i cordova-ios@3.5.0".  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> Personally, I think that workflow could work, and has  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> a  
> >>>  
> >>>> few  
> >>>>>  
> >>>>>> benefits,  
> >>>>>>>>>>  
> >>>>>>>>>>> but  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> I'm not sure that option compares well to the  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> alternative  
> >>>>  
> >>>>> of  
> >>>>>  
> >>>>>> just  
> >>>>>>>>  
> >>>>>>>>> lazy  
> >>>>>>>>>>  
> >>>>>>>>>>> loading using npm cache add as Mark has already  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> implemented  
> >>>>>  
> >>>>>> an  
> >>>>>>  
> >>>>>>> experiment  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> (anyone interested in this topic should take a look at  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> that  
> >>>>>  
> >>>>>> patch).  
> >>>>>>>>>  
> >>>>>>>>>> The steps Brian & Ian outline about how to package  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> platforms  
> >>>>>  
> >>>>>> for  
> >>>>>>>  
> >>>>>>>> release  
> >>>>>>>>>>>  
> >>>>>>>>>>>> to  
> >>>>>>>>>>>>>> npm are possibly an improvement over the old-style  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> platform-centric  
> >>>>>>>>>  
> >>>>>>>>>> workflow. Instead of downloading a tarball and  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> running  
> >>>  
> >>>> a  
> >>>>  
> >>>>> create  
> >>>>>>>  
> >>>>>>>> script,  
> >>>>>>>>>>>  
> >>>>>>>>>>>> you npm install and run a create() function, and that  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> can  
> >>>>  
> >>>>> more  
> >>>>>>  
> >>>>>>> easily  
> >>>>>>>>>>  
> >>>>>>>>>>> be  
> >>>>>>>>>>>  
> >>>>>>>>>>>> bundled into other build scripts/boilerplate. For CLI  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> workflow,  
> >>>>>>>  
> >>>>>>>> not  
> >>>>>>>>>  
> >>>>>>>>>> sure  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> that there is any real difference (as Jesse says).  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> One  
> >>>  
> >>>> note,  
> >>>>>>  
> >>>>>>> though:  
> >>>>>>>>>>  
> >>>>>>>>>>> cordova-* platforms are templates for projects, so  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> the  
> >>>  
> >>>> package.json  
> >>>>>>>>>>  
> >>>>>>>>>>> of  
> >>>>>>>>>>>  
> >>>>>>>>>>>> the  
> >>>>>>>>>>>>>> npm package itself shouldn't end up inside projects  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> that  
> >>>  
> >>>> are  
> >>>>>  
> >>>>>> created  
> >>>>>>>>>  
> >>>>>>>>>> with  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> it. I think.  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> -Michal  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 3:42 PM, Ian Clelland <  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> iclelland@chromium.org>  
> >>>>>>>>>>  
> >>>>>>>>>>> wrote:  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> There seems to be some confusion -- I think people  
> >>>>>>>>>>>>>>  
> >>>>>>>>>>>>> are  
> >>>  
> >>>> talking  
> >>>>>>>  
> >>>>>>>> about  
> >>>>>>>>>>  
> >>>>>>>>>>> different things here, but perhaps it's just me ;)  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> I thought that Brian's original suggestion was about  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> being  
> >>>>>  
> >>>>>> able  
> >>>>>>>  
> >>>>>>>> to  
> >>>>>>>>>  
> >>>>>>>>>> host  
> >>>>>>>>>>>  
> >>>>>>>>>>>> Cordova platforms directly on NPM. That's why each  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> one  
> >>>  
> >>>> would  
> >>>>>>  
> >>>>>>> require  
> >>>>>>>>>>  
> >>>>>>>>>>> a  
> >>>>>>>>>>>  
> >>>>>>>>>>>> package.json. (which would probably end up in  
> >>>>>>>>>>>>>>> <project>/platforms/<platform> in a project, but  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> that's  
> >>>  
> >>>> not  
> >>>>>  
> >>>>>> the  
> >>>>>>>  
> >>>>>>>> point  
> >>>>>>>>>>  
> >>>>>>>>>>> of  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> it).  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> As an NPM project, we then would have the opportunity  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> (though  
> >>>>>>  
> >>>>>>> not  
> >>>>>>>>  
> >>>>>>>>> the  
> >>>>>>>>>>  
> >>>>>>>>>>> obligation) to make all of the supporting scripts for  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> each  
> >>>>>  
> >>>>>> platform  
> >>>>>>>>>  
> >>>>>>>>>> (create, build, run, etc) part of the node module,  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> for  
> >>>  
> >>>> a  
> >>>>  
> >>>>> uniform  
> >>>>>>>>  
> >>>>>>>>> interface  
> >>>>>>>>>>>>>>> that doesn't require going through the command line.  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> It's not about making platforms into CLI dependencies  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> (any  
> >>>>>  
> >>>>>> more  
> >>>>>>>  
> >>>>>>>> than  
> >>>>>>>>>>  
> >>>>>>>>>>> plugins are CLI dependencies right now), or about  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> making  
> >>>>  
> >>>>> a  
> >>>>>  
> >>>>>> cordova-based  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> project into a node package.  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> If that's right, then I support that -- I'd like the  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> platforms  
> >>>>>>>  
> >>>>>>>> to  
> >>>>>>>>  
> >>>>>>>>> be  
> >>>>>>>>>>  
> >>>>>>>>>>> installable through npm, and to be versioned  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> separately,  
> >>>>  
> >>>>> installable  
> >>>>>>>>>>  
> >>>>>>>>>>> separately, and scriptable without having to spawn  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> subshells.  
> >>>>>>  
> >>>>>>> And if I have it completely wrong, then let me know  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> --  
> >>>  
> >>>> I'll  
> >>>>>  
> >>>>>> just  
> >>>>>>>>  
> >>>>>>>>> go  
> >>>>>>>>>  
> >>>>>>>>>> back  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> to  
> >>>>>>>>>>>>>>> fixing File bugs ;)  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 3:29 PM, Andrew Grieve <  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>> agrieve@chromium.org>  
> >>>>>>>>>>  
> >>>>>>>>>>> wrote:  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> Not sure what your question is.  
> >>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 2:03 PM, Brian LeRoux <  
> >>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>> b@brian.io>  
> >>>>>  
> >>>>>> wrote:  
> >>>>>>>>>  
> >>>>>>>>>> *ahem  
> >>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> On Wed, May 28, 2014 at 11:20 AM, Brian LeRoux <  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>> b@brian.io  
> >>>>>>  
> >>>>>>> wrote:  
> >>>>>>>>>>  
> >>>>>>>>>>> npm i cordova-ios@3.5.0  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> Right?  
> >>>>>>>>>>>>>>>>>> On May 27, 2014 11:06 PM, "Andrew Grieve" <  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> agrieve@chromium.org  
> >>>>>>>>>  
> >>>>>>>>>> wrote:  
> >>>>>>>>>>>>>>>>> Lazy loading is what will give us the ability to  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>> support  
> >>>>>  
> >>>>>> multiple  
> >>>>>>>>>  
> >>>>>>>>>> versions  
> >>>>>>>>>>>>>>>>>> of platforms.  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> If we don't support users choosing the version of  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> the  
> >>>>  
> >>>>> platform  
> >>>>>>>>>  
> >>>>>>>>>> they  
> >>>>>>>>>>>  
> >>>>>>>>>>>> want,  
> >>>>>>>>>>>>>>>>>> then they will resist updating their version of  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> CLI  
> >>>  
> >>>> (like  
> >>>>>>  
> >>>>>>> they  
> >>>>>>>>  
> >>>>>>>>> do  
> >>>>>>>>>>  
> >>>>>>>>>>> right  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> now).  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> I'm very keen to allow users to chose their  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> platform  
> >>>>  
> >>>>> versions,  
> >>>>>>>>>  
> >>>>>>>>>> just  
> >>>>>>>>>>>  
> >>>>>>>>>>>> as  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> they  
> >>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> are able to choose their plugin versions.  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> On Tue, May 27, 2014 at 5:57 PM, Mark Koudritsky  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> <  
> >>>  
> >>>> kamrik@google.com  
> >>>>>>>>>>>>  
> >>>>>>>>>>>>> wrote:  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> +1  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>> Steve published (some of?) the platforms on npm  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> as  
> >>>  
> >>>> part  
> >>>>>>  
> >>>>>>> of  
> >>>>>>>  
> >>>>>>>> the  
> >>>>>>>>>  
> >>>>>>>>>> latest  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> release.  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> https://www.npmjs.org/package/cordova-android  
> >>>>>>>>>>>>>>>>>>>> https://www.npmjs.org/package/cordova-ios  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>> CLI already require()s npm for downloading  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> plugins  
> >>>  
> >>>> from  
> >>>>>>  
> >>>>>>> the  
> >>>>>>>>  
> >>>>>>>>> registry.  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> Extending this to platforms is on my todo list for  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>> this\next  
> >>>>>>>  
> >>>>>>>> week.  
> >>>>>>>>>>  
> >>>>>>>>>>> The "lazy" part of the loading was about  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> caching,  
> >>>  
> >>>> so  
> >>>>  
> >>>>> we  
> >>>>>>  
> >>>>>>> don't  
> >>>>>>>>>  
> >>>>>>>>>> lose  
> >>>>>>>>>>>  
> >>>>>>>>>>>> it  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> since  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> npm does its own caching.  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>> On Tue, May 27, 2014 at 5:42 PM, Parashuram  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> Narasimhan  
> >>>>>  
> >>>>>> (MS  
> >>>>>>>  
> >>>>>>>> OPEN  
> >>>>>>>>>>  
> >>>>>>>>>>> TECH)  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>> <  
> >>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>> panarasi@microsoft.com> wrote:  
> >>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> +1. This will also be a step towards releasing  
> >>>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>> platforms  
> >>>>>>>  
> >>>>>>>> independently.  
> >>>>>>>>>>>>>>>>>>>> Will the CLI have a semver like dependency on  
> >>>>>>>>>>>>>>>>>>>  
> >>>>>>>>>>>>>>>>>>>  
>  
>  


Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message