-module(eratosthenes).
-export([prime_numbers/1]).

% Sieve of Eratosthenes algorithm for finding all prime numbers up to N.
% http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

% Generate list of prime numbers up to N.
prime_numbers(N) when is_number(N) ->
  prime_numbers(N, generate(N)).

prime_numbers(Max, [H|T]) when H * H =
  [H | prime_numbers(Max, [R || R  0])];

prime_numbers(_, T) -> T.

% Generate sequence 2..N
generate(N) -> generate(N, 2).

generate(Max, Max) -> [Max];

generate(Max, X) -> [X | generate(Max, X + 1)].

What can I say… Love Erlang

module Sinatra
  module BuilderHelper
    def helper_modules
      @helper_mods ||= Sinatra::Application.ancestors.select{|m| m.name =~ /Helper/}
    end

    def builder_partial(template, xml, locals = {}, helper_mods = nil)
      template = "#{template}.builder" unless "#{template}" =~ /[.]builder$/
      helper_mods ||= self.helper_modules

      class << (context = OpenStruct.new({:xml => xml}.merge(locals))); self; end.send(:include, *helper_mods)

      File.open(File.join(settings.views, "#{template}")) do |f|
        eval f.read, context.send(:binding)
      end
    end
  end

  helpers BuilderHelper
end

As you can see, I am using OpenStruct as a context object in order to limit variable scope to the locals being passed to the partial… If you use other Sinatra helper modules and follow a naming convention, helper_mod will find it and make them available to the builder template…
This is a pretty simple helper module… but I am hoping it will save somebody time.

(function( $ ){
  $.fn.collectFields = function(fieldSelector) {
	var convert = function(type, value) {
		switch (type) {
			case "int"     : return value ? parseInt(value) : 0;
			case "float"   : return value ? parseFloat(value): 0.0;
			case "boolean" : return Boolean(value);
			default        : return value;
		}
	};

	var result = [];
	this.each(function() {
	  	var fields = {};
		$(this).find(fieldSelector).each(function(){
			var name = $(this).attr('name');
			if (name) {
				fields[name] = convert($(this).attr("json-type"), $(this).val());
			}
		});
		result.push(fields);
	});
	return result;

  };
})( jQuery );

As you can see, I am using “json-type” attribute to indicate a type of the data field. In html it looks something like the following:


<tr class="player">
  <td><input type="hidden" id="id__5" name="_id" value="5" class="field" /></td>
  <td><input type="text" id="number__5" name="number" value="23" class="field" json-type="int"/></td>
  <td><input type="text" id="name__5" name="name" value="Some Good Player" class="field"/></td>
</tr>
...


Script to collect data for all players would look something like this:

<script>
  var players = $(".player").collectFields(".field");
</script>


Functional Example (very Erlangish and Rubyish in the same time )

In [21]: def wrapper(fun):
      ....:   def func(*args, **kwargs):
      ....:     print " begin execution %s " % (fun.__name__)
      ....:     fun(*args, **kwargs)
      ....:     print " finished execution %s " % (fun.__name__)
      ....:   return func
      ....: 

In [22]: def hello(msg):
      ....:   print "hello %s" % (msg)
      ....: 

In [23]: f = wrapper(hello)

In [24]: f("Alex")
 begin execution hello
 hello Alex
 finished execution hello

require 'rubygems'
require 'sinatra'

helpers do
  def request_headers
    env.inject({}){|acc, (k,v)| acc[$1.downcase] = v if k =~ /^http_(.*)/i; acc}
  end
end

get '/headers' do
  puts request_headers.inspect
 end

request_headers helper will filter all HTTP headers and downcase names.

-module(mock_store, [MockStore]).
-export([read/1, create/1]).

read(Key) ->
	callback(read, [Key]).

create(Key, Document) ->
	callback(create, [Key, Document]).

%% Helper Functions

callback(Name, Args) ->
	case proplists:lookup(Name, MockStore) of
		none -> undefined;
		{Name, Fun} when is_function(Fun) -> Fun(Args);
		{Name, Value} -> Value
	end.

The callback is pretty simple, but allows to pass in ether mock result or a function, which will generate response based on parameters, passed to the method.
Now I can mock read/create in the test as following:

test_mod(StoreOptions) ->
	Store = mock_store:new(StoreOptions),
	yarmo_destination:new(Store).

....

Mod = test_mod([{read, not_found}]),
.....

Mod = test_mod([{read, fun([Key]) -> ?assertEqual("sample", Key), Doc end}])

Nothing special, but so far it is helping me to keep my tests from hitting real storage

Ruby:

  NO_FORWARD = ['Host', 'Content-Length', 'Accept-Encoding']

  def filter_headers(headers)
      headers.inject({}) do |result, (name, value)|
         result[name.to_s] = value unless NO_FORWARD.include?(name.to_s)
         result
      end
  end

Now, same code … but in Erlang:


filter_headers(Headers) ->
NoForward = ['Host', 'Content-Length', 'Accept-Encoding'],

lists:foldl(Pred, [], Headers).


I think given a bit more effort, each code sample might be even more compact, but even what I have looks pretty readable

first we have an entry point:


parse(Ttl) -> parse_ttl(lists:reverse(Ttl)).


And here comes all the fun :


%% Private Functions.

parse_ttl([$s | Ttl]) -> list_to_integer(lists:reverse(Ttl));
parse_ttl([$S | Ttl]) -> parse_ttl([$s | Ttl]);

parse_ttl([$m | Ttl]) -> 60 * list_to_integer(lists:reverse(Ttl));
parse_ttl([$M | Ttl]) -> parse_ttl([$m | Ttl]);

parse_ttl([$h | Ttl]) -> 60* 60 * list_to_integer(lists:reverse(Ttl));
parse_ttl([$H | Ttl]) -> parse_ttl([$h | Ttl]);

parse_ttl(_) -> false.

Since strings in Erlang are just lists of integers, it is very common to apply list functions to strings. The [H | T] notation allows you to separate “head” and a “tail” of the list; in our case first symbol and the rest of the string. And since we have reversed our original string before applying our pattern … it is working pretty well

module Components

  components_path = File.expand_path(File.dirname(__FILE__) + '/components')

  files = Dir.new(components_path).select{|f| f =~ /.*\.rb/ } || []
  files.each do |f|
    body = File.new(File.join([components_path, f])).read
    name = File.basename(f, '.rb').capitalize + "Helper"
    module_eval <<-"end;"
      module #{name}
        #{body}
      end
    end;
    Sinatra.helpers(const_get(name))
  end

end

Link to the file: http://gist.github.com/141220

As you can see this pretty simple Ruby magic allows me to put my “components” into a subdirectory and add them all as Sinatra helpers. Since the body of the component is wrapped into a module, component development becomes very easy. Following code, once saved into components directory will add a search helper to your app:

def search(options = {})
......
end


Pretty simple, but still fun