thorsson_cups 0.0.8

data/ext/cups.c

@@ -0,0 +1,480 @@
+#include <ruby_cups.h>
+
+cups_dest_t *dests, *dest;
+VALUE rubyCups, printJobs;
+
+// Need to abstract this out of cups.c
+VALUE ipp_state_to_symbol(int state)
+{
+
+  VALUE jstate;
+
+  switch (state) {
+    case IPP_JOB_PENDING :
+      jstate = ID2SYM(rb_intern("pending"));  
+      break;
+    case IPP_JOB_HELD :
+      jstate = ID2SYM(rb_intern("held"));
+      break;
+    case IPP_JOB_PROCESSING :
+      jstate = ID2SYM(rb_intern("processing"));
+      break;
+    case IPP_JOB_STOPPED :
+      jstate = ID2SYM(rb_intern("stopped"));
+      break;
+    case IPP_JOB_CANCELED :
+      jstate = ID2SYM(rb_intern("cancelled"));
+      break;
+    case IPP_JOB_ABORTED :
+      jstate = ID2SYM(rb_intern("aborted"));
+      break;
+    case IPP_JOB_COMPLETED :
+      jstate = ID2SYM(rb_intern("completed"));
+      break;
+    default:
+      jstate = ID2SYM(rb_intern("unknown"));
+  }
+  return jstate;
+}
+
+int printer_exists(VALUE printer){
+  // 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...
+  rb_ary_includes(dest_list, printer) ? 1 : 0;
+}
+
+/*
+* 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, job_options;
+  
+  rb_scan_args(argc, argv, "12", &filename, &printer, &job_options);
+  
+  rb_iv_set(self, "@filename", filename);
+  
+  if (NIL_P(job_options)) {
+    rb_iv_set(self, "@job_options", rb_hash_new());
+  } else {
+    rb_iv_set(self, "@job_options", job_options);
+  }
+
+  if (NIL_P(printer)) {
+
+    // Fall back to default printer
+    VALUE def_p = rb_funcall(rubyCups, rb_intern("default_printer"), 0);
+
+    if (def_p == Qfalse) {
+			rb_raise(rb_eRuntimeError, "There is no default printer!");
+		} else {
+			rb_iv_set(self, "@printer", def_p);
+		}
+    
+  } else {
+    if (printer_exists(printer)) {
+      rb_iv_set(self, "@printer", printer);
+    } else {
+      rb_raise(rb_eRuntimeError, "The printer or destination doesn't exist!");
+    }
+  }
+  return self;
+}
+
+/*
+ * Note: rb_hash_keys is defined in 1.8.6, but not in 1.8.7 ubuntu shared lib
+ * This is so that I can get a list of keys to convert to options
+ */
+static int
+cups_keys_i(key, value, ary)
+  VALUE key, value, ary;
+{
+  if (key == Qundef) return ST_CONTINUE;
+  rb_ary_push(ary, key);
+  return ST_CONTINUE;
+}
+
+/*
+* 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)
+{
+  int job_id;
+  VALUE file = rb_iv_get(self, "@filename");
+  VALUE 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);
+
+    VALUE job_options = rb_iv_get(self, "@job_options");
+
+    // Create an array of the keys from the job_options hash
+    VALUE job_options_keys = rb_ary_new();
+    rb_hash_foreach(job_options, cups_keys_i, job_options_keys);
+  
+    VALUE iter;
+    int num_options = 0;
+    cups_option_t *options = NULL;
+
+    // foreach option in the job options array
+    while (!  NIL_P(iter = rb_ary_pop(job_options_keys))) {
+
+      VALUE value = rb_hash_aref(job_options, iter);
+
+      // assert the key and value are strings
+      if (NIL_P(rb_check_string_type(iter)) || NIL_P(rb_check_string_type(value))) {
+        cupsFreeOptions(num_options, options);
+        rb_raise(rb_eTypeError, "job options is not string => string hash");
+        return Qfalse;
+      }
+
+      // convert to char pointers and add to cups optoins
+      char * iter_str  = rb_string_value_ptr(&iter);
+      char * value_str = rb_string_value_ptr(&value);
+      cupsAddOption(iter_str, value_str, num_options++, &options);
+    }
+
+    job_id = cupsPrintFile(target, fname, "rCUPS", num_options, options); // Do it. "rCups" should be the filename/path
+
+    cupsFreeOptions(num_options, options);
+
+    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 Qfalse;
+  }
+}
+
+/*
+* 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;
+  }
+  // should return nil if no default printer is found!
+}
+
+/*
+* 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);
+ 
+    jstate = ipp_state_to_symbol(job_state);
+
+    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 hashes of job info
+* with keys:
+*
+* [:title, :submitted_by, :size, :format, :state]
+*/
+
+
+static VALUE cups_get_jobs(VALUE self, VALUE printer)
+{
+  // Don't have to lift a finger unless the printer exists.
+  if (!printer_exists(printer)){
+    rb_raise(rb_eRuntimeError, "The printer or destination doesn't exist!");
+  }
+  
+  VALUE job_list, job_info_hash, 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_hash = rb_hash_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);
+    jstate = ipp_state_to_symbol(jobs[i].state);
+
+    rb_hash_aset(job_info_hash, ID2SYM(rb_intern("title")), jtitle);
+    rb_hash_aset(job_info_hash, ID2SYM(rb_intern("submitted_by")), juser);
+    rb_hash_aset(job_info_hash, ID2SYM(rb_intern("size")), jsize);
+    rb_hash_aset(job_info_hash, ID2SYM(rb_intern("format")), jformat);
+    rb_hash_aset(job_info_hash, ID2SYM(rb_intern("state")), jstate);
+    
+    rb_hash_aset(job_list, jid, job_info_hash); // 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)
+{
+  // Don't have to lift a finger unless the printer exists.
+  if (!printer_exists(printer)){
+    rb_raise(rb_eRuntimeError, "The printer or destination doesn't exist!");
+  }
+
+  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;
+  }
+
+}
+
+/*
+*/
+
+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);
+  rb_define_attr(printJobs, "job_options", 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,14 @@
+#include <cups/cups.h>
+
+// st.h is needed for ST_CONTINUE constant
+#ifdef __APPLE__
+  #include <ruby/ruby.h>
+  #include <ruby/st.h>
+#else
+  #include <ruby.h>
+  #include <st.h>
+#endif
+
+#ifndef MAXOPTS
+  #define MAXOPTS 100
+#endif

data/lib/cups/print_job/transient.rb

@@ -0,0 +1,56 @@
+require "cups"
+require "tempfile"
+
+module Cups
+
+  class PrintJob
+
+    # Unlike its superclass, a Transient object takes a string of data (e.g. from an IO object).
+    # This is useful when you've got something like a PDF, an ImageMagick byte array, etc that you
+    # just want to send on its way rather than having to touch the file system directly.
+    # === A contrived example:
+    # Say we're using Prawn[http://prawn.majesticseacreature.com/] to generate PDF invoices for some nebulous,
+    # ever-expanding system that promises us sex, drugs, rock & roll, fame and perhaps a pay-rise. Instead of just
+    # generating a file, let's pass the rendered version to a Transient object and let it take care of things:
+    #
+    # ---
+    #
+    #   require 'cups/print_job/transient'
+    #   require 'prawn'
+    #
+    #   invoice = Prawn::Document.new do
+    #     text "Invoice."
+    #   end
+    #
+    #   paper_copy = Cups::PrintJob::Transient.new(invoice.render)
+    #   paper_copy.print
+    #
+    # ---
+    #
+    # As of 0.0.5, all instance methods inherited from PrintJob are unaltered. This may change if I need to
+    # delay passing the print data or change it after initialization, just as PrintJob currently permits the
+    # file to be written to/moved/nonexistent until print is called.
+    #
+    # Enjoy.
+
+    class Transient < PrintJob
+
+      alias_method :old_init, :initialize
+
+      # Create a print job from a non-empty string. Takes optional printer argument, otherwise uses default.
+      # As the tempfile is written to and closed upon initialization, an error will be raised if an empty
+      # string is passed as the first argument.
+      def initialize(data_string, printer=nil)
+        raise "Temporary print job has no data!" if data_string.empty?
+
+        file = Tempfile.new('')
+        file.puts(data_string)
+        file.close
+
+        old_init(file.path, printer)
+      end
+
+    end
+
+  end
+end

data/lib/cups/printer/printer.rb

@@ -0,0 +1,35 @@
+require "cups"
+
+module Cups
+
+  # Right now this just wraps the Cups.options_for hash using method_missing, allowing you to call
+  # things like Printer#printer_make_and_model on an instance.
+  class Printer
+
+    # Creates a Cups::Printer object. Defaults to the default printer, if there is one.
+    def initialize(printer=nil)
+      if printer.nil?
+        raise "There is no default printer!" if !Cups.default_printer
+        @printer = Cups.default_printer
+      else
+        raise "The printer or destination doesn't exist!" unless Cups.show_destinations.include?(printer)
+        @printer = printer
+      end
+    end
+
+    # Call an options key on this object (with hyphens substituted with underscores). Passes onto super if
+    # no key is found or its value is nil.
+    def method_missing(m)
+      get_options
+      key = m.to_s.gsub(/\_/, "-")
+      @options[key].nil? ? super : @options[key]
+    end
+
+    private
+
+    def get_options
+      @options ||= Cups.options_for(@printer)
+    end
+
+  end
+end

data/test/cups_test.rb

@@ -0,0 +1,159 @@
+$LOAD_PATH.unshift File.expand_path( File.dirname(__FILE__) )
+
+require 'rubygems'
+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 setup
+    @printer = Cups.show_destinations.select {|p| p =~ /pdf/i}.first
+    raise "Can't find a PDF printer to run tests with." unless @printer
+  end
+
+  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", @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_we_can_pass_args_down_as_options
+    options = {:foo => 'bar'}
+    pj = Cups::PrintJob.new(sample, @printer, options)
+    assert_equal(options, pj.job_options)
+  end
+  
+  def test_we_can_only_pass_strings_down_as_options
+    options = {:foo => 'bar'}
+    pj = Cups::PrintJob.new(sample, @printer, options)
+    assert_raise(TypeError) { pj.print }
+  end
+  
+  def test_we_can_omit_options_and_will_set_to_empty
+    pj = Cups::PrintJob.new(sample, @printer)
+    assert_equal({}, pj.job_options)
+  end
+  
+  def test_print_job_cancellation
+    pj = Cups::PrintJob.new(sample, @printer)
+    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_raises_with_nonexistent_printers
+    assert_raise(RuntimeError) { Cups.all_jobs(nil) }
+  end
+  
+  def test_all_jobs_returns_hash
+    assert Cups.all_jobs(Cups.default_printer).is_a?(Hash)
+  end
+
+  def test_all_jobs_hash_contains_info_hash
+    pj = Cups::PrintJob.new(sample, @printer)
+    pj.print
+    info = Cups.all_jobs(@printer)[pj.job_id]
+    assert info.is_a?(Hash)
+    assert info.keys.all?{|key| [:title, :format, :submitted_by, :state, :size].include?(key)}
+  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(@printer).is_a?(Hash)
+  end
+
+  def test_dest_options_raises_exception_if_not_real
+    assert_raise(RuntimeError, "The printer or destination doesn't exist!") { Cups.options_for("bollocks_printer") }
+  end
+  
+  def test_job_failed_boolean
+    pj = Cups::PrintJob.new(sample, @printer)
+    pj.print
+    pj.cancel
+    assert !pj.failed?
+  end
+  
+  def test_returns_failure_string_on_cancellation
+    pj = Cups::PrintJob.new(blank_sample, @printer)
+    pj.print
+
+    # assert pj.job_id == 0 # Failed jobs have an ID of zero
+    # assert pj.failed?
+
+    # assert pj.error_reason.is_a?(Symbol)
+  end
+
+  def test_job_state_string
+    pj = Cups::PrintJob.new(sample, @printer)
+    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
+    "#{File.dirname(__FILE__)}/sample.txt"
+  end
+  
+  def blank_sample
+    "#{File.dirname(__FILE__)}/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,74 @@
+--- !ruby/object:Gem::Specification 
+name: thorsson_cups
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
+platform: ruby
+authors: 
+- Ivan Turkovic
+- Chris Mowforth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-08 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: 
+- me@ivanturkovic.com
+- chris@mowforth.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- test/cups_test.rb
+- test/sample_blank.txt
+- test/sample.txt
+- ext/cups.c
+- ext/ruby_cups.h
+- ext/extconf.rb
+- lib/cups/printer/printer.rb
+- lib/cups/print_job/transient.rb
+has_rdoc: true
+homepage: https://github.com/Thorsson/cups
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: thorsson_cups
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A lightweight Ruby library for printing.
+test_files: []
+