hubris 0.0.3 → 0.0.4

data/Haskell/Language/Ruby/Hubris/ZCode.hs

@@ -0,0 +1,68 @@
+{-# LANGUAGE PatternGuards #-}
+
+module Language.Ruby.Hubris.ZCode (zenc,zdec,Zname(..)) where
+
+import Data.Char
+import Data.Ix
+import qualified Data.Map as M
+import Numeric
+
+zemap :: M.Map Char String
+zemap = M.fromList $
+    [ ('(', "ZL")
+    , (')', "ZR")
+    , ('[', "ZM")
+    , (']', "ZN")
+    , (':', "ZC")
+    , ('Z', "ZZ")
+
+    , ('z', "zz")
+    , ('&', "za")
+    , ('|', "zb")
+    , ('^', "zc")
+    , ('$', "zd")
+    , ('=', "ze")
+    , ('>', "zg")
+    , ('#', "zh")
+    , ('.', "zi")
+    , ('<', "zl")
+    , ('-', "zm")
+    , ('!', "zn")
+    , ('+', "zp")
+    , ('\'', "zq")
+    , ('\\', "zr")
+    , ('/', "zs")
+    , ('*', "zt")
+    , ('_', "zu")
+    , ('%', "zv")
+    ]
+
+zdmap :: M.Map String Char
+zdmap = M.fromList . map (\(a, b) -> (b, a)) . M.toList $ zemap
+
+newtype Zname = Zname String
+zenc :: String -> Zname
+zenc s = Zname $ concatMap (\c -> M.findWithDefault (z c) c zemap) s
+    where
+    z c
+        | any (($ c) . inRange) [('a', 'y'), ('A', 'Z'), ('0', '9')] =
+            [c]
+        | otherwise =
+            let
+                s = showHex (ord c) "U"
+                p = if inRange ('0', '9') (head s) then id else ('0' :)
+            in
+            'z' : p s
+
+zdec :: String -> String
+zdec "" = ""
+zdec [c] = [c]
+zdec (c : cs@(c' : cs'))
+    | c `elem` "zZ"
+    , Just x <- M.lookup [c, c'] zdmap
+    = x : zdec cs'
+    | c == 'z'
+    , (h@(_ : _), 'U' : t) <- span isHexDigit cs
+    , [(n, "")] <- readHex h
+    = chr n : zdec t
+    | otherwise = c : zdec cs

data/Haskell/Language/Ruby/Hubris.hs

@@ -0,0 +1,254 @@
+{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables, TypeSynonymInstances, FlexibleInstances, OverlappingInstances, UndecidableInstances#-}
+module Language.Ruby.Hubris  where
+
+--import Data.Word
+import Data.Map as Map
+-- import Language.Ruby.Hubris.Binding
+-- import System.IO.Unsafe (unsafePerformIO)
+--import Foreign.C.Types
+import Language.Ruby.Hubris.Binding
+--import Control.Monad (forM)
+import Control.Applicative
+import qualified Debug.Trace as T
+import Foreign.C.String
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Lazy as L
+import  Data.ByteString.Internal(w2c,c2w)
+-- type Value = CULong
+import System.IO.Unsafe
+import Data.Array.IArray
+import Data.Maybe
+import Control.Exception
+import Prelude hiding(catch)
+import Monad hiding (when)
+import Data.Typeable
+
+class Callable a where
+  arity :: a -> Int
+  
+instance (Callable b, Haskellable a) => Callable (a -> b) where
+  arity x = 1 + arity (undefined :: b)
+  
+instance Rubyable a => Callable a where
+  arity x = 0
+  
+-- with thanks to copumpkin on #haskell and twitter
+
+-- wrap :: (Haskellable a, Rubyable b) => (a->b) -> (Value -> Value)
+-- wrap func v= unsafePerformIO $ do r <- try (evaluate $ toRuby . func $ toHaskell v)
+--                                   case r of
+--                                     Left (e::SomeException) -> createException (show e) `traces` "died in haskell"
+--                                     Right a                 -> return a
+-- -- wrapIO too? Is there a more generic way of doin
+--             g this? would need a = a', b = IO c, so Rubyable b => Rubyable (IO c). (Throw away Show constraint, not necessary)
+                                    
+data HubrisException = HubrisException String
+  deriving(Show, Typeable)
+
+
+instance Exception HubrisException
+
+-- utility stuff:
+sshow :: S.ByteString -> [Char]
+sshow s = Prelude.map w2c $S.unpack s
+lshow :: L.ByteString -> [Char]
+lshow s = Prelude.map w2c $L.unpack s
+
+-- debugging only
+trace a b = b
+traces :: b -> String -> b
+traces = flip trace
+
+when :: Value -> RubyType -> a -> a
+when v b c = if (rubyType v == b)
+               then c
+               else trace (show (rubyType v,b)) $ throw (HubrisException "failed in when")
+
+class Haskellable a where
+  toHaskell :: Value -> a
+
+class Rubyable a where
+  toRuby :: a -> Value
+
+instance Haskellable Int where
+  toHaskell v = when v RT_FIXNUM $ fix2int v
+
+-- this is ugly, maybe we can use template haskell to remove the boilerplate?
+instance (Rubyable a, Rubyable b) => Rubyable (a,b) where
+  toRuby (a,b) = unsafePerformIO $ do ary <- rb_ary_new2 2
+                                      rb_ary_push ary (toRuby a)
+                                      rb_ary_push ary (toRuby b)
+                                      return ary
+
+instance (Rubyable a, Rubyable b, Rubyable c) => Rubyable (a,b,c) where
+  toRuby (a,b,c) = unsafePerformIO $ do ary <- rb_ary_new2 3
+                                        rb_ary_push ary (toRuby a)
+                                        rb_ary_push ary (toRuby b)
+                                        rb_ary_push ary (toRuby c)
+                                        return ary
+
+instance (Haskellable a, Haskellable b) => Haskellable (a,b) where
+  toHaskell v = when v RT_ARRAY $ unsafePerformIO $
+                do a <- toHaskell <$> rb_ary_entry v 0
+                   b <- toHaskell <$> rb_ary_entry v 1
+                   return (a,b)
+
+instance (Haskellable a, Haskellable b, Haskellable c) => Haskellable (a,b,c) where
+  toHaskell v = when v RT_ARRAY $ unsafePerformIO $
+                do a <- toHaskell <$> rb_ary_entry v 0
+                   b <- toHaskell <$> rb_ary_entry v 1
+                   c <- toHaskell <$> rb_ary_entry v 2
+                   return (a,b,c)
+
+
+
+instance Rubyable Int where
+  toRuby i = int2fix i
+
+instance Rubyable a => Rubyable (IO a) where
+  toRuby a = unsafePerformIO (a >>= return . toRuby)
+instance Haskellable Integer where
+  toHaskell v = case rubyType v of
+                  RT_BIGNUM -> trace ("got a big") $ read  $ unsafePerformIO (rb_big2str v 10 >>= str2cstr >>= peekCString)
+                  RT_FIXNUM -> trace("got a fix") $ fromIntegral $ fix2int v
+                  _         -> throw (HubrisException "Integer") -- wonder if it's kosher to just let the pattern match fail...
+
+instance  Rubyable Integer where
+  toRuby i = trace ("integer to ruby") $ rb_str_to_inum (unsafePerformIO $ (newCAString $ show i) >>= rb_str_new2) 10 1
+
+instance Haskellable Bool where
+  toHaskell v = case rubyType v of
+                RT_TRUE  -> True
+                RT_FALSE -> False
+                _        -> throw (HubrisException "Bool")
+
+instance Rubyable Bool where
+  toRuby True  = constToRuby RUBY_Qtrue
+  toRuby False = constToRuby RUBY_Qfalse
+
+instance Rubyable Double where
+  toRuby d = rb_float_new d
+
+instance Haskellable Double where
+  toHaskell v = case rubyType v of
+                  RT_FLOAT  -> num2dbl v
+                  RT_FIXNUM -> fromIntegral $ fix2int v
+                  _         -> throw (HubrisException "Double")
+
+instance Rubyable Value where
+  toRuby v = v
+
+instance Haskellable Value where
+  toHaskell v = v
+
+
+instance Haskellable S.ByteString where
+  toHaskell v = when v RT_STRING $ unsafePerformIO $ 
+                str2cstr v >>= S.packCString  >>= \a -> return a `traces` ("strict to Haskell: " ++ sshow a)
+
+instance Rubyable S.ByteString where
+  toRuby s = unsafePerformIO $ S.useAsCStringLen s  rb_str_new
+--                               \(cs,len) -> rb_str_new (cs,len) --`traces` ("sstrict back to ruby:" ++ (show $ S.unpack s))
+                                                          
+
+instance Rubyable () where
+  toRuby () = toRuby True -- ???
+
+instance Haskellable L.ByteString where
+  toHaskell v = L.fromChunks [toHaskell v]
+
+instance Rubyable L.ByteString where
+  toRuby s = let res = S.concat $ L.toChunks s
+             in trace ("lazy back to ruby: " ++ show (S.unpack res)) (toRuby res)
+
+instance Haskellable a => Haskellable [a] where
+  toHaskell v = when v RT_ARRAY $ Prelude.map toHaskell $ unsafePerformIO  $ mapM (rb_ary_entry v . fromIntegral) [0..(rb_ary_len v) - 1]
+
+
+
+instance Rubyable a => Rubyable [a] where
+  toRuby l = unsafePerformIO $ do ary <- rb_ary_new2 $ fromIntegral $ Prelude.length l
+                                  mapM_ (\x -> rb_ary_push ary (toRuby x))  l
+                                  return ary
+
+-- this one is probably horribly inefficient.
+instance (Integral a, Ix a, Haskellable b) => Haskellable (Array a b) where
+  toHaskell v = let x = toHaskell v in (listArray (0, fromIntegral $ Prelude.length x) x)
+
+-- could be more efficient, perhaps, but it's space-efficient still thanks to laziness
+instance (Rubyable b, Ix a) => Rubyable (Array a b) where
+  toRuby a = toRuby $ Data.Array.IArray.elems a
+
+instance Haskellable RubyHash where
+  toHaskell v = when v RT_HASH $ RubyHash v
+
+instance Rubyable RubyHash where
+  toRuby (RubyHash v) = v
+
+
+-- Nil maps to Nothing - all the other falsey values map to real haskell values.
+instance Haskellable a => Haskellable (Maybe a) where 
+  toHaskell v = case rubyType v of
+                  RT_NIL -> Nothing                `traces` "Haskell got nothing"
+                  _      -> Just (toHaskell v)     `traces` "Haskell got a value"
+                                                
+instance Rubyable a => Rubyable (Maybe a) where
+  toRuby Nothing  = constToRuby RUBY_Qnil          `traces` "Sending ruby a nil"
+  toRuby (Just a) = toRuby a                       `traces` "Sending a value back"
+
+newtype RubyHash = RubyHash Value -- don't export constructor
+
+instance (Ord a, Eq a, Rubyable a, Rubyable b) => Rubyable (Map.Map a b) where
+  toRuby s = unsafePerformIO $ 
+             do hash <- rb_hash_new
+                mapM_ (\(k,v) -> rb_hash_aset hash (toRuby k) (toRuby v))  (toList s)
+                return hash
+
+instance (Ord a, Eq a, Haskellable b, Haskellable a) => Haskellable (Map.Map a b) where
+  toHaskell hash = when hash RT_HASH $ unsafePerformIO $ 
+                -- fromJust is legit, rb_keys will always return list
+                     do -- putStrLn "Bringing hash over" 
+                        keys <- rb_keys hash
+                        -- putStrLn ("got the keys: "  ++ show keys)
+                        l :: [Value] <- toHaskell <$> rb_keys hash
+
+                        r <- foldM (\m k -> do -- putStrLn $ "Key is " ++ show k
+                                               val <- rb_hash_aref hash k
+                                               -- putStrLn $ "Val is " ++ show val
+                                               return $ Map.insert (toHaskell k) 
+                                                              (toHaskell val)
+                                                              m)
+                                    Map.empty l
+                        return r
+                                                   
+
+
+-- This is a tricky case.
+-- The ruby FFI wants us to pass a C callback which it can apply to each key-value pair
+-- of the hash, so Haskell cannot be fully in control of the process - this makes building
+-- up a Data.Map object in the natural way a bit tricky.
+
+-- current thoughts:
+--  1. write a direct binding to the ruby API, include a C level function for getting the keys.
+--     just eat the cost of transferring through a keys call + looping over the elements.
+--     One big benefit - while iteration is expensive, using it as a hash table should be cheap
+--     (although probably needs to stay in the IO monad, which is less convenient.)
+--
+--  2. write a binding to the Judy library that creates a Judy object directly. If we can convince
+--     HsJudy to accept that, then we're golden - we still have to copy over, but keys operations
+--     should be cheap (and hopefully lazy, but test to make sure).
+--
+-- These are of course not mutually exclusive.
+--
+-- The first should probably be a part of the base package. The second needs access to internals,
+-- but should probably be an optional package. This means that in Hubris.Internals, we should expose
+
+-- > rb_foreach :: Value {- HASH -} -> (CFunction ((Key,Value,a) -> a)) -> a -> IO a 
+-- 
+-- 
+
+-- instance Haskellable (Map.Map a b ) where 
+--   toHaskell (T_HASH s) = unsafePerformIO $ 
+--                          get_each
+                         
+--   toHaskell _ = Nothing

data/Haskell/Language/Ruby/Wrappers.hs

@@ -0,0 +1,32 @@
+module Wrappers where
+import Hubris
+data RValue = T_FIXNUM Int
+            | T_STRING String
+            | T_NIL
+            | T_BIGNUM Integer
+            deriving (Eq, Show,Ord)
+
+wrap :: (Haskellable a, Rubyable b) => (a->b) -> (RValue -> RValue)
+wrap func ar = case (toHaskell ar) of
+                Just a ->  toRuby $ func a
+                Nothing -> T_NIL
+
+class Haskellable a where
+  toHaskell :: RValue -> Maybe a
+
+class Rubyable a where
+  toRuby :: a -> RValue
+
+instance Haskellable Int where
+  toHaskell (T_FIXNUM i) = Just i
+  toHaskell _ = Nothing
+
+instance Rubyable Int where
+  toRuby i = T_FIXNUM i
+
+instance Haskellable Integer where
+  toHaskell (T_BIGNUM i) = Just i
+  toHaskell _ = Nothing
+
+instance Rubyable Integer where
+  toRuby i = T_BIGNUM i

data/Haskell/Language/Ruby/testLib.hs

@@ -0,0 +1,9 @@
+import Language.Ruby.Hubris.LibraryBuilder
+
+main = do 
+  -- Hubris.hs ought to be installed on the system, really.
+  source <- generateSource ["Language/Ruby/Hubris.hs","Language/Ruby/Foo.hs"] "Foo"
+  case source of
+    Left err ->      error $ show err
+    Right Nothing -> error "shouldn't happen" -- maybe throw an error in the interpreter monad instead
+    Right (Just a) -> putStrLn a

data/Haskell/Setup.hs

@@ -0,0 +1,31 @@
+{-# LANGUAGE NamedFieldPuns #-}
+import Distribution.Simple
+import Distribution.Simple.Setup
+import Distribution.Simple.LocalBuildInfo
+import Distribution.Simple.Utils
+import qualified Distribution.PackageDescription as D
+import Distribution.Verbosity
+import System.Directory
+import System.Process
+import Maybe
+import qualified Distribution.ModuleName as Modname
+main = do
+  includeDir <- readProcess "ruby" ["-rrbconfig", "-e", "print RbConfig::CONFIG['rubyhdrdir']"] ""
+  archDir <- readProcess "ruby" ["-rrbconfig", "-e", "print RbConfig::CONFIG['archdir'].gsub(/\\/lib\\//, '/include/').gsub(/\\/include\\/ruby\\//, '/include/ruby-')"] ""
+  defaultMainWithHooks (hooks includeDir archDir)
+
+hooks includeDir archDir = simpleUserHooks
+  {
+   preConf = \arg flags -> do
+      -- probably a nicer way of getting that directory...
+      createDirectoryIfMissing True "dist/build/autogen"
+      -- FILTHY HACK
+      writeFile "dist/build/autogen/Includes.hs" ("module Includes where\nextraIncludeDirs=[\"" ++ includeDir++"\",\"" ++ archDir ++ "\"]") -- show (configExtraIncludeDirs flags))
+      return D.emptyHookedBuildInfo,
+   confHook = \ info flags ->  (confHook simpleUserHooks) info (flags { configSharedLib = Flag True, configExtraIncludeDirs = [includeDir] }),
+   sDistHook = \ pkg lbi hooks flags -> let lib = fromJust $ D.library pkg
+                                            modules = filter (/= Modname.fromString "Includes") $ D.exposedModules lib
+                                            pkg' = pkg { D.library = Just $ lib { D.exposedModules = modules } }   
+                                        in sDistHook simpleUserHooks pkg' lbi hooks flags  
+
+  }

data/Haskell/cbits/rshim.c

@@ -0,0 +1,46 @@
+
+#include "rshim.h"
+
+#include <ruby.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);
+}
+
+VALUE int2fix(long x) {
+  // printf("long2fix called\n");
+  return LONG2FIX(x);
+}
+
+long fix2int(VALUE x) {
+  // printf("fix2long called\n");
+  // return rb_num2int(x);
+  return FIX2LONG(x);
+  //return FIX2INT(x);
+}
+
+double num2dbl(VALUE x) {
+  //  printf("num2dbl called\n");
+  return NUM2DBL(x);
+}
+
+unsigned int rb_ary_len(VALUE x) {
+  return RARRAY_LEN(x);
+}
+
+VALUE keys(VALUE hash) {
+  rb_funcall(hash, rb_intern("keys"), 0);
+}
+
+VALUE buildException(char * message) {
+  VALUE errclass = rb_eval_string("HaskellError");
+  VALUE errobj = rb_exc_new2(errclass, message);
+  return errobj;
+}
+

data/Haskell/cbits/rshim.h

@@ -0,0 +1,50 @@
+#ifndef __FOOSHIM__
+#define __FOOSHIM__ 1
+#define HAVE_STRUCT_TIMESPEC 1 
+#include <ruby.h>
+
+// did this really have to be a macro? BAD MATZ
+unsigned int rtype(VALUE obj);
+VALUE int2fix(long i);
+long fix2int(VALUE x);
+double num2dbl(VALUE x);
+unsigned int rb_ary_len(VALUE x);
+VALUE keys(VALUE hash);
+VALUE buildException(char *);
+// 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/Haskell/hubris.cabal

@@ -0,0 +1,53 @@
+Name:                hubris
+Version:             0.0.4
+Author:              Mark Wotton
+Maintainer:          mwotton@gmail.com
+Build-Type:          Simple
+Cabal-Version:       >=1.2
+License:        OtherLicense
+License-File:   LICENSE
+Build-Type:     Simple
+Author:         Mark Wotton <mwotton@gmail.com>
+Maintainer:     Mark Wotton <mwotton@gmail.com>
+bug-reports:    http://github.com/mwotton/Hubris-Haskell/issues
+Category:       Language
+Stability:      Experimental
+extra-source-files: 
+Synopsis:       Support library for Hubris, the Ruby <=> Haskell bridge
+Description:    Support library for Hubris, the Ruby to Haskell bridge
+                more info at <http://github.com/mwotton/Hubris-Haskell>
+                .
+                Anyway, this version strips the boilerplate that used to be necessary, and is intended to be used in conjunction with <http://github.com/mwotton/Hubris>.
+
+Library
+        -- the ordering is critical, because Cabal doesn't do dependency analysis.
+        Exposed-Modules: Language.Ruby.Hubris.Binding, Language.Ruby.Hubris, Language.Ruby.Hubris.LibraryBuilder, Language.Ruby.Hubris.ZCode, Language.Ruby.Hubris.GHCBuild,Language.Ruby.Hubris.Includes
+-- , Language.Ruby.Hubris.Includes
+        c-sources: cbits/rshim.c
+        -- includes:  cbits/rshim.h
+        install-includes:  cbits/rshim.h
+        include-dirs: cbits
+        cc-options: -U__BLOCKS__ -DHAVE_SNPRINTF
+        extra-libraries: ruby
+        -- a proper fix for this would involve autoconf and I'm not feeling up to it.
+        -- best to pass the args on the command line.
+        --extra-include-dirs=/opt/local/include/ruby-1.9.1/ 
+        --extra-lib-dirs: /opt/local/lib
+        extra-libraries: ruby
+        build-depends: ghc, Cabal>=1.7.4 && < 2.0, base, haskell98, containers, bytestring, array, mtl, old-time, ghc-paths, hint >= 0.3.3.2, HUnit
+
+Executable Hubrify
+  Main-is:           Hubrify.hs
+  Build-Depends:     base >= 3 && < 5, Cabal>=1.7.4 && < 2.0, base, haskell98, containers, bytestring, array, mtl, old-time, ghc-paths, hint, process,ghc
+  Other-Modules:     Language.Ruby.Hubris.Binding
+  c-sources: cbits/rshim.c 
+  include-dirs: cbits 
+  cc-options: -U__BLOCKS__ -DHAVE_SNPRINTF
+  extra-libraries: ruby
+  -- extra-libraries: ruby1.9
+  -- This is bad form, apparently, and if i include it, ./Setup dist cries big fat tears,
+  --  but you _really_ want a dynamic lib with Hubrify, or you'll get a truly
+  -- huge binary (may not even link, I had problems with the iconv dependency from HSbase)
+  -- anyway, pass "--ghc-options=-dynamic" to ./Setup configure, and you should be apples.
+  ghc-options: -dynamic
+

data/INSTALL

@@ -0,0 +1,21 @@
+This is a bit involved at the moment, because you need to have a development version of GHC, 
+as well as having a bootstrapping version of GHC to build it with.
+
+So, on Ubuntu, 
+
+sudo apt-get install ruby ruby-dev ghc libopenssl-ruby
+sudo gem install rake open4 rspec hoe
+cabal install c2hs
+wget http://www.haskell.org/ghc/dist/current/dist/ghc-6.11.20090907-src.tar.bz2
+tar -jxvf ghc-6.11.20090907-src.tar.bz2
+cd ghc-6.11.20090907
+# adjust the argument to -j to your number of cores, and the prefix if you need to install somewhere else
+sh boot && ./configure --enable-shared --prefix=/usr/local && make -j 4 && sudo make install
+cd ..
+git clone git://github.com/mwotton/Hubris.git
+cd Hubris
+rake
+# here's where you'll see a whole lot of successes, if you're very lucky
+# There's a good chance you won't. Tell me what went wrong and i'll fix the docs.
+spec spec/*_spec.rb
+

data/Manifest.txt

@@ -0,0 +1,22 @@
+CommonErrors.txt
+HISTORY.markdown
+History.txt
+HubrisStubLoader.so
+Manifest.txt
+PostInstall.txt
+README.markdown
+Rakefile
+examples/simple_inline/clean_and_run.sh
+examples/simple_inline/haskell_math.rb
+examples/simple_rack_app/Test.hs
+examples/simple_rack_app/config.ru
+examples/simple_rack_app/hsload.rb
+hubris.gemspec
+lib/Makefile
+lib/hubris.rb
+rspec.rake
+sample/Fibonacci.hs
+sample/config.ru
+spec/hubris_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/PostInstall.txt

@@ -0,0 +1 @@
+For more information on Hubris, see http://github.com/mwotton/Hubris/tree/master