gecoder-with-gecode 0.7.1

data/specs/set_var.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::FreeSetVar, '(not assigned)' do
+  before do
+    model = Gecode::Model.new
+    @var = model.set_var(1..3, 0..4)
+  end
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should give glb and lub ranges when inspecting' do
+    @var.inspect.should include('lub-range')
+    @var.inspect.should include('glb-range')
+  end
+  
+  it 'should report the correct bounds' do
+    @var.lower_bound.sort.to_a.should == (1..3).to_a
+    @var.upper_bound.sort.to_a.should == (0..4).to_a
+  end
+  
+  it 'should report correct bounds on upper bound' do
+    @var.upper_bound.min.should == 0
+    @var.upper_bound.max.should == 4
+  end
+  
+  it 'should report correct bounds on lower bound' do
+    @var.lower_bound.min.should == 1
+    @var.lower_bound.max.should == 3
+  end
+  
+  it 'should raise error when trying to access assigned value' do
+    lambda{ @var.value }.should raise_error(RuntimeError)
+  end
+  
+  it 'should not raise error when enumerating over bound multiple times' do
+    # For C0 coverage.
+    lower_bound = @var.lower_bound
+    lambda do
+      lower_bound.each{}
+      lower_bound.each{}
+    end.should_not raise_error
+  end
+end
+
+describe Gecode::FreeSetVar, '(assigned)' do
+  before do
+    model = Gecode::Model.new
+    @var = model.set_var([1], [1])
+    model.solve!
+  end
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it "should give it's value when inspecting" do
+    @var.inspect.should include('[1]')
+    @var.inspect.should_not include('lub-range')
+  end
+  
+  it 'should report the correct bounds' do
+    @var.upper_bound.to_a.should == [1]
+    @var.lower_bound.to_a.should == [1]
+    @var.value.to_a.should == [1]
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/gecoder'
+
+module CustomVarMatchers
+  class HaveDomain
+    def initialize(expected)
+      @expected = expected.to_a
+    end
+    
+    def matches?(target)
+      @target = target
+      return false unless @target.size == @expected.size
+      @expected.each do |element|
+        return false unless @target.include? element
+      end
+      return true
+    end
+    
+    def failure_message
+      "expected #{@target.inspect} to have domain #{@expected.inspect}"
+    end
+    
+    def negative_failure_message
+      "expected #{@target.inspect} not to have domain #{@expected.inspect}"
+    end
+  end
+
+  # Tests whether a variable has the expected domain.
+  def have_domain(expected)
+    HaveDomain.new(expected)
+  end
+  
+  class HaveBounds
+    def initialize(expected_glb, expected_lub)
+      @expected_glb = expected_glb.to_a
+      @expected_lub = expected_lub.to_a
+    end
+    
+    def matches?(target)
+      @target = target
+      return @target.lower_bound.to_a == @expected_glb &&
+        @target.upper_bound.to_a == @expected_lub
+    end
+    
+    def failure_message
+      "expected #{@target.inspect} to have greatest lower bound " + 
+        "#{@expected_glb.inspect} and least upper bound #{@expected_lub.inspect}"
+    end
+    
+    def negative_failure_message
+      "expected #{@target.inspect} to not have greatest lower bound " + 
+        "#{@expected_glb.inspect} and least upper bound #{@expected_lub.inspect}"
+    end
+  end
+
+  # Tests whether a set variable has the expected bounds.
+  def have_bounds(expected_glb, expected_lub)
+    HaveBounds.new(expected_glb, expected_lub)
+  end
+  
+  class IsAlias
+    def initialize(expected)
+      @expected = expected.to_a
+    end
+    
+    def matches?(target)
+      @target = target
+      return false unless @target.size == @expected.size
+      @expected.each do |element|
+        return false unless @target.in(element)
+      end
+      return true
+    end
+    
+    def failure_message
+      "expected #{@target.inspect} to be an alias of #{@expected.inspect}"
+    end
+    
+    def negative_failure_message
+      "expected #{@target.inspect} not to be an alias of #{@expected.inspect}"
+    end
+  end
+
+  # Tests whether a method with a specified name is the alias of another.
+  def is_alias_of(expected)
+    HaveDomain.new(expected)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(CustomVarMatchers)
+end

data/tasks/all_tasks.rb

@@ -0,0 +1 @@
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }

data/tasks/distribution.rake

@@ -0,0 +1,129 @@
+require 'lib/gecoder/version'
+
+PROJECT_NAME = PKG_NAME = 'gecoder'
+PKG_NAME_WITH_GECODE = 'gecoder-with-gecode'
+PKG_VERSION = GecodeR::VERSION
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILE_NAME_WITH_GECODE = "#{PKG_NAME_WITH_GECODE}-#{PKG_VERSION}"
+
+desc 'Generate RDoc'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/output/rdoc'
+  rdoc.options << '--title' << 'Gecode/R' << '--line-numbers' << 
+    '--inline-source' << '--accessor' << 'delegate' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'CHANGES', 'LGPL-LICENSE', 'lib/**/*.rb')
+end
+
+desc 'Generate RDoc, ignoring nodoc'
+Rake::RDocTask.new(:rdoc_dev) do |rdoc|
+  rdoc.rdoc_dir = 'doc/output/rdoc_dev'
+  rdoc.options << '--title' << 'Gecode/R Developers RDoc' << '--line-numbers' << 
+    '--inline-source' << '--accessor' << 'delegate'
+    
+  # Copy the rdoc and remove all #:nodoc: .
+  TMP_DIR = 'doc/tmp/rdoc_dev'
+  Dir['lib/**/*.rb'].each do |source_name|
+    destination_name = source_name.sub('lib', TMP_DIR)
+    File.makedirs File.dirname(destination_name)
+    destination = File.open(destination_name, 'w')
+    File.open(source_name) do |source|
+      source.each{ |line| destination << line.gsub('#:nodoc:', '' ) }
+    end
+    destination.close
+  end
+  
+  rdoc.rdoc_files.include("#{TMP_DIR}/**/*.rb")
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = GecodeR::VERSION
+  s.summary = 'Ruby interface to Gecode, an environment for constraint programming.'
+  s.description = <<-end_description
+    Gecode/R is a Ruby interface to the Gecode constraint programming library. 
+    Gecode/R is intended for people with no previous experience of constraint 
+    programming, aiming to be easy to pick up and use.
+  end_description
+
+  s.files = FileList[
+    '[A-Z]*',
+    'lib/**/*.rb', 
+    'example/**/*',
+    'src/**/*',
+    'vendor/**/*',
+    'tasks/**/*',
+    'specs/**/*',
+    'ext/*'
+  ].to_a
+  s.require_path = 'lib'
+  s.extensions << 'ext/extconf.rb'
+  s.requirements << 'Gecode 1.3.1'
+
+  s.has_rdoc = true
+  s.rdoc_options = rd.options
+  s.extra_rdoc_files = rd.rdoc_files
+  s.test_files = FileList['specs/**/*.rb']
+
+  s.autorequire = 'gecoder'
+  s.author = ["Gecode/R Development Team"]
+  s.email = "gecoder-users@rubyforge.org"
+  s.homepage = "http://gecoder.rubyforge.org"
+  s.rubyforge_project = "gecoder"
+end
+
+# Create a clone of the gem spec that includes Gecode.
+spec_with_gecode = spec.clone
+spec_with_gecode.name = PKG_NAME_WITH_GECODE
+spec_with_gecode.extensions = ['ext/gecode-1.3.1/extconf.rb'] + spec.extensions
+spec_with_gecode.requirements = []
+spec_with_gecode.files = spec.files + FileList['ext/gecode-*/**/*'].to_a 
+
+desc 'Generate Gecode/R Gem'
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc 'Generate Gecode/R + Gecode Gem'
+Rake::GemPackageTask.new(spec_with_gecode) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Publish packages on RubyForge"
+task :publish_packages => [:publist_gecoder_packages, 
+  :publish_gecoder_with_gecode_packages]
+
+desc "Publish Gecode/R packages on RubyForge"
+task :publish_gecoder_packages => [:verify_user, :package] do
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/#{PKG_FILE_NAME}.tgz",
+    "pkg/#{PKG_FILE_NAME}.zip"
+  ]
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PROJECT_NAME)) do |xf|
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.files = release_files.to_a
+    xf.release_name = "Gecode/R #{PKG_VERSION}"
+  end
+end
+
+desc "Publish Gecode/R with Gecode packages on RubyForge"
+task :publish_gecoder_with_gecode_packages => [:verify_user, :package] do
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME_WITH_GECODE}.gem",
+    "pkg/#{PKG_FILE_NAME_WITH_GECODE}.tgz",
+    "pkg/#{PKG_FILE_NAME_WITH_GECODE}.zip"
+  ]
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PROJECT_NAME)) do |xf|
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.files = release_files.to_a
+    xf.release_name = "Gecode/R with Gecode #{PKG_VERSION}"
+  end
+end

data/tasks/rcov.rake

@@ -0,0 +1,17 @@
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+RCOV_DIR = "#{File.dirname(__FILE__)}/../doc/output/coverage"
+
+desc "Run all specs with rcov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = FileList['specs/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude examples', '--exclude specs']
+  t.rcov_dir = RCOV_DIR
+end
+
+RCov::VerifyTask.new(:verify_rcov => :rcov) do |t|
+  t.threshold = 100.0
+  t.index_html = "#{RCOV_DIR}/index.html"
+end

data/tasks/specs.rake

@@ -0,0 +1,15 @@
+require 'spec/rake/spectask'
+
+spec_files = FileList['specs/**/*.rb']
+
+desc 'Run all specs'
+Spec::Rake::SpecTask.new('specs') do |t|
+  t.libs = ['lib']
+  t.spec_files = spec_files
+end
+
+desc 'Generate an rspec html report'
+Spec::Rake::SpecTask.new('spec_html') do |t|
+  t.spec_files = spec_files
+  t.spec_opts = ['--format html:doc/output/rspec.html','--backtrace']
+end

data/tasks/svn.rake

@@ -0,0 +1,11 @@
+require 'lib/gecoder/version'
+
+desc "Tag the release in svn"
+task :tag do
+  from = `svn info`.match(/Repository Root: (.*)/n)[1] + '/trunk'
+  to = from.gsub(/trunk/, "tags/gecoder-#{GecodeR::VERSION}")
+
+  puts "Creating tag in SVN"
+  tag_cmd = "svn cp #{from} #{to} -m \"Tag release Gecode/R #{GecodeR::VERSION}\""
+  `#{tag_cmd}` ; raise "ERROR: #{tag_cmd}" unless $? == 0
+end

data/tasks/website.rake

@@ -0,0 +1,51 @@
+require 'rake/contrib/rubyforgepublisher'
+
+desc 'Regenerates the contents of the website'
+task :website do
+  mkpath 'doc/output'
+  Rake::Task[:spec_html].invoke
+  Rake::Task[:rdoc].invoke
+  Rake::Task[:rdoc_dev].invoke
+  Rake::Task[:rcov].invoke
+  WebsiteRakeHelpers.webgen
+end
+
+desc 'Removes generated documentation'
+task :clobber do
+  WebsiteRakeHelpers.clobber
+end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+desc "Uploads the website to RubyForge"
+task :publish_website => [:verify_user, :website] do
+  publisher = Rake::SshDirPublisher.new(
+    "#{ENV['RUBYFORGE_USER']}@rubyforge.org",
+    "/var/www/gforge-projects/gecoder",
+    "doc/output"
+  )
+  publisher.upload
+end
+
+module WebsiteRakeHelpers
+  module_function
+  
+  # Remove generated documentation.
+  def clobber
+    rm_rf 'doc/output'
+    rm_rf 'doc/tmp'
+  end
+  
+  # Generates the website with webgen.
+  def webgen
+    Dir.chdir 'doc' do
+      output = nil
+      IO.popen('webgen 2>&1') do |io|
+        output = io.read
+      end
+      raise "ERROR while running webgen: #{output}" if output =~ /ERROR/n || $? != 0
+    end
+  end
+end

data/vendor/rust/README

@@ -0,0 +1,28 @@
+When I wanted to write a GUI tagger for KDE using Korundum (KDE Ruby
+bindings), I discovered to my sadness that most of the tagging
+extensions for Ruby were simple bindings for the C interface of the
+most common TagLib library (that is written in C++ instead); writing
+bindings for the C++ interface was quite a complex task, and boring as
+it was to copy and paste the same code over and over.
+
+For this reason I started first writing a simple extensions generator
+that used a YAML description of the namespaces and the classes to
+write bindings for. This method worked fine for what I was working on
+(RubyTag++), and also allowed me to write quite quickly some Ruby
+bindings for Hunspell too.
+
+Unfortunately this generator was not adaptable enough to write
+bindings for C libraries that used some object oriented interfaces,
+and was a mess to extend to provide bindings more suitable to some
+different cases than the ones I've already used the script for.
+
+For this reason I've started working on Rust: a more flexible
+extensions builder, that allowed to bind even C libraries by faking
+some classes on Ruby (although I haven't implemented this yet).
+
+Hopefully in the future Rust can be used to easily produce Ruby
+bindings for a number of libraries that currently aren't available at
+all.
+
+To contact me, send me patches or comments, just write to
+<flameeyes@gmail.com> .

data/vendor/rust/bin/cxxgenerator.rb

@@ -0,0 +1,93 @@
+
+require 'rust/cppifaceparser'
+
+
+if __FILE__ == $0
+  def usage
+    puts "Use: #{File.basename($0)} [header] [module name] [output file]"
+  end
+  
+  parser = Rust::Cpp::IfaceParser.new
+  
+  if ARGV.size != 3 or not File.exists?(ARGV[0].to_s)
+    usage
+    exit 0
+  end
+  
+  header = ARGV[0]
+  namespace = ARGV[1]
+  outputfile = ARGV[2]
+  outputfile += ".rb" if not outputfile =~ /\.rb$/
+  
+  classes = parser.parseFile(header)
+  
+  rust = %@
+require 'rust'
+
+Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "#{namespace}" do |b|
+  b.include_header '#{header}', Rust::Bindings::HeaderGlobal
+  b.add_namespace "#{namespace}", "" do |ns|
+@
+  classes.each { |klass|
+    rust += %@  ns.add_cxx_class "#{klass[:name]}" do |klass|\n@
+    klass[:constructors].each { |constructor|
+      rust += "    klass.add_constructor "
+      if not constructor[:params].empty? and not constructor[:params].detect { |p| p[:type] =~ /void/ }
+        rust += "do |method|\n"
+        constructor[:params].each { |param|
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "    end"
+      end
+      rust += "\n"
+    }
+    
+    klass[:methods].each { |method|
+      comment_method = false
+      if method[:params].detect { |p| p[:type] =~ /\s*\*\s*\*/ }
+        $stderr << "Ignoring method: #{method[:name]}\n"
+        comment_method = true
+      end
+      
+      rust += "# " if comment_method
+      rust += %@    klass.add_method "#{method[:name]}", "#{method[:type]}"@
+      if not method[:params].empty? and not method[:params].detect { |p| p[:type] =~ /void/ }
+        rust += " do |method|\n" if not method[:params].empty?
+        
+        
+        method[:params].each { |param|
+          rust += "# " if comment_method
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "# " if comment_method
+        rust += "    end"
+      end
+      
+      rust += "\n"
+    }
+    rust += "    end\n" 
+  }
+  
+  rust += %@
+  end
+end
+@
+  
+  File.open( outputfile, "w" ) { |f|
+    f << rust << "\n"
+  }
+  
+  # Create configure.rb
+  File.open( File.dirname(outputfile)+"/configure.rb", "w" ) { |f|
+    f << %@
+require 'mkmf'
+find_header("rust_conversions.hh", "./include" )
+eval File.open("#{File.basename(outputfile)}").readlines.to_s
+create_makefile("#{namespace}")
+    @
+  }
+  
+end
+
+
+