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:45:00 GMT
After sleeping on it, I think if you're going to introduce package.json and
local installs of cli & platforms, and require node scripts to manage
environment, you really may as well go the last mile and replace use of the
global CLI installation with grunt/gulp plugins.  (that sounds interesting,
but I do not know who would be willing & able to do it.)

In the mean time, the existing CLI is already solving all the use cases
pointed out in this thread, and I'm not aware of it being a problem.

-Michal


On Wed, Jun 4, 2014 at 11:29 AM, Michal Mocny <mmocny@chromium.org> wrote:

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

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