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

  1. 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!")
  2. Save it as a .py file in Packages/User folder (it should be the default folder when you select save). I chose testPlugin.py
  3. 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

Bootloader Android

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

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)

  1. Reboot into the bootloader
    adb reboot bootloader
  2. Unlock the bootloader
    fastboot oem unlock

Bootloader unlockBootloader unlock icon

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

Custom Recovery TWRP

  1. Install a custom recovery
  2. Install it on your device
  3. Download your custom ROM
  4. Reboot your device into recovery
    adb reboot recovery
  5. 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
  6. 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

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

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

  1. Untracked: Will not be saved / commited into the repo (“git add filename” to stage”)
  2. Staged: To be saved into the repo (“git commit” to save into repo and make it unmodified)
  3. Unmodified: Previously committed. Currently has no changes
  4. 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

  1. 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
  2. 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
  3. Create a folder to store your database
    cd mongodb-osx-x86_64-2.4.8
    mkdir db
  4. 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

  1. 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
  2. List / show databases
    show dbs
  3. Select a database (no need to created a database)
    > use unicorn
    switched to db unicorn
    > db
    unicorn
  4. Show collections (tables)
    show collections
  5. 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']})
  6. 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'}]})
  7. 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
  8. 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 }
    )
  9. 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)
  10. Drop collection
    db.unicorns.drop()

Other Considerations

  1. 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

Considering Android Development: A bit of basics and then some

Considering Android Development Slidedeck

This was the talk I gave at GDG Brunei DevFest 2013 and I aimed for the content to be basic and accessible with a workable app, so that the attendees could use it as a starting off point for the hackathon, should they want to learn how to build an Android app.

I should have published the APK on the Play Store before the talk so that people could have downloaded the app and see what I was building as part of the talk

Source code: https://github.com/CornerGeeks/GDGBruneiDevFest2013/

Melbourne Fringe Festival – Unofficial Offline Guide

Melbourne Fringe Festival Unofficial Offline Guide
http://thewheatfield.org/mff/

A couple of weeks back it was time for the Melbourne Fringe Festival again and I was keen to see some shows and there was a heck of a lot of events to go to that it was pretty overwhelming to search through and I had issues with actually looking for events. Thought it would be a good time to learn some Python and use Zurb Foundation.

Source Code available at https://github.com/thewheat/melbourne-fringe-festival

Image

Problems I faced when using the Melbourne Fringe Festival website

  • A lot of data 300+ events and with max items per page, there was still 9 pages
  • Searching relied too much of going to the event detail page, and having over 300 events, this would be very time consuming
  • Had to go to event detail page to view:
    • description of event (had to view page in order to find what the event is about: title and subtitle was not enough information)
    • dates
    • prices
    • venue
  • Couldn’t search by budget

Features of the Unofficial Offline Guide

  • Viewing all events on 1 page
  • Show all necessary info on list page (event description, dates, prices, venue)
  • Search by date, category, venue, cost
  • Offline access
  • Should work with lower end phones (pauses between searches)Image

 

SMARTER eVCS Android app source

It is now available at: https://github.com/thewheat/SMARTER-eVCS-Android

The Android app is currently meant to be used in conjunction with the SMARTER eVCS webapp but hopefully I’ll get time to upgrade both the Android app the make it a standalone app.

Also once again, anybody interested in helping in this community development project, do get in contact or just get the code, make some changes and submit pull requests.