gecoder-with-gecode 0.9.0-x86-mswin32-60

data/tasks/distribution.rake

@@ -0,0 +1,194 @@
+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}"
+# The location where the precompiled DLL should be placed.
+DLL_LOCATION = 'lib/gecode.dll'
+EXT_DIR = 'ext'
+
+desc 'Generate RDoc'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/output/rdoc'
+  rdoc.title = 'Gecode/R'
+  rdoc.template = 'doc/rdoc/jamis.rb'
+  rdoc.options << '--line-numbers' << '--inline-source' << 
+    '--accessor' << 'delegate' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'CHANGES', 'LGPL-LICENSE', 'lib/**/*.rb')
+end
+
+TMP_DIR = 'doc/tmp/rdoc_dev'
+desc 'Generate RDoc, ignoring nodoc'
+Rake::RDocTask.new(:rdoc_dev => :prepare_rdoc_dev) do |rdoc|
+  rdoc.rdoc_dir = 'doc/output/rdoc_dev'
+  rdoc.options << '--title' << 'Gecode/R Developers RDoc' << '--line-numbers' << 
+    '--inline-source' << '--accessor' << 'delegate'
+  
+  rdoc.rdoc_files.include("#{TMP_DIR}/**/*.rb")
+end
+
+desc 'Copies the files that RDoc should parse, removing #:nodoc:'
+task :prepare_rdoc_dev do
+  # Copy the rdoc and remove all #:nodoc: .
+  Dir['lib/**/*.rb'].each do |source_name|
+    destination_name = source_name.sub('lib', TMP_DIR)
+    FileUtils.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
+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/**/*.rb',
+    'src/**/*',
+    'vendor/rust/**/*',
+    'tasks/**/*',
+    'specs/**/*',
+    'ext/*.cpp',
+    'ext/*.h',
+    'ext/extconf.rb'
+  ].to_a
+  s.require_path = 'lib'
+  s.extensions << 'ext/extconf.rb'
+  s.requirements << 'Gecode 2.1.1'
+
+  s.has_rdoc = true
+  s.rdoc_options = rd.options
+  s.extra_rdoc_files = rd.rdoc_files
+  s.test_files = FileList['specs/**/*.rb']
+
+  s.authors = ["Gecode/R Development Team"]
+  s.email = "gecoder-users@rubyforge.org"
+  s.homepage = "http://gecoder.rubyforge.org"
+  s.rubyforge_project = "gecoder"
+
+=begin
+  # Development dependencies.
+  # Not listed: rubygems >= 1.2
+  [['rake'], 
+    ['webgen', '= 0.4.7'], 
+    ['coderay'], 
+    ['rspec', '>= 1.0'], 
+    ['rcov'], 
+    ['meta_project'], 
+    ['rubyforge']].each do |dependency|
+    s.add_development_dependency(*dependency)
+  end
+=end
+end
+
+# Create a clone of the gem spec with the precompiled binaries for Windows.
+spec_windows_binary_with_gecode = spec.dup
+spec_windows_binary_with_gecode.name = PKG_NAME_WITH_GECODE
+spec_windows_binary_with_gecode.extensions = []
+spec_windows_binary_with_gecode.requirements = []
+# Add the precompiled Gecode DLLs and precompiled bindings.
+spec_windows_binary_with_gecode.files = spec.files.dup -
+  FileList['ext/**/*'].to_a + 
+  FileList['vendor/gecode/win32/lib/*'].to_a << 'lib/gecode.dll'
+spec_windows_binary_with_gecode.platform = 'x86-mswin32-60' #Gem::Platform::WIN32
+
+# Create a clone of the gem spec that includes Gecode.
+spec_with_gecode = spec.dup
+spec_with_gecode.name = PKG_NAME_WITH_GECODE
+spec_with_gecode.extensions = 
+  spec_with_gecode.extensions.dup.unshift 'ext/gecode-2.1.1/configure'
+spec_with_gecode.requirements = []
+spec_with_gecode.files = spec.files.dup + 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 'Generate Gecode/R + Gecode Gem (windows binary)'
+Rake::GemPackageTask.new(spec_windows_binary_with_gecode) do |pkg|
+end
+
+desc 'Precompiles the Gecode/R bindings for Windows platforms'
+file 'lib/gecode.dll' do
+  cd 'ext' do
+    sh 'ruby -Iwin32 extconf-win32.rb'
+    sh 'make'
+    mv 'gecode.so', "../#{DLL_LOCATION}"
+  end
+end
+
+desc 'Removes generated distribution files'
+task :clobber do
+  rm DLL_LOCATION if File.exists? DLL_LOCATION
+  FileList[
+    "#{EXT_DIR}/*.o",
+    "#{EXT_DIR}/gecode.{cc,hh}",
+    "#{EXT_DIR}/Makefile",
+    "#{EXT_DIR}/mkmf.log"
+  ].to_a.each{ |file| rm file if File.exists? file }
+end
+
+desc 'Publish packages on RubyForge'
+task :publish_packages => [:publish_gecoder_packages, 
+  :publish_gecoder_with_gecode_packages]
+
+# Files included in the vanilla Gecode/R release.
+vanilla_release_files = [
+  "pkg/#{PKG_FILE_NAME}.gem",
+  "pkg/#{PKG_FILE_NAME}.tgz",
+  "pkg/#{PKG_FILE_NAME}.zip"
+]
+desc 'Publish Gecode/R packages on RubyForge'
+task :publish_gecoder_packages => [:verify_user] + vanilla_release_files do
+  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 = vanilla_release_files.to_a
+    xf.release_name = "Gecode/R #{PKG_VERSION}"
+    xf.package_name = PKG_NAME
+  end
+end
+
+# Files included in the release with Gecode.
+gecode_release_files = [
+  "pkg/#{PKG_FILE_NAME_WITH_GECODE}.gem",
+  #"pkg/#{PKG_FILE_NAME_WITH_GECODE}.tgz",
+  #"pkg/#{PKG_FILE_NAME_WITH_GECODE}.zip",
+  "pkg/#{PKG_FILE_NAME_WITH_GECODE}-x86-mswin32.gem"
+]
+desc 'Publish Gecode/R with Gecode packages on RubyForge'
+task :publish_gecoder_with_gecode_packages => 
+    [:verify_user] + gecode_release_files do
+  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 = gecode_release_files.to_a
+    xf.release_name = "Gecode/R with Gecode #{PKG_VERSION}"
+    xf.package_name = PKG_NAME_WITH_GECODE
+  end
+end

data/tasks/rcov.rake

@@ -0,0 +1,18 @@
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+RCOV_DIR = "#{File.dirname(__FILE__)}/../doc/output/coverage"
+
+desc "Run all specs (except examples) with rcov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = FileList['specs/**/*.rb']
+  t.spec_files.exclude 'examples.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,21 @@
+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 'Run specs for the examples'
+Spec::Rake::SpecTask.new(:example_specs) do |t|
+  t.libs = ['lib']
+  t.spec_files = FileList['specs/examples.rb']
+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,16 @@
+require 'lib/gecoder/version'
+
+desc "Tag the release in svn"
+task :tag do
+  base_url = `svn info`.match(/Repository Root: (.*)/n)[1]
+  unless base_url.include? ENV['RUBYFORGE_USER']
+    base_url.gsub!('rubyforge', "#{ENV['RUBYFORGE_USER']}@rubyforge")
+  end
+  from = base_url + '/trunk'
+  to = base_url + "/tags/gecoder-#{GecodeR::VERSION}"
+  options = "-m \"Tag release Gecode/R #{GecodeR::VERSION}\""
+
+  puts "Creating tag in SVN"
+  tag_cmd = "svn cp #{from} #{to} #{options}"
+  `#{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
+
+
+

data/vendor/rust/include/rust_checks.hh

@@ -0,0 +1,116 @@
+/* Copyright (c) 2007 David Cuadrado <krawek@gmail.com>
+ * 
+ * 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.
+ */
+
+#ifndef __RUST_CHECKS__
+#define __RUST_CHECKS__
+
+#include <ruby.h>
+
+static inline void rust_CheckType(VALUE *a)
+{
+	Check_Type(a[0], NUM2INT(a[1]));
+}
+
+static inline bool isType(VALUE val, int type)
+{
+  int result;
+  if( type == 0x0 ) return false;
+  
+  VALUE args[2];
+  args[0] = (VALUE)val;
+  args[1] = INT2FIX(type);
+  
+  rb_protect( (VALUE(*)(VALUE))rust_CheckType, (VALUE)args, &result);
+  return result == 0;
+}
+
+
+static inline bool is_object(VALUE val)
+{
+  return isType(val, T_OBJECT);
+}
+
+static inline bool is_class(VALUE val)
+{
+  return isType(val, T_CLASS);
+}
+
+static inline bool is_module(VALUE val)
+{
+  return isType(val, T_MODULE);
+}
+
+static inline bool is_fLoat(VALUE val)
+{
+  return isType(val, T_FLOAT);
+}
+
+static inline bool is_string(VALUE val)
+{
+  return isType(val, T_STRING);
+}
+
+static inline bool is_regexp(VALUE val)
+{
+  return isType(val, T_REGEXP);
+}
+
+static inline bool is_array(VALUE val)
+{
+  return isType(val, T_ARRAY);
+}
+
+static inline bool is_int(VALUE val)
+{
+  return isType(val, T_FIXNUM) || 
+  	(isType(val, T_BIGNUM) && NUM2INT(val) < INT_MAX);
+}
+
+static inline bool is_hash(VALUE val)
+{
+  return isType(val, T_HASH);
+}
+
+static inline bool is_symbol(VALUE val)
+{
+  return isType(val, T_SYMBOL);
+}
+
+static inline bool is_bool(VALUE val)
+{
+  return val == Qtrue || val == Qfalse;
+}
+
+static inline bool is_charPtr(VALUE val)
+{
+  char *c = 0;
+  c = reinterpret_cast<char *>(DATA_PTR(val));
+  
+  return c != 0; // FIXME
+}
+
+
+
+
+#endif 
+