mwotton-hubris 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2009-08-10
+
+* 1 major enhancement:
+  * Initial release - allows calls to haskell from ruby.

data/README.markdown

@@ -0,0 +1,117 @@
+# Hubris
+
+## Description
+
+This is a quick and dirty way to call Haskell functions from ruby.
+
+Hubris will wash your car, lie to your boss, and salvage your love life.
+If you are very, very lucky, it might also let you get some uber-fast
+functional goodness into your ruby programs through the back door.
+
+## Synopsis
+
+Eventually, we'll integrate with RubyInline or something similar, 
+so we can write inline Haskell. Until that happy day:
+
+* write a haskell file (say sample/foo.hs) with some ccall exports declared
+* call "jhc_builder.sh foo.hs". This will build "libfoo.so".
+* write a ruby file similar to sample/hsload.rb in order to call the functions from ruby
+
+If all else fails, mail mwotton@gmail.com with tales of woe.
+
+## Requirements
+
+
+* jhc (John's Haskell Compiler)
+* gcc (oh, come on. don't tell me you don't have it)
+* ruby 1.8.6 or higher
+* Mac OSX or Linux
+* bash
+
+## Install
+
+- Install the Hubris gem from RubyForge
+
+<pre>
+    sudo gem install hubris
+</pre>
+
+- Or live on the bleeding edge and install the latest from Github
+
+<pre>
+    gem source --add http://gems.github.com
+    sudo gem install mwotton-hubris
+</pre>
+
+- Get the [Haskell Platform][haskell_platform] and install this for your platform (now we have GHC for building JHC)
+
+- Install Darcs (so we can access the JHC repository)
+
+<pre>
+    sudo cabal update
+    sudo cabal install --global darcs
+</pre>
+
+  Don't worry too much about any warnings that you may see while this builds.
+
+- Install [JHC][jhc] (the instructions there are slightly out of date so use the following instead). Before you start get a cup of tea, and get comfy. This may take a while...
+
+<pre>
+    darcs get --partial http://repetae.net/repos/jhc
+    cd jhc/src
+    darcs get --partial http://repetae.net/repos/Doc
+    cd ../lib
+    darcs get --partial http://darcs.haskell.org/packages/haskell98
+    darcs get --partial http://darcs.haskell.org/packages/containers
+</pre>
+
+- Copy the jhc binary in the root jhc directory to somewhere in your $PATH
+
+## Troubleshooting installation
+
+JHC doesn't have a heap of mac users, so there were a few problems I had in installing.
+
+in ./src/data/rts/jhc_rts_header.h:
+
+    -#include <endian.h>
+    +#include <sys/types.h>
+    +#include <sys/param.h>
+
+make libs doesn't always seem to work off the bat. so long as jhc builds, it's probably ok
+for the moment - copy the jhc binary in the root jhc directory to somewhere in your $PATH.
+
+## Contributors
+
+
+* Mark Wotton
+* James Britt
+* Josh Price
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2009 Mark Wotton
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+[haskell_platform]: http://hackage.haskell.org/platform/
+[jhc]: http://repetae.net/computer/jhc/

data/Rakefile

@@ -0,0 +1,31 @@
+# TODO - want other tests/tasks run by default? Add them to the list
+
+# remove_task :default
+
+# task :default => [:spec, :features]
+
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/hubris'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'hubris' do
+  self.developer 'Mark Wotton', 'mwotton@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = "hubris"
+  self.summary = 'tool to help build .so files from haskell code for use in Ruby via dl' 
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/bin/jhc_builder

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# $1 is our source haskell
+rm -rf tmp.old
+mv tmp tmp.old
+mkdir tmp
+tmp="tmp/$1"
+cat $1 >> $tmp
+echo "main :: IO ()" >> $tmp
+echo "main = return ()"  >> $tmp
+
+cd tmp
+jhc "$1"
+sed -i 's/^main(/disregard_main(/' hs.out_code.c
+gcc '-std=gnu99' -D_GNU_SOURCE '-falign-functions=4' -ffast-math -Wshadow -Wextra -Wall -Wno-unused-parameter -o libdynhs.so \
+  hs.out_code.c -DNDEBUG -O3 -fPIC -shared
+mv libdynhs.so ..

data/lib/Mapper.hs

@@ -0,0 +1,93 @@
+{-# LANGUAGE FlexibleInstances, ForeignFunctionInterface #-}
+{-# INCLUDE <ruby.h> #-}
+
+module Mapper where
+import qualified Data.ByteString.Char8 as B -- do we need Unicode?
+import Data.Array.CArray as CArray
+import Data.Word
+import Foreign.C.String
+import Foreign.Ptr
+import Foreign.Storable
+import RubyMap
+import System.IO.Unsafe
+newtype RString = RString CString
+newtype RSymbol = RSymbol Word
+
+
+
+class Rubyable a where
+  toRuby :: a -> RValue
+  fromRuby :: RValue -> a
+
+instance Rubyable Int where
+  toRuby a  = T_FIXNUM a
+  fromRuby (T_FIXNUM a) = a
+
+instance Rubyable Integer where
+  toRuby a  = T_ a
+  fromRuby (T_FIXNUM a) = a
+
+instance Rubyable Bool where
+  toRuby False  = T_FALSE
+  toRuby True   = T_TRUE
+  fromRuby T_FALSE = False
+  fromRuby T_TRUE = True
+
+instance Rubyable (CArray Word RValue) where 
+  toRuby arr = T_ARRAY arr
+  fromRuby (T_ARRAY arr) = arr
+
+instance Rubyable a => Rubyable [a] where
+  toRuby l = unsafePerformIO $ do
+             arr <- rb_ary_new2 (length l)
+             mapM_ (\(i,x) -> rb_ary_store i arr x) l
+             return $ T_ARRAY arr
+  fromRuby (T_ARRAY arr) = map fromRuby $ CArray.elems arr
+
+instance Rubyable RString where
+    toRuby (RString cstr) = T_STRING cstr
+    fromRuby (T_STRING cstr) = RString cstr
+
+instance Rubyable RSymbol where
+    toRuby (RSymbol index) = T_SYMBOL index
+    fromRuby (T_SYMBOL index) = RSymbol index
+
+
+-- --            | T_REGEXP     
+--               -- the array needs to be managed by ruby
+--             | T_ARRAY (CArray Word RValue)
+--             | T_FIXNUM Int --fixme, probably
+--               -- the hash needs to be managed by ruby
+--             | T_HASH  Int -- definitely FIXME - native ruby hashes, or going to translitrate?
+-- --            | T_STRUCT     
+--             | T_BIGNUM Integer    
+-- --            | T_FILE       
+--             | T_TRUE  
+--             | T_FALSE      
+-- --            | T_DATA       
+--             | T_SYMBOL Word -- interned string
+
+instance Storable RValue where
+    sizeOf _ = 8 -- urgh, fixme. it's just a pointer, basically.
+    alignment _ = 8
+
+-- so here's the problem - TYPE(...) is a macro, so we can't call it from haskell.
+  --   peek ptr = case toEnum $ rb_type ptr of
+--                  RT_FLOAT -> T_FLOAT (rb_num2dbl ptr)
+--                  RT_STRING -> T_STRING (rb_str_to_str ptr)
+                 
+--                  otherwise -> undefined
+               
+               
+-- undefined -- insert definition of loadruby
+ --   poke ptr a = undefined
+
+
+
+
+
+loadRuby :: Ptr RValue -> IO RValue
+loadRuby ptr = undefined
+
+dumpRuby :: RValue -> IO (Ptr RValue)
+dumpRuby rval = undefined

data/lib/RubyMap.chs

@@ -0,0 +1,49 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+module RubyMap where
+#include "rshim.h"
+#include <ruby.h>
+
+-- import Data.Array.CArray as CArray
+import Data.Word
+import Foreign.Ptr
+import Foreign.C.Types	
+import Foreign.C.String
+
+{# context lib="rshim" #}
+{# enum RubyType {} deriving (Eq) #} -- maybe Ord?
+
+-- can we have a type for Value, plz?
+type Value = Ptr () -- fixme
+
+-- we're being a bit filthy here - the interface is all macros, so we're digging in to find what it actually is
+foreign import ccall unsafe "rshim.h rtype" rb_type :: Value -> CInt
+-- FIXME jhc doesn't like importing floating point numbers, for some reason.
+-- foreign import ccall unsafe "ruby.h rb_num2dbl" rb_num2dbl :: Value -> CDouble 
+foreign import ccall unsafe "ruby.h rb_str_to_str" rb_str_to_str :: Value -> CString
+foreign import ccall unsafe "ruby.h rb_ary_new2" rb_ary_new :: Int -> IO Value
+foreign import ccall unsafe "ruby.h rb_ary_store" rb_ary_store :: Value -> Int -> Value -> IO ()
+
+
+-- all values in here need to be allocated and tracked by ruby.
+-- ByteStrings... hm. Probably better to keep them as C-side ruby strings.
+-- better come back and expand this later
+data RValue = T_NIL  
+--            | T_OBJECT 
+--             | T_CLASS      
+--             | T_MODULE     
+            | T_FLOAT Double
+            | T_STRING CString
+--            | T_REGEXP     
+              -- the array needs to be managed by ruby
+--            | T_ARRAY (CArray Word RValue)
+            | T_FIXNUM Int --fixme, probably
+              -- the hash needs to be managed by ruby
+            | T_HASH  Int -- definitely FIXME - native ruby hashes, or going to translitrate?
+--            | T_STRUCT     
+            | T_BIGNUM Integer    
+--            | T_FILE       
+            | T_TRUE  
+            | T_FALSE      
+--            | T_DATA       
+            | T_SYMBOL Word -- interned string

data/lib/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+create_makefile("rshim")
+

data/lib/hubris.rb

@@ -0,0 +1,70 @@
+require 'dl/import'
+require 'tempfile'
+
+module Hubris
+  VERSION = '0.0.1'
+  class Hubris
+    extend DL::Importer # Importable in 1.8, FIXME
+    
+    def initialize(haskell_str)
+      build_jhc(haskell_str)
+    end
+    
+    def noisy(str)
+      print "Noisy: #{str}\n"
+      system(str)
+    end
+    
+    def build_jhc(haskell_str)
+      file=Tempfile.new("TempHs.hs")
+      # cheap way: assert type sigs binding to RValue. Might be able to do better after,
+      # but this'll do for the moment
+      file.print(<<EOF
+import RubyMap
+import Mapper
+main :: IO ()
+main = return ()
+EOF
+                 )
+      file.print(haskell_str)
+      # TODO add foreign export calls immediately for each toplevel func
+      # cheap hacky way: first word on each line, nub it to get rid of
+      # function types.
+      # tricky bit: generating interface for each
+      functions={}
+      haskell_str.each_line do |line|
+        # if line ~= /^[^ ]/ then
+        functions[line.split(/ /)[0]]=1
+      end
+      functions.keys.each do |fname|
+        file.print "#{fname} :: RValue -> IO RValue\n"
+        # end
+      end
+      
+      file.flush
+      # this is so dumb
+      system("cat #{file.path}; cp #{file.path} #{file.path}.hs")
+      if(0!=noisy("jhc  #{file.path}.hs -ilib")) then
+          raise SyntaxError, "JHC build failed"
+      end
+      # output goes to hs_out.code.c
+      # don't need to grep out main any more
+      # FIXME unique name for dynamic lib
+      lib = Tempfile.new("libDyn.so")
+      if(0!=noisy("gcc '-std=gnu99' -D_GNU_SOURCE -D'-falign-functions=4' '-D_JHC_STANDALONE=0' -ffast-math -Wshadow -Wextra -Wall -Wno-unused-parameter -o libdynhs.so \
+ -DNDEBUG -D_JHC_STANDALONE=0 -O3 -fPIC -shared #{file.dirname}/hs.out_code.c -o {lib.name}")) then
+          raise SyntaxError, "C build failed"
+      end
+      dlload lib.name
+      # get all the headers from ... somewhere
+      headers = []
+      headers.each do |header|
+        extern header
+      end
+      extern "hs_init"
+      hs_init
+      # TODO load all the object headers into the lib
+    end
+  end
+  
+end

data/lib/rshim.c

@@ -0,0 +1,11 @@
+#include "rshim.h"
+#include <stdio.h>
+
+void Init_rshim() {
+  printf("loaded, bitches\n");
+}
+
+// did this really have to be a macro? BAD MATZ
+unsigned int rtype(VALUE obj) {
+  return TYPE(obj);
+}

data/lib/rshim.h

@@ -0,0 +1,65 @@
+#ifndef __rshim_h__
+#define __rshim_h__
+#define HAVE_STRUCT_TIMESPEC 1 
+// this is about as filthy as it looks, but c2hs chokes otherwise.
+
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+
+#include <ruby/encoding.h>
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  ({ \
+    VALUE _string = rb_str_new2((const char *)str); \
+    int _enc = rb_enc_find_index(encoding); \
+    rb_enc_associate_index(_string, _enc); \
+    _string; \
+  })
+
+#else
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  rb_str_new2((const char *)str)
+
+#endif
+
+// did this really have to be a macro? BAD MATZ
+unsigned int rtype(VALUE obj);
+
+
+// argh, and again
+enum RubyType {
+ RT_NONE     = T_NONE,
+
+ RT_NIL      = T_NIL    ,
+ RT_OBJECT   = T_OBJECT ,
+ RT_CLASS    = T_CLASS  ,
+ RT_ICLASS   = T_ICLASS ,
+ RT_MODULE   = T_MODULE ,
+ RT_FLOAT    = T_FLOAT  ,
+ RT_STRING   = T_STRING ,
+ RT_REGEXP   = T_REGEXP ,
+ RT_ARRAY    = T_ARRAY  ,
+ RT_FIXNUM   = T_FIXNUM ,
+ RT_HASH     = T_HASH   ,
+ RT_STRUCT   = T_STRUCT ,
+ RT_BIGNUM   = T_BIGNUM ,
+ RT_FILE     = T_FILE   ,
+
+ RT_TRUE     = T_TRUE   ,
+ RT_FALSE    = T_FALSE  ,
+ RT_DATA     = T_DATA   ,
+ RT_MATCH    = T_MATCH  ,
+ RT_SYMBOL   = T_SYMBOL ,
+
+ // t_BLKTAG   = T_BLKTAG , // this one is broken in ruby 1.9
+
+ RT_UNDEF    = T_UNDEF  ,
+ // t_VARMAP   = T_VARMAP , // this one is broken in ruby 1.9
+ // t_SCOPE    = T_SCOPE  , // this one is broken in ruby 1.9
+ RT_NODE     = T_NODE   ,
+
+ RT_MASK     = T_MASK   ,
+};
+#endif

data/sample/Makefile

@@ -0,0 +1,6 @@
+all: libdynhs.so
+libdynhs.so: Test.hs
+	../bin/jhc_builder.sh Test.hs
+
+clean:
+	rm -rf tmp/ libdynhs.so

data/sample/Test.hs

@@ -0,0 +1,28 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+
+-- module Test where
+
+import Foreign.C.Types
+-- import Data.Map
+import Maybe
+
+-- main = putStrLn "11"
+
+fibonacci :: Int -> Int
+fibonacci n = fibs !! n
+  where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
+
+-- local_map = Data.Map.fromList [(1,2), (3,4)]
+
+
+
+-- lookup_hs ::CInt -> CInt
+-- lookup_hs = fromIntegral . Maybe.fromJust . ((flip Data.Map.lookup) local_map) . fromIntegral
+-- foreign export ccall lookup_hs :: CInt -> CInt
+
+fibonacci_hs :: CInt -> CInt
+fibonacci_hs = fromIntegral . fibonacci . fromIntegral
+
+foreign export ccall fibonacci_hs :: CInt -> CInt
+
+-- main = putStrLn "foo"

data/sample/hsload.rb

@@ -0,0 +1,9 @@
+require 'dl/import' 
+
+module HaskyPants
+  extend DL::Importable
+  dlload "./libdynhs.so"
+  extern "int fibonacci_hs(int)"
+end
+
+puts HaskyPants.fibonacci_hs(12)

data/spec/hubris_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Hubris" do
+  
+  it "can whine like a little baby when you pass it bad haskell" do
+    lambda {Hubris::Hubris.new("broken _ = return (1 + \"a string\")")}.should raise_error(SyntaxError)
+  end
+  
+  it "can sing like a golden bird when you treat it right, aw yeah" do
+    lambda {Hubris::Hubris.new("working _ = return (toRuby $ 1 + 2)")}.should_not raise_error
+  end
+  
+  it "can double an int in Haskell-land" do
+    haskell = Hubris::Hubris.new(<<EOF
+-- partial function, will probably crash and burn
+double i = let j = fromRuby i in return (toRuby $ j + j)
+EOF
+                                 )
+    haskell.double(1).should eql(2)
+    haskell.double("foo").should raise_error(RuntimeError)
+  end
+    
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'hubris'

data/tasks/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

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: mwotton-hubris
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Mark Wotton
+- James Britt
+- Josh Price
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Ruby Haskell bridge
+email: mwotton@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- bin/jhc_builder
+- History.txt
+- lib/extconf.rb
+- lib/hubris.rb
+- lib/Mapper.hs
+- lib/rshim.c
+- lib/rshim.h
+- lib/RubyMap.chs
+- Rakefile
+- README.markdown
+- sample/hsload.rb
+- sample/Makefile
+- sample/Test.hs
+- spec/hubris_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: false
+homepage: http://github.com/mwotton/hubris
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: hubris
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Hubris is a Ruby Haskell bridge allowing you to call Haskell functions from your Ruby code.
+test_files: []
+