cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Brian LeRoux...@brian.io>
Subject Re: adding platforms to npm for dependency sanity
Date Wed, 04 Jun 2014 18:42:34 GMT
Oh whoops, not crazy just excited. Saying YES!! to everything Michal said
in that last msg.


On Wed, Jun 4, 2014 at 11:34 AM, Carlos Santana <csantana23@gmail.com>
wrote:

> YES!! to what? Brian
>
>
> On Wed, Jun 4, 2014 at 11:18 AM, Brian LeRoux <b@brian.io> wrote:
>
> > YES!!!
> >
> >
> > On Wed, Jun 4, 2014 at 8:45 AM, Michal Mocny <mmocny@chromium.org>
> wrote:
> >
> > > After sleeping on it, I think if you're going to introduce package.json
> > and
> > > local installs of cli & platforms, and require node scripts to manage
> > > environment, you really may as well go the last mile and replace use of
> > the
> > > global CLI installation with grunt/gulp plugins.  (that sounds
> > interesting,
> > > but I do not know who would be willing & able to do it.)
> > >
> > > In the mean time, the existing CLI is already solving all the use cases
> > > pointed out in this thread, and I'm not aware of it being a problem.
> > >
> > > -Michal
> > >
> > >
> > > On Wed, Jun 4, 2014 at 11:29 AM, Michal Mocny <mmocny@chromium.org>
> > wrote:
> > >
> > > >
> > > >
> > > >
> > > > On Wed, Jun 4, 2014 at 11:10 AM, Carlos Santana <
> csantana23@gmail.com>
> > > > wrote:
> > > >
> > > >> I think regardless how much sugar we use to make it easy, I think
> the
> > > >> under
> > > >> the hood foundation/architecture should be something like:
> > > >>
> > > >> LocalProject/www/
> > > >> LocalProject/config.xml
> > > >> LocalProject/package.json
> > > >> LocalProject/node_module/.bin/cordova
> > > >>
> > > >> config.xml (manages the cordova app)
> > > >> package.json (manages the cordova project)
> > > >>
> > > >> pacakge.json (will specify all dependencies and npm will take care
> of
> > > >> fulfill them)
> > > >> {
> > > >> cordova: ">3.6",
> > > >> cordova-ios: "3.6.1",
> > > >> cordova-android: "3.6.2",
> > > >> cordova-plugin-device: "*",
> > > >> cordova-plugin-file: "^0.2.4"
> > > >> }
> > > >> npm install will take care of making everything available locally.
> > > >>
> > > >> I know that we don't have plugins in npm, but something to think
> > about,
> > > in
> > > >> terms of just a secondary repository to download the files and
> > caching.
> > > >>
> > > >> a global @cordova-cli, can be available like grunt-cli, to look
> first
> > in
> > > >> local directory (i.e. findup)
> > > >>
> > > >> like someone mentioned npm installs hooks can run the "cordova
> > platform
> > > >> add"
> > > >>
> > > >
> > > > Looked into it.  Apparently this is really really taboo, which
> signals
> > we
> > > > will not have a good time down this path.
> > > >
> > > >
> > > >>
> > > >> this way minimal set of files can be put a dev repo, and reproduce
> by
> > > >> another developer very easy both getting same resulting project.
> > > >>
> > > >> git clone https://github.com/myuser/cordovapp && cd cordovapp &&
> npm
> > > >> install && cordova run android
> > > >>
> > > >>
> > > >>
> > > >> On Tue, Jun 3, 2014 at 6:35 PM, Terence M. Bandoian <
> > terence@tmbsw.com>
> > > >> wrote:
> > > >>
> > > >> > I still consider myself a relative newcomer to Cordova but, from a
> > > >> > development standpoint, it would be easiest for me if I could
> manage
> > > >> each
> > > >> > platform of a project independently - including plugins.
>  Creating a
> > > >> > parallel project to make sure that the plugins and Cordova base
> > don't
> > > >> > change for one platform while I work on another isn't ideal but it
> > > isn't
> > > >> > completely unmanageable either.  It just makes the workflow a
> little
> > > >> more
> > > >> > complex.
> > > >> >
> > > >> > -Terence
> > > >> >
> > > >> >
> > > >> >
> > > >> > On 6/3/2014 7:12 PM, Michal Mocny wrote:
> > > >> >
> > > >> >> We don't do platform-plugin version matching *at all* today.
> > >  Everyone
> > > >> >> uses
> > > >> >> the latest plugins and any platform version they want, and its
> been
> > > >> >> "fine".
> > > >> >>   So using different platform versions isn't as hard as you guys
> > are
> > > >> >> making
> > > >> >> it out to be.
> > > >> >>
> > > >> >> Still, I've already said its not necessarily a complexity that
> > needs
> > > >> to be
> > > >> >> addressed in a world where you can create multiple projects and
> use
> > > >> >> --link-to or whatever, so long as your platforms aren't installed
> > > >> >> globally.
> > > >> >>
> > > >> >>
> > > >> >> Anyway, thanks for posting your instructions Brian/Tommy.  As I
> > > >> mentioned
> > > >> >> it would be, thats a different workflow than we have now.  I'm
> > going
> > > to
> > > >> >> sleep on it before I comment, but it certainly isn't just like
> "You
> > > >> know
> > > >> >> how we do it today".
> > > >> >>
> > > >> >> -Michal
> > > >> >>
> > > >> >>
> > > >> >> On Tue, Jun 3, 2014 at 7:59 PM, tommy-carlos williams <
> > > >> tommy@devgeeks.org
> > > >> >> >
> > > >> >> wrote:
> > > >> >>
> > > >> >>  I don’t think you really can forget about plugins for a second.
> > > >> >>>
> > > >> >>> In my personal opinion, the entire ./platforms folder should be
> a
> > > >> build
> > > >> >>> artefact. If you want to freeze iOS, then use a branch or a new
> > > clone
> > > >> of
> > > >> >>> the project.
> > > >> >>>
> > > >> >>> It’s not that I can think of no scenarios where supporting
> > multiple
> > > >> >>> platform versions would be needed, it’s just that I think it’s
> > > >> needlessly
> > > >> >>> complex vs using a dev workflow to solve those problems.
> > > >> >>>
> > > >> >>> I already version cordova within a project… I have a local
> version
> > > of
> > > >> >>> cordova installed into ./node_modules for each project and use
> > Grunt
> > > >> to
> > > >> >>> call ./node_modules/.bin/cordova rather than the global cordova
> > cli.
> > > >> >>>
> > > >> >>> On 4 June 2014 at 9:46:29, Terence M. Bandoian (
> terence@tmbsw.com
> > )
> > > >> >>> wrote:
> > > >> >>>
> > > >> >>> Forgetting about plugins for a second, what if:
> > > >> >>>
> > > >> >>> - I complete a project for iOS
> > > >> >>> - six months later the client decides to port to Android and:
> > > >> >>> - I want the latest fixes for Android
> > > >> >>> - I want to keep the iOS version frozen for the time being
> > > >> >>>
> > > >> >>> I would expect releases for each platform to be on different
> > > >> schedules.
> > > >> >>>
> > > >> >>> -Terence
> > > >> >>>
> > > >> >>>
> > > >> >>> On 6/3/2014 6:17 PM, Michal Mocny wrote:
> > > >> >>>
> > > >> >>>> Most plugins will work across a wide range of platform
> versions,
> > so
> > > >> >>>> often
> > > >> >>>> it would work to have disparate platform versions even with
> > > plugins.
> > > >> >>>> However, I do concede that in general this isn't a complexity
> we
> > > >> focus
> > > >> >>>>
> > > >> >>> on.
> > > >> >>>
> > > >> >>>> Interested in your thoughts about the other points.
> > > >> >>>>
> > > >> >>>> -Michal
> > > >> >>>>
> > > >> >>>>
> > > >> >>>> On Tue, Jun 3, 2014 at 7: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
> > > >> >>>>>>>>>>>>>>>>>>>>>>>>>
> > > >> >>>>>>>>>>>>>>>>>>>>>>>>
> > > >> >>>
> > > >> >>>
> > > >> >
> > > >>
> > > >>
> > > >> --
> > > >> Carlos Santana
> > > >> <csantana23@gmail.com>
> > > >>
> > > >
> > > >
> > >
> >
>
>
>
> --
> Carlos Santana
> <csantana23@gmail.com>
>

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