cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Michal Mocny <mmo...@chromium.org>
Subject Re: adding platforms to npm for dependency sanity
Date Wed, 04 Jun 2014 15:29:44 GMT
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>
>

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