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 20:38:56 GMT
Michal
  The grunt plugin and yeoman generator I implemented a long ago. So it's
implemented on top of what cordova provides.

I'm confuse, this is the point I was trying to get that there is "user
space" and "cordova platform space", Doing a plugin for yeoman, gulp ,
grunt, or the next thing is user space.

cordova as a platform should be using flexbile and clear on what is doing,
so "user space" can customize on top of it.


On Wed, Jun 4, 2014 at 12:44 PM, Terence M. Bandoian <terence@tmbsw.com>
wrote:

> This is helpful.  Thank you for posting this, Carlos.  I have a couple of
> related questions.
>
> The config files I've used iOS and Android are significantly different for
> the same project.  Is combining everything for all platforms into one
> config.xml recommended?
>
> What cordova commands cause the www folder to be copied to a platforms
> directory?  My workflow for iOS/Xcode is typically (similar for
> Android/Eclipse):
>
> - add/build iOS platform using cordova
> - edit, build, test iteratively in Xcode using platforms/ios directory
>
> Xcode doesn't copy from the outer www directory when it builds. Should it?
>  All of the files added to the Xcode project are in the platforms/ios
> directory.
>
> -Terence
>
>
>
> On 6/4/2014 10:10 AM, Carlos Santana 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"
>>
>> 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