spade-packager 0.1.0

data/packages/coffee-script/examples/beautiful_code/binary_search.coffee

@@ -0,0 +1,16 @@
+# Beautiful Code, Chapter 6.
+# The implementation of binary search that is tested.
+
+# Return the index of an element in a sorted list. (or -1, if not present)
+index = (list, target) ->
+  [low, high] = [0, list.length]
+  while low < high
+    mid = (low + high) >> 1
+    val = list[mid]
+    return mid if val is target
+    if val < target then low = mid + 1 else high = mid
+  return -1
+
+console.log 2 is index [10, 20, 30, 40, 50], 30
+console.log 4 is index [-97, 35, 67, 88, 1200], 1200
+console.log 0 is index [0, 45, 70], 0

data/packages/coffee-script/examples/beautiful_code/quicksort_runtime.coffee

@@ -0,0 +1,13 @@
+# Beautiful Code, Chapter 3.
+# Produces the expected runtime of Quicksort, for every integer from 1 to N.
+
+runtime = (N) ->
+  [sum, t] = [0, 0]
+  for n in [1..N]
+    sum += 2 * t
+    t = n - 1 + sum / n
+  t
+
+console.log runtime(3) is 2.6666666666666665
+console.log runtime(5) is 7.4
+console.log runtime(8) is 16.92142857142857

data/packages/coffee-script/examples/beautiful_code/regular_expression_matcher.coffee

@@ -0,0 +1,34 @@
+# Beautiful Code, Chapter 1.
+# Implements a regular expression matcher that supports character matches,
+# '.', '^', '$', and '*'.
+
+# Search for the regexp anywhere in the text.
+match = (regexp, text) ->
+  return match_here(regexp.slice(1), text) if regexp[0] is '^'
+  while text
+    return true if match_here(regexp, text)
+    text = text.slice(1)
+  false
+
+# Search for the regexp at the beginning of the text.
+match_here = (regexp, text) ->
+  [cur, next] = [regexp[0], regexp[1]]
+  if regexp.length is 0 then return true
+  if next is '*' then return match_star(cur, regexp.slice(2), text)
+  if cur is '$' and not next then return text.length is 0
+  if text and (cur is '.' or cur is text[0]) then return match_here(regexp.slice(1), text.slice(1))
+  false
+
+# Search for a kleene star match at the beginning of the text.
+match_star = (c, regexp, text) ->
+  loop
+    return true if match_here(regexp, text)
+    return false unless text and (text[0] is c or c is '.')
+    text = text.slice(1)
+
+console.log match("ex", "some text")
+console.log match("s..t", "spit")
+console.log match("^..t", "buttercup")
+console.log match("i..$", "cherries")
+console.log match("o*m", "vrooooommm!")
+console.log match("^hel*o$", "hellllllo")

data/packages/coffee-script/examples/blocks.coffee

@@ -0,0 +1,54 @@
+# After wycats' http://yehudakatz.com/2010/02/07/the-building-blocks-of-ruby/
+
+# Sinatra.
+get '/hello', ->
+  'Hello World'
+
+
+# Append.
+append = (location, data) ->
+  path = new Pathname location
+  throw new Error("Location does not exist") unless path.exists()
+
+  File.open path, 'a', (file) ->
+    file.console.log YAML.dump data
+
+  data
+
+
+# Rubinius' File.open implementation.
+File.open = (path, mode, block) ->
+  io = new File path, mode
+
+  return io unless block
+
+  try
+    block io
+  finally
+    io.close() unless io.closed()
+
+
+# Write.
+write = (location, data) ->
+  path = new Pathname location
+  raise "Location does not exist" unless path.exists()
+
+  File.open path, 'w', (file) ->
+    return false if Digest.MD5.hexdigest(file.read()) is data.hash()
+    file.console.log YAML.dump data
+    true
+
+
+# Rails' respond_to.
+index = ->
+  people = Person.find 'all'
+
+  respond_to (format) ->
+    format.html()
+    format.xml -> render xml: people.xml()
+
+
+# Synchronization.
+synchronize = (block) ->
+  lock()
+  try block() finally unlock()

data/packages/coffee-script/examples/code.coffee

@@ -0,0 +1,167 @@
+# Functions:
+square = (x) -> x * x
+
+sum = (x, y) -> x + y
+
+odd = (x) -> x % 2 isnt 0
+
+even = (x) -> x % 2 is 0
+
+run_loop = ->
+  fire_events((e) -> e.stopPropagation())
+  listen()
+  wait()
+
+# Objects:
+dense_object_literal = {one: 1, two: 2, three: 3}
+
+spaced_out_multiline_object =
+  pi: 3.14159
+  list: [1, 2, 3, 4]
+  regex: /match[ing](every|thing|\/)/gi
+  three: new Idea
+
+  inner_obj:
+    freedom: -> _.freedom()
+
+# Arrays:
+stooges = [{moe: 45}, {curly: 43}, {larry: 46}]
+
+exponents = [((x) -> x), ((x) -> x * x), ((x) -> x * x * x)]
+
+empty = []
+
+multiline = [
+  'line one'
+  'line two'
+]
+
+# Conditionals and ternaries.
+if submarine.shields_up
+  full_speed_ahead()
+  fire_torpedos()
+else if submarine.sinking
+  abandon_ship()
+else
+  run_away()
+
+eldest = if 25 > 21 then liz else marge
+
+decoration = medal_of_honor if war_hero
+
+go_to_sleep() unless coffee
+
+# Returning early:
+race = ->
+  run()
+  walk()
+  crawl()
+  if tired then return sleep()
+  race()
+
+# Conditional assignment:
+good or= evil
+wine and= cheese
+
+# Nested property access and calls.
+((moon.turn(360))).shapes[3].move({x: 45, y: 30}).position['top'].offset('x')
+
+a = b = c = 5
+
+# Embedded JavaScript.
+callback(
+  `function(e) { e.stop(); }`
+)
+
+# Try/Catch/Finally/Throw.
+try
+  all_hell_breaks_loose()
+  dogs_and_cats_living_together()
+  throw "up"
+catch error
+  print(error)
+finally
+  clean_up()
+
+try all_hell_breaks_loose() catch error then print(error) finally clean_up()
+
+# While loops, break and continue.
+while demand > supply
+  sell()
+  restock()
+
+while supply > demand then buy()
+
+loop
+  break if broken
+  continue if continuing
+
+# Unary operators.
+!!true
+
+# Lexical scoping.
+v_1 = 5
+change_a_and_set_b = ->
+  v_1 = 10
+  v_2 = 15
+v_2 = 20
+
+# Array comprehensions.
+supper = food.capitalize() for food in ['toast', 'cheese', 'wine']
+
+drink bottle for bottle, i in ['soda', 'wine', 'lemonade'] when even i
+
+# Switch statements ("else" serves as a default).
+activity = switch day
+  when "Tuesday"   then eat_breakfast()
+  when "Sunday"    then go_to_church()
+  when "Saturday"  then go_to_the_park()
+  when "Wednesday"
+    if day is bingo_day
+      go_to_bingo()
+    else
+      eat_breakfast()
+      go_to_work()
+      eat_dinner()
+  else go_to_work()
+
+# Semicolons can optionally be used instead of newlines.
+wednesday = -> eat_breakfast(); go_to_work(); eat_dinner()
+
+# Multiline strings with inner quotes.
+story = "Lorem ipsum dolor \"sit\" amet, consectetuer adipiscing elit,
+sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna
+aliquam erat volutpat. Ut wisi enim ad."
+
+# Inheritance and calling super.
+class Animal
+  (@name) ->
+
+  move: (meters) ->
+    alert this.name + " moved " + meters + "m."
+
+class Snake extends Animal
+  move: ->
+    alert 'Slithering...'
+    super 5
+
+class Horse extends Animal
+  move: ->
+    alert 'Galloping...'
+    super 45
+
+sam = new Snake "Sammy the Snake"
+tom = new Horse "Tommy the Horse"
+
+sam.move()
+tom.move()
+
+# Numbers.
+a_googol =  1e100
+hex      =  0xff0000
+negative =  -1.0
+infinity =  Infinity
+nan      =  NaN
+
+# Deleting.
+delete secret.identity

data/packages/coffee-script/examples/computer_science/README

@@ -0,0 +1,4 @@
+Ported from Nicholas Zakas' collection of computer science fundamentals, written
+in JavaScript. Originals available here:
+
+http://github.com/nzakas/computer-science-in-javascript

data/packages/coffee-script/examples/computer_science/binary_search.coffee

@@ -0,0 +1,25 @@
+# Uses a binary search algorithm to locate a value in the specified array.
+binary_search = (items, value) ->
+
+  start = 0
+  stop  = items.length - 1
+  pivot = Math.floor (start + stop) / 2
+
+  while items[pivot] isnt value and start < stop
+
+    # Adjust the search area.
+    stop  = pivot - 1 if value < items[pivot]
+    start = pivot + 1 if value > items[pivot]
+
+    # Recalculate the pivot.
+    pivot = Math.floor (stop + start) / 2
+
+  # Make sure we've found the correct value.
+  if items[pivot] is value then pivot else -1
+
+
+# Test the function.
+console.log 2 is binary_search [10, 20, 30, 40, 50], 30
+console.log 4 is binary_search [-97, 35, 67, 88, 1200], 1200
+console.log 0 is binary_search [0, 45, 70], 0
+console.log(-1 is binary_search [0, 45, 70], 10)

data/packages/coffee-script/examples/computer_science/bubble_sort.coffee

@@ -0,0 +1,11 @@
+# A bubble sort implementation, sorting the given array in-place.
+bubble_sort = (list) ->
+  for i in [0...list.length]
+    for j in [0...list.length - i]
+      [list[j], list[j+1]] = [list[j+1], list[j]] if list[j] > list[j+1]
+  list
+
+
+# Test the function.
+console.log bubble_sort([3, 2, 1]).join(' ') is '1 2 3'
+console.log bubble_sort([9, 2, 7, 0, 1]).join(' ') is '0 1 2 7 9'

data/packages/coffee-script/examples/computer_science/linked_list.coffee

@@ -0,0 +1,108 @@
+# "Classic" linked list implementation that doesn't keep track of its size.
+class LinkedList
+
+  ->
+    this._head = null # Pointer to the first item in the list.
+
+
+  # Appends some data to the end of the list. This method traverses the existing
+  # list and places the value at the end in a new node.
+  add: (data) ->
+
+    # Create a new node object to wrap the data.
+    node = data: data, next: null
+
+    current = this._head or= node
+
+    if this._head isnt node
+      (current = current.next) while current.next
+      current.next = node
+
+    this
+
+
+  # Retrieves the data at the given position in the list.
+  item: (index) ->
+
+    # Check for out-of-bounds values.
+    return null if index < 0
+
+    current = this._head or null
+    i = -1
+
+    # Advance through the list.
+    (current = current.next) while current and index > (i += 1)
+
+    # Return null if we've reached the end.
+    current and current.data
+
+
+  # Remove the item from the given location in the list.
+  remove: (index) ->
+
+    # Check for out-of-bounds values.
+    return null if index < 0
+
+    current = this._head or null
+    i = -1
+
+    # Special case: removing the first item.
+    if index is 0
+      this._head = current.next
+    else
+
+      # Find the right location.
+      ([previous, current] = [current, current.next]) while index > (i += 1)
+
+      # Skip over the item to remove.
+      previous.next = current.next
+
+    # Return the value.
+    current and current.data
+
+
+  # Calculate the number of items in the list.
+  size: ->
+    current = this._head
+    count = 0
+
+    while current
+      count += 1
+      current = current.next
+
+    count
+
+
+  # Convert the list into an array.
+  toArray: ->
+    result  = []
+    current = this._head
+
+    while current
+      result.push current.data
+      current = current.next
+
+    result
+
+
+  # The string representation of the linked list.
+  toString: -> this.toArray().toString()
+
+
+# Tests.
+list = new LinkedList
+
+list.add("Hi")
+console.log list.size()  is 1
+console.log list.item(0) is "Hi"
+console.log list.item(1) is null
+
+list = new LinkedList
+list.add("zero").add("one").add("two")
+console.log list.size()     is 3
+console.log list.item(2)    is "two"
+console.log list.remove(1)  is "one"
+console.log list.item(0)    is "zero"
+console.log list.item(1)    is "two"
+console.log list.size()     is 2
+console.log list.item(-10)  is null

data/packages/coffee-script/examples/computer_science/luhn_algorithm.coffee

@@ -0,0 +1,36 @@
+# Use the Luhn algorithm to validate a numeric identifier, such as credit card
+# numbers, national insurance numbers, etc.
+# See: http://en.wikipedia.org/wiki/Luhn_algorithm
+
+is_valid_identifier = (identifier) ->
+
+  sum = 0
+  alt = false
+
+  for i in [identifier.length - 1..0] by -1
+
+    # Get the next digit.
+    num = parseInt identifier.charAt(i), 10
+
+    # If it's not a valid number, abort.
+    return false if isNaN(num)
+
+    # If it's an alternate number...
+    if alt
+      num *= 2
+      num = (num % 10) + 1 if num > 9
+
+    # Flip the alternate bit.
+    alt = !alt
+
+    # Add to the rest of the sum.
+    sum += num
+
+  # Determine if it's valid.
+  sum % 10 is 0
+
+
+# Tests.
+console.log is_valid_identifier("49927398716")      is true
+console.log is_valid_identifier("4408041234567893") is true
+console.log is_valid_identifier("4408041234567890") is false