cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Carlos Santana <csantan...@gmail.com>
Subject Re: adding platforms to npm for dependency sanity
Date Wed, 04 Jun 2014 18:48:25 GMT
Micha you mean something like this?
https://github.com/csantanapr/grunt-cordovacli



On Wed, Jun 4, 2014 at 8: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