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 15:31:37 GMT
I would add that I'm in agreement with Tommy that "platforms/*" should be
consider build artifacts. this should not be checking into source version
control.
If user changes contents under "platforms/" then it should move any changes
back to "merges/" or write some logic to recover the canges using "hooks/"

I would prefer if we could rename "platforms" into "buids/" or "dist/", but
I would be happy making the path name "platforms/" configurable



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