hubris 0.0.3 → 0.0.4

data/doc/ruby-hubris.tex

@@ -0,0 +1,176 @@
+% Local Variables:
+% compile-command: "/opt/local/bin/pdflatex fp-syd.tex && open fp-syd.pdf"
+% End:
+
+\documentclass{beamer}
+\usepackage{listings}
+\usepackage{beamerthemesplit}
+
+\title{Hubris}
+\subtitle{subjecting Haskell to Ruby's iron will}
+\author{Mark Wotton \textless mwotton@shimweasel.com\textgreater}
+\date{\today}
+
+\begin{document}
+\lstset{language=Haskell}
+\section{Two cultures}
+\frame{\titlepage}
+
+% \subsection
+\begin{frame}
+  \frametitle{I \ding{170} Ruby}
+  \begin{itemize}
+  \item concise and flexible
+  \item Big web community, many libraries
+  \item Fun
+  \end{itemize}
+\end{frame}
+
+
+
+\begin{frame} 
+  \frametitle{I \ding{170} Haskell}
+  \begin{itemize}
+  \item<1-> Fast (optimised native code, multicore, etc)
+  \item<2-> Expressive - type systems don't have to suck.
+  \item<3-> Provably safe at compile time
+  \end{itemize}
+\end{frame}
+
+
+\subsection{lies, damn lies, benchmarks}
+\begin{frame}
+  \frametitle{the slide that's going to get me lynched}
+  \center{JRuby vs GHC}
+  \begin{tabular}{l l l l} 
+    Program &	        Time	&Memory &	Source Size\\ \hline
+    reverse-complement	&5	&1	&1/4\\
+    regex-dna	        &7	&3	&1/5\\	
+    binary-trees	        &8	&7	&1	\\	
+    k-nucleotide	        &10	&1	&1/7	\\	
+    pidigits	        &18	&18	&2	\\	
+    n-body	        &26	&53	&1	\\	
+    chameneos-redux	&30	&24	&1	\\	
+    fasta	                &31	&142	&1	\\	
+    fannkuch	        &45	&22	&1/4	\\	
+    spectral-norm	        &227	&56	&1/3	\\	
+    mandelbrot	        &319	&3	&1/2\\	
+  \end{tabular}
+\end{frame}
+
+\begin{frame}
+  \frametitle{319 times? Really?}
+  \begin{itemize}
+  \item<1-> Haskell code written by expert hackers
+  \item<2-> Longer in some cases - gone hard on optimisations
+    even when they blow out source code size. But...
+  \item <3-> 319 times faster, 1/3 the memory.
+  \end{itemize}
+\end{frame}
+
+\subsection{problems with Haskell}
+\begin{frame}
+\frametitle{more lies to outrage Myles}
+\setlength\parskip{0.1in}
+there are approximately twelve programmers in the world who know Haskell
+
+Nine are working on four different compilers with extensions for
+solving logic puzzles in the type system (not kidding, google
+``haskell instant insanity'')
+
+The other three are working on six different web frameworks
+\end{frame}
+
+\section{Hubris}
+\begin{frame}
+\frametitle{Peanut butter, meet chocolate}
+Ruby has a heap of web frameworks, convenience libraries, well-tested
+integration with javascript + CSS
+\setlength\parskip{0.25in}
+
+Haskell is smoking fast with rock solid type safety but a tiny
+community
+
+Hubris is my bridge between the two
+\end{frame}
+
+\subsection{Haskell example}
+\begin{frame}[fragile]
+  \frametitle{lazy, statically typed, and pure}
+  \begin{lstlisting}
+clMax lim = maximumBy (comparing snd) (assocs arr)
+  where arr = listArray (1,lim) 
+                       (0:(map depth [2..]))
+        step x = if even x 
+                   then div x 2 
+                   else 3 * x + 1
+        depth x = 1 + if n <= lim 
+                        then arr ! n 
+                        else depth n
+          where n = step x    
+  \end{lstlisting}
+\end{frame}
+
+
+\subsection{wrap it in Ruby}
+\begin{frame}[fragile]
+  \frametitle{actually using it}
+  \lstset{language=Ruby}
+  \begin{lstlisting}
+    require Hubris           # my favourite line
+    c = Collatz.new          # any ruby object
+    c.inline(haskell_string) # from above
+    puts c.clMax(1000000)
+    >> 837799
+  \end{lstlisting}
+\end{frame}
+
+% \frametitle{Predictive}
+\section{TODO, gotchas, FIXME}
+\begin{frame}
+\setlength\parskip{0.1in}
+\frametitle{Making it less sucky}
+Needs to use jhc, because ghc can't produce dynamic libs right now
+(works with GHC HEAD, will be compatible with 6.12)
+
+one-way bridge, no callbacks to Ruby
+
+a smarter mapping layer
+
+caching of Haskell binaries
+
+cleanup of ruby interface
+
+shore up support for arrays, hashes, BigInts
+
+autoconf support to find ruby libs and includes
+
+... lots to do
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Try it out!}
+  install GHC and JHC
+
+  git clone git://github.com/mwotton/Hubris.git
+
+  follow the README
+
+  tell me what's missing
+
+  patches very much welcome (thanks to Josh Price, James Britt and Tatsuhiro Ujihisa)
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Learning Haskell}
+  Learn You A Haskell: why the lucky stiff's academic cousin
+
+  Real World Haskell: awesome, practical introduction
+
+  haskell channel on freenode
+
+  beginners@haskell.org
+\end{frame}
+\end{document}

data/doc/wisdom_of_ancients.txt

@@ -0,0 +1,55 @@
+15:31 < mmorrow> blackdog: i think it's a matter of each .so having the correct list of .so's that its dependent on included within it, 
+                 which (i'm not positive why) ghc doesn't currently do/have-done
+15:31 -!- Saizan [n=saizan@host19-23-dynamic.9-79-r.retail.telecomitalia.it] has quit [Read error: 110 (Connection timed out)]
+15:32 < mmorrow> blackdog: so i think if you can manage to add this info to your .so files, you'd be ok. i'm not sure about what the 
+                 options are to accomplish this though (maybe ld has some options to modify .so's)
+15:32 < mmorrow> i don't recall the name of the field for ELF, but iirc it's DEPENDS or something like that
+15:35 < blackdog> so if i want to depend on a standard installed package, i'd have to fiddle with the .so files that are being built so 
+                  it knows its dependencies too?
+15:36 < blackdog> i think i need .hi files as well - i need to do some reflection on the interface
+15:39 -!- Saizan [n=saizan@host86-241-static.12-87-b.business.telecomitalia.it] has joined #ghc
+15:48 -!- blackh [n=blackh@125-236-232-55.adsl.xtra.co.nz] has quit [Read error: 110 (Connection timed out)]
+15:50 -!- blackh [n=blackh@125-236-232-55.adsl.xtra.co.nz] has joined #ghc
+15:54 -!- Saizan_ [n=saizan@host241-26-dynamic.9-79-r.retail.telecomitalia.it] has quit [Read error: 110 (Connection timed out)]
+16:37 -!- dolio [n=dolio@nr22-66-161-253-70.fuse.net] has quit [Read error: 104 (Connection reset by peer)]
+16:41 -!- dolio [n=dolio@nr22-66-161-253-70.fuse.net] has joined #ghc
+16:46 < mmorrow> blackdog: yeah, fixing the .so files to have the dependency info they should have would fix the linking problem, but 
+                 if you don't know anything about the code you're dlopen()'ing (and you wanted/needed to), you'd need to decode .hi 
+                 files
+16:46 < mmorrow> blackdog: which you'd need to use the ghc-api for
+16:47 < mmorrow> blackdog: the old hs-plugins code that had its own .hi parser is bitrotted
+16:47 < mmorrow> since the binary format for .hi files is unstable
+16:50 < mmorrow> blackdog: although i suppose you could "extract" from ghc what you'd need to decode .hi files, and the associated data 
+                 decls for the contents thereof/etc to avert linking ghc into you app (that'd be nice if the ghc-api itself was in a 
+                 .so..)
+16:54 -!- Saizan_ [n=saizan@host27-5-dynamic.9-79-r.retail.telecomitalia.it] has joined #ghc
+17:07 < blackdog> mmorrow: thanks, that's useful to know. i won't rely wholly on hs-plugins, then
+17:09 < blackdog> so if I want to be able to do it without an installed ghc, I'd better build a .so myself that can do whatever munging 
+                  I need, then just embed the dependencies into that and just ship .so files
+17:10 -!- Saizan [n=saizan@host86-241-static.12-87-b.business.telecomitalia.it] has quit [Read error: 110 (Connection timed out)]
+17:10 < blackdog> what would be the semantics of dlopen-ing two haskell .so files and calling them concurrently from C? will horrible 
+                  things happen?
+17:11 < mmorrow> oh, calling them from C.. hmm, i'm not positive.
+17:12 < mmorrow> i know each module has a module init area, where there a .long/.quad in .data that's either 0 or 1, and initializing a 
+                 module amounts to jumping to some label in that area, and a module will recursively initialize all mods it depends on
+17:13 < mmorrow> i'm not sure exactly though what the deal is if you've got an rts instance, say, then you dlopen a few haskell .so's 
+                 from C
+17:14 < blackdog> do you know who would know? it's a difficult thing to test for, it might work fine for a million tests then launch 
+                  the missiles on the next
+17:14 < mmorrow> blackdog: re: building an .so yourself, aside from ensuring there's the needed .so dep info in the dynamic section (or 
+                 whatever), i guess you could go about embedding type/etc info in two ways/at two different levels
+17:15 < mmorrow> the first level being to add that info to each module (say in "interface :: Map String Info"), or alternatively (and 
+                 probably epic) would be to embed that info in the .so file itself somewhere
+17:15 < mmorrow> e.g. ELF has NOTE sections..
+17:15 < blackdog> i think i can probably get away with a bit less information
+17:15 < mmorrow> but that would mean you'd need to parse the object files themselves ..
+17:16 < mmorrow> blackdog: i'd ask JaffaCake about this
+17:16 < mmorrow> if anyone knew what you need to do/what could do wrong i'd say it'd be him
+17:17 -!- bos [n=bos@67.188.108.77] has quit [Read error: 145 (Connection timed out)]
+17:18 < blackdog> well, i can write a program that uses the ghc-api at compile time to get a list of the identifiers in a given module, 
+                  with their types. I can then filter out the identifiers that don't fit my scheme, and create an SO with the minimal 
+                  info i need to call it from outside
+17:18 < blackdog> at that stage, the types will be exactly the same, all i need is the names of the wrapper functions
+17:18 < mmorrow> blackdog: totally, that sounds do-able
+17:18 < mmorrow> right
+17:18 < blackdog> ok, cool. thanks for helping me vet my logic:)

data/ext/hubris.rb

@@ -0,0 +1,4 @@
+
+puts "I AM A BANANA"
+# raise "FUCK YOOOOOOOOOOOOU"
+system "touch Makefile"

data/ext/stub/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("stub")
+have_header("ruby.h")
+create_makefile("stub")

data/ext/{HubrisStubLoader.c → stub/stub.c}

@@ -17,7 +17,7 @@ void safe_hs_init() {
   } 
 }
 
-void Init_HubrisStubLoader() {
+void Init_stub() {
   // don't do anything, we just want to make
   // sure that the other objects can see the
   // safe_hs_init symbols at the C level

data/hubris.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hubris/version"
+require 'rake'
+
+Gem::Specification.new do |s|
+  s.name        = "hubris"
+  s.version     = Hubris::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mark Wotton", "James Britt", "Josh Price"]
+  s.email       = ["mwotton@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/hubris"
+  s.summary     = %q{A bridge between Ruby and Haskell}
+  s.description = %q{A bridge between Ruby and Haskell}
+
+  s.rubyforge_project = "Hubris"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rake-compiler', '>= 0.7.6'
+  s.add_development_dependency 'rspec', '2.4.0'
+  s.add_dependency 'rake'
+  s.add_dependency 'open4'
+  s.extensions =  'Rakefile' # ext/mkrf_conf.rb'
+  # system "bundle exec rake compile"
+  # Rake::Task['compile'].invoke
+end

data/lib/Makefile

@@ -0,0 +1,181 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /opt/local/include/ruby-1.9.1
+hdrdir = /opt/local/include/ruby-1.9.1
+arch_hdrdir = /opt/local/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/opt/local
+exec_prefix = $(prefix)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_INSTALL_NAME)-$(ruby_version)
+vendordir = $(libdir)/$(RUBY_INSTALL_NAME)/vendor_ruby
+sitedir = $(libdir)/$(RUBY_INSTALL_NAME)/site_ruby
+mandir = $(DESTDIR)/opt/local/share/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+rubylibdir = $(libdir)/$(ruby_install_name)/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+CC = /usr/bin/gcc-4.0
+CXX = /usr/bin/g++-4.0
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+OUTFLAG = -o 
+COUTFLAG = -o 
+
+RUBY_EXTCONF_H = 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+optflags = -O2
+debugflags = -g
+warnflags = -Wall -Wno-parentheses
+CFLAGS   =  -fno-common -O2 $(cflags)  -fno-common -pipe -fno-common 
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/opt/local/include -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) -O2 $(cxxflags)
+ldflags  = -L. -L/opt/local/lib -L/usr/local/lib
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+LDSHAREDXX = $(LDSHARED)
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i386-darwin9
+sitearch = i386-darwin9
+ruby_version = 1.9.1
+ruby = /opt/local/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = $(RUBY) -run -e rmdir -- -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc  
+SRCS = HubrisStubLoader.c
+OBJS = HubrisStubLoader.o
+TARGET = HubrisStubLoader
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-rb-default clean-rb
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		@-$(RMDIRS) $(DISTCLEANDIRS)
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $(@)
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h

data/lib/hubris/version.rb

@@ -0,0 +1,3 @@
+module Hubris
+  VERSION='0.0.4'
+end

data/lib/hubris.rb

@@ -3,7 +3,8 @@ require 'rubygems'
 require 'open4'
 require 'digest/md5'
 require 'rbconfig'
-
+$:.unshift File.dirname(__FILE__) + "/../ext/stub"
+require 'stub'
 # require 'file/temp'
 # require 'libHaskell'
 # TODO delete old files
@@ -26,10 +27,10 @@ class File
 end
 
 module Hubris
-  VERSION = '0.0.3'
-  SO_CACHE = File.expand_path("/var/hubris/cache")
-  HS_CACHE = File.expand_path("/var/hubris/source")
-  require 'HubrisStubLoader'
+  HUBRIS_DIR = ENV['HUBRIS_DIR'] || "/var/hubris"
+  SO_CACHE = File.expand_path(HUBRIS_DIR + "/cache")
+  HS_CACHE = File.expand_path(HUBRIS_DIR + "/source")
+  # require 'stub'
   [SO_CACHE,HS_CACHE].each {|dir| FileUtils.mkdir_p(dir)}
   $:.push(SO_CACHE)
   @always_rebuild=false
@@ -79,10 +80,14 @@ module Hubris
   
   def hubrify(mod, args, src,packages=[])
     libFile = "#{SO_CACHE}/#{zencode(mod)}.#{dylib_suffix}"
+    headers = ""
+    libraries = ""
     if @always_rebuild or !File.exists?(libFile)
-      status,msg = Hubris.noisy("Hubrify --module #{mod} --output #{libFile} #{args.join(' ')} " + 
+      status,msg = Hubris.noisy("Hubrify #{headers} #{libraries} -v --module #{mod} --output #{libFile} #{args.join(' ')} " + 
                                 (packages+@@basepackages).collect{|x| "--package #{x}"}.join(' ') + ' ' + src)
-      # if Hubrify's not installed, we throw an exception. just as good as explicitly checking a flag.
+      # if Hubrify's not installed, we throw an exception. just as
+      # good as explicitly checking a flag.
+      # puts msg
       raise HaskellError.new("Hubrify error:\n#{msg + status.exitstatus.to_s}") unless status.exitstatus == 0
     end
     return libFile
@@ -90,12 +95,9 @@ module Hubris
   
   def dylib_suffix
     case Config::CONFIG['target_os']
-    when /darwin/
-      "bundle"
-    when /linux/
-      "so"
-    else
-      "so" #take a punt
+    when /darwin/; "bundle"
+    when /linux/;  "so"
+    else;          "so" #take a punt
     end
   end
   
@@ -113,6 +115,7 @@ ran   |#{str}|
 output|#{stdout.read}|
 error |#{stderr.read}|
 EOF
+    puts msg
     ignored, status = Process.waitpid2 pid
     msg += "status |#{status}|"
     return status, msg

data/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/sample/Fibonacci.hs

@@ -7,8 +7,8 @@ import Maybe
 
 -- main = putStrLn "11"
 
-fibonacci :: Int -> Int
-fibonacci n = fibs !! n
+fibonacci :: Integer -> Integer
+fibonacci n = fibs !! (fromIntegral n)
   where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
 
 -- local_map = Data.Map.fromList [(1,2), (3,4)]

data/sample/config.ru

@@ -10,12 +10,14 @@ end
 
 
 def arg_from env
- env['REQUEST_URI'] ? env['REQUEST_URI'].to_s.sub(/^\//, '').to_i : 0
+ #env['REQUEST_URI'] ? env['REQUEST_URI'].to_s.sub(/^\//, '').to_i : 0
+ env['PATH_INFO'] ? env['PATH_INFO'].to_s.sub(/^\//, '').to_i : 0
 end
 
 app = proc do |env|
   value = Fibonacci.new.fibonacci( arg_from env )
   [ 200, {'Content-Type' => 'text/plain'}, "The fib number is #{value }" ]
+  # [ 200, {'Content-Type' => 'text/plain'}, "The fib number is #{arg_from env}" ]
 end
 
 run app

data/script/ci.sh

@@ -0,0 +1,25 @@
+
+#!/bin/bash -x
+ghc_version=$1
+set -e
+export PATH=$PATH:$HOME/.cabal/bin
+# another huge hack. let's fix this properly soon TODO
+# export LD_LIBRARY_PATH=$HOME/.rvm/rubies/ruby-1.9.1-p378/lib/    
+export HUBRIS_DIR=~/tmp
+mkdir $HUBRIS_DIR || true
+rm -rf $HUBRIS_DIR/* || true
+rm -rf /tmp/hubris* ||true
+cabal install zlib --user  --enable-shared # needed for tests
+
+# delete old haskell stuff
+ghc-pkg-$ghc_version unregister hubris || true
+rm `which Hubrify` || true
+rvm 1.9.1
+gem build hubris.gemspec
+gem install hubris-0.0.4.gem # can we do these two in one step?
+
+#gem install bundler # i am aware how awful this is.
+#bundle install
+#bundle exec rake compile
+#rm -rf $HUBRIS_DIR/*
+#bundle exec rake

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/hubris.rb'}"
+puts "Loading Hubris gem"
+exec "#{irb} #{libs} --simple-prompt"