PHP

1

php -S localhost:[port] -t [root-path]

Example

1

php -S localhost:8080 -t ./_build

Python

Python 2.x

1

python -m SimpleHTTPServer [port]

Example

1

python -m SimpleHTTPServer 8080

Python 3.x

1

python -m http.server [port]

Example

1

python -m http.server 8080

Ruby

1

ruby -run -e httpd . -p [port]

Example

1

ruby -run -e httpd . -p 8080

Documentation

PHP

Python 2

Python 3

Ruby Webrick

Sources

Thanks to Adriano Guerrero for the PHP command and to Dallas Reedy for the Ruby command.

Usage

1

awk '/TODO/ {print NR "\t" ($1=$2="") $0}' <source filepath>

Example

Source

1
2
3
4
5
6
7
8
9
10
11

#!/usr/bin/env python
# encoding: utf-8
# file: pydoc.py

## TODO this needs a lot of this and that
class PythonThreeDocCommand(sublime_plugin.TextCommand):

...

## TODO wow, did I really release it like this?
class PythonTwoDocCommand(sublime_plugin.TextCommand):

Command Line

1
2
3

$ awk '/TODO/ {print NR "\t" ($1=$2="") $0}' pydoc.py
10    this needs a lot of this and that
39    wow, did I really release it like this?

Use an all-caps TODO comment in your source (like I did above) or modify the regular expression /TODO/ in the awk script to whatever format you use. Limit the comment to a single line or add TODO at the beginning of additional lines in your comment block.

Usage

1

git log --oneline --decorate=short | awk '/tag/ {print substr($3,0,(length($3)-1)) "\t" $1 "\t" ($1=$2=$3="") $0}'

Example

1
2
3
4
5
6

$ git log --oneline --decorate=short | awk '/tag/ {print substr($3,0,(length($3)-1)) "\t" $1 "\t" ($1=$2=$3="") $0}'
v1.3.3       6d2a491       Refactored text handling
v1.3.2       7e35d5b       Merge branch 'development'
v1.3.1       307b457       Updated Python 2 vs 3 interpreter check
v1.3.0       61f43bf       Added support for Python 3.x
[...]

Here’s how you get started with it.

Install Glue in Your Sublime Text Editor

Glue works in Sublime Text versions 2 and 3 and these install instructions apply for either version.

Install with Package Control

If you are using Will Bond’s Package Control, the install is simple. Open the Command Palette in your Sublime Text editor with the menus Tools > Command Palette and then type install in the text entry field. Select the option Package Control - Install Package. Next, type ‘glue’ in the text input box and select the ‘Glue’ plugin option that is displayed in the Command Palette. The install automatically takes place. You will see a confirmation in the status bar at the bottom of the editor window.

Install with Git

Open your Packages directory with the Sublime Text menu items Preferences > Browse Packages. Then git clone the Glue repository as a new directory named ‘Glue’ in your Packages directory with the following command:

1

$ git clone https://github.com/chrissimpkins/glue.git "Glue"

Install Manually

If you like to do things the good ole’ fashion way, download the source repository from GitHub (tar.gz | zip). Decompress the archive and rename it “Glue”.

Then, open your Sublime Text Packages directory using the Preferences > Browse Packages menu items and move the entire Glue directory into your Packages directory.

Confirm Your Install

Glue should automatically load in your editor after you install with any of the above approaches. You can confirm that it is installed by opening a project, right clicking in the sidebar and selecting the menu item Open Glue Terminal.

Confirm Your PATH

The next step is to confirm that your PATH is properly set in Glue. Glue assigns a default user PATH from your environment PATH variable. In general the PATH is correct, but on some installs it may require a bit of assistance.

First, check the PATH that Glue is using by entering the following command on the Glue command line:

1

$ glue path

This will display a colon-delimited PATH string for Unix/Linux users and a semicolon delimited PATH string for Windows users. If the PATH doesn’t match your existing system PATH, you can set a new Glue PATH string. This does not modify your existing system PATH.

To do this, open the Glue user settings JSON file by navigating to Preferences > Package Settings > Glue > Glue Settings - User. If you have not already entered settings in this file, it will appear as an empty buffer in Sublime Text. Create a JSON file with the following syntax:

1
2
3

{
      "glue_userpath": "your path string here"
}

Unix (including Mac OSX) and Linux users should enter a colon delimited string. Windows users should include semicolons as delimiters.

Here is an example for Unix/Linux users:

1
2
3

{
      "glue_userpath" : "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
}

and for Windows users:

1
2
3

{
      "glue_userpath": "C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem"
}

Windows users should escape their backward slashes as shown above.

Use Glue

Glue works with many of your favorite system utilities and allows you to extend what you can do inside the Sublime Text editor window. Here are a few examples:

Glue + grep

1

$ grep "def" *.py

Glue + git

1
2
3

$ git init
$ git add .
$ git commit -m "'initial commit'"

Glue + cURL

1

$ curl -sS https://raw.githubusercontent.com/chrissimpkins/naked/master/lib/Naked/app.py

Glue + Your Own Scripts

1
2
3
4

$ node test.js
$ python test.py
$ ruby test.rb
$ ./test.sh

Glue Commands

Glue includes its own set of built in commands that let you navigate around your directory structure, manipulate the editor (e.g. create new buffers, open files by wildcard), and perform other useful tasks:

Extend Glue

You can extend the built-in Glue commands with aliases that support system utilities, your own compiled executables, shell scripts, and source from any scripting language that is supported on your machine.

These Glue aliases can be called from the command line with the syntax:

1

$ glue <your-command> [optional args]

They are incredibly simple to develop and require absolutely no programming knowledge (but can be hooked into anything that you develop with the capability to process data from the standard input stream).

Here are the steps to create your own extensions:

Create the Glue-Commands Directory

Create a Glue-Commands directory inside your Sublime Text Packages directory. You can open your Sublime Text Packages directory with the menu item Preferences > Browse Packages.

Create a glue.json File

Create a glue.json file inside the Glue-Commands directory.

Define Your Glue Extensions

Commands are defined in the glue.json file with a simple mapping of JSON key:value pairs using the following syntax

1
2
3
4
5

{
        "<command-name-1>": "<system command string 1>",
        "<command-name-2>": "<system command string 2>",
        [...]
}

You have the option to include replacement tags in your system command string that allow you to pass command line arguments, the text in your clipboard, or the current working directory path to the aliased command:

Glue Extension Replacement Tags

JavaScript Minifier Extension Example

Here is an example that will take you through each of these steps to create a command that will minify and obfuscate a JavaScript file, and then save it in the same directory with the new path <filename>-min.js:

If you are following along, you can download YUICompressor from the GitHub repository. You will need to have Java version 1.4+ installed to use it. Unpack the repository and move the yuicompressor-2.4.8.jar file to a directory for safe keeping (you will run it from this directory).

Next, create a shell script named minijs.sh. Include the following script and modify the YUI_PATH variable with the actual path to your YUICompressor jar file:

JavaScript Minifier Shell Script

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/bin/sh

# Modify YUI_PATH with the path to the yuicompressor jar file
YUI_PATH="path/to/yuicompressor-2.4.8.jar"

if [ $# -eq 0 ]; then
  echo "Please include the file path(s) for the file(s) that you would like to compress." 1>&2
  exit 1
fi

for file in "$@";
do
if [ -f "$file" ]; then
      java -jar "$YUI_PATH" -o "${file%%.*}-min.js" "$file"
      if (( $? )); then
          echo "$file was not able to be minified"
          exit 1
      else
          echo "$file was minified to ${file%%.*}-min.js"
      fi
  else
      echo "Unable to find the javascript file '$file'."
fi
done;
exit 0

Next, create a Glue extension that will serve as an alias for the call to this shell script when you use the glue minijs command. We’ll include the {{args}} template tag so that we can pass filepath arguments to our script. Insert the following in your glue.json file that you generated above:

1
2
3

{
  "minijs" : "/path/to/minijs.sh { {args} }"
}

To use your new Sublime Text feature, launch Glue in your editor and minify JS files in the working directory with a command like this:

1

$ glue minijs awesome.js

The minified file is saved as awesome-min.js in the same directory.

You can use the same technique with any compiled application or interpreted script that accepts the standard input stream and returns the data to be displayed for the user in the standard output stream. Glue provides the interface with your shell to take care of the rest.

Learn More

The Glue documentation is available here.

Issue Reporting

If you come across a bug in the plugin, please report it on the GitHub repository.

Install PyDOC

Using Sublime Package Control

PyDOC can be installed using Sublime Package Control. Open the command palette with:

Mac OSX

1

Cmd + Shift + P

Linux & Windows

1

Ctrl + Shift + P

Type install and select the menu item, Package Control: Install Package.

Type PyDOC and select the PyDOC package that is displayed. This will install the package in your editor.

Using Git

Use the Sublime Text menu items Preferences -> Browse Packages to locate your Packages directory.

Navigate to the directory in your terminal and clone the PyDOC source repository inside the Packages directory using the command:

1

git clone https://github.com/chrissimpkins/PyDOC.git "PyDOC"

Manual Install

Download the zip compressed archive from GitHub.

Decompress the zip archive and rename the directory PyDOC.

Open your Sublime Text Packages directory using the Preferences -> Browse Packages menu items.

Move the entire PyDOC directory into your Sublime Text Packages directory.

Use PyDOC

Search with Right Click Menu

Select a built-in Python object in your editor text, then use the Python 2 Doc Search or Python 3 Doc Search menu item in the right click menu.

Search with Keybinding

Select a built-in Python object in your editor text, then use one of the following keybindings to perform the search:

Python 2 Documentation Search Keybinding

1

Ctrl-2

Python 3 Documentation Search Keybinding

1

Ctrl-3

Search with the Command Palette

Select a built-in Python object in your editor text then enter the keybinding to open the command palette (see description above in the Sublime Package Control section). Type ‘pydoc’ and then select either Python 2 Doc Search (PyDOC) or Python 3 Doc Search (PyDOC).

Ruby Dependency

Execution of local Ruby script files requires you to have Ruby installed on your system. Refer to the Ruby documentation for details.

The Naked Shell Library

The functions that we will use are available in the Naked Framework shell library. To install Naked with pip, use the following command:

Install Naked with Pip

1

pip install Naked

or download the source from GitHub, decompress the source archive locally, navigate to the top level source directory and run the following command:

Install Naked from Source

1

python setup.py install

Import Naked Shell Library Functions

1

from Naked.toolshed.shell import execute_rb, muterun_rb

Execute a Ruby Script

To execute a Ruby file and allow the Ruby side to control the standard output and standard error streams for the user, use the execute_rb() function. The path to the Ruby file is included as a parameter to the function like this:

Execute the Ruby File

1
2
3

from Naked.toolshed.shell import execute_rb

success = execute_rb('testscript.rb')

The execute_rb() function returns a boolean value for the success (or lack thereof) of the Ruby script. This is based upon the zero (success) or non-zero (failure) exit code returned from the Ruby code to the Python calling code.

You can test for the success of the Ruby script like this:

Test for Success of Ruby Execution

1
2
3
4

if success:
    # handle success of the Ruby code
else:
    # handle failure of the Ruby code

because the success variable is defined with the returned boolean value from the execute_rb() function.

This function executes the Ruby file with the following system command:

1

ruby <Ruby file path> [arguments]

To pass additional arguments to the ruby executable, include them as a second string parameter in the execute_rb() function. See the Naked documentation for additional details.

Execute a Ruby Script and Control the Standard Ouput and Standard Error from the Python Side

To gain control over the standard output and standard error streams returned from the Ruby script, use the muterun_rb() function rather than the execute_rb() function. This function suppresses output of the standard output and error streams from the Ruby script and, instead, returns these streams along with the exit code to the Python script as attributes of a generic object. You can access these strings (actually bytes strings) using standard Python dot syntax.

As with the execute_rb() function, use the Ruby file path as the argument to the function:

Execute the Ruby File

1
2
3
4

import sys
from Naked.toolshed.shell import muterun_rb

response = muterun_rb('testscript.rb')

The object is assigned to the response variable. To confirm that the executed code was successful, you can test the exitcode attribute returned in the object:

Test for Success of the Executed Ruby File

1
2
3
4

if response.exitcode == 0:
    # the command was successful (returned 0 exit code)
else:
    # the command was not successful (returned non-0 exit code)

You can then access the standard output and standard error stream strings (acutally bytes strings) with the stdout and stderr attributes, respectively:

1
2
3
4

if response.exitcode == 0:
  print(response.stdout)
else:
  sys.stderr.write(response.stderr)

Here, we simply push it back out to the standard output or error stream from the Python script. You can manipulate the output however you would like in your Python code before pushing it to the user.

You have the option to pass additional arguments to the ruby system command that this function wraps by including them in a second parameter string to the function. Details are available in the Naked documentation.

Distribute Naked With Your Code

To make the Naked Framework available for other users of the Python script that you developed, include the following line in your setup.py file:

1

install_requires=['Naked'],

This includes Naked as a dependency in your project and automatically installs the Naked Framework on the user’s system when they install your application or library using commands based on distutils, including the commonly used pip install and python setup.py install install commands.

The Naked Shell Library

If you are interested in learning more about the Naked shell library module, you can find the documentation here.

Naked Does Node Too…

Naked includes a method for Node.js scripts as well. Details are available in this post.

Confirm Command Line Tools Install

Atom installs the atom and apm executables as part of the MacOSX install. We will be using the atom executable to open files and directories in Atom. To confirm that atom is installed, call the help documentation with:

1

atom --help

If you don’t see a help message, use the Atom menu item and select Atom > Install Shell Commands. You will receive a confirmation message if this was successful.

Open a File in Atom

To open a file in Atom, enter the path to the file as the argument to the atom executable:

1

atom <filepath>

For a file named ‘test.c’ in the working directory, use the following command:

1

atom test.c

Open the Current Working Directory in Atom

To open your working directory in Atom, use the following command:

1

atom .

Key to the Keys

• ⌘ : Command key
• ⌃ : Control key
• ⌫ : Delete key
• ← : Left arrow key
• → : Right arrow key
• ↑ : Up arrow key
• ↓ : Down arrow key
• ⌥ : Option or Alt key
• ↩ : Return or Enter key
• ⇧ : Shift key

Contents

• The Command Palette
• Configuration
• Application Tasks
• Autocomplete
• Bookmarks
• Brackets
• Code Folding
• Code Navigation & Management
• Character Transformations
• Comments
• Editor View Tasks
• File Tasks
• Find & Replace
• Font Tasks
• Grammar
• Search Tasks

The Command Palette

Configuration

Application Tasks

Autocomplete

Bookmarks

Brackets

Code Folding

Code Navigation & Management

Character Transformations

Comments

Editor View Tasks

File Tasks

Find & Replace

Font Tasks

Grammar

Search Tasks

How it Works

You view the documentation with the following command syntax:

1

tldr <command>

Here is an example of the tldr documentation for the tar executable:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$ tldr tar

 Archiving utility
 Optional compression with gzip / bzip

 - create an archive from files

   tar cf target.tar file1 file2 file3

 - create a gzipped archive

   tar cfz target.tar.gz file1 file2 file3

 - extract an archive in a target folder

   tar xf source.tar -C folder

 - extract a gzipped archive in the current directory

   tar xzf source.tar.gz

Install

tldr requires a local install of Node.js.

tldr is installed with npm:

1

npm install -g tldr

This command may need to be run with superuser privileges on your box.

Contribute

The project already includes many Unix (including Mac OSX specific) and Linux commands. If you’d like to extend the current documentation or add additional pages, you can do so by forking the GitHub repository, creating the documentation in Markdown, and submitting a pull request back to the main repository.

Here is the GitHub Guide documentation on forks and pull requests for those who are unfamiliar (it’s simple).

Source

tldr was spotted on The Changelog.

Open the Current Working Directory in the OSX Finder

The open command is your ticket:

1

open .

Enter open with a period symbol (i.e. the current directory) and the finder will open in your current working directory.

open is an extremely flexible and useful executable. Here is the manual page for OSX version 10.9 from the Mac Developer Library:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

OPEN(1)                   BSD General Commands Manual                  OPEN(1)

NAME
     open -- open files and directories

SYNOPSIS
     open [-e] [-t] [-f] [-F] [-W] [-R] [-n] [-g] [-h] [-b bundle_identifier] [-a application] file ...
          [--args arg1 ...]

DESCRIPTION
     The open command opens a file (or a directory or URL), just as if you had double-clicked the file's
     icon. If no application name is specified, the default application as determined via LaunchServices is
     used to open the specified files.

     If the file is in the form of a URL, the file will be opened as a URL.

     You can specify one or more file names (or pathnames), which are interpreted relative to the shell or
     Terminal window's current working directory. For example, the following command would open all Word
     files in the current working directory:

     open *.doc

     Opened applications inherit environment variables just as if you had launched the application directly
     through its full path.  This behavior was also present in Tiger.

     The options are as follows:

     -a application
         Specifies the application to use for opening the file

     -b bundle_indentifier
         Specifies the bundle identifier for the application to use when opening the file

     -e  Causes the file to be opened with /Applications/TextEdit

     -t  Causes the file to be opened with the default text editor, as determined via LaunchServices

     -f  Reads input from standard input and opens the results in the default text editor.  End input by
         sending EOF character (type Control-D).  Also useful for piping output to open and having it open
         in the default text editor.

     -F  Opens the application "fresh," that is, without restoring windows. Saved persistent state is lost,
         except for Untitled documents.

     -W  Causes open to wait until the applications it opens (or that were already open) have exited.  Use
         with the -n flag to allow open to function as an appropriate app for the $EDITOR environment vari-able. variable.
         able.

     -R  Reveals the file(s) in the Finder instead of opening them.

     -n  Open a new instance of the application(s) even if one is already running.

     -g  Do not bring the application to the foreground.

     -h  Searches header locations for a header whose name matches the given string and then opens it.  Pass
         a full header name (such as NSView.h) for increased performance.

     --args
         All remaining arguments are passed to the opened application in the argv parameter to main().
         These arguments are not opened or interpreted by the open tool.

EXAMPLES
     "open '/Volumes/Macintosh HD/foo.txt'" opens the document in the default application for its type (as
     determined by LaunchServices).

     "open '/Volumes/Macintosh HD/Applications/'" opens that directory in the Finder.

     "open -a /Applications/TextEdit.app '/Volumes/Macintosh HD/foo.txt'" opens the document in the applica-tion application
     tion specified (in this case, TextEdit).

     "open -b com.apple.TextEdit '/Volumes/Macintosh HD/foo.txt'" opens the document in the application
     specified (in this case, TextEdit).

     "open -e '/Volumes/Macintosh HD/foo.txt'" opens the document in TextEdit.

     "ls | open -f" writes the output of the 'ls' command to a file in /tmp and opens the file in the
     default text editor (as determined by LaunchServices).

     "open http://www.apple.com/" opens the URL in the default browser.

     "open 'file://localhost/Volumes/Macintosh HD/foo.txt'" opens the document in the default application
     for its type (as determined by LaunchServices).

     "open 'file://localhost/Volumes/Macintosh HD/Applications/'" opens that directory in the Finder.

     "open -h NSView" lists headers whose names contain NSView and allows you to choose which ones to open.

     "open -a Xcode -h NSString.h" quickly opens /System/Library/Frameworks/Foundation.framework/Head-ers/NSString.h /System/Library/Frameworks/Foundation.framework/Headers/NSString.h
     ers/NSString.h in Xcode.

HISTORY
     First appeared in NextStep.

Node Dependency

Execution of these local JavaScript files is dependent on a local Node.js install on the system where the Python code is executed. See the Node documentation for install details.

The Naked Shell Library

The functions that we will use are available in the Naked Framework shell library. To install Naked with pip, use the following command:

Install Naked with Pip

1

pip install Naked

or download the source from GitHub, decompress the source archive locally, navigate to the top level source directory and run the following command:

Install Naked from Source

1

python setup.py install

The Naked shell library is part of the larger Naked toolshed library in the framework. You can import the functions that we will use in these examples with the following Python import statement:

Import Naked Shell Library Functions

1

from Naked.toolshed.shell import execute_js, muterun_js

Execute a Node.js Script

To execute a JavaScript file and allow the JavaScript side to control the standard output and standard error streams for the user, use the execute_js() function. The path to the JavaScript file is included as a parameter to the function like this:

Execute the JS File

1
2
3

from Naked.toolshed.shell import execute_js

success = execute_js('testscript.js')

The execute_js() function returns a boolean value for the success (or lack thereof) of the JavaScript. This is based upon the zero (success) or non-zero (failure) exit code returned from the JavaScript to the Python code.

You can test for the success of the JavaScript like this:

Test for Success of JS Execution

1
2
3
4

if success:
    # handle success of the JavaScript
else:
    # handle failure of the JavaScript

because the success variable is defined with the returned boolean value from the execute_js() function.

This function executes the JavaScript file with the following system command:

1

node <JS file path> [arguments]

To pass additional arguments to the node executable, include them as a second string parameter in the execute_js() function. See the Naked documentation for additional details.

Execute a Node.js Script and Control the Standard Output and Standard Error from the Python Side

To gain control over the standard output and standard error streams returned from the JS script, use the muterun_js() function rather than the execute_js() function. This function suppresses output of the standard output and error streams from the JavaScript and, instead, returns these streams along with the exit code to the Python script as attributes of a generic object. You can access these strings (actually bytes strings) using standard Python dot syntax.

As with the execute_js() function, use the JavaScript file path as the argument to the function:

Execute the JS File

1
2
3
4

import sys
from Naked.toolshed.shell import muterun_js

response = muterun_js('testscript.js')

The object is assigned to the response variable. To confirm that the executed code was successful, you can test the exitcode attribute returned in the object:

Test for Success of the Executed JS File

1
2
3
4

if response.exitcode == 0:
    # the command was successful (returned 0 exit code)
else:
    # the command was not successful (returned non-0 exit code)

You can then access the standard output and standard error stream strings (acutally bytes strings) with the stdout and stderr attributes, respectively:

1
2
3
4

if response.exitcode == 0:
  print(response.stdout)
else:
  sys.stderr.write(response.stderr)

Here, we simply push it back out to the standard output or error stream from the Python script. You can manipulate the output however you would like in your Python code before pushing it to the user.

You have the option to pass additional arguments to the node system command that this function wraps by including them in a second parameter string to the function. Details are available in the Naked documentation.

Distribute Naked With Your Code

To make the Naked Framework available for other users of the Python script that you developed, include the following line in your setup.py file:

1

install_requires=['Naked'],

This includes Naked as a dependency in your project and automatically installs the Naked Framework on the user’s system when they install your application or library using commands based on distutils, including the commonly used pip install and python setup.py install install commands.

The Naked Shell Library

If you are interested in learning more about the Naked shell library module, you can find the documentation here.

Naked Does Ruby Too

Naked includes a method for Ruby scripts as well. Details are available in this post.

Install Naked

The Naked framework is distributed as a command line executable and a library of Python source files. You can install it with pip using the command:

1

pip install Naked

or download the source, unpack it, and navigate to the top level directory. Then run:

1

python setup.py install

The Naked Executable

The naked executable is run with the naked command. There are a number of useful secondary commands that you can view with naked --help. We will focus on

1

$ naked make

Naked Make

The make command builds the directory tree and project files for a new Python project and can be configured with a simple YAML settings file.

The file and directory structure for command line parsing logic, command development, testing, profiling/benchmarking, licensing, application documentation, and deployment are included in the new project. Help, version, and usage command handling is automatically implemented for you. This eliminates many of the setup tasks for a new project and should allow you to start coding pronto.

How to Create a Python Project from a YAML File

The syntax of the Naked YAML settings file is:

1
2
3

application: <application name>
developer: <developer or organization name>
license: <license name>

Here’s an example of my naked.yaml file from status :

1
2
3

application: status
developer: Christopher Simpkins
license: MIT license

Save this file as naked.yaml in the directory where you would like to create your project directories. Then navigate into the directory to make it your working directory and run:

1

naked make

Naked will prompt you to confirm your project settings. Here is the prompt screen that I received when I created status:

1
2
3
4
5
6
7
8
9
10
11
12

██ naked make
Detected a Naked project YAML setup file (naked.yaml).

Please confirm the information below:

----------------------------------------------------------
 status
 Copyright 2014 Christopher Simpkins
 MIT license
----------------------------------------------------------

Is this correct? (y/n)

If your settings are correct, enter ‘y’ and your project is generated in the same directory with the following structure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

PROJECT---|
          |
          docs---|
          |      LICENSE
          |      |
          |      README.rst
          |
          tests---(__init__.py)
          |
          |
          lib----|
          |      PROJECT-------|
          |      |             commands---(__init__.py)
          |      |             |
          |      profiler.py   app.py
          |                    |
          |                    settings.py
          |
          MANIFEST.in
          |
          README.md
          |
          setup.cfg
          |
          setup.py

The LICENSE file was populated with the complete text of my MIT license, including the copyright statement and the current year. The setup.py file is set to automatically import my version number from the settings.py file and to populate the long description of the project from the README.rst reStructuredText file in the docs directory (which gets pushed to PyPI as your project description). The app.py file is the main application script and it is fully tricked out to handle help, version, and usage command parsing. I simply added the text that will be displayed to the user for each of these requests in the settings.py file as definitions of the respective string variables.

The project setup.py file is generated in such a way that, when installed on a user’s system (or on your own with a develop install — see below), my project name can be used as the executable:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

$ status --help
---------------------------------------
 status
 Copyright 2014 Christopher Simpkins
 MIT license
---------------------------------------

Status reports the HTTP response status code(s) for GET and POST requests.

USAGE
  status [-p --post] <url>

OPTIONS
  -p  --post    POST request

The default is a GET request.  You can modify this to use a POST request with the -p or --post option.

The URL argument can be entered with or without the protocol. If you do not enter a protocol (http:// or https://), then http:// is assumed.  If you intend to test with the secure HTTP protocol, then make this explicit in your URL.

EXAMPLES
  status http://google.com
  status https://www.google.com
  status google.com
  status -p httpbin.org/post

SOURCE REPOSITORY
  https://github.com/chrissimpkins/status

ISSUE TRACKING
  https://github.com/chrissimpkins/status/issues

In order to begin testing your new project, enter the following in the top level directory that contains your setup.py file:

1

python setup.py develop

And in under 5 minutes, you can begin coding and testing your application without the need to manually address these common setup tasks.

Learn More

Naked is a large project and both the executable as well as the Naked toolshed library contain many more helpful features for command line application developers.

The documentation is available at http://docs.naked-py.com if you’d like to learn more.

Install

You can install status with pip using the following command:

1

pip install status

or download the source repository, unpack it, and navigate to the top level directory. Then enter the following:

1

python setup.py install

You can confirm the install by checking that the help displays with the following command:

1

status --help

GET Request Status Codes

GET requests are the default. To check the response status code for a URL, enter the URL as the argument to status:

1

status <url>

You do not need to include the protocol (http://) unless you are interested in testing a URL with the secure http protocol (https://) in which case this needs to be part of the URL.

Here are examples of tests on google.com:

1
2

$ status http://www.google.com
200 : http://www.google.com/

1
2
3

$ status google.com
301 : http://google.com/
200 : http://www.google.com/

Status follows all 300 status range redirects and displays each of the URL with the status codes across these jumps.

POST Request Status Codes

To run a POST request, add the -p or --post option to your command:

1

status -p <url>

Here is an example:

1
2

$ status -p httpbin.org/post
200 : http://httpbin.org/post

Status Help

Help is available with the -h or --help options.

Source Repositories

The source is available on GitHub and PyPI.

Issue Tracking

If you come across a bug, please report it on the GitHub issue tracker.

The built-in function returns the string that was entered by the user. Pass the query prompt to the user as an argument to the built-in function like this:

Python 2

1

response = raw_input("Please enter your name: ")

Python 3

1

response = input("Please enter your name: ")

Testing for the Python Version

To add the Python interpreter version testing logic to your script, use the sys.version_info tuple:

1
2
3
4
5
6
7
8

from sys import version_info

py3 = version_info[0] > 2 #creates boolean value for test that Python major version > 2

if py3:
  response = input("Please enter your name: ")
else:
  response = raw_input("Please enter your name: ")

advPNG

To install the application, download the binary (for Windows users) or source (for Linux / Unix – including Mac OSX users) for the project. If you are installing from source, navigate to the decompressed source directory and use the following commands:

1
2

./configure
sudo make && sudo make install

This will compile the source to an executable which can be run by typing:

1

advpng

on your command line. For windows users, enter the full path to the .exe file or place the .exe file in a directory on your system PATH so that you can enter the filename and extension without the absolute file path.

My testing was performed with v1.17 of advPNG.

How to Maximize Image Compression

There are four available flags that modify the level of compression that you achieve on the file. The tradeoff for the compression level is the time spent on the compression which can be significant for large image files.

The flags (and their associated descriptions in the advpng --help) are:

Results

Here are the results for my PNG file that started at 42889 bytes. This file was saved in the default PNG format and was not exported in the Photoshop web format (which notably produces a smaller, already compressed file if you are using Photoshop for your images).

Not bad, 5% of the original file size and there wasn’t a significant decrease across the different compression flags with this file. Have a go at it for yourself and see how it works for your files with the applications that you use to generate or modify images. If you have storage space or bandwidth constraints, it may be worth the effort.

Sublime Text Group Panes

Open a file in your editor and then create a second group pane with the menu items View > Groups > New Group. This gives you a vertical divider with a new file group pane on the right side. Click in the right pane and then open another file. The files are displayed adjacent to each other like this:

Make Additional Groups

Open another file in either of the groups and (with the file selected) use the menu items View > Groups > Move File to New Group. This will place a horizontal divider below your right side pane with the new file in the bottom right corner.

The Shugr Editor

Shugr is an open source HTML editor that provides a cross-platform interface to the Emmet HTML toolkit. Shugr allows you to develop HTML in real time without the need for a separate preprocessor run on a markup document.

Detailed documentation is available here.

The Emmet HTML Toolkit

If you do any signficant amount of work with HTML and haven’t used the Emmet toolkit, you are in for a treat. Spend some time learning the syntax for the HTML entities that you commonly use and this will dramatically improve your productivity. It is possible to create hundreds of characters of HTML in a few short lines of Emmet script. A press of your TAB key and the HTML is immediately populated in the location where you placed the script in the Shugr editor (including within other tags of preexisting HTML).

Here are several common tasks that demonstrate the Emmet syntax in action:

HTML 5 Document Creation

To begin a new HTML 5 document, type the following in Shugr:

1

html:5

Leave your cursor positioned immediately after the ‘5’ and press your TAB key. The editor will remove the Emmet script and replace it with the following:

1
2
3
4
5
6
7
8
9
10

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
</head>
<body>
  
</body>
</html>

Create a Body div

Now let’s place a div with the id, “main-content”, inside our body tags. Place the cursor in between the body tags and enter:

1

#main-content

press the TAB key with the cursor positioned at the end of the above script and the text in the editor becomes:

1
2
3
4
5
6
7
8
9
10

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
</head>
<body>
  <div id="main-content"></div>
</body>
</html>

Create Multiple HTML Headers with Classes

Let’s create several h2 headers in the div with the “main-content” id and assign the class, “headclass”, to these headers. This example demonstrates how you can use multiplication to specify the number of HTML entities that you want to generate.

Place your cursor inside the “main-content” div tags and then type:

1

h2.headclass*7

Then click your TAB key and now you have:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
</head>
<body>
  <div id="main-content">
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
  </div>
</body>
</html>

Add CSS File Links

Now add a few CSS file links to the head section with this script:

1

link:css*3

Click the TAB key and you have CSS tags. Enter the path to the appropriate files and they are complete.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <link rel="stylesheet" href="style.css" media="all" />
  <link rel="stylesheet" href="style.css" media="all" />
  <link rel="stylesheet" href="style.css" media="all" />
</head>
<body>
  <div id="main-content">
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
  </div>
</body>
</html>

Add JavaScript File Links

And finally let’s add a couple of JavaScript file links to the document. We’ll place the following script just before the final body tag:

1

script:src*2

And with the last click on the TAB key, you now have a framework for your web page:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <link rel="stylesheet" href="style.css" media="all" />
  <link rel="stylesheet" href="style.css" media="all" />
  <link rel="stylesheet" href="style.css" media="all" />
</head>
<body>
  <div id="main-content">
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
      <h2 class="headclass"></h2>
  </div>
<script src=""></script>
<script src=""></script>
</body>
</html>

And Much More…

These simple examples only scratch the surface of the Emmet toolkit capabilities. Have a look through the Emmet documentation for more details on how to use it. The Emmet developer has also released a comprehensive cheat sheet that is very helpful.

Feedback and Contributions

If you have any issues with Shugr, please submit an issue report on the GitHub repository. If you’d like to contribute to the Shugr source, fork the develop branch of the repository, edit it, and submit a pull request back to the main repository with a description of your changes.

Automate the Source Distribution Build

The source distribution is built and pushed to PyPI with the command:

1

python setup.py sdist upload

and the script confirms that it succeeded by checking the exit code and displaying an error message for any non-zero exit codes:

1
2
3
4

if (( $? )); then
  echo "Unable to distribute your release to PyPI" >&2
  exit 1
fi

Automate the Wheel Distribution Build

Next, the script builds your wheel release and distributes it to PyPI with :

1

python setup.py bdist_wheel upload

It again confirms that it exited with a success exit code:

1
2
3
4

if (( $? )); then
  echo "Unable to distribute your wheel to PyPI" >&2
  exit 1
fi

and prompts you if there were problems.

The PyPush.sh Script

Here it is in its entirety:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/bin/sh
# Scriptacular - pypush.sh
# Create a Python source distribution and push it to PyPi
# Copyright 2013 Christopher Simpkins
# MIT License

# Build and push to PyPi
python setup.py sdist upload

# Confirm that it worked
if (( $? )); then
  echo "Unable to distribute your release to PyPI" >&2
  exit 1
fi

python setup.py bdist_wheel upload

# Confirm that wheel distribution worked
if (( $? )); then
  echo "Unable to distribute your wheel to PyPI" >&2
  exit 1
fi

# Exit success
exit 0

Drop it in the same directory as your setup.py file, give it executable permission (e.g. chmod 744 pypush.sh), and run it.

Install Setuptools and Pip

Simply pipe the remote Python install script to a local Python interpreter and Pip Installer will take care of the rest. Here is how you do it with cURL:

Unix + Linux

1

curl "https://raw.github.com/chrissimpkins/pip-installer/master/pipinstall.py" | python

What it Does

The script executes the install scripts provided by the setuptools and pip projects and then upgrades the setuptools package to the current release.

When you run Pip Installer by piping the remote script to the Python interpreter, it pipes the setuptools install script to the Python interpreter:

1

os.system("curl 'https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py' | python")

then it pipes the pip install script to the Python interpreter:

1

os.system("curl 'https://raw.github.com/pypa/pip/master/contrib/get-pip.py' | python")

and finally, it upgrades setuptools to the current release version with your new pip install:

1

os.system("pip install --upgrade setuptools")

Use Pip

After running this install script, you can use pip to install a Python package:

1

pip install <package-name>

or upgrade a Python package:

1

pip install --upgrade <package-name>

from the Python Package Index (PyPI).

Here is a link to the Pip Installer project repository if you would prefer to save the files locally.

Mac OSX Copy and Paste Commands

Mac OSX Command Line Copy

To add the standard output from any other command to the clipboard, pipe it to the pbcopy command:

1

curl -L "http://coolsite.com" | pbcopy

and then paste it in your GUI applications wherever you need.

Mac OSX Command Line Paste

To paste text from the clipboard to the standard output stream, use the pbpaste command:

1

pbpaste

and the clipboard text will be printed out in your terminal window.

If you’d like to do more with it, you can pipe the clipboard data to any other application that accepts the standard input stream. For instance, to create paginated output from a large block of text, you can pipe it to less:

1

pbpaste | less

Source

Kudos to Chealion on apple.stackexchange.com.