Tj Holowaychuk

[Ruby] On ActiveRecord find_by_sql

2010-01-18T19:16:21-08:00

still there lol.. google sql injection

[Ruby] On ActiveRecord find_by_sql

2010-01-18T15:03:28-08:00

well there is a huge security flaw in what you have now...

[Ruby] On Stable sort in ruby

2009-12-14T16:07:35-08:00

whats wrong sort ?

[C] On Css minification

2009-12-02T00:49:20-08:00

I like keeping the state machines really simple, all the local vars kinda suck though, limited to macros

[C] On Css minification

2009-12-02T00:47:36-08:00

my bad, think your right. The macros were from another project that actually needed to buffer strings. I previously thought that fgetc() did some internal stream buffering, but I could not find the source or much info but yeah wow in my other project after just using fread() its a huge huge performance gain

[JavaScript] On Money formatting

2009-11-26T06:59:58-08:00

damn, mine is twice as slow lol to much baggage along with js arrays blah blah o well

[JavaScript] On Money formatting

2009-11-26T05:42:41-08:00

It can be done pretty easily with regular expressoins, but im in C text parsing mode lol this is probably faster than regexps too not sure tho yet

[JavaScript] Money formatting

2009-11-25T23:05:47-08:00

Just needed to whip up a really quick routine for formatting money

function format_money(n) {
  var buf = [], 
      str = parseFloat(n).toFixed(2).toString(), 
      i = str.length,
      s = str.length - 5,
      p = 0
  while (++p, i) {
    buf.push(str[--i])
    if (i && i < s && p % 3 == 0) buf.push(',')
  }
  return buf.reverse().join('')
}

print(format_money(125.99))
print(format_money(1.99))
print(format_money(15000.99))
print(format_money(1500000.99))
print(format_money(15000000000000.99))


// =>

125.99
1.99
15,000.99
1,500,000.99
15,000,000,000,000.99

[C] Css minification

2009-11-25T22:05:35-08:00

Repo is here http://github.com/visionmedia/cssmin looking for any suggestions

// 
// cssmin.c
// 
// (c) 2009 TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
//
 
#include "cssmin.h"
 
#define last l
#define undo (ungetc(n, stream), n)
#define next (n = fgetc(stream), undo)
#define buffer (buf[bufpos++] = c)
#define end (buf[bufpos] = '\0')
#define out (++nchars_out, putchar(c))
#define input (l = c, c = fgetc(stream))
#define stat(S, ...) fprintf(stderr, S "\n", __VA_ARGS__);
#define option(S) (strcmp(argv[1], S) == 0)
 
static int 
minify(FILE *stream) {
  clock_t start = clock();
  char c, l, n, buf[CSSMIN_BUFFER_MAX];
  int bufpos = 0, inblock = 0, nchars = 0, nchars_out = 0;
start:
  switch (++nchars, input) {
    case '\n': goto start;
    case '{' : goto block;
    case '}' : goto blockend;
    case ' ' : goto space;
    case '"' : goto string;
    case EOF : goto finish;
    default  : out;
  }
  goto start;
block:
  out; inblock = 1;
  goto start;
blockend:
  out; inblock = 0;
  goto start;
string:
  out;
  if (input != '"') goto string;
  else out;
  goto start;
space:
  if ((isalpha(last) && isalpha(next)) || // foo bar
      (isalpha(last) && isdigit(next)) || // 1px 0
      (isalpha(last) && next == '"') ||   // 1px "solid"
      (last == '"' && !ispunct(next)) ||  // "solid" red
      (!inblock && next == ':') ||        // foo :last-child
      isdigit(last) ||                    // 0 0
      (next == '*' || last == '*')) out;  // foo * bar
  goto start;
finish:
  stat("bytes: %d", nchars);
  stat("bytes saved: %d", nchars - nchars_out);
  stat("duration: %0.5f milliseconds", (float) (clock() - start) / CLOCKS_PER_SEC);
  return 0;
}
 
static int
usage() {
  printf("cssmin: %s\n"
         "usage: cssmin < in.css > out.min.css\n", CSSMIN_VERSION);
  exit(0);
}
 
int 
main(int argc, char **argv) {
  if (argc > 1)
    if (option("--help")) usage();
    else if (option("--version")) puts(CSSMIN_VERSION), exit(0);
  return minify(stdin);
}

[C] On LPT garland

2009-11-18T16:39:24-08:00

SIGINT interrupts normally no? why handle it and say it cant be handled lol id probably just leave it out completely if thats all your doing

[PHP] On An easy one: traversing through an array

2009-11-16T16:54:55-08:00

If only PHP did not suck so much you could do this:

function GET($key, $default = null) {
  return $_GET[$key] || $default;
}

[Ruby] On lexer

2009-11-13T22:27:08-08:00

ya an enumerator would work fine, this is 1.8.x tho

[Ruby] lexer

2009-11-13T16:41:42-08:00

Everything else in my lib is pretty elegant, however this part bugs me. I cant use #find since I need the value the method send(token) returns, not the token name itself. Is there a baked in iterator that I forgot about that would work good here?

    def get_token
      self.class.precedence.each do |token|
        if val = send(token)
          return val
        end
      end
      error 'syntax error'
    end

[JavaScript] On Need help with creating a loop

2009-11-01T20:56:09-08:00

dont use for / in with an array

[C] On Enumerator

2009-10-29T20:30:00-07:00

Just playing around with a little prototype based lang im working on for fun. I prefer C's simplicity to c++ (though i dont know much c++).

[C] Enumerator

2009-10-29T16:53:06-07:00

yup

#include <stdio.h>
#include <stdlib.h>

typedef struct {
  int (* next)();
  void (* reset)();
} Enumerator;

Enumerator *
Enumerator_new(int (* next)(), void (* reset)()) {
  Enumerator *self = (Enumerator *) malloc(sizeof(Enumerator));
  if (!self) fprintf(stderr, "failed to allocate memory for Enumerator\n");
  self->next = next;
  self->reset = reset;
  return self;
}

static int n = 0;
static int evens() { return n += 2; }
static void reset() { n = 0; }

int 
main(int argc, char **argv) {
  int n;
  Enumerator *e = Enumerator_new(evens, reset);
  while ((n = e->next()) < 50)
    printf("%d\n", n);
  return 0;
}

[C] On C Array Implementation

2009-10-19T21:17:35-07:00

ah lame. as far as i know this is the only exception

[JavaScript] On My1stJavascript: Dice roller

2009-10-19T17:30:36-07:00

Check out my tiny js-oo lib, if your more comfortable with classes over prototypal idioms http://github.com/visionmedia/js-oo

Dice = Class({
  init: function(){
    ...
  },

  roll: function(){
    ...
  }
})

[JavaScript] On My1stJavascript: Dice roller

2009-10-19T17:29:39-07:00

Your not utilizing the OO aspects of javascript.

;(function(){
  Dice = function() {
    
  }

  Dice.prototype = {
    roll: function(){ ... }
    renderTo: function(){ ... }
  }
})

(new Dice()).roll().renderTo('#some-element')

[C] On C Array Implementation

2009-10-19T15:16:15-07:00

I dont know any C++ (well a tiny bit). that is ansi c99 no?

[C] C Array Implementation

2009-10-19T00:24:22-07:00

im no c pro. may be some memory management issues. from my project "CKit" at http://github.com/visionmedia/ckit

// 
// array.h - CKit
// 
// (c) 2009 TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
//

#ifndef __CKIT_ARRAY__
#define __CKIT_ARRAY__

#include "ckit.h"

#define CKIT_ARRAY(N, T) CKIT_ARRAY_INIT(N, T, free)
#define CKIT_ARRAY_INIT(N, T, F)                                                      \
                                                                                      \
   typedef struct {                                                                   \
     int len, max;                                                                    \
     T *vals;                                                                         \
   } N;                                                                               \
                                                                                      \
  /*                                                                                  \
   * Allocate new N.                                                                  \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_new() {                                                                         \
    N *self = (N *) CKIT_MALLOC(sizeof(N));                                           \
    self->len = 0, self->max = 0;                                                     \
    self->vals = NULL;                                                                \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Push _val_ onto _self_.                                                          \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_push(N *self, T val) {                                                          \
    if (self->len == self->max)                                                       \
      self->max = self->max ? self->max << 1 : 2,                                     \
      self->vals = (T *) CKIT_REALLOC(self->vals, self->max * sizeof(T));             \
    self->vals[self->len++] = val;                                                    \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Slice _self_ at _beg_ to _len_.                                                  \
   *                                                                                  \
   *   Array_slice(array, 0, 3);                                                      \
   *   Array_slice(array, 5, 10);                                                     \
   *   Array_slice(array, 1, -1);                                                     \
   *   Array_slice(array, -5, -1);                                                    \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_slice(N *self, register int beg, register int len) {                            \
    N *slice = N##_new();                                                             \
    if (beg < 0) beg = self->len + 1 -(-beg+1);                                       \
    if (len < 0) len = self->len + 2 -(-len+1);                                       \
    if (beg < 0) beg = 0;                                                             \
    if (len < 0) len = 1;                                                             \
    if (self->len && len != 0)                                                        \
      for (; len > 0 && beg < self->len; --len, ++beg)                                \
        if (self->vals[beg])                                                          \
          N##_push(slice, self->vals[beg]);                                           \
    return slice;                                                                     \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Return elements after _i_.                                                       \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_from(N *self, const int i) {                                                    \
    return N##_slice(self, i, -1);                                                    \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Return elements upto _i_.                                                        \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_to(N *self, int i) {                                                            \
    return N##_slice(self, 0, ++i);                                                   \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Return last _n_ elements.                                                        \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_last_n(N *self, int n) {                                                        \
    return N##_slice(self, -n, n);                                                    \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Select from _self_ with _callback_. Returns                                      \
   * a new array of values which evaluate to 1.                                       \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_select(N *self, int (* callback)()) {                                           \
    N *selected = N##_new();                                                          \
    for (int i = 0; i < self->len; ++i)                                               \
      if (callback(i, self->vals[i]))                                                 \
        N##_push(selected, self->vals[i]);                                            \
    return selected;                                                                  \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Map _self_ with _callback_. Returns a new array                                  \
   * of mapped values.                                                                \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_map(N *self, void *(* callback)()) {                                            \
    N *map = N##_new();                                                               \
    for (int i = 0; i < self->len; ++i)                                               \
      N##_push(map, callback(i, self->vals[i]));                                      \
    return map;                                                                       \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Find an element in _self_ using _callback_. When _callback_                      \
   * evaluates to 1, the value will be returned, otherwise NULL.                      \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  T                                                                                   \
  N##_find(N *self, int (* callback)()) {                                             \
    for (int i = 0; i < self->len; ++i)                                               \
      if (callback(i, self->vals[i]))                                                 \
        return self->vals[i];                                                         \
    return NULL;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Check if an element in _self_ will evaluate to 1                                 \
   * when passed to _callback_.                                                       \
   *                                                                                  \
   * @api public                                                                      \
   * @see Array_find()                                                                \
   */                                                                                 \
                                                                                      \
  int                                                                                 \
  N##_any(N *self, int (* callback)()) {                                              \
    return !! N##_find(self, callback);                                               \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Return the last element in _self_.                                               \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  T                                                                                   \
  N##_last(N *self) {                                                                 \
    return self->vals[self->len - 1];                                                 \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Pop an element off the end of _self_'s stack.                                    \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  T                                                                                   \
  N##_pop(N *self) {                                                                  \
    return self->len ?                                                                \
      self->vals[--self->len] :                                                       \
        NULL;                                                                         \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Merge _self_ with _other_ array.                                                 \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_merge(N *self, N *other) {                                                      \
    for (int i = 0; i < other->len; ++i)                                              \
      N##_push(self, other->vals[i]);                                                 \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Unshift _val_ onto _self_'s stack, prepending it.                                \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_unshift(N *self, T val) {                                                       \
    *self = *N##_merge(N##_push(N##_new(), val), self);                               \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Delete element at index _i_ from _self_.                                         \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  T                                                                                   \
  N##_delete_at(N *self, int i) {                                                     \
    register int len = self->len;                                                     \
    if (i > -1 && i < len) {                                                          \
      --self->len;                                                                    \
      T val = self->vals[i];                                                          \
      for (int j = i + 1; j < len; ++j, ++i)                                          \
        self->vals[i] = self->vals[j];                                                \
      return val;                                                                     \
    }                                                                                 \
    return NULL;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Remove duplicate values from _self_ using _callback_ for comparison.             \
   *                                                                                  \
   *  Array_unique(array, strcmp);                                                    \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_unique(N *self, int (* callback)()) {                                           \
    for (int i = 0; i < self->len; ++i)                                               \
      for (int j = 0; j < self->len; ++j)                                             \
        if (i != j && callback(self->vals[i], self->vals[j]) == 0)                    \
          N##_delete_at(self, i);                                                     \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Sort _self_ with comparison _callback_.                                          \
   *                                                                                  \
   *  static int                                                                      \
   *  compare_string(void *p1, void *p2) {                                            \
   *     return strcmp(* (char * const *) p1, * (char * const *) p2);                 \
   *  }                                                                               \
   *                                                                                  \
   *  Array_sort(array, compare_string);                                              \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_sort(N *self, int (* callback)(const void *, const void *)) {                   \
    qsort(self->vals, self->len - 1, sizeof(T), callback);                            \
    return self;                                                                      \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Create a union of _self_ and _other_ array. Merging                              \
   * and removing duplicates using _callback_ for comparison.                         \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  N *                                                                                 \
  N##_union(N *self, N *other, int (* callback)()) {                                  \
    return N##_unique(N##_merge(self, other), callback);                              \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Shift an element off the beginning of _self_'s stack.                            \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  T                                                                                   \
  N##_shift(N *self) {                                                                \
    return N##_delete_at(self, 0);                                                    \
  }                                                                                   \
                                                                                      \
  /*                                                                                  \
   * Destroy _self_.                                                                  \
   *                                                                                  \
   * @api public                                                                      \
   */                                                                                 \
                                                                                      \
  void                                                                                \
  N##_destroy(N *self) {                                                              \
    for (int i = 0; i < self->len; ++i)                                               \
      F(self->vals[i]);                                                               \
    if (self) free(self);                                                             \
  }

#endif

[Ruby] On Roman numeral parser

2009-10-16T22:05:17-07:00

oh.. fuck.. haha I should have ... actually known that first I suppose :P

[Ruby] Roman numeral parser

2009-10-16T18:43:55-07:00

little parser. I am working with strings that may or may not be roman numerals, so to prevent a bunch of cruft we pass through regular numerical values

module RomanNumeral
  
  #--
  # Numerals
  #++
  
  I = 1
  V = 5
  X = 10
  L = 50
  C = 100
  D = 500
  M = 1000
  
  ##
  # Parse roman numerals where _val_
  # may be Numeric, a string consisting of 
  # digits, or roman numerals.
  
  def self.parse val
    return val if Numeric === val
    return val.to_i if val =~ /\A\d+\Z/
    val.scan(/[IVXLCDM]/).inject(0) do |sum, numeral| 
      sum + const_get(numeral) 
    end
  end
end


p RomanNumeral.parse('12')
p RomanNumeral.parse('II')
p RomanNumeral.parse('IV')
p RomanNumeral.parse('X')
p RomanNumeral.parse(1)
p RomanNumeral.parse(1.5)

[C] On Version comparison

2009-10-15T16:26:27-07:00

This allows for "1.0.0-alpha < 1.0.0-beta", "yui3-1200 < yui3-9000" etc, but still the same issue you mentioned

int
Version_compare(Version *a, Version *b) {
  return (a->major * 100 + a->minor * 10 + a->patch) - 
         (b->major * 100 + b->minor * 10 + b->patch) +
         strcmp(a->str, b->str);
}

[C] On Version comparison

2009-10-15T16:24:30-07:00

ya thats an issue. 2.0 and 1.10.0 == 0 currently which.. is no good lol. I need a better way to hash their position / value. Ideally I want to support arbitrary depth in terms of n.n.n.n.n+ so I can refactor for that, but first I should get this working better. Instead of 100 it could be 999 or something stupid