For Ultima III 2.x only. For users of Mac OS X earlier than 10.4. For users of Mac OS 8 and 9. For users with ancient 68K Macintoshes or 68K-based Mac emulators. For users of Mac OS X earlier than 10.6. For Mac OS 8 and 9. Download RetroArch 1.9.7 for Mac for free, without any viruses, from Uptodown. Try the latest version of RetroArch for Mac.
This article describes in great detail what I learned about setting up AngularJS applications in terms of project structure, tools, dependency management, test automation and code distribution. The result is a seed project that is easily extendable, clearly structured, self-documenting, and comfortable to work with.
One of the key points of this setup is that everything that is needed for the application itself to run and the tests to works, and every other relevant task related to developing the application, is pulled in through tool-based dependency management. However, the tools that do the job need a basic global setup – which is not specific to the project itself – available on your development machine: Node.js, the Grunt CLI, and Bower.
The following steps describe how to create this setup on a Linux or Mac OS X system.
Step 1: Installing Node.js
- Download the latest available version of the source code of Node.js from http://nodejs.org/download. As of this writing, the latest version is 0.10.28, available as node-v0.10.28.tar.gz.
tar xvfz node-v0.10.28.tar.gzto extract the archive.
./configure && make && sudo make installin order to compile and install the software .
Step 2: Installing the Grunt CLI
Download G-switch For Mac 1.9.7
The Grunt Command Line Interface is a Node.js module which allows us to execute the Grunt tasks of our project on the command line. This way, we can handle every task that is related to the development process of the application – e.g. syntax checking, code style verification, running the unit tests, building a distributable – through a single interface, and we can configure all available tasks in great detail, making Grunt the one-stop assistant for all our project needs (with the notable exception of writing code and tests, which, I’m afraid, still has to be done by us).
The Grunt CLI ships as a Node.js module and is therefore installed using the Node Package Manager, NPM:
npm install -g grunt-cli
The -g switch installs the command line tool globally, that is, to a central location on our system. Grunt needs additional modules to actually do something useful, but these will be installed locally to the project location, as we will see later. The globally installed command line tool, which is invoked as grunt, will then use these local modules to execute the tasks for our project.
Step 3: Installing Bower
In order to make the command line tool bower available on our system, we install it through NPM just as we did with the Grunt CLI:
npm install -g bower
Creating an initial project structure
With all global requirements installed and in place, we can now start to create our project, putting NPM, Grunt and Bower to use.
The first step is to define the local dependencies of our project – we need several backend libraries (managed through NPM) and several frontend libraries (managed through Bower). Both tools need a JSON configuration file that defines these dependencies. Let’s start with the NPM packages by creating a file package.json in our project root:
As you can see, these are all development dependencies; none of these packages are needed to run the actual application. We are going to pull in the local grunt module and several of its plugins, and we make Karma, the AngularJS test runner, available. Satisfying these dependencies allows us to use the Grunt command line interface on this project and enables us to run Jasmine test cases against the PhantomJS headless browser.
Note the scripts block: we can use the postinstall statement to make NPM run bower install after installing its modules – this way, we need to execute only one command in order to pull in development and application dependencies.
We also need a configuration file for Bower, again in the root directory of the project, named bower.json:
These are all dependencies which the application needs to actually run.
Both JSON files belong into version control; however, the libraries they pull in should not be added to a repository; instead, they should be ignored:
We can now start to create our very first test and implementation code and see if the setup is able to run the test case.
Setting up the test infrastructure
We start by creating a specification for an ExampleController in a new folder called test:
We now need to set up the Karma test runner configuration, which will allow us to run the test case. To do so, we need to create a configuration file for Karma at the root folder of the project, called karma.conf.js:
Let’s see if we can run the specification. We don’t expect it to pass, of course, because we have not yet written a single piece of implementation code – however, at this point it is interesting to see if the infrastructure we created so far is already sufficient to run test cases.
If our setup is correct, then we should be able to launch Karma, the AngularJS test runner, as soon as our project dependencies are put in place through NPM. The following commands all need to be executed at the top level of the project folder structure.
This installs all local Node.js dependencies and then runs bower install, which installs the application dependencies. We can now run Karma:
Which results in a failing test run, but should demonstrate that the testcase can at least be executed:
Audio Converter For Mac
A first implementation
We will now add the implementation code that is neccessary to make the test case pass. Let’s start by adding controller code to source/controllers.js:
This obviously needs a UserdataService, so let’s implement that, too:
Finally, we can set up the application in source/app.js:
Now the testcase runs and passes:
Running unit tests is the first of many differents tasks that need to be performed while developing a project. We can configure all these tasks into Grunt, which results in a unified interface for managing our project tasks. In order to set up unit test execution as a Grunt task, we need to describe it in a file named Gruntfile.js in our project root folder:
This configures the task karma:development using the grunt-karma plugin, plus an alias test that maps to karma:development. Note that Grunt isn’t just a dumb command executor like a bash script – with its specialized plugins, it understands the tools it runs in its tasks; as you can see, we configure the basic set of files that are needed for a test run in meta.jsFilesForTesting, and then use this set in karma.development.options.files. Later, we are going to define other Karma subtasks (in addition to karma.development), pointing at the basic set of files but including other files than source/**/*js.
Don’t worry if this doesn’t make sense right now; we will take it step by step.
Because now we configure the files set within the Grunt config files, we no longer need it in our karma.conf file:
Flip For Mac Download
With this, we can start the unit test run using Grunt:
Note that it doesn’t matter in which subfolder of our project we are while running this command – Grunt gets the paths right for us, another benefit of using Grunt that makes working with our project more comfortable.
Linting code using Grunt
With this, running grunt jshint lints our source code files:
Real developers ship
Until now we have only handled our source files. But that’s probably not the format we want to use when shipping our application to production. A minified single file with all our source code concatenated together is usually the preferred end result.
The goal is to end up with two files in the dist folder of our project root:
As you can see, the file name contains the name and version of our project. Grunt can be configured to derive these values from the package.json file of our project. Then, the concat plugin can be used to generate a non-minified dist file that contains the content of all source files concatenated together, and the uglify plugin then generates a minified version of this file. Let’s look at the changes to our Gruntfile:
Now we can run both tasks…
…and the dist files will be generated.
From single tasks to complete workflows
Another really nice aspect of managing tasks through Grunt is that tasks can be combined into workflows. A very likely workflow during development is to lint and unit test our code, then concatenate and minify it if no errors were detected. Instead of running each of these tasks manually, we can use registerTask to create a new task which executes the other tasks for us:
grunt build will execute this workflow.
Real developers ship tested files
We are not yet using our Grunt-based task management approach to its full potential; now that the most important moving parts are in place, reaping additional benefits is simple. It would be great, for example, to unit test our dist files, too – this way we get additional safety in regards to the stability of our code without extra costs. All that is needed to achieve this is to add two additional Karma subtasks, and to make them part of the build workflow:
And with this, we have at our fingertips a complete AngularJS workflow: our source code is linted and tested, merged into a distribution file, which is tested, too, and then minified and tested again. Our application is verified and ready to ship with a single command:
With a first complete workflow in place, we can now add other useful steps; for example, generating a JSDoc documentation from our inline source code comments is straight-forward:
First, we add the plugin and task configuration for JSDoc to the Gruntfile, and make the jsdoc task part of our build workflow:
If you don’t want the generated documentation to be part of the repository, add the doc folder to .gitignore:
Now, generating the documentation is simple:
From task management to Continuous Integration
One of the huge benefits of having each project-related task managed by a tool like Grunt is that automation is now simple. And that’s the key to the final step: Setting up the project for Continuous Integration. We will look at what needs to be done to make our project usable with TravisCI and Jenkins, respectively.
Integrating with TravisCI
We need to do some minimal changes to our project to make it able to run on TravisCI. First, let’s create the obligatory .travis.yml file:
As you can see, we declare our project to be a Node.js project. This is because from TravisCI’s point of view, only Node.js scripts (npm install, grunt build, karma etc.) are run for building and testing the project.
Just as we prepared our personal development environment, we need to globally install grunt-cli and bower globally.
This is all we need to put into the .travis.yml file because TravisCI runs npm install and then npm test on Node.js projects by default, after checking them out of version control. However, npm test doesn’t do anything useful yet for our project. Let’s change that by adding a line to our package.json:
Now, TravisCI executing npm test will result in grunt build being run. Should any single step in grunt build fail, then the TravisCI run will fail; if everything succeeds, then TravisCI will consider the run a success, too.
If you would like to use the project setup described herein as a base template for your own projects, see https://github.com/manuelkiessling/angular-seed-enhanced.
My fork of MenuMeters for El Capitan, Sierra, High Sierra, Mojave, Catalina and Big Sur.
If you just want to use it, please go to http://member.ipmu.jp/yuji.tachikawa/MenuMetersElCapitan/ or https://github.com/yujitach/MenuMeters/releases and download the binary. The detailed installation instruction is given in the former.
If you run Mojave and higher, https://github.com/exelban/stats is another menubar monitor which has a more modern look and feel, often offers more capability, and is maintained actively. It is heavily recommended.
There are also further forks of my version of MenuMeters, which implement more features. You might want to try them out:
- https://github.com/emcrisostomo/MenuMeters which has DMG installers
- https://gitlab.com/axet/MenuMeters which has new features in the CPU meter, etc.
If you'd like your version mentioned here, please tell me at the issues page.
Switch For Mac Osx
It's a great utility originally developed at http://www.ragingmenace.com/software/menumeters/ . The original version does not work on El Capitan and later, due to the fact that SystemUIServer doesn't load Menu Extras not signed by Apple any longer.
I'm making here a minimal modification so that it runs as a faceless app, putting NSStatusItem's instead of NSMenuExtra's. Since then, many people contributed pull requests, most of which have been incorporated.
More recently, starting from Catalina, MenuMeters was changed from a preference pane within System Preferences to an independent app. This is due to an increasing amount of security features imposed by Apple on preference panes running within System Preferences, which made it too cumbersome to develop MenuMeters as a preference pane.
Clone the git repo, open MenuMeters.xcodeproj, and build the target MenuMeters. This will create an independent app which runs outside of System Preferences.