cups 0.0.5

data/ext/cups.c

@@ -0,0 +1,457 @@
+#include <ruby_cups.h>
+
+static int num_options;
+static cups_option_t *options;
+cups_dest_t *dests, *dest;
+VALUE rubyCups, printJobs;
+
+
+/*
+* call-seq:
+*   PrintJob.new(filename, printer=nil)
+*
+* Initializes a new PrintJob object. If no target printer/class is specified, the default is chosen.
+* Note the specified file does not have to exist until print is called.
+*/
+static VALUE job_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE filename, printer;
+  
+  rb_scan_args(argc, argv, "11", &filename, &printer);
+  
+  rb_iv_set(self, "@filename", filename);
+  
+  if (NIL_P(printer)) {
+
+    // Fall back to default printer
+    VALUE def_p = rb_funcall(rubyCups, rb_intern("default_printer"), 0);
+    rb_iv_set(self, "@printer", def_p);
+    
+  } else {
+    // First call Cups#show_destinations
+    VALUE dest_list = rb_funcall(rubyCups, rb_intern("show_destinations"), 0);
+    // Then check the printer arg is included in the returned array...
+    if (rb_ary_includes(dest_list, printer)) {
+      rb_iv_set(self, "@printer", printer);
+    } else {
+      rb_raise(rb_eRuntimeError, "The printer or destination doesn't exist!");
+    }
+  }
+  return self;
+}
+
+/*
+* call-seq:
+*   print_job.print -> Fixnum
+*
+* Submit a print job to the selected printer or class. Returns true on success.
+*/
+static VALUE cups_print(VALUE self, VALUE file, VALUE printer)
+{
+  int job_id;
+  file = rb_iv_get(self, "@filename");
+  printer = rb_iv_get(self, "@printer");
+  
+  char *fname = RSTRING_PTR(file); // Filename
+  char *target = RSTRING_PTR(printer); // Target printer string
+  
+  FILE *fp = fopen(fname,"r");
+  // Check @filename actually exists...
+  if( fp ) {
+    fclose(fp);
+    job_id = cupsPrintFile(target, fname, "rCUPS", num_options, options); // Do it.
+    rb_iv_set(self, "@job_id", INT2NUM(job_id));
+    return Qtrue;
+  } else {
+  // and if it doesn't...
+    rb_raise(rb_eRuntimeError, "Couldn't find file");
+    return self;
+  }
+}
+
+/*
+* call-seq:
+*   Cups.show_destinations -> Array
+*
+* Show all destinations on the default server
+*/
+static VALUE cups_show_dests(VALUE self)
+{
+  VALUE dest_list;
+  int i;
+  int num_dests = cupsGetDests(&dests); // Size of dest_list array
+  dest_list = rb_ary_new2(num_dests);
+  
+  for (i = num_dests, dest = dests; i > 0; i --, dest ++) {
+    VALUE destination = rb_str_new2(dest->name);
+    rb_ary_push(dest_list, destination); // Add this testination name to dest_list string
+  }
+  return dest_list;
+}
+
+/*
+* call-seq:
+*   Cups.default_printer -> String or nil
+*
+* Get default printer or class. Returns a string or false if there is no default
+*/
+static VALUE cups_get_default(VALUE self)
+{
+  const char *default_printer;
+  default_printer = cupsGetDefault();
+
+  if (default_printer != NULL) {
+    VALUE def_p = rb_str_new2(default_printer);
+    return def_p;
+  }
+}
+
+/*
+* call-seq:
+*   print_job.cancel -> true or false
+*
+* Cancel the current job. Returns true if successful, false otherwise.
+*/
+static VALUE cups_cancel(VALUE self)
+{
+  VALUE printer, job_id;
+  printer = rb_iv_get(self, "@printer");
+  job_id = rb_iv_get(self, "@job_id");
+  
+  if (NIL_P(job_id)) {
+    return Qfalse; // If @job_id is nil
+  } else { // Otherwise attempt to cancel
+    int job = NUM2INT(job_id);
+    char *target = RSTRING_PTR(printer); // Target printer string
+    int cancellation;
+    cancellation = cupsCancelJob(target, job);
+    return Qtrue;
+  }
+}
+
+/*
+* call-seq:
+*   print_job.failed? -> true or false
+*
+* Did this job fail?
+*/
+static VALUE cups_job_failed(VALUE self)
+{
+  VALUE job_id = rb_iv_get(self, "@job_id");
+
+ if (NIL_P(job_id) || !NUM2INT(job_id) == 0) {
+   return Qfalse;
+ } else {
+   return Qtrue;
+ }
+}
+
+/*
+* call-seq:
+*   print_job.error_reason -> String
+*
+* Get the last human-readable error string
+*/
+static VALUE cups_get_error_reason(VALUE self)
+{
+  VALUE job_id = rb_iv_get(self, "@job_id");
+  
+  if (NIL_P(job_id) || !NUM2INT(job_id) == 0) {
+    return Qnil;
+  } else {
+    VALUE error_exp = rb_str_new2(cupsLastErrorString());
+    return error_exp;
+  }
+}
+
+/*
+* call-seq:
+*   print_job.error_code -> Fixnum
+*
+* Get the last IPP error code.
+*/
+static VALUE cups_get_error_code(VALUE self)
+{
+  VALUE job_id = rb_iv_get(self, "@job_id");
+  
+  if (NIL_P(job_id) || !NUM2INT(job_id) == 0) {
+    return Qnil;
+  } else {
+    VALUE ipp_error_code = INT2NUM(cupsLastError());
+    return ipp_error_code;
+  }
+}
+
+/*
+* call-seq:
+*   print_job.state -> String
+*
+* Get human-readable state of current job.
+*/
+static VALUE cups_get_job_state(VALUE self)
+{
+  VALUE job_id = rb_iv_get(self, "@job_id");
+  VALUE printer = rb_iv_get(self, "@printer");
+  VALUE jstate;
+  
+  int num_jobs;
+  cups_job_t *jobs;
+  ipp_jstate_t job_state = IPP_JOB_PENDING;
+  int i;
+  char *printer_arg = RSTRING_PTR(printer);
+ 
+  if (NIL_P(job_id)) {
+    return Qnil;
+  } else {
+    num_jobs = cupsGetJobs(&jobs, printer_arg, 1, -1); // Get jobs
+
+    for (i = 0; i < num_jobs; i ++) {
+      if (jobs[i].id == NUM2INT(job_id)) {
+        job_state = jobs[i].state;
+        break;
+      }
+    }
+
+     // Free job array
+     cupsFreeJobs(num_jobs, jobs);
+ 
+    switch (job_state) {
+      case IPP_JOB_PENDING :
+        jstate = rb_str_new2("Pending...");
+        break;
+      case IPP_JOB_HELD :
+        jstate = rb_str_new2("Held");
+        break;
+      case IPP_JOB_PROCESSING :
+        jstate = rb_str_new2("Processing...");
+        break;
+      case IPP_JOB_STOPPED :
+        jstate = rb_str_new2("Stopped");
+        break;
+      case IPP_JOB_CANCELED :
+        jstate = rb_str_new2("Cancelled");
+        break;
+      case IPP_JOB_ABORTED :
+        jstate = rb_str_new2("Aborted");
+        break;
+      case IPP_JOB_COMPLETED :
+		jstate = rb_str_new2("Completed");
+        break;
+      default:
+		jstate = rb_str_new2("Unknown Job Code...");
+    }
+
+    return jstate;
+  }
+}
+
+/*
+* call-seq:
+*   print_job.completed? -> true or false
+*
+* Has the job completed?
+*/
+static VALUE cups_job_completed(VALUE self)
+{
+  VALUE job_id = rb_iv_get(self, "@job_id");
+  VALUE printer = rb_iv_get(self, "@printer");
+  VALUE jstate;
+
+  int num_jobs;
+  cups_job_t *jobs;
+  ipp_jstate_t job_state = IPP_JOB_PENDING;
+  int i;
+  char *printer_arg = RSTRING_PTR(printer);
+
+  if (NIL_P(job_id)) {
+    return Qfalse;
+  } else {
+    num_jobs = cupsGetJobs(&jobs, printer_arg, 1, -1); // Get jobs
+    // job_state = IPP_JOB_COMPLETED;
+
+    for (i = 0; i < num_jobs; i ++) {
+      if (jobs[i].id == NUM2INT(job_id)) {
+        job_state = jobs[i].state;
+        break;
+      }
+      
+      // Free job array
+      cupsFreeJobs(num_jobs, jobs);
+      
+      if (job_state == IPP_JOB_COMPLETED) {
+        return Qtrue;
+      } else {
+        return Qfalse;
+      }
+      
+    }
+  }  
+}
+
+/*
+* call-seq:
+*   Cups.all_jobs(printer) -> Hash
+*
+* Get all jobs from default CUPS server. Takes a single printer/class string argument.
+* Returned hash keys are CUPS job ids, and the values are arrays of job info in the
+* following order:
+*
+* [title,submitted_by,size,format,state]
+*/
+static VALUE cups_get_jobs(VALUE self, VALUE printer)
+{
+  VALUE job_list, job_info_ary, jid, jtitle, juser, jsize, jformat, jstate;
+  int job_id;
+  int num_jobs;
+  cups_job_t *jobs;
+  ipp_jstate_t state;
+  int i;
+  char *printer_arg = RSTRING_PTR(printer);
+  
+  num_jobs = cupsGetJobs(&jobs, printer_arg, 1, -1); // Get jobs
+  job_list = rb_hash_new();
+  
+  for (i = 0; i < num_jobs; i ++) { // Construct a hash of individual job info
+    job_info_ary = rb_ary_new();
+    jid = INT2NUM(jobs[i].id);
+    jtitle = rb_str_new2(jobs[i].title);
+    juser = rb_str_new2(jobs[i].user);
+    jsize = INT2NUM(jobs[i].size);
+    jformat = rb_str_new2(jobs[i].format);
+    
+    // Let's elaborate on that job state...
+    switch (jobs[i].state) {
+      case IPP_JOB_PENDING :
+        jstate = rb_str_new2("Pending...");
+        break;
+      case IPP_JOB_HELD :
+        jstate = rb_str_new2("Held");
+        break;
+      case IPP_JOB_PROCESSING :
+        jstate = rb_str_new2("Processing...");
+        break;
+      case IPP_JOB_STOPPED :
+        jstate = rb_str_new2("Stopped");
+        break;
+      case IPP_JOB_CANCELED :
+        jstate = rb_str_new2("Cancelled");
+        break;
+      case IPP_JOB_ABORTED :
+        jstate = rb_str_new2("Aborted");
+        break;
+      case IPP_JOB_COMPLETED :
+        jstate = rb_str_new2("Completed");
+    }
+    
+    rb_ary_push(job_info_ary, jtitle);
+    rb_ary_push(job_info_ary, juser);
+    rb_ary_push(job_info_ary, jsize);
+    rb_ary_push(job_info_ary, jformat);
+    rb_ary_push(job_info_ary, jstate);
+    
+    rb_hash_aset(job_list, jid, job_info_ary); // And push it all into job_list hash
+  }
+
+  // Free job array
+  cupsFreeJobs(num_jobs, jobs);
+
+  return job_list;
+}
+
+/*
+ * call-seq:
+ *   Cups.options_for(name) -> Hash or nil
+ *
+ * Get all options from CUPS server with name. Returns a hash with key/value pairs
+ * based on server options, or nil if no server with name.
+ */
+static VALUE cups_get_options(VALUE self, VALUE printer)
+{
+  VALUE options_list;
+  int i;
+  char *printer_arg = RSTRING_PTR(printer);
+
+  options_list = rb_hash_new();
+
+  cups_dest_t *dests;
+  int num_dests = cupsGetDests(&dests);
+  cups_dest_t *dest = cupsGetDest(printer_arg, NULL, num_dests, dests);
+
+  if (dest == NULL) {
+    cupsFreeDests(num_dests, dests);
+    return Qnil;
+  } else {
+    for(i =0; i< dest->num_options; i++) {
+      rb_hash_aset(options_list, rb_str_new2(dest->options[i].name), rb_str_new2(dest->options[i].value));
+    }
+
+    cupsFreeDests(num_dests, dests);
+    return options_list;
+  }
+
+}
+
+// TODO
+// int ipp_state_to_string(int state)
+// {
+//   // char *jstate;
+//   switch (state) {
+//     case IPP_JOB_PENDING :
+//       // jstate = rb_str_new2("Pending...");
+//       // char jstate[] = "Pending...";
+//       break;
+//     case IPP_JOB_HELD :
+//       // jstate = rb_str_new2("Held");
+//       // char jstate[] = "Held";
+//       break;
+//     case IPP_JOB_PROCESSING :
+//       // jstate = rb_str_new2("Processing...");
+//       // char jstate[] = "Processing...";
+//       break;
+//     case IPP_JOB_STOPPED :
+//       // jstate = rb_str_new2("Stopped");
+//       // char jstate[] = "Stopped";
+//       break;
+//     case IPP_JOB_CANCELED :
+//       // jstate = rb_str_new2("Cancelled");
+//       // char jstate[] = "Cancelled";
+//       break;
+//     case IPP_JOB_ABORTED :
+//       // jstate = rb_str_new2("Aborted");
+//       // char jstate[] = "Aborted";
+//       break;
+//     case IPP_JOB_COMPLETED :
+//       // jstate = rb_str_new2("Completed");
+//       break;
+//   }
+//   return 0;
+// }
+
+/*
+*/
+
+void Init_cups() {
+  rubyCups = rb_define_module("Cups");
+  printJobs = rb_define_class_under(rubyCups, "PrintJob", rb_cObject);
+
+  // Cups::PrintJob Attributes
+  rb_define_attr(printJobs, "printer", 1, 0);
+  rb_define_attr(printJobs, "filename", 1, 0);
+  rb_define_attr(printJobs, "job_id", 1, 0);
+
+  // Cups::PrintJob Methods
+  rb_define_method(printJobs, "initialize", job_init, -1);
+  rb_define_method(printJobs, "print", cups_print, 0);
+  rb_define_method(printJobs, "cancel", cups_cancel, 0);
+  rb_define_method(printJobs, "state", cups_get_job_state, 0);
+  rb_define_method(printJobs, "completed?", cups_job_completed, 0);
+  rb_define_method(printJobs, "failed?", cups_job_failed, 0);
+  rb_define_method(printJobs, "error_reason", cups_get_error_reason, 0);
+  rb_define_method(printJobs, "error_code", cups_get_error_code, 0);
+
+  // Cups Module Methods
+  rb_define_singleton_method(rubyCups, "show_destinations", cups_show_dests, 0);
+  rb_define_singleton_method(rubyCups, "default_printer", cups_get_default, 0);
+  rb_define_singleton_method(rubyCups, "all_jobs", cups_get_jobs, 1);
+  rb_define_singleton_method(rubyCups, "options_for", cups_get_options, 1);
+}

data/ext/extconf.rb

@@ -0,0 +1,15 @@
+require "mkmf"
+
+unless have_library("cups") && find_executable("cups-config")
+  puts "Couldn't find CUPS libraries on your system. Check they're installed and in your path."
+  exit
+end
+
+cups_cflags = `cups-config --cflags`.chomp || ""
+cups_libs = `cups-config --libs`.chomp || ""
+
+with_cflags(cups_cflags) {
+  with_ldflags(cups_libs) {
+    create_makefile("cups")
+  }
+}

data/ext/ruby_cups.h

@@ -0,0 +1,10 @@
+#include <cups/cups.h>
+#ifdef __APPLE__
+#include <ruby/ruby.h>
+#else
+#include <ruby.h>
+#endif
+
+#ifndef MAXOPTS
+  #define MAXOPTS 100
+#endif

data/test/cups_test.rb

@@ -0,0 +1,121 @@
+require "cups"
+require "test/unit"
+
+# The tests which don't make use of mocking go on the operating assumption that you have
+# the CUPS command line utilities installed and in your $PATH
+
+class CupsTest < Test::Unit::TestCase
+  def test_same_printers_returned
+    lplist = `lpstat -a`.split("\n").map { |pr| pr.split(' ').first }
+    cups_destinations = Cups.show_destinations
+    assert cups_destinations.is_a?(Array)
+    assert_equal cups_destinations, lplist
+  end
+  
+  def test_can_instantiate_print_job_object_with_correct_args
+    assert_raise(ArgumentError) do
+      Cups::PrintJob.new
+    end
+    
+    assert_nothing_raised do
+      Cups::PrintJob.new("/path", "PDF_Printer")
+      Cups::PrintJob.new("/path")
+    end
+  end
+  
+  def test_job_defaults_to_default
+    assert_nothing_raised do
+      pj = Cups::PrintJob.new("/non/existent/file")
+
+      assert_equal Cups.default_printer, pj.instance_variable_get(:@printer)
+    end
+  end
+  
+  def test_we_cant_print_to_nonexistent_printers
+    assert_raise(RuntimeError) do
+      pj = Cups::PrintJob.new("/non/existent/file", "bollocks_printer")
+      
+      assert !Cups.show_destinations.include?(pj.instance_variable_get(:@printer))
+    end
+  end
+  
+  def test_we_cant_print_nonexistent_files
+    pj = Cups::PrintJob.new("soft_class")
+    
+    assert_raise(RuntimeError) do
+      pj.print
+    end
+  
+    assert_nil pj.job_id
+  end
+  
+  def test_print_job_cancellation
+    pj = Cups::PrintJob.new(sample, "soft_class")
+    pj.print
+    assert_not_nil pj.job_id
+    assert_equal pj.cancel, true
+    assert pj.job_id.is_a?(Fixnum)
+  end
+  
+  def test_all_jobs_returns_hash
+    assert Cups.all_jobs(Cups.default_printer).is_a?(Hash)
+  end
+  
+  def test_dest_list_returns_array
+    assert Cups.show_destinations.is_a?(Array)
+  end
+  
+  def test_dest_options_returns_hash_if_real
+    assert Cups.options_for("PDF_Printer").is_a?(Hash)
+  end
+
+  def test_dest_options_returns_nil_if_not_real
+    assert_nil Cups.options_for("bollocks_printer")
+  end
+  
+  def test_job_failed_boolean
+    pj = Cups::PrintJob.new(sample, "soft_class")
+    pj.print
+    pj.cancel
+    assert !pj.failed?
+  end
+  
+  def test_returns_failure_string_on_cancellation
+    pj = Cups::PrintJob.new(blank_sample, "PDF_Printer")
+    pj.print
+    
+    assert pj.job_id == 0 # Failed jobs have an ID of zero
+    assert pj.failed?
+    
+    assert pj.error_reason.is_a?(String)
+  end
+  
+  def test_job_state_string
+    pj = Cups::PrintJob.new(sample, "soft_class")
+    assert_nil pj.state # A job can't have a state if it hasn't been assigned a job_id yet
+    assert !pj.completed?
+
+    pj.print
+
+    pj.cancel
+    assert pj.state == "Cancelled"
+    assert !pj.completed?
+  end
+  
+  def test_print_job_attributes
+    pj = Cups::PrintJob.new(sample)
+    [:printer, :filename, :job_id].each do |attr|
+      assert pj.respond_to?(attr)
+    end
+  end
+
+  private
+  
+  def sample
+    "#{Dir.pwd}/sample.txt"
+  end
+  
+  def blank_sample
+    "#{Dir.pwd}/sample_blank.txt"
+  end
+end

data/test/sample.txt

@@ -0,0 +1,9 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris rutrum, nibh ut hendrerit luctus, nisl risus ultrices lorem, sed luctus ipsum velit eget ante. Vestibulum eget est. Sed lectus odio, eleifend non, iaculis in, varius ut, sapien. Suspendisse suscipit urna in sem. Cras in mauris. Sed sapien urna, semper vitae, vulputate a, venenatis et, lacus. Praesent tristique turpis quis quam. Nullam a velit a erat imperdiet luctus. Cras vulputate dignissim leo. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut nulla lorem, dictum quis, cursus eu, dictum ac, nisi.
+
+Pellentesque posuere commodo nunc. Sed eu turpis ac neque cursus aliquet. Nullam semper turpis. In sit amet metus. Nunc vel diam. Praesent sit amet ipsum varius dolor pulvinar pellentesque. Nullam hendrerit. Curabitur condimentum luctus nisi. Morbi eu erat vel eros aliquam sagittis. Sed pellentesque hendrerit augue. Pellentesque facilisis, dui at placerat vulputate, odio metus pulvinar metus, ac porta metus nibh a tortor. Cras lorem dolor, ornare quis, tempor quis, faucibus ut, metus. Donec ac ipsum. Sed pretium.
+
+Praesent elementum dapibus sapien. Nam eleifend faucibus felis. Aliquam erat volutpat. In egestas, ipsum non rutrum cursus, ante libero hendrerit enim, ut lobortis nibh ligula sit amet enim. Nullam dui nulla, ullamcorper et, posuere ac, hendrerit vel, ligula. Suspendisse vel urna non nibh ultrices congue. Sed neque. Sed id tellus eget turpis aliquet mollis. Suspendisse sed eros. Vivamus nulla. Maecenas pulvinar. Aliquam sodales blandit mi.
+
+Curabitur lacinia. Mauris vehicula enim at odio. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque augue sapien, faucibus et, pulvinar vel, tempor eget, elit. Cras a leo vitae justo aliquam laoreet. In et orci sed leo scelerisque condimentum. Integer scelerisque condimentum nisl. Aenean sit amet ligula. In fringilla. Nam elementum diam in dui.
+
+Maecenas aliquam volutpat lectus. Vivamus tellus purus, scelerisque ac, suscipit sed, rhoncus id, justo. Quisque dolor sapien, accumsan vitae, dignissim sed, pulvinar nec, ligula. Cras ligula quam, iaculis ut, ultrices id, varius nec, neque. Mauris ornare nisl ac nunc. Maecenas interdum nisl et quam. Etiam purus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Nam sodales odio. Cras eu ipsum. Donec fringilla odio. Etiam vitae felis vitae lectus porttitor molestie. Nunc consectetur enim at elit tincidunt tempor. Ut fringilla, tortor in rutrum egestas, magna ante suscipit nunc, sit amet sagittis justo quam quis est. Nulla sit amet tortor nec ligula ultricies placerat. Cras congue quam in magna. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce a ante. Etiam congue nunc quis ligula. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: cups
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Chris Mowforth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: "    Ruby CUPS provides a wrapper for the Common UNIX Printing System, allowing rubyists to perform basic tasks like printer discovery, job submission & querying.\n"
+email: 
+- chris@mowforth.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- test/cups_test.rb
+- test/sample.txt
+- test/sample_blank.txt
+- ext/cups.c
+- ext/ruby_cups.h
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://cups.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cups
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: A lightweight Ruby library for printing.
+test_files: []
+