clamsy 0.0.3 → 0.0.4

data/lib/clamsy/configuration.rb

@@ -0,0 +1,128 @@
+require 'yaml'
+
+module Clamsy
+
+  class ConfigFileSettingNotSupportedError < Exception ; end
+
+  module Configuration
+
+    ENV_REPLACE_PATTERN = /(\$\{(.*?)\})/
+
+    def self.new(file, is_base_config=false)
+      if (config = YAML.load_file(path = File.expand_path(file)) rescue nil)
+        config = replace_with_env_vars(config).merge(:config_src => path)
+        is_base_config ? BundledFileConfig.new(config) : UserFileConfig.new(config)
+      end
+    end
+
+    def method_missing(method, *args)
+      !"#{method}".include?('=') ? get_config_var(method) :
+        set_config_var("#{method}".sub('=','').to_sym, args[0])
+    end
+
+    protected
+
+      def initialize_config_vars(config)
+        @config_vars = {
+          :printer => (printer = config['printer']),
+          :printer_specific => (config[printer] || {}).
+            inject({}) {|memo, args| memo.merge(args[0].to_sym => args[1]) }
+        }
+      end
+
+      def set_config_var(name, value)
+        case name
+        when :printer then @config_vars[name] = value
+        else (@config_vars[:printer_specific] ||= {})[name] = value
+        end
+      end
+
+      def get_config_var(name)
+        case name
+        when :printer then @config_vars[name]
+        else (@config_vars[:printer_specific] ||= {})[name]
+        end
+      end
+
+      def self.replace_with_env_vars(hash)
+        hash.inject({}) do |memo, args|
+          key, val = args
+          if val.is_a?(Hash)
+            memo.merge(key => replace_with_env_vars(val))
+          elsif !val.nil?
+            while val[ENV_REPLACE_PATTERN,1]
+              (m = val.match(ENV_REPLACE_PATTERN)) && val.sub!(m[1], ENV[m[2]] || '')
+            end
+            memo.merge(key => val)
+          else
+            memo
+          end
+        end
+      end
+
+  end
+
+  private
+
+    class BundledFileConfig
+
+      include Configuration
+      include FileSystemSupport
+      attr_reader :config_file
+
+      def initialize(config)
+        initialize_config_vars(config)
+        @config_file = config['config_file']
+        @configs = {
+          :default => self, :user_proc => UserProcConfig.new({}),
+          :user_config => Configuration.new(@config_file)
+        }
+      end
+
+      def config_file=(file)
+        file_must_exist!(@config_file = file)
+        @configs[:user_config] = Configuration.new(file)
+      end
+
+      private
+
+        def set_config_var(name, value)
+          @configs[:user_proc].send(:"#{name}=", value)
+        end
+
+        def get_config_var(name)
+          key = [:user_proc, :user_config].find do |k|
+            @configs[k] && (val = @configs[k].send(name)) && !"#{val}".strip.empty?
+          end
+          key ? @configs[key].send(name) : super(name)
+        end
+
+    end
+
+    class UserFileConfig
+
+      include Configuration
+
+      def initialize(config)
+        ensure_valid_config!(config)
+        initialize_config_vars(config)
+      end
+
+      private
+
+        def ensure_valid_config!(config)
+          if file = config['config_file']
+            raise ConfigFileSettingNotSupportedError.new \
+              "Specifying of 'config_file' setting in user config '%s' is not supported." %
+                config[:config_src]
+          end
+        end
+
+    end
+
+    class UserProcConfig
+      include Configuration
+      def initialize(config) ; initialize_config_vars(config) ; end
+    end
+
+end

data/lib/clamsy/cups_pdf_printer.rb

@@ -0,0 +1,26 @@
+module Clamsy
+  class CupsPdfPrinter < BasePrinter
+    class << self
+
+      private
+
+        def doc_to_pdf(doc_path)
+          system("#{config.ooffice_cmd} #{doc_path}")
+          pdf_path = tmp_pdf_path(doc_path)
+          file_must_exist!(pdf_path, 10) ; pdf_path
+        end
+
+        def tmp_pdf_path(doc_path)
+          if output_file = config.cups_output_file
+            output_file.is_a?(Proc) ? output_file.call : output_file
+          else
+            # NOTE: we don't attempt to trim away the extension cos it is a hard
+            # fact that internally we are always working with paths derived from
+            # Tempfile instances, thus, no need for extension replacing.
+            File.join(config.cups_output_dir, File.basename(doc_path)) + '.pdf'
+          end
+        end
+
+    end
+  end
+end

data/lib/clamsy/file_system_support.rb

@@ -0,0 +1,36 @@
+require 'tempfile'
+require 'digest/md5'
+
+module Clamsy
+
+  class FileNotFoundError < Exception ; end
+
+  module FileSystemSupport
+
+    def file_must_exist!(path, timeout=0)
+      if timeout.zero?
+        File.exists?(path) or raise_file_not_found_error(path)
+      else
+        0.upto(timeout.pred) {|i| File.exists?(path) ? (return true) : sleep(1) }
+        raise_file_not_found_error(path)
+      end
+    end
+
+    def trash_tmp_files
+      (@trashable_tmp_files || []).each {|f| f.path && f.unlink }
+      @trashable_tmp_files = nil
+    end
+
+    def tmp_file(file_name = nil)
+      file_name ||= Digest::MD5.hexdigest(Time.now.to_s)
+      ((@trashable_tmp_files ||= []) << Tempfile.new(file_name))[-1]
+    end
+
+    protected
+
+      def raise_file_not_found_error(path)
+        raise Clamsy::FileNotFoundError.new("File '#{path}' not found.")
+      end
+
+  end
+end

data/lib/clamsy/template_open_doc.rb

@@ -0,0 +1,122 @@
+require 'digest/md5'
+require 'nokogiri'
+require 'zip/zip'
+require 'ftools'
+
+module Clamsy
+
+  class TemplateDocIsNotFoundError < Exception ; end
+  class TemplateDocIsCorruptedError < Exception ; end
+  class TemplateDocContentIsCorruptedError < Exception ; end
+  class RenderedDocContentIsCorruptedError < Exception ; end
+
+  class TemplateOpenDoc
+
+    include Clamsy::FileSystemSupport
+
+    def initialize(template_doc)
+      file_must_exist!(@template_doc = template_doc)
+      initialize_template_workers
+    end
+
+    def render(context)
+      File.copy(@template_doc, (file = tmp_file).path)
+      OpenDoc.new(file, @template_workers, context).transform
+    end
+
+    private
+
+      def initialize_template_workers
+        begin
+          OpenDoc.per_content_entry(@template_doc) \
+            {|@entry| (@template_workers_cache ||= {})[@entry.to_s] = template_worker }
+          @template_workers = lambda {|entry| @template_workers_cache[entry.to_s] }
+        rescue Zip::ZipError
+          raise TemplateDocIsCorruptedError.new \
+            "Template doc '#{@template_doc}' is corrupted."
+        end
+      end
+
+      def template_worker
+        file, content = tmp_file, @entry.get_input_stream.read
+        File.open(file.path, 'w') {|f| f.write(content) }
+        enhance_worker_with_picture_paths(Tenjin::Template.new(file.path), content)
+      end
+
+      def enhance_worker_with_picture_paths(worker, content)
+        begin
+          class << worker ; attr_accessor :picture_paths ; end
+          worker.picture_paths = OpenDoc.extract_picture_paths(content)
+          worker
+        rescue Nokogiri::XML::SyntaxError
+          raise TemplateDocContentIsCorruptedError.new \
+            "Template doc content '#{@template_doc}'/'#{@entry.to_s}' is corrupted."
+        end
+      end
+
+  end
+
+  private
+
+    class OpenDoc
+
+      def self.per_content_entry(file, &blk)
+        Zip::ZipFile.open(file) do |zip|
+          zip.select {|entry| entry.file? && entry.to_s =~ /\.xml$/ }.each do |entry|
+            class << entry ; attr_accessor :zip ; end
+            entry.zip = zip
+            yield(entry)
+          end
+        end
+      end
+
+      def self.string_to_xml_doc(string)
+        Nokogiri::XML(string.gsub(':','')) do |config|
+          config.options = Nokogiri::XML::ParseOptions::STRICT
+        end
+      end
+
+      def self.extract_picture_paths(content)
+        doc = string_to_xml_doc(content)
+        nodes = lambda {|path| doc.xpath(path) }
+        nodes['//drawframe/@drawname'].inject({}) do |memo, node|
+          path = nodes[%\//drawframe[@drawname="#{node.value}"]//drawimage/@xlinkhref\][0]
+          memo.merge(path ? {:"#{node.value}" => path.value} : {})
+        end
+      end
+
+      def initialize(file, workers, context)
+        @file, @workers, @context = file, workers, context
+      end
+
+      def transform
+        OpenDoc.per_content_entry(@file.path) do |@entry|
+          @entry.zip.get_output_stream(@entry.to_s) do |@io|
+            replace_texts ; replace_pictures
+          end
+        end
+        @file
+      end
+
+      private
+
+        def replace_texts
+          begin
+            @io.write(content = @workers[@entry].render(@context))
+            OpenDoc.string_to_xml_doc(content)
+          rescue Nokogiri::XML::SyntaxError
+            raise Clamsy::RenderedDocContentIsCorruptedError.new \
+              'Rendered doc content is corrupted, use ${ ... } where text escaping is needed.'
+          end
+        end
+
+        def replace_pictures
+          (@context[:_pictures] || {}).each do |name, src_path|
+            (dest_path = @workers[@entry].picture_paths[:"#{name}"]) \
+              && @entry.zip.replace(dest_path, src_path)
+          end
+        end
+
+    end
+
+end

data/spec/clamsy/base_printer_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe 'Base printer' do
+
+  describe '> getting any printer' do
+
+    should 'raise Clamsy::PrinterNotFoundError when printer is not yet defined' do
+      lambda { Clamsy::BasePrinter.get('super_duper', 'dummy_config') }.
+        should.raise(Clamsy::PrinterNotFoundError).
+        message.should.equal("Printer 'super_duper' cannot be found.")
+    end
+
+    should "return Clamsy::CupsPdfPrinter when printer is 'cups_pdf'" do
+      Clamsy::BasePrinter.get('cups_pdf', 'dummy_config').should.equal Clamsy::CupsPdfPrinter
+    end
+
+  end
+
+end

data/spec/clamsy/configuration_spec.rb

@@ -0,0 +1,290 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+def Clamsy.unconfigure
+  @config = nil
+end
+
+describe "Clamsy configuration" do
+
+  before do
+    Clamsy.unconfigure
+    $bundled_config_file = File.join(File.dirname(__FILE__),'..','..','lib','clamsy.yml')
+    $user_config_file = Tempfile.new('clamsy.yml').path
+    @write_config = lambda do |data|
+      File.open($user_config_file,'w') {|io| YAML.dump(data, io) }
+    end
+  end
+
+  after do
+    class << Clamsy::Configuration
+      alias_method :new, :orig_new
+    end
+  end
+
+  describe '> default (w missing default user config file)' do
+
+    before do
+      class << Clamsy::Configuration
+        alias_method :orig_new, :new
+        def new(file, is_base_config=false)
+          file == '~/.clamsy.yml' ? nil : orig_new($bundled_config_file, true)
+        end
+      end
+    end
+
+    should "have :printer as 'cups_pdf'" do
+      Clamsy.configure do |config|
+        config.printer.should.equal 'cups_pdf'
+      end
+    end
+
+    should "have :config_file as '~/.clamsy.yml'" do
+      Clamsy.configure do |config|
+        config.config_file.should.equal '~/.clamsy.yml'
+      end
+    end
+
+    should "have :cups_output_dir (cups_pdf) as '/var/spool/cups-pdf/#{ENV['USER']}'" do
+      Clamsy.configure do |config|
+        config.cups_output_dir.should.equal "/var/spool/cups-pdf/#{ENV['USER']}"
+      end
+    end
+
+    should "have :cups_output_file (cups_pdf) be nil (unspecified)" do
+      Clamsy.configure do |config|
+        config.cups_output_file.should.equal nil
+      end
+    end
+
+    should "have :ooffice_cmd (cups_pdf) as " +
+      "'ooffice -norestore -nofirststartwizard -nologo -headless -pt Cups-PDF'" do
+      Clamsy.configure do |config|
+        config.ooffice_cmd.should.equal \
+          'ooffice -norestore -nofirststartwizard -nologo -headless -pt Cups-PDF'
+      end
+    end
+
+  end
+
+  describe '> configuring (using default user config file)' do
+
+    before do
+      class << Clamsy::Configuration
+        alias_method :orig_new, :new
+        def new(file, is_base_config=false)
+          file != '~/.clamsy.yml' ?
+            orig_new($bundled_config_file, true) : orig_new($user_config_file)
+        end
+      end
+    end
+
+    should "use specified :printer if it has been specified" do
+      @write_config[{'printer' => 'dummy'}]
+      Clamsy.configure {|config| config.printer.should.equal 'dummy' }
+    end
+
+    should "use default :printer if it has not been specified" do
+      @write_config[{}]
+      Clamsy.configure {|config| config.printer.should.equal 'cups_pdf' }
+    end
+
+    should "raise Clamsy::ConfigFileSettingNotSupportedError if :config_file has been specified" do
+      @write_config[{'config_file' => 'ddd'}]
+      lambda { Clamsy.configure {|config| 'do nothing here' } }.
+        should.raise(Clamsy::ConfigFileSettingNotSupportedError).
+        message.should.equal(
+          "Specifying of 'config_file' setting in user config '#{$user_config_file}' is not supported."
+        )
+    end
+
+    should 'use specified printer-specific settings if they have been specified' do
+      @write_config[{'printer' => 'cups_pdf', 'cups_pdf' => {'cups_output_dir' => '/x/y/z'}}]
+      Clamsy.configure {|config| config.cups_output_dir.should.equal '/x/y/z' }
+    end
+
+    should 'use default printer-specific settings if they have not been specified' do
+      Clamsy.configure do |config|
+        config.cups_output_dir.should.equal "/var/spool/cups-pdf/#{ENV['USER']}"
+      end
+    end
+
+  end
+
+  describe '> configuring (using only config proc)' do
+
+    behaves_like 'has standard files support'
+
+    before do
+      class << Clamsy::Configuration
+        alias_method :orig_new, :new
+        def new(file, is_base_config=false)
+          file == '~/.clamsy.yml' ? nil : orig_new($bundled_config_file, true)
+        end
+      end
+    end
+
+    should 'use specified :printer if it has been specified' do
+      Clamsy.configure do |config|
+        config.printer = 'dummy'
+        config.printer.should.equal 'dummy'
+      end
+    end
+
+    should "use default :printer if it has not been specified" do
+      Clamsy.configure do |config|
+        config.printer.should.equal 'cups_pdf'
+        [nil, ''].each do |val|
+          config.printer = val
+          config.printer.should.equal 'cups_pdf'
+        end
+      end
+    end
+
+    should "use specified :config_file if it has been specified" do
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.config_file.should.equal $user_config_file
+      end
+    end
+
+    should "use raise Clamsy::FileNotFoundError if the specified config file does not exist" do
+      lambda {
+        Clamsy.configure {|config| config.config_file = "#{__FILE__}.clamsy.yml" }
+      }.should.raise(Clamsy::FileNotFoundError).message.should.equal(
+        "File '#{__FILE__}.clamsy.yml' not found."
+      )
+    end
+
+    should 'use specified printer-specific settings if they have been specified' do
+      Clamsy.configure do |config|
+        config.cups_output_dir = '/x/y/z'
+        config.cups_output_dir.should.equal '/x/y/z'
+      end
+    end
+
+    should 'use default printer-specific settings if they have not been specified' do
+      Clamsy.configure do |config|
+        config.cups_output_dir.should.equal "/var/spool/cups-pdf/#{ENV['USER']}"
+      end
+    end
+
+  end
+
+  describe '> configuring (using only specified user config file in config proc)' do
+
+    should 'use specified :printer if it has been specified' do
+      @write_config[{'printer' => 'dummy'}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.printer.should.equal 'dummy'
+      end
+    end
+
+    should 'use default :printer if it has not been specified' do
+      @write_config[{}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.printer.should.equal 'cups_pdf'
+      end
+    end
+
+    should "raise Clamsy::ConfigFileSettingNotSupportedError if :config_file has been specified" do
+      @write_config[{'config_file' => 'ddd'}]
+      lambda {
+        Clamsy.configure {|config| config.config_file = $user_config_file }
+      }.should.raise(Clamsy::ConfigFileSettingNotSupportedError).
+        message.should.equal(
+          "Specifying of 'config_file' setting in user config '#{$user_config_file}' is not supported."
+        )
+    end
+
+    should 'use specified printer-specific settings if they have been specified' do
+      @write_config[{'printer' => 'cups_pdf', 'cups_pdf' => {'cups_output_dir' => '/x/y/z'}}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.cups_output_dir.should.equal '/x/y/z'
+      end
+    end
+
+    should 'use default printer-specific settings if they have not been specified' do
+      @write_config[{}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.cups_output_dir.should.equal "/var/spool/cups-pdf/#{ENV['USER']}"
+      end
+    end
+
+  end
+
+  describe '> configuring (with clashes in specified user config file & config proc)' do
+
+    should 'use proc specified :printer if it is specified in both config proc & file' do
+      @write_config[{'printer' => 'dummy'}]
+      Clamsy.configure do |config|
+        # NOTE: it doesn't matter how we order the declaration !!
+        config.config_file = $user_config_file
+        config.printer = 'mummy'
+        config.printer.should.equal 'mummy'
+        config.config_file = $user_config_file
+        config.printer.should.equal 'mummy'
+      end
+    end
+
+    should 'use proc specified printer-specific settings if they are specified in both config proc & file' do
+      @write_config[{'printer' => 'cups_pdf', 'cups_pdf' => {'cups_output_dir' => '/x/y/x'}}]
+      Clamsy.configure do |config|
+        # NOTE: it doesn't matter how we order the declaration !!
+        config.config_file = $user_config_file
+        config.cups_output_dir = '/a/b/c'
+        config.cups_output_dir.should.equal '/a/b/c'
+        config.config_file = $user_config_file
+        config.cups_output_dir.should.equal '/a/b/c'
+      end
+    end
+
+  end
+
+  describe '> configuring can also be done while doing processing' do
+
+    before do
+      class << Clamsy
+        def generate_pdf(*args) ; end
+      end
+    end
+
+    should 'use specified :printer if it has been specified' do
+      Clamsy.process([], '/dummy/template/doc', '/dummy/final/pdf') do |config|
+        config.printer = 'dummy'
+      end
+      Clamsy.configure {|config| config.printer.should.equal 'dummy' }
+    end
+
+    should 'use default :printer if it has not been specified' do
+      Clamsy.process([], '/dummy/template/doc', '/dummy/final/pdf')
+      Clamsy.configure {|config| config.printer.should.equal 'cups_pdf' }
+    end
+
+  end
+
+  describe '> retrieving of config values' do
+
+    should 'replace any ${...} with matching environment variable value' do
+      @write_config[{'printer' => 'dummy', 'dummy' => {'output_dir' => '/home/${USER}'}}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.output_dir.should.equal "/home/#{ENV['USER']}"
+      end
+    end
+
+    should "replace any ${...} wo matching environment variable with blank string" do
+      @write_config[{'printer' => 'dummy', 'dummy' => {'output_dir' => '/home/${WHATEVER}'}}]
+      Clamsy.configure do |config|
+        config.config_file = $user_config_file
+        config.output_dir.should.equal "/home/"
+      end
+    end
+
+  end
+
+end
+