Sublime Text Plugin Quickstart

Based on the fact that the Sublime Text plugin example page is outdated below is a quick guide to create a Sublime Text Plugin for Sublime Text 2

Go to Tools > New Plugin to auto generate a template for a plug-in

import sublime, sublime_plugin

class ExampleCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        self.view.insert(edit, 0, "Hello, World!")

Save it as a .py file in Packages/User folder (it should be the default folder when you select save). I chose testPlugin.py
You can run in from the Sublime Text console (Ctrl + ~ in Windows) using the following command. (if it doesn’t work try, try saving the file again with the console open to see any errors and also try closing and reopening Sublime Text)
```
view.run_command("example")
```

Running Camel Case Commands

Use underscores

class ExampleTextCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        self.view.insert(edit, 0, "Hello, World!")

 view.run_command("example_text")

sublime.Edit & sublime_plugin.EventListener

If an edit object is needed (seems to be needed for writing things on the page), use view.begin_edit() but don’t forget to end_edit()

They can be created by view.begin_edit(). Every call to view.begin_edit() must have a corresponding call to view.end_edit(), typically wrapped in a try … finally block.

Sublime Text 2 API reference

The EventListener class let’s you trigger things on an event happening and the code below shows inserting text to a document when it is opened. (Disclaimer: I’m not fluent in Python so I’m not sure if the below is fully correct but it does seem to work)

import sublime, sublime_plugin
class OnOpenCommand( sublime_plugin.EventListener):
   def on_load(self, view):
       try :
           edit = view.begin_edit()
           view.insert(edit, 0, "on load")
       finally :
           view.end_edit(edit)

Quickstart to Android Flashing Custom ROMs

I know I was a bit confused when initially rooting and installing custom ROMs on my Android device and while I don’t consider myself an expert there are a few terms that could use a quick definition to know your way around custom ROM installations.

Device Modes/States

When you start your device you can boot into 1 of 3 modes

Bootloader: a mode that can boot into Recovery or start the regular boot process (into Android) and also shows some details of your device. ROMs can be flashed in the bootloader but it is not the typical case
Recovery: a mode to flash ROMs (stock / custom)
Regular system boot: boots into the operating system while would typically be Android

Communication Tools

These tools can be used to communicate and even transfer files with your device

adb: when in recovery mode / standard Android
fastboot : when in bootloader

Unlocking the Bootloader

Boot loaders can be locked which prevents custom ROMS from being flashed. Unlocking the bootloader can be done with the following commands (this was done on a Nexus 7 2013, other devices may need other commands)

Reboot into the bootloader
```
adb reboot bootloader
```
Unlock the bootloader
```
fastboot oem unlock
```

Once the bootloader is unlocked you can install a custom ROM. While I believe it is possible to install custom ROMs without a custom recovery program, the typical way to install a ROM is with one. I’ve used ClockWorkMod Recovery and Team Win Recovery Project (TWRP) but there are others other there. Just make sure you install the right one for your device.

Flashing a Custom ROM

Install a custom recovery
Install it on your device
Download your custom ROM
Reboot your device into recovery
```
adb reboot recovery
```
Follow the on screen instructions to install the ROM
1. Typically you have to wipe your device (dalvik cache, system and personal data)
2. Install the custom ROM from a zip file
Reboot into your new ROM

Custom ROMS

Custom builds/implementation of Android with some famous ones such as CyanogenMod and ParanoidAndroid (currently I’m using OmniROM)
Stock ROMs are the original ROM that came with the device
Custom ROMs typically will not have the Google services and usually need to be manually installed. Typically packaged / called gapps
Some problem with custom ROMs is usually hardware support: some things may not work as well as they do on stock ROMs. Thus custom ROMs that are based on stock ROMs will probably have better hardware support compared to generic custom ROMs

Rooting

Rooting gives you more control on your device and lets you run apps that have special abilities. Some features that I use are
- A complete Linux installation on your Android device: Complete Linux Installer / LinuxOnAndoird.org
- Screen recordings on the device with mic audio: SCR Screen Recorder
Rooting can be done on a device with a stock ROM or can be automatically bundled with a custom ROM
Applications that use root privileges have to request for these functions to be run and these can be managed using superuser apps such as Superuser from ChainsDD / Superuser from ClockworkMod / SuperSU from Chainfire

Other Terms

“Unlocked”: this can mean several things
- Unlocked from a carrier: it can us SIM cards from any carrier
- Unlocked bootloader: it can load custom ROMs

Things I’m still unsure of

If the bootloader needs to be unlocked in order to flash a custom recovery
“Secure boot”: shown on the boot loader but doesn’t affect flashing a custom ROM

Links

Everything You Need to Know About Rooting Your Android Phone

Quickstart: Git

Introduction

A distributed revision control system
Doesn’t require a central server to work
Download at: http://git-scm.com/
Command line tutorial below, execute code blocks in sequence
Lines starting with # are command line outputs or notes
Available on GitHub CornerGeeks/test-git

Configuration

git config --global user.name "John Doe"
git config --global user.email johndoe@example.com
git config --list

# user.name=John Doe
# user.email=johndoe@example.com
# -- other config

git config user.name

# John Doe

user.name and user.email is what is recorded in commit logs

Initialise

Go to a folder in command line and initialise it as a git repository

git init

# # Initialized empty Git repository in /Users/user/test_git/.git/

See current status and branch

git status

# # On branch master
# #
# # Initial commit
# #
# nothing to commit (create/copy files and use "git add" to track)

Will show current branch and status of files in the folder

Save (Commit) files into the Repo

Create a file & add it to the staging area
```
touch README
git add README
```

See current status

git status

# # On branch master
# #
# # Initial commit
# #
# # Changes to be committed:
# #   (use "git rm --cached <file>..." to unstage)
# #
# #    new file:   a
# #

Commit the file

git commit -m "Added README (C1)"

# [master (root-commit) 93ecaa8] Added README (C1)
#  1 file changed, 0 insertions(+), 0 deletions(-)
#  create mode 100644 README

Can also commit with “git commit” then type in the editor and save

Status of Files

Untracked: Will not be saved / commited into the repo (“git add filename” to stage”)
Staged: To be saved into the repo (“git commit” to save into repo and make it unmodified)
Unmodified: Previously committed. Currently has no changes
Modified: Previously committed. Content has changed. Stage file (“git add filename”) in order to commit new version to repo

Cannot commit empty folders into git

Staging Files

A file needs to be staged before it can be committed

A staged file will stage the file at that point in time

git status

  # # On branch master
  # nothing to commit, working directory clean 

echo "line 1" >> README
git status      

  # # On branch master
  # # Changes not staged for commit:
  # #   (use "git add <file>..." to update what will be committed)
  # #   (use "git checkout -- <file>..." to discard changes in working directory)
  # #
  # #    modified:   README
  # #
  # no changes added to commit (use "git add" and/or "git commit -a")

git add README
echo "line 2" >> README
git commit -m "commits only line 1 (C2)"

   # [master 58001d6] commits only line 1 (C2)
   #  1 file changed, 1 insertion(+)      

git status

  # # On branch master
  # # Changes not staged for commit:
  # #   (use "git add <file>..." to update what will be committed)
  # #   (use "git checkout -- <file>..." to discard changes in working directory)
  # #
  # #    modified:   README
  # #
  # no changes added to commit (use "git add" and/or "git commit -a")      

git commit -am "auto stage tracked files and commit (C3)"

   # [master cbf5a24] auto stage tracked files and commit (C3)
   #  1 file changed, 1 insertion(+)

Viewing previous commit logs

git log
git log -2
git log --pretty=oneline
git log --pretty="format:%h: %s (%an)"

See previous commit states

-Checkout the state of the repo at any commit

# git checkout previousCommitHashShownInGitLog

git log --pretty=oneline

  # cbf5a24f41bb8a2f70527f5a96cea4fca411910b auto stage tracked files and commit (C3)
  # 58001d6d9c474a6e5b102cf53a1948b0f5fd213d commits only line 1 (C2)
  # 93ecaa8c1238b872827781f6136401e4b9e3849b Added README (C1)

cat README

  # line 1
  # line 2

git checkout 25555caa7589363b20b3e1b34bd7ba979c13ff57
cat README

  # line 1

git checkout master
cat README

  # line 1
  # line 2

Think of commits as chain of events linked to the previous commit
```
C1 - C2 - C3 <-- master <-- head
```
master is the default branch and points to the last commit in the branch
HEAD points to you current location in the commit chain (changes when you checkout)
Checking out will move the head pointer and shows the state of the files at the point in time
“git checkout master” will point the HEAD back to master which is the latest commit
Note: All version of files are stored locally so you can git checkout without any network

Ignoring Files

Specify in .gitignore folder

touch ignore_this_file
git status
  # # On branch master
  # # Untracked files:
  # #   (use "git add <file>..." to include in what will be committed)
  # #
  # #    ignore_this_file
  # nothing added to commit but untracked files present (use "git add" to track)

echo "ignore_this_file" >> .gitignore
git status
  # # On branch master
  # # Untracked files:
  # #   (use "git add <file>..." to include in what will be committed)
  # #
  # #    .gitignore

Branches

When working on a new feature, create a feature branch, work on it and then merge it into the master branch

View Branches

git branch
    # * master

    # C1 - C2 - C3 <-- master <-- head

Create New Branch

git branch new_feature
    # C1 - C2 - C3 <-- master <-- head
    #           ^
    #           '---- new_feature

git branch
    # * master
    #   new_feature

Switch to new branch

git checkout new_feature
    # Switched to branch 'new_feature'

    # C1 - C2 - C3 <-- master
    #           ^
    #           '---- new_feature <-- head

git branch
    #   master
    # * new_feature

echo "new feature" >> README

git commit -am "new feature added (C4)"          

   # C1 - C2 - C3 <-- master
   #           |
   #           '---- C4 <-- new_feature <-- head

Merging Branches

Merge changes from new_feature into master

git checkout master

  # C1 - C2 - C3 <-- master <-- head
  #           |
  #           '- C4 <-- new_feature

git merge new_feature master
  # Updating e7578b4..13107de
  # Fast-forward
  #  README | 1 +
  #  1 file changed, 1 insertion(+)

  # C1 - C2 - C3 
  #           |
  #           '- C4 <-- new_feature 
  #               ^
  #               '---- master <-- head

As master has not been changed, the master pointer just “fast forwards”

Delete Branch after use

git branch -d new_feature

    # C1 - C2 - C3
    #           |
    #           '- C4
    #               ^
    #               '---- master <-- head

Merge Conflicts

Happens when conflicting changes happen between merges
```
  C1 - C2 - C3 - C4 <-- master
```

Create new branch and switch to it (shortcut)

git checkout -b merge_conflict

echo "merge_conflict_branch" > README
git commit -am "one line README in merge_conflict (C5)"

  # C1 - C2 - C3 - C4 <-- master
  #                |
  #                C5 <-- merge_conflict  <-- head

git checkout master
echo "master add new line" >> README
git commit -am "yet another line (C6)"

  # C1 - C2 - C3 - C4 - C6 <-- master  <-- head
  #                |
  #                C5 <-- merge_conflict

git merge merge_conflict master

  # Auto-merging README
  # CONFLICT (content): Merge conflict in README
  # Automatic merge failed; fix conflicts and then commit the result.

Will now need to edit the README file manually to resolve conflicts

 cat README

   # <<<<<<< HEAD
   #  line 1
   #  line 2
   #  new feature
   #  master add new line
   #  =======
   #  merge_conflict_branch
   #  >>>>>>> merge_conflict

New file shows the changes between the branches.
Delete and clean the <<<<<<, =======, >>>>>> and text in between.
- “<<<<<<<” : start of your current branch’s file
- “=======” : end of your current branch’s file & start of the difference from other (merged) branch changes
- “>>>>>>>” : end of other branch changesgit commit -am “merged merge_conflict with master (C7)”
```
 # C1 - C2 - C3 - C4 - C6 -C7 <-- master  <-- head
 #                |
 #                C5 <-- merge_conflict
```

Show changes

Changes that haven’t been staged

echo "diff me" >> README
git diff

  # diff --git a/README b/README
  # index 4b7c1e3..f6a1b72 100644
  # --- a/README
  # +++ b/README
  # @@ -4,3 +4,4 @@ new feature
  #  master add new line
  #  merge_conflict_branch
  # +diff me

Changes that have been staged

echo "diff me again" >> README    
git diff --cached    
  #
git add README
git diff --cached
  # diff --git a/README b/README
  # index 4b7c1e3..fbe856c 100644
  # --- a/README
  # +++ b/README
  # @@ -4,3 +4,5 @@ new feature
  #  master add new line
  #  merge_conflict_branch
  # +diff me
  # +diff me again

Unstage a file

echo "to be unstaged" >> README
git add README
git status

  # On branch master
  # Changes to be committed:
  #   (use "git reset HEAD <file>..." to unstage)
  #
  #    modified:   README
  #    

git reset HEAD README

  # Unstaged changes after reset:
  # M    README    

git status

  # # On branch master
  # # Changes not staged for commit:
  # #   (use "git add <file>..." to update what will be committed)
  # #   (use "git checkout -- <file>..." to discard changes in working directory)
  # #
  # #    modified:   README
  # #
  # no changes added to commit (use "git add" and/or "git commit -a")

Restore file to previous version

echo "these changes will be reset" >> README
git status

  # # On branch master
  # # Changes not staged for commit:
  # #   (use "git add <file>..." to update what will be committed)
  # #   (use "git checkout -- <file>..." to discard changes in working directory)
  # #
  # #    modified:   README
  # #
  # no changes added to commit (use "git add" and/or "git commit -a")

git checkout -- README
git status

  # # On branch master
  # nothing to commit, working directory clean

Reset all tracked files to previous commit

git reset --hard

Deletes all changes since last commit
Only affects tracked files
Untracked files do not get deleted

Working with remotes

(e.g. GitHub, your own server, etc)

Push Changes to Remote

Add a remote to you bare repo

“git push repo_name branch_to_push”

git remote -v
  # 
git init ../git.git --bare
git remote add my_repo ../git.git 
git remote -v

  # my_repo  ../git.git (fetch)
  # my_repo  ../git.git (push)

git push my_repo master

  # Counting objects: 24, done.
  # Delta compression using up to 2 threads.
  # Compressing objects: 100% (14/14), done.
  # Writing objects: 100% (24/24), 2.07 KiB | 0 bytes/s, done.
  # Total 24 (delta 1), reused 0 (delta 0)
  # To ../git.git
  #  * [new branch]      master -> master

Clone from a remote repo

  git clone ../git.git ../git_clone
  cd ../git_clone
  git remote -v
     # origin    /Users/user/test_git/../git.git (fetch)
     # origin    /Users/user/test_git/../git.git (push)

“origin” is the default name of your git repo that you have access to

Download changes from a Remote URL

  # git fetch remote_name
  git fetch origin

Does not merge into your existing code, just downloads all changes locally so can merge / checkout

Merge Changes from Remote Branch

  git fetch origin
  git merge origin/master master
    #  **fix any conficts if needed and commit**
    # can also do "git pull origin"

Workflow for pushing to a Repo

Clone from Repo
```
git clone url_to_git_repo
```

Go into directory and make changes

cd url_to_git_repo
echo "cloned" >> README

Commit your changes
```
git commit -am "my changes"
```
Fetch and merge from origin
```
git pull origin
```

Fix conflicts (if any)

git commit -am "merged origin to masteR"

Push to origin
```
git push origin master
```

GitHub Pull Requests

Fork a project
Clone locally
Add remote to project you forked from (typically called “upstream”)
```
git remote add upstream git.repo
```
Make your changes

Make your commit

git pull upstream/master master
*resolve conflicts*
git commit

Use web interface to create pull request
Go to your fork
Sidebar > Pull Request

Note: Markdown was a pain. It rendered the HTML but a mix of tabs and spaces and even manual spacing caused inconsistent behaviour.

MongoDB – Quick Start Installation and Usage

2 weeks back I attended yet another RHoK Melbourne event and ended up working on a project with NodeJS & MongoDB: both unfamiliar territories for me and thought it would be a good opportunity to create a quick start guide: here is the MongoDB one

Installing and Running the Server

Get the binaries on the download page (http://www.mongodb.org/downloads) and get the necessary download for your platform (Windows/Linux/OS X/Solaris). Following commands will be based on OSX but similar actions can be one on other platforms
In a terminal, navigate to where you downloaded the package and extract it
```
cd ~/Downloads
tar -zxf mongodb-osx-x86_64-2.4.8.tgz
```
Create a folder to store your database
```
cd mongodb-osx-x86_64-2.4.8
mkdir db
```
Start the server specifying the folder created
```
bin/mongod --dbpath=db
```

Terminology coming from the typical relational database world

Relational Database	MongoDB
Database / Schema	Database
Table	Collections
Row	Record
Field / Column	Field

Quick start of the MongoDB Shell

Connect to the server
Navigate to the folder where the files are extratcted, run the mongo Javascript shell (which has tab completion)
```
cd ~/Downloads/mongodb-osx-x86_64-2.4.8
bin/mongo
```
List / show databases
```
show dbs
```

Select a database (no need to created a database)

> use unicorn
switched to db unicorn
> db
unicorn

Show collections (tables)
```
show collections
```

Inserting a record (row in a table)Collections do not need to be initialised, they are auto generated.
Below shows the output of the Mongo shell. system.indexes contains indexes for collections

> show collections
> db.unicorns.insert({name: 'Aurora', 
   gender: 'f', weight: 450})
> show collections
system.indexes
unicorns

Mismatched fields

db.unicorns.insert({name: 'Aurora', gender: 'f', weight: 450})
db.unicorns.insert({name: 'Leto', gender: 'm', 
    home: 'Arrakeen', worm: false})

Arrays

db.unicorns.insert({
    name: 'Solnara', 
    loves:['apple', 'carrot', 'chocolate']})

Listing / Querying records

> db.unicorns.find()
{ "_id" : ObjectId("52b65132eb122da0e6dd19a9"), "name" : "Aurora", "gender" : "f", "weight" : 450 }
{ "_id" : ObjectId("52b6519127026146f128de90"), "name" : "Leto", "gender" : "m", "home" : "Arrakeen", "worm" : false }

Items have _id auto generated. No need to set an auto increment field.

Filtering and field selection

db.collection.find(
   {andedFilters}, 
   {fieldWith1AsShow0asHide}
)

Search by name and show only name and worm fields

> db.unicorns.find({name: 'Aurora'}, {name: 1, worm:1, _id: 0})
{ "name" : "Aurora" }
> db.unicorns.find({
    $or: [{name: 'Aurora'}, {'name': 'Leto'}]}, 
   {name: 1, worm:1, _id: 0}
)
{ "name" : "Leto", "worm" : false }
{ "name" : "Aurora" }

Paging and Limiting results

db.unicorns.find().skip(1).limit(2)

Record Counting

db.unicorns.count()
db.unicorns.find({'name' : 'Aurora'}).count()

Distinct

db.unicorns.distinct('name')
db.unicorns.distinct('name', 
   {$or: [{'name' : 'Leto'}, {'name':'Aurora'}]})

Query Selectors
1. Comparison:
  1. $gt / $lt ($gte / $lte): Greater/Less than (or equal).
  2. $ne, $in / $nin: Not equal. In / Non in
2. Logical: $or, $and, $not, $nor

Updating:
Update first matching record

db.unicorns.update(
  { name: 'Aurora' }, 
  { $set : { weight: 10 } } 
)

Update all matching records

db.unicorns.update(
  { name: 'Aurora' }, 
  { $set : { weight: 10 } },
  { multi: true }
)

Update matching record but insert if doesn’t exist

db.unicorns.update(
  { name: 'Roooooodles' }, 
  { $set : { weight: 10 } } ,
  { upsert: true }
)

Deleting:
Deleting all records:

db.unicorns.remove()

Delete all matching records

db.unicorns.remove({name: 'Aurora'})

Delete only first matching record

db.unicorns.remove({name: 'Aurora'}, true)

Drop collection
```
db.unicorns.drop()
```

Other Considerations

No joins. But has embedded documents

> db.unicorns.insert({name: 'Aurora', gender: 'f', weight: 1450, owner: {'name': ['You', 'Me']}})
> db.unicorns.find({'owner.name': 'Me'}, {'name': 1, 'owner.name': 1, _id: 0})
{ "name" : "Aurora", "owner" : { "name" : [ "You", "Me" ] } }

Further References

The Little MongoDB book (got a copy at the MongoDB User Group and it’s a nice short intro. Physically – 34 pages in a A5 format)
Mongo DB Manual
GUI-style administrative interface

Running Camel Case Commands

sublime.Edit & sublime_plugin.EventListener

Share this:

Like this:

Device Modes/States

Communication Tools

Unlocking the Bootloader

Flashing a Custom ROM

Custom ROMS

Rooting

Things I’m still unsure of

Share this:

Like this:

Introduction

Configuration

Initialise

See current status and branch

Save (Commit) files into the Repo

Status of Files

Staging Files

Viewing previous commit logs

See previous commit states

Ignoring Files

Branches

View Branches

Create New Branch

Switch to new branch

Merging Branches

Delete Branch after use

Merge Conflicts

Show changes

Unstage a file

Restore file to previous version

Reset all tracked files to previous commit

Working with remotes

Push Changes to Remote

Clone from a remote repo

Download changes from a Remote URL

Merge Changes from Remote Branch

Workflow for pushing to a Repo

GitHub Pull Requests

Share this:

Like this:

Installing and Running the Server

Terminology coming from the typical relational database world

Quick start of the MongoDB Shell

Other Considerations

Share this:

Like this: