hubris 0.0.3 → 0.0.4

data/spec/hubris_spec.rb

@@ -1,27 +1,13 @@
 # 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
+Hubris.add_packages %w(base bytestring)
 
 Signal.trap("INT", 'EXIT');
 
-describe "Target" do  
+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)
+    lambda{ class Foo; hubris :inline => "broken = (1 + \"a string\")"; end}.should raise_error(HaskellError)
   end
 
   it "ignores a comment" do
@@ -34,13 +20,21 @@ 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
+  it "doesn't get fussy about non-exportable stuff" do
+    lambda { class Empty; hubris :inline => "data Foo=Foo; fooerator :: Foo->Foo; fooerator Foo = Foo";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
+end  
   #   it "handles booleans" do
   #     class Bar
   #       hubris :inline => "my_negate True = False;my_negate False = True", :no_strict => true
@@ -51,13 +45,16 @@ foo False = True"; end
   #     t.my_negate(true).should eql(false)
   #     lambda{ t.my_negate("Banana")}.should raise_error
   #   end
-  
-  it "handles doubles" do
+
+
+describe "Floats" do
+  before do
     class Doubler
       hubris :inline => "triple :: Double -> Double; triple a = a*3.0", :no_strict => true
     end
+  end
+  it "handles doubles" do
     d = Doubler.new
-
     d.triple(3.4).should eql(10.2)
   end
 end
@@ -71,14 +68,101 @@ describe "Strings" do
   end
 end
 
+describe "tuples" do
+  before do
+    class Tupler
+      hubris :inline => "revTup :: (Integer,Integer) -> (Integer,Integer); revTup (a,b) = (b,a)"
+      hubris :inline => "expand :: (Integer,Integer) -> (Integer,Integer,Integer); expand (a,b) = (b,a,b)"
+    end
+  end
+  
+  before :each do
+    @t = Tupler.new
+  end
+
+  it 'can call a tuple with an array' do
+    @t.revTup([1,2]).should == [2,1]
+  end
+
+  it 'has no funny array business' do
+    @t.expand([1,2]).should == [2,1,2]
+  end
+end
+
 describe "BigInt" do
-  it "handles BigInts" do
+  before 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
+
+  before(:each) do
+    # pending
+    @b = Bigint.new
+  end
+
+  it "handles smalls" do
+    @b.big_inc(1).should eql(2)
+  end
+
+
+  it 'handles foo' do
+    @b.big_inc(536870912).should ==     536870913
+  end
+
+  it 'handles foo' do
+    @b.big_inc(536870913).should == 536870914
+  end
+
+  # it 'tests' do
+  #   low = 536870912
+  #   high = 1073741825
+    
+  #   while low != high
+  #     mid = (high + low)/2
+  #     puts "mid is #{mid}"
+  #     if @b.big_inc(mid) == mid + 1
+  #       low = mid
+  #     else
+  #       high = mid
+  #     end
+  #   end
+  #   puts "highest working is #{mid}"
+  # end
+
+  it 'handles 30 bits' do
+    @b.big_inc(1073741822).should == 1073741823
+  end
+  it 'handles > 30 bits' do
+    @b.big_inc(1073741823).should == 1073741824
+  end
+  
+  it "handles really big ints" do
+    @b.big_inc(1000000000000000000000000).should eql(1000000000000000000000001)
+  end
+  
+  it "handles ints just before the border" do
+    @b.big_inc(2147483647).should == 2147483648
+  end
+  
+  it "handles > int but < bigint" do
+    @b.big_inc(2147483648).should == 2147483649
+  end
+
+end
+
+describe "BigID" do
+
+  before do
+    class BigId
+      hubris :inline => "big_inc :: Integer -> Integer; big_inc i = i"
+    end
+    @b = BigId.new
+  end
+
+  it 'returns a big fix'  do
+
+    @b.big_inc(1073741824).should == 1073741824
   end
 end
 
@@ -97,10 +181,7 @@ describe 'Multiple' do
     # 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)
+    lambda { t.mydouble(2.3)}.should raise_error(HaskellError)
   end
 end
 
@@ -118,7 +199,7 @@ describe 'Arrays' do
     end
     t=ArrayTest2.new
     t.elts(5).should eql([1,2,3,4,5])
-    lambda { t.elts("A Banana")}.should raise_error(HaskellError)
+    lambda { t.elts("A Banana").should == "FOO" }.should raise_error(HaskellError)
   end
   it "uses a Haskell array" do
     class ArrayTest3
@@ -148,9 +229,9 @@ describe "MaybeIn" do
       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
+    m.foo(1).should == 2
+    m.foo(20).should == 40
+    m.foo(nil).should == 0
     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.
@@ -158,8 +239,8 @@ describe "MaybeIn" do
     # 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
+    #lazy = MaybeLazy.new
+    #lazy.foo("blah").should == 1
   end
 end
 
@@ -207,6 +288,7 @@ describe "Overwrite" do
       hubris :inline => "myid::Int -> Int; myid i = i+1"
     end
     t=Overlapping.new
+    # puts t.methods
     t.myid(1).should eql(2)
   end
   
@@ -255,6 +337,7 @@ describe 'Idempotence' do
   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
@@ -270,9 +353,9 @@ end
 
 describe 'Realworld' do
   it "can handle the bytestring lib" do
-
+    # pending "check"
     class ByteString
-      hubris :module => "Data.ByteString"
+      hubris :module => "Data.ByteString", :no_strict => true
     end
     
     b = ByteString.new
@@ -280,18 +363,23 @@ describe 'Realworld' do
   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
+        pending "Not doing the right thing with embedded nulls yet"
+    # for the moment, we're happy if it errors out in a controlled way
+    
+    lambda {z.decompress(z.compress(w)).should eql(w)}.should raise_error(HaskellError)
+
     x=z.compress(w)
-    x.each_byte {|c| print c, ' ' }
+    x.each_byte {|c| print c, ':' }
     puts "length|#{x.length}|"
+#    x.length.should > 5 # probably some shannon thing here
     puts "second"
-    z.decompress(z.compress(w)).should eql(w)
+    lambda {z.decompress(z.compress(w)).should eql(w)}.should_not raise_error
   end
   
 end
@@ -304,7 +392,6 @@ describe 'Performance' do
   it "caches its output" do
     # only relevant for inlining
     
-    t=Target.new
     class First
       hubris :inline => "foobar::Int->Int; foobar a = a"
     end
@@ -347,4 +434,43 @@ describe 'Performance' do
       threads.each { |t| t.join }
     }.should_not raise_error
   end
+ 
+end
+
+describe "IO" do
+  it "can write a variable" do
+    pending
+    class IOTest
+      hubris :inline =><<EOF
+import Data.IORef
+import System.IO.Unsafe
+ref :: IORef Int
+ref = unsafePerformIO $ newIORef 10
+
+readRef :: IO Int
+readRef = readIORef ref
+modify :: Int -> IO ()
+modify n = writeIORef ref n 
+EOF
+      
+    end
+    i = IOTest.new
+    i.readRef(nil).should == 10
+    i.modify(20)
+    i.readRef(nil).should == 20
+    
+  end
+end
+
+describe "multiple arguments" do
+  it "can call a haskell function with multiple arguments" do
+    class Mult
+      hubris :inline => <<EOF
+add :: Integer -> Integer -> Integer -> Integer
+add x y z = x+y+z
+EOF
+    end
+
+    Mult.new.add(1,9,100).should == 110
+  end
 end

data/tasks/extconf/stub.rake

@@ -0,0 +1,43 @@
+namespace :extconf do
+  extension = File.basename(__FILE__, '.rake')
+
+  ext = "ext/#{extension}"
+  ext_so = "#{ext}/#{extension}.#{Config::CONFIG['DLEXT']}"
+  ext_files = FileList[
+    "#{ext}/*.c",
+    "#{ext}/*.h",
+    "#{ext}/*.rl",
+    "#{ext}/extconf.rb",
+    "#{ext}/Makefile",
+    # "lib"
+  ]
+
+
+  task :compile => extension do
+    if Dir.glob("**/#{extension}.{o,so,dll}").length == 0
+      STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+      STDERR.puts "Gem actually failed to build.  Your system is"
+      STDERR.puts "NOT configured properly to build #{GEM_NAME}."
+      STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+      exit(1)
+    end
+  end
+
+  desc "Builds just the #{extension} extension"
+  task extension.to_sym => ["#{ext}/Makefile", ext_so ]
+
+  file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
+    Dir.chdir(ext) do ruby "extconf.rb" end
+  end
+
+  file ext_so => ext_files do
+    Dir.chdir(ext) do
+      sh(PLATFORM =~ /win32/ ? 'nmake' : 'make') do |ok, res|
+        if !ok
+          require "fileutils"
+          FileUtils.rm Dir.glob('*.{so,o,dll,bundle}')
+        end
+      end
+    end
+  end
+end

data/tasks/extconf.rake

@@ -0,0 +1,13 @@
+namespace :extconf do
+  desc "Compiles the Ruby extension"
+  task :compile
+end
+
+task :compile => "extconf:compile"
+
+task :test => :compile
+
+BIN = "*.{bundle,jar,so,obj,pdb,lib,def,exp}"
+$hoe.clean_globs |= ["ext/**/#{BIN}", "lib/**/#{BIN}", 'ext/**/Makefile']
+$hoe.spec.require_paths = Dir['{lib,ext/*}']
+$hoe.spec.extensions = FileList["ext/**/extconf.rb"].to_a

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hubris
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Mark Wotton
@@ -11,77 +17,162 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-30 00:00:00 +11:00
+date: 2011-02-24 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 7
+        - 6
+        version: 0.7.6
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: open4
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: A Ruby Haskell bridge
-email: mwotton@gmail.com
+  type: :runtime
+  version_requirements: *id004
+description: A bridge between Ruby and Haskell
+email: 
+- mwotton@gmail.com
 executables: []
 
 extensions: 
-- ext/extconf.rb
+- Rakefile
 extra_rdoc_files: []
 
 files: 
+- .gitignore
+- .rvmrc
+- Gemfile
 - HISTORY.markdown
-- ext/extconf.rb
-- ext/HubrisStubLoader.c
-- lib/hubris.rb
+- Haskell/Hubrify.hs
+- Haskell/LICENSE
+- Haskell/Language/Ruby/Foo.hs
+- Haskell/Language/Ruby/Hubris.hs
+- Haskell/Language/Ruby/Hubris/Binding.hsc
+- Haskell/Language/Ruby/Hubris/GHCBuild.hs
+- Haskell/Language/Ruby/Hubris/Hash.hs
+- Haskell/Language/Ruby/Hubris/Interpolator.hs
+- Haskell/Language/Ruby/Hubris/LibraryBuilder.hs
+- Haskell/Language/Ruby/Hubris/ZCode.hs
+- Haskell/Language/Ruby/Wrappers.hs
+- Haskell/Language/Ruby/testLib.hs
+- Haskell/Setup.hs
+- Haskell/cbits/rshim.c
+- Haskell/cbits/rshim.h
+- Haskell/hubris.cabal
+- INSTALL
+- Manifest.txt
+- PostInstall.txt
+- README.markdown
 - Rakefile
-- sample/config.ru
+- VERSION
+- doc/CommonErrors.txt
+- doc/CommonErrors.txt~HEAD
+- doc/don_feedback.txt
+- doc/haskell-hubris.tex
+- doc/new_interface.rb
+- doc/ruby-hubris.tex
+- doc/wisdom_of_ancients.txt
+- ext/hubris.rb
+- ext/stub/extconf.rb
+- ext/stub/stub.c
+- hubris.gemspec
+- lib/Makefile
+- lib/hubris.rb
+- lib/hubris/version.rb
+- rspec.rake
 - sample/Fibonacci.hs
+- sample/config.ru
+- script/ci.sh
+- script/console
 - spec/hubris_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- tasks/extconf.rake
+- tasks/extconf/stub.rake
 has_rdoc: true
-homepage: http://github.com/mwotton/hubris
+homepage: http://rubygems.org/gems/hubris
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --inline-source
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: hubris
-rubygems_version: 1.3.5
+rubyforge_project: Hubris
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Hubris is a Ruby Haskell bridge allowing you to call Haskell functions from your Ruby code.
+summary: A bridge between Ruby and Haskell
 test_files: []
 

data/ext/extconf.rb

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