hubris 0.0.2 → 0.0.3

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
-gem 'hoe', '>= 2.1.0'
-require 'hoe'
+#gem 'hoe', '>= 2.1.0'
+#require 'hoe'
 require 'fileutils'
 require './lib/hubris'
 
@@ -10,14 +10,14 @@ require './lib/hubris'
 
 # 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.rubyforge_name = "hubris"
-  self.summary = 'tool to help build .so files from haskell code for use in Ruby via dl'
-  self.post_install_message = 'PostInstall.txt'
-  self.readme_file = "README.markdown"
-  self.history_file = "HISTORY.markdown"
-end
+#$hoe = Hoe.spec 'hubris' do
+#  self.developer 'Mark Wotton', 'mwotton@gmail.com'
+#  self.rubyforge_name = "hubris"
+#  self.summary = 'tool to help build .so files from haskell code for use in Ruby via dl'
+#  self.post_install_message = 'PostInstall.txt'
+#  self.readme_file = "README.markdown"
+#  self.history_file = "HISTORY.markdown"
+#end
 
 #require 'newgem/tasks'
 # Dir['tasks/**/*.rake'].each { |t| load t }

data/ext/HubrisStubLoader.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ruby.h>
+
+int loaded = 0;
+VALUE Exports = Qnil;
+extern void hs_init(int * argc, char ** argv[]);
+void safe_hs_init() {
+  char ** argv = malloc(sizeof(char**) * 1);
+  int argc = 1;
+
+  argv[0]="haskell_extension";
+  if (! loaded) {
+    loaded=1;
+    // printf("really loading haskell runtime\n");
+    hs_init(&argc, &argv);
+  } 
+}
+
+void Init_HubrisStubLoader() {
+  // 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
+
+  // so, ok. we do do some stuff here.:) but it's really two separate things.
+  VALUE Hubris = rb_define_module("Hubris");
+  Exports = rb_define_module_under(Hubris, "Exports");
+  
+}

data/ext/extconf.rb

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

data/lib/hubris.rb

@@ -26,7 +26,7 @@ class File
 end
 
 module Hubris
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
   SO_CACHE = File.expand_path("/var/hubris/cache")
   HS_CACHE = File.expand_path("/var/hubris/source")
   require 'HubrisStubLoader'

data/spec/hubris_spec.rb

@@ -0,0 +1,350 @@
+# encoding: ASCII-8BIT
+load File.dirname(__FILE__) + '/spec_helper.rb'
+require "hubris"
+Hubris.add_packages %w(base)
+
+# # just want to check it's actually possible to load a library dynamically
+# describe "dlload" do
+#   it "actually builds and loads a C level dylib stupidly" do
+#     system "cd sample; make"
+#     `cd sample; ruby hsload.rb`.chomp.should eql("144")
+#   end
+# end
+
+class Target
+  def foo_local
+    14
+  end
+end
+
+Signal.trap("INT", 'EXIT');
+
+describe "Target" do  
+  it "whines like a little baby when you pass it bad haskell" do
+    lambda{ class Foo; hubris :inline => "broken _ = (1 + \"a string\")", :no_strict => true; end}.should raise_error(HaskellError)
+  end
+
+  it "ignores a comment" do
+    lambda {
+      class Foo; hubris :inline => "--blah blah blah
+{- another silly comment -}
+foo :: Bool -> Bool
+foo True = False
+foo False = True"; end
+    }.should_not raise_error
+  end
+
+  it "sings like a golden bird when you treat it right, aw yeah" do
+    #    t = Target.new
+    #    lambda { t.inline("working _ = T_FIXNUM (1+2)", { :no_strict => true }) }.should_not raise_error
+    lambda { class Foo; hubris :inline => "working :: Integer -> Integer; working a = 2*a"; end}.should_not raise_error
+  end
+
+
+  #   it "handles booleans" do
+  #     class Bar
+  #       hubris :inline => "my_negate True = False;my_negate False = True", :no_strict => true
+  #     end
+  #     t = Bar.new
+  #     # puts t.methods
+  #     t.my_negate(false).should eql(true)
+  #     t.my_negate(true).should eql(false)
+  #     lambda{ t.my_negate("Banana")}.should raise_error
+  #   end
+  
+  it "handles doubles" do
+    class Doubler
+      hubris :inline => "triple :: Double -> Double; triple a = a*3.0", :no_strict => true
+    end
+    d = Doubler.new
+
+    d.triple(3.4).should eql(10.2)
+  end
+end
+
+describe "Strings" do
+  it "can reverse a string" do 
+    class Stringer
+      hubris :inline => "import Data.ByteString; my_reverse::ByteString->ByteString; my_reverse s = Data.ByteString.reverse s", :no_strict => true
+    end
+    Stringer.new.my_reverse("foot").should eql("toof")
+  end
+end
+
+describe "BigInt" do
+  it "handles BigInts" do
+    class Bigint
+      hubris :inline => "big_inc :: Integer -> Integer; big_inc i = i + 1"
+    end
+    b = Bigint.new
+    b.big_inc(10000000000000000).should eql(10000000000000001)
+    b.big_inc(1).should eql(2)
+  end
+end
+
+describe 'Multiple' do
+  # this one requires multiple lib linking
+  it "can load multiple libs" do
+    class Multiple
+      def foo_local
+        14
+      end
+      hubris :inline => "mydouble::Int->Int; mydouble i =(i + i)" 
+      hubris :inline => "incr::Int->Int;incr i = 1+i"
+    end
+    t=Multiple.new
+    t.mydouble(1).should eql(2)
+    # and it doesn't wipe out other methods on the class
+    t.foo_local.should eql(14)
+    t.incr(3).should eql(4)
+    # FIXME this one is waiting for support of Control.Exception in
+    # JHC
+    # lambda { t.mydouble(2.3)}.should raise_error(HaskellError)
+    # Fooclever.mydouble(2.3).should raise_error(RuntimeError)
+  end
+end
+
+describe 'Arrays' do
+  it "can use arrays sensibly" do
+    class ArrayTest
+      hubris :inline => "mylength :: [Int] -> Int; mylength [] = 0; mylength (_:xs) = 1 + mylength xs"
+    end
+    
+    ArrayTest.new.mylength([1,2,3,4]).should eql(4)
+  end
+  it "returns a haskell list as  an array" do
+    class ArrayTest2
+      hubris :inline => "elts :: Int -> [Int]; elts i = take i [1..]"
+    end
+    t=ArrayTest2.new
+    t.elts(5).should eql([1,2,3,4,5])
+    lambda { t.elts("A Banana")}.should raise_error(HaskellError)
+  end
+  it "uses a Haskell array" do
+    class ArrayTest3
+      hubris :inline => "import Data.Array.IArray; larr :: Int -> Array Int Int; larr x = listArray (0,x-1) [1..x]"
+    end
+    ArrayTest3.new.larr(7).should == [1,2,3,4,5,6,7]
+  end
+end
+
+describe 'MaybeOut' do
+  it "passes back maybes" do
+    class Maybe
+      hubris :inline => "foo:: Int -> Maybe Int; foo 1 = Just 1; foo _ = Nothing"
+    end
+    m=Maybe.new
+    m.foo(1).should == 1
+    m.foo(2).should == nil
+    lambda{ m.foo("blah") }.should raise_error(HaskellError)
+  end
+end
+describe "MaybeIn" do
+  it "takes in Maybes" do
+    class MaybeIn
+      hubris :inline => "foo:: Maybe Int -> Int; foo (Just n) = 2*n; foo Nothing = 0"
+    end
+    class MaybeLazy
+      hubris :inline => "foo:: Maybe Int -> Int; foo (Just _) = 1; foo Nothing = 0"
+    end
+    m=MaybeIn.new
+#    m.foo(1).should == 1
+#    m.foo(20).should == 1
+#    m.foo(nil).should == 2
+    lambda{ m.foo("blah") }.should raise_error(HaskellError)
+    # here's a tricky bit: in the previous example, we had to look at the value of the
+    # Maybe, so the exception got triggered.
+    # Here, however, we're not passing in a nil, so we get a "Just 'something'", and never
+    # deeply examine the something. Arguably, it would be less surprising if we always looked
+    # deeply into it, but it's up for debate. TODO
+    
+    lazy = MaybeLazy.new
+    lazy.foo("blah").should == 1
+  end
+end
+
+describe 'Hashes' do
+  it "can move a Haskell map to ruby" do
+    class HaskellMap
+      hubris :inline => "import Data.Map ; h :: Int -> Map Int Int; h n = Data.Map.fromList $ zip [1..n] [n, n-1 .. 1]"
+    end
+    rh=HaskellMap.new.h(3)
+    rh[3].should == 1
+    rh[2].should == 2
+    rh[1].should == 3
+  end
+  
+  it "can move a ruby map to haskell" do
+    class RubyMap
+      hubris :inline => "import Data.Map; h :: Map Int Int -> Maybe Int; h m = Data.Map.lookup 10 m"
+    end
+    rb = RubyMap.new
+    rb.h({8 => 100, 2 => 7}).should eql(nil)
+    rb.h({10 => 100, 2 => 7}).should eql(100)
+  end
+  
+end
+
+
+
+describe "Blocks" do
+  
+  it "can be called in a block" do
+    class T2
+      hubris :inline => "foo::Integer->Integer;foo i = -i"
+    end
+    t = T2.new
+    (1..2).each do |x|
+      t.foo(x).should eql(0-x)
+    end
+  end
+end
+
+describe "Overwrite" do
+  it "can overwrite old functions" do
+    class Overlapping
+      hubris :inline => "myid::Int -> Int; myid i = i"
+      hubris :inline => "myid::Int -> Int; myid i = i+1"
+    end
+    t=Overlapping.new
+    t.myid(1).should eql(2)
+  end
+  
+  
+end
+
+describe "Exceptions" do
+  it "throws an exception on partial match" do
+    class BoolFunc
+      hubris :inline => "mynot :: Bool -> Bool; mynot True = False; mynot False = True"
+    end
+    t=BoolFunc.new
+    lambda{ t.mynot(true) }.should_not raise_error(HaskellError)
+    lambda{ puts t.mynot("blah") }.should raise_error(HaskellError)
+  end
+
+  it "catches incomplete code unless you turn no_strict on" do
+    lambda {
+      class Incomplete
+        hubris :inline => "incomplete :: Int -> Bool; incomplete 1 = True"
+      end
+    }.should raise_error(HaskellError)
+    lambda { 
+      class IncompleteButOk
+        hubris :inline => "incomplete :: Int -> Bool; incomplete 1 = True" , :no_strict => true
+      end
+    }.should_not raise_error()
+    
+  end
+
+end
+
+describe 'Idempotence' do 
+  it "doesn't affect other modules" do
+    class Existing
+    end
+
+    class Target
+      hubris :inline => "fun :: Int -> Int; fun x = x+1"
+    end
+    e=Existing.new
+    t=Target.new
+    lambda{ e.fun(10)}.should raise_error(NoMethodError)
+    lambda{ t.fun(10)}.should_not raise_error(NoMethodError)
+    t.fun(10).should eql(11)
+  end
+  
+  it "can insert the same code into two ruby modules" do
+    class Foo10
+      hubris :inline => "foobar::Double -> Double;foobar n = n+1.0"
+    end
+    class Foo11
+      hubris :inline => "foobar::Double -> Double;foobar n = n+1.0"
+    end
+
+    Foo10.new.foobar(1.0).should eql(2.0)
+    Foo11.new.foobar(1.0).should eql(2.0)
+
+  end
+end
+
+describe 'Realworld' do
+  it "can handle the bytestring lib" do
+
+    class ByteString
+      hubris :module => "Data.ByteString"
+    end
+    
+    b = ByteString.new
+    b.sort("zabcdfg").should == "abcdfgz"
+  end
+  
+  it "can import zlib" do
+    pending "Not doing the right thing with embedded nulls yet"
+    class ZLib
+      hubris :module => 'Codec.Compression.GZip', :packages => ['zlib', 'bytestring']
+    end
+    z=ZLib.new
+    w="osatnoensauhoestnuhoastuhoeatnuhosnueohnsauostneo"
+    puts w.encoding
+    x=z.compress(w)
+    x.each_byte {|c| print c, ' ' }
+    puts "length|#{x.length}|"
+    puts "second"
+    z.decompress(z.compress(w)).should eql(w)
+  end
+  
+end
+
+describe 'Performance' do
+  def be_quick
+    simple_matcher("a small duration") { |given| given < 0.1 }
+  end
+
+  it "caches its output" do
+    # only relevant for inlining
+    
+    t=Target.new
+    class First
+      hubris :inline => "foobar::Int->Int; foobar a = a"
+    end
+    before = Time.now   
+    class Second
+      hubris :inline => "foobar::Int->Int; foobar a = a"
+    end
+    after = Time.now    
+
+    (after-before).should be_quick
+  end
+
+  it "behaves memory-wise" do
+    # so, how on earth do we do this? Conceptually, we want to bind a function,
+    # call it many times, and assert that memory use is (eventually) constant
+    # possible approaches
+    #   - caveman: ps, grep etc.
+    #   - galois style (is that haskell-dtrace?)
+  end
+  
+  it "behaves concurrently" do
+    # create a bunch of ruby threads which all call a given Haskell function
+    # repeatedly. Checks that we get the right result, and that we don't crash.
+    pending "Don't wanna run this every time"
+    no_threads = 10
+    reps=1000
+    class ConcTest
+      hubris :inline => "sumInts :: Int -> Int; sumInts n = sum [0..n]"
+    end
+    t = ConcTest.new
+    
+    res = (0..no_threads).map { |n| (0..n).inject { |sum,n| sum+n } }
+    threads = []
+    lambda {
+      (0..no_threads).each { |n|
+        threads << Thread.start(n) { |x|
+          reps.times { t.sumInts(x).should eql(res[x]) }
+        }
+      }
+      threads.each { |t| t.join }
+    }.should_not raise_error
+  end
+end

metadata

@@ -1,10 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: hubris
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Mark Wotton
+- James Britt
+- Josh Price
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -13,55 +15,55 @@ date: 2009-11-30 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
+  name: rspec
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.3.3
+        version: "0"
     version: 
-description: |-
-  Hubris is a bridge between Ruby and Haskell, between love and bondage,
-  between slothful indolence and raw, blazing speed. 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 functional goodness 
-  into your ruby programs through the back door.
-  
-  I probably don't have to say this, but patches are very much
-  welcome. If you have trouble installing it, tell me, and help me
-  improve the docs.
-email: 
-- mwotton@gmail.com
+- !ruby/object:Gem::Dependency 
+  name: open4
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Ruby Haskell bridge
+email: mwotton@gmail.com
 executables: []
 
-extensions: []
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
 
-extra_rdoc_files: 
-- Manifest.txt
-- PostInstall.txt
 files: 
 - HISTORY.markdown
-- Manifest.txt
-- PostInstall.txt
-- README.markdown
-- Rakefile
+- ext/extconf.rb
+- ext/HubrisStubLoader.c
 - lib/hubris.rb
-- sample/Fibonacci.hs
+- Rakefile
 - sample/config.ru
+- sample/Fibonacci.hs
+- spec/hubris_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
-homepage: 
+homepage: http://github.com/mwotton/hubris
 licenses: []
 
-post_install_message: PostInstall.txt
+post_install_message: 
 rdoc_options: 
-- --main
-- README.markdown
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
@@ -80,6 +82,6 @@ rubyforge_project: hubris
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: tool to help build .so files from haskell code for use in Ruby via dl
+summary: Hubris is a Ruby Haskell bridge allowing you to call Haskell functions from your Ruby code.
 test_files: []
 

data/Manifest.txt

@@ -1,10 +0,0 @@
-HISTORY.markdown
-Manifest.txt
-PostInstall.txt
-README.markdown
-Rakefile
-lib/hubris.rb
-sample/Fibonacci.hs
-sample/config.ru
-spec/spec.opts
-spec/spec_helper.rb

data/PostInstall.txt

@@ -1,3 +0,0 @@
-For more information on Hubris, see http://github.com/mwotton/Hubris/tree/master
-
-You should now have a bin file named jhc_builder that you can use to compile Haskell files into .so files

data/README.markdown

@@ -1,142 +0,0 @@
-# Hubris
-
-## Description
-
-Hubris is a bridge between Ruby and Haskell, between love and bondage,
-between slothful indolence and raw, blazing speed. 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 functional goodness 
-into your ruby programs through the back door.
-
-I probably don't have to say this, but patches are very much
-welcome. If you have trouble installing it, tell me, and help me
-improve the docs.
-
-## Synopsis
-
-The best docs, as ever, are in the tests, but as a quick precis, you
-can use it a little like this:
-
-    require 'hubris' # best line ever
-
-    class Target
-      hubris :inline =>"triple::Int->Int; triple n = 3*n"
-    end
-
-    t = Target.new
-    puts t.triple(10)
-       => 30
-
-There are a few restrictions. All functions take one argument and
-return one value: this shouldn't be a major problem because you can
-pass arrays of arguments in if you need more. Hubris can currently
-handle numbers, strings, basic types (like nil, true and false),
-arrays and hashes. There will probably be some Ruby structures
-(modules, regular expressions, etc) that won't ever be handled
-natively unless someone can convince me it's a sensible thing to do.
-
-Hubris will refuse to compile Haskell code that produces any
-warnings. You can suppress this admittedly fairly strict behaviour by
-passing the ":no_strict => true" flag, but in your heart of hearts
-you'll know you've done the wrong thing.
-
-There are also two other modes:
-
-      hubris :source => "MyCoolModule.hs"
-
-which loads a source file on disk (in the same directory as your ruby),
-and
-
-      hubris :module => "Data.ByteString", :packages => ["bytestring"]
-
-which will load the Data.ByteString module which is installed on the
-system. In this case, we also need to let the Haskell side know that
-we'll be using the "bytestring" package, so we pass that too: You may
-need to load extra packages with :inline and :source as well, and
-that's supported.
-
-
-## Requirements
-
-* ghc 6.10 (to bootstrap 6.12) and cabal-install. This comes with the
-  Haskell Platform
-* ruby 1.8.6 or higher (most heavily tested on 1.9.1)
-* Linux or Mac. See
-  <http://www.shimweasel.com/2009/09/14/unprincipled-skulduggery-with-ghc-6-12-dylibs-on-mac-os-x>
-  and the following entry for more info on the Mac build.
-* zsh or bash
-* git
-
-## Install
-
-First, we install GHC 6.12 RC2 (living on the cutting edge is fun,
-right?)
-
-    wget http://www.haskell.org/ghc/dist/6.12.1-rc2/ghc-6.12.0.20091121-src.tar.bz2
-    tar -jxvf ghc-6.12.0.20091121-src.tar.bz2
-    cd ghc-6.12.0.20091121-src
-    # 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
-    # check ghc --version at the prompt tells you you're running 6.12
-
-Then get the Haskell support libraries installed
-
-    cabal install c2hs
-    # probably a better way of doing this, but this is how i build it.
-    cabal unpack hubris
-    cd hubris-0.0.2
-    # edit the --extra-include-dirs and --extra-lib-dirs to reflect
-    # your installation. You'll need the ruby headers installed -
-    # they're installed already in ports, and it's ruby1.9.dev on Ubuntu.
-    runhaskell Setup configure  --enable-shared --user --ghc-options=-dynamic --extra-include-dirs=/usr/local/include/ruby-1.9.1/ --extra-lib-dirs=/usr/local/lib/
-    runhaskell Setup build
-    runhaskell Setup install
-    # check that Hubrify is now in your path.
-
-Then the Ruby side
-
-    sudo gem install rake open4 rspec hubris
-
-    git clone git://github.com/mwotton/Hubris.git
-    cd Hubris/lib
-    ruby extconf.rb && make
-    cd ..
-    spec .
-
-I'll gemify this soon too.
-
-
-## Contributors
-
-* Mark Wotton
-* James Britt
-* Josh Price
-* Tatsuhiro Ujihisa
-
-## 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/