infopark_rails_connector 6.8.0.beta.200.621.4c8e1b0

data/lib/rails_connector/fop_on_rails/document/images.rb

@@ -0,0 +1,34 @@
+module RailsConnector
+  module FopOnRails
+    module Document # :nodoc: all
+      module Images
+        def self.absolutize_src_attrs(xml, url)
+          @url = URI.parse(url)
+          xml.elements.each('//img') do |img|
+            url = URI.parse(img.attributes['src'])
+            unless (url.host == @url.host)
+              url = @url.merge(url)
+            end
+            img.attributes['src'] = url.to_s
+          end
+          xml
+        end
+
+        def self.dump_images(xml)
+          xml.elements.each('//img') do |img|
+            unless URI.parse(src = img.attributes['src']).absolute?
+              if relative_url_root = ActionController::Base.config.relative_url_root
+                src.sub!(/\A#{relative_url_root}/i, '')
+              end
+              params = Rails.application.routes.recognize_path(src)
+              if params[:controller] == 'rails_connector/cms_dispatch' and params[:id]
+                img.attributes['src'] = Obj.find(params[:id]).body_data_path
+              end
+            end
+          end
+          xml
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/fop_on_rails/document/tables.rb

@@ -0,0 +1,67 @@
+module RailsConnector
+  module FopOnRails
+    module Document # :nodoc: all
+      module Tables
+        def self.repair(xml)
+          xml.elements.each '//table' do |table|
+            add_missing_cols(table)
+            add_col_metadata(table)
+          end
+        end
+
+        private
+
+        def self.add_missing_cols(table)
+          @@max = 0
+          trs = table.get_elements('./tr | ./tbody/tr | ./thead/tr | ./tfoot/tr')
+          trs.each do |tr|
+            n = 0
+            tr.each_element('./td | ./th') do |elem|
+              colspan = elem.attributes['colspan'].to_i
+              if colspan > 0
+                n += colspan
+              else
+                n += 1
+                elem.delete_attribute 'colspan'
+              end
+            end
+            @@max = n if n > @@max
+          end
+          trs.each do |tr|
+            n = @@max - tr.get_elements('./td | ./th').size
+            tr.each_element('./td | ./th') do |elem|
+              colspan = elem.attributes['colspan'].to_i
+              n -= colspan if colspan > 0
+            end
+            n.times do
+              tr.add_element 'td'
+            end
+          end
+        end
+
+        def self.add_col_metadata(table)
+          default_width = 480
+          cols = table.get_elements('./col | ./colgroup/col')
+          vals, total, not_nulls = [], 0, 0
+          [@@max, cols.size].min.times do |i|
+            width = cols[i].attributes['width'].to_i
+            if width > 0
+              vals[i] = width
+              not_nulls += 1
+            end
+            total += width
+          end
+          total = default_width unless total > 0
+          @@max.times do |i|
+            if val = vals[i]
+              vals[i] = (val * default_width * not_nulls) / (total * @@max)
+            else
+              vals[i] = default_width / @@max
+            end
+          end
+          table.attributes['cols'] = vals * "\s"
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/fop_on_rails/document.rb

@@ -0,0 +1,25 @@
+require 'rails_connector/fop_on_rails/document/dom_tree'
+require 'rails_connector/fop_on_rails/document/images'
+require 'rails_connector/fop_on_rails/document/tables'
+
+module RailsConnector
+  module FopOnRails
+    module Document # :nodoc: all
+      def self.repair(path, xml_uri = nil)
+        xml = DomTree.repair(File.read(path))
+
+        if xml_uri
+          Images.absolutize_src_attrs(xml, xml_uri)
+        else
+          Images.dump_images(xml)
+        end
+
+        Tables.repair(xml)
+
+        File.open(path, 'w') do |f|
+          f.write(xml.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/fop_on_rails.rb

@@ -0,0 +1,92 @@
+module RailsConnector
+  #
+  # This module provides an interface for generating PDF files.
+  #
+  module FopOnRails
+    #
+    # Is raised if the response was not 200.
+    #
+    class DownloadError < RuntimeError; end
+
+    READ_TIMEOUT = 300
+
+    #
+    # Generates a PDF from <code>xml_location</code> and <code>xsl_location</code> and returns its
+    # path in the file system.
+    #
+    # If the file <code>xml_location</code> doesn't already exist, then <code>xml_location</code>
+    # and <code>xsl_location</code> are interpreted as URLs and will be downloaded before
+    # the PDF is generated.
+    #
+    # If the download of <code>xml_location</code> or <code>xsl_location</code> fails, then
+    # the <code>RailsConnector::FopOnRails::DownloadError</code> is raised.
+    #
+    # To generate a PDF, the given XML <b>must</b> be valid. If for some reasons it is not, then you can use the
+    # <code>tidy</code> option to repair it.
+    #
+    # If the PDF generation fails, then the <code>RailsConnector::Fop::GenerationFailed</code> error
+    # is raised.
+    #
+    # Example:
+    #
+    #   RailsConnector::FopOnRails.generate_pdf('/tmp/test.xml', '/tmp/test.xsl')
+    #   # This will generate a PDF and return its path
+    #
+    #   RailsConnector::FopOnRails.generate_pdf('http://mywebsite.com/test.xml', 'http://mywebsite.com/test.xsl', true)
+    #   # This will download both files, repair the XML, generate a PDF, and return its path
+    #
+    def self.generate_pdf(xml_location, xsl_location, tidy = false)
+      log("\nStarting PDF generation...")
+
+      w_dir = File.join(Rails.root, %w(tmp fop_on_rails), $$.to_s)
+      FileUtils.rm_rf(w_dir)
+      FileUtils.mkdir_p(w_dir)
+
+      pdf = "#{w_dir}/pdf"
+
+      if File.exist?(xml_location)
+        xml = xml_location
+        xsl = xsl_location
+        log("\trepairing XML")
+        FopOnRails::Document.repair(xml)
+      else
+        xml = "#{w_dir}/xml"
+        xsl = "#{w_dir}/xsl"
+
+        log("\tgetting XSL source from #{xsl_location}")
+        download(xml_location, xml)
+        log("\tgetting XML source from #{xml_location}")
+        download(xsl_location, xsl)
+      end
+
+      if tidy
+        log("\trepairing XML")
+        FopOnRails::Document.repair(xml, xml_location)
+      end
+
+      log("\tgenerating PDF\n\n")
+      Fop.generate_pdf(xml, xsl, pdf)
+
+      return pdf
+    end
+
+    private
+
+    def self.download(src, dest)
+      url = URI.parse(src)
+      http = Net::HTTP.new(url.host, url.port)
+      http.read_timeout = READ_TIMEOUT
+      resp = http.get(url.request_uri)
+      unless resp.kind_of?(Net::HTTPSuccess)
+        raise DownloadError, "Could not download #{src}"
+      end
+      File.open dest, 'w' do |f|
+        f.write resp.body
+      end
+    end
+
+    def self.log(msg)
+      Rails.logger.info(msg)
+    end
+  end
+end

data/lib/rails_connector/googlebot_checker.rb

@@ -0,0 +1,47 @@
+#:stopdoc:
+module RailsConnector
+
+  module GooglebotChecker
+    require 'socket'
+
+    protected
+
+    def referer_is_google?
+      return true if request.headers['Referer'] =~ /google/
+    end
+
+    def is_genuine_googlebot?(ip_address)
+      if ip_address =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+        host = reverse_dns_lookup_for_ip(ip_address)
+        return false unless host =~ /googlebot.com$/
+        res = forward_dns_matcher(host, ip_address)
+        return res
+      else
+        return false
+      end
+    end
+
+    private
+
+    def reverse_dns_lookup_for_ip(ip_address)
+      begin
+        addr = Socket.gethostbyname(ip_address)
+        Socket.gethostbyaddr(addr[3],Socket::AF_INET)[0]
+      rescue
+        []
+      end
+    end
+
+    def forward_dns_matcher(host, ip_address)
+      begin
+        lookup = Socket.getaddrinfo(host, 0,
+                  Socket::AF_INET, Socket::SOCK_STREAM, nil,
+                  Socket::AI_CANONNAME)
+        return true if lookup.collect {|info| info[3]}.uniq.include?(ip_address)
+      rescue
+        false
+      end
+      false
+    end
+  end
+end

data/lib/rails_connector/html_string.rb

@@ -0,0 +1,19 @@
+module RailsConnector
+
+  # Include this module in order to tag the string as one with HTML content
+  module HtmlString #:nodoc:
+    include LinkResolvable
+    # Returns whether the String contains HTML (default to true, overrides String.html?).
+    def html?
+      true
+    end
+  end
+
+end
+
+class String #:nodoc:
+  # Returns whether the String contains HTML (default to false).
+  def html?
+    false
+  end
+end

data/lib/rails_connector/infopark_base.rb

@@ -0,0 +1,2 @@
+# legacy compatablity (CmsBaseModel used to be called InfoparkBase)
+::RailsConnector::InfoparkBase = ::RailsConnector::CmsBaseModel

data/lib/rails_connector/link_resolvable.rb

@@ -0,0 +1,9 @@
+module RailsConnector
+
+  module LinkResolvable #:nodoc:
+    attr_accessor :source
+
+  end
+
+
+end

data/lib/rails_connector/liquid_support/action_marker.rb

@@ -0,0 +1,69 @@
+module RailsConnector::LiquidSupport
+
+  # Usage example for actionmarkers in Liquid templates:
+  #   {% actionmarker obj.images[0] editImageWizard param_a:value_a param_b:value_b %}
+  #     [Edit image]
+  #   {% endactionmarker %}
+  #
+  # The first parameter may be an instance of +ObjDrop+ (usually +obj+ in Liquid templates),
+  # +Array+ (such as a +LinkList+ field), or +LinkDrop+ (as in the example above).
+  #
+  # The second parameter is the action to be run on the target objects.
+  # Additional parameters to be forwarded to the action can be added as <tt>key:value</tt> pairs.
+  # All parameters are evaluated in the current Liquid context and thus may contain,
+  # for example, method calls on objects.
+  #
+  # Internally, the parameter <tt>:context</tt> is always set to the currently viewed object (+obj+)
+  # and can not be overwritten.
+  #
+  # The Liquid actionmarker uses RailsConnector::MarkerHelper#action_marker.
+  class ActionMarker < Liquid::Block
+    def initialize(tag_name, markup, tokens)
+      @obj_name, @method_name = markup.to_s.split(/\s+/)
+      unless @obj_name && @method_name
+        raise Liquid::SyntaxError.new("Syntax Error in 'actionmarker' - Valid syntax: actionmarker obj [action] [foo:bar]")
+      end
+      @params = {}
+      markup.scan(/#{Liquid::TagAttributes}(#{Liquid::SpacelessFilter})?/) do |key, value, spaceless_filter|
+        @params[key] = spaceless_filter.blank? ? value : "#{value}|#{spaceless_filter}"
+      end
+      super
+    end
+
+    def render(context)
+      context.registers[:action_view].action_marker(
+        (context[@method_name] || @method_name).to_s,
+        target_objs(context),
+        :params => params(context),
+        :context => context['obj'].__drop_content
+      ) do
+        context.stack { render_all(@nodelist, context) }
+      end
+    end
+
+  protected
+
+    def target_objs(context)
+      [ context[@obj_name] ].flatten.map do |item|
+        case item
+        when RailsConnector::Link
+          item.destination_object
+        when LinkDrop
+          item.destination.__drop_content
+        else
+          item.__drop_content
+        end
+      end
+    end
+
+    def params(context)
+      result = {}
+      @params.each do |key, value|
+        result[(context[key] || key).to_s] = (context[value] || value).to_s
+      end
+      result
+    end
+  end
+
+  Liquid::Template.register_tag('actionmarker', ActionMarker)
+end

data/lib/rails_connector/liquid_support/field_value_drop.rb

@@ -0,0 +1,22 @@
+module RailsConnector::LiquidSupport
+
+  class FieldValueDrop < Liquid::Drop #:nodoc:
+    attr_accessor :__value, :__marker
+
+    def initialize(obj, field, value, marker)
+      @obj, @field, @__value, @__marker = obj, field, value, marker
+    end
+
+    def to_s
+      action_view = @context.registers[:action_view]
+      safe_value = __value.to_s.html_safe
+      if __marker
+        action_view.edit_marker(@obj, @field) { safe_value }
+      else
+        safe_value
+      end
+    end
+
+  end
+
+end

data/lib/rails_connector/liquid_support/general_helper_tag.rb

@@ -0,0 +1,44 @@
+module RailsConnector::LiquidSupport
+
+  # This is a wrapper class used internally to make helper methods available in
+  # Liquid templates. Helpers have to be enabled in the app initialization like this:
+  #
+  #    RailsConnector::LiquidSupport.enable_helpers(
+  #       :helper_a,
+  #       :helper_b
+  #     )
+  class GeneralHelperTag < Liquid::Tag
+    attr_reader :params
+
+    def initialize(tag_name, markup, tokens)
+      @tag_name = tag_name
+      @params = markup.to_s.scan(/(#{::Liquid::Expression})*/).flatten.compact.map(&:strip)
+      super
+    end
+
+    def render(context)
+      context.registers[:action_view].__send__(@tag_name, *params(context))
+    end
+
+    def self.<<(helper)
+      Liquid::Template.register_tag(helper, self)
+      self
+    end
+
+  protected
+
+    def params(context)
+      @params.map { |p| context[p] || p }.map do |item|
+        case item
+        when LinkDrop
+          item.destination.__drop_content
+        when ObjDrop
+          item.__drop_content
+        else
+          item.to_s
+        end
+      end
+    end
+  end
+
+end

data/lib/rails_connector/liquid_support/link_drop.rb

@@ -0,0 +1,22 @@
+module RailsConnector::LiquidSupport
+
+  # Dieser Drop kapselt einen Link.
+  class LinkDrop < Liquid::Drop #:nodoc:
+    def initialize(link)
+      @link = link
+    end
+
+    def __drop_content
+      @link
+    end
+
+    [:url, :external?, :internal?, :title, :display_title].each do |m|
+      define_method(m) { @link.__send__(m).to_liquid }
+    end
+
+    def destination
+      @link.destination_object.to_liquid
+    end
+  end
+
+end

data/lib/rails_connector/liquid_support/liquid_template_handler.rb

@@ -0,0 +1,162 @@
+module RailsConnector::LiquidSupport
+
+  module FieldValueDropPatcher #:nodoc:
+    def self.patch(mod)
+      mod.module_eval do
+        return if method_defined?(:field_value_drop_patched)
+        define_method :field_value_drop_patched do; end
+        (public_instance_methods - Module.public_instance_methods).each do |m|
+          alias_method(old_m = "infopark_rails_connector_%s" % m, m)
+          define_method m do |*args|
+            first_arg = args.shift
+            args.map!{|arg| arg.kind_of?(FieldValueDrop) ? arg.__value : arg}
+            args.unshift(first_arg)
+            if (drop = args.first).kind_of? FieldValueDrop
+              args[0] = drop.__value
+              value = __send__(old_m, *args)
+              new_drop = drop.dup
+              new_drop.__value = value
+              return new_drop
+            else
+              return __send__(old_m, *args)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  FieldValueDropPatcher.patch(Liquid::StandardFilters)
+
+  # A tag for rendering partials in Liquid templates
+  #
+  # Example:
+  #    {% template 'name-of-partial' %}
+  class TemplateTag < Liquid::Tag
+    Syntax = /(#{Liquid::QuotedFragment}+)/ #:nodoc:
+
+    def initialize(tag_name, markup, tokens) #:nodoc:
+
+      if markup =~ Syntax
+        @partial_name = $1
+      else
+        raise Liquid::SyntaxError.new("Error in tag 'template' - Valid syntax: template '[name-of-template]'")
+      end
+
+      super
+    end
+
+    def render(context) #:nodoc:
+      context.registers[:action_view].controller.__send__(
+        :render_to_string, :partial => context[@partial_name]
+      )
+    end
+
+    Liquid::Template.register_tag('template', TemplateTag)
+  end
+
+  # Das LiquidTemplateRepository kann Liquid-Templates anwenden.
+  # Zunächst muss das Template kompiliert werden, danach kann es gerendert werden.
+  class LiquidTemplateRepository #:nodoc:
+
+    cattr_accessor :compiled_templates
+    self.compiled_templates = {}
+
+    def self.compile(template)
+      template_id = generate_unique_template_id
+      compiled_templates[template_id] = Liquid::Template.parse(template.source)
+      template_id
+    end
+
+    def self.render(template_id, action_view)
+      compiled_template = compiled_templates[template_id]
+
+      unless compiled_template
+        # this should never happen
+        raise "render() called with illegal template id: #{template_id}"
+      end
+
+      rendered_template = compiled_template.render(
+        {
+          "obj" => action_view.instance_variable_get("@obj"),
+          "named_object" => NamedObjectDrop.instance
+        },
+        :filters => [ObjFilters] + load_custom_filters,
+        :registers => {:action_view => action_view}
+      )
+
+      report_errors(compiled_template, action_view.logger) unless compiled_template.errors.blank?
+
+      rendered_template
+    end
+
+    # Nur zum Testen gedacht
+    def self.drop_all
+      self.compiled_templates = {}
+    end
+
+    def self.load_custom_filters
+      return @loaded_custom_filters if @loaded_custom_filters
+      extract = /^#{Regexp.quote(filters_dir)}\/?(.*_filters).rb$/
+      @loaded_custom_filters = Dir["#{filters_dir}/**/*_filters.rb"].map do |file|
+        filename = file.sub extract, '\1'
+        require File.join(filters_dir, filename)
+        filename.camelcase.constantize
+      end
+      @loaded_custom_filters.each {|m| FieldValueDropPatcher.patch(m)}
+      @loaded_custom_filters
+    end
+
+    # Nur zum Testen gedacht
+    def self.reset_custom_filters
+      @loaded_custom_filters = nil
+    end
+
+    class << self
+
+      private
+
+      def generate_unique_template_id
+        @template_id_counter ||= 0
+        @template_id_counter += 1
+        # include object_id to generate different id's if this class is reloaded by accident
+        # (which should never happen, but you never know)
+        "#{object_id}-#{@template_id_counter}"
+      end
+
+      def report_errors(compiled_template, logger)
+        if ::RailsConnector::LiquidSupport.raise_template_errors
+          raise compiled_template.errors.first
+        else
+          logger.warn(
+            compiled_template.errors.map do |exception|
+              "[Liquid Error] #{exception.message} trace: \n#{exception.backtrace.join("\n")}"
+            end.join("\n\n")
+          )
+        end
+      end
+
+      def filters_dir
+        Rails.root.join('app', 'filters')
+      end
+
+    end
+
+  end
+
+  # Dieser TemplateHandler integriert Liquid in Rails.
+  #
+  # Die Klasse ist bewusst sehr schlank gehalten und delegiert das eigentliche
+  # Verarbeiten der Templates an das LiquidTemplateRepository.
+  # Der Grund ist, dass die Klassen, die in Rails als TemplateHandler registriert
+  # sind von Rails eingefroren werden (mittels Object.freeze) und daher keine
+  # Klassenvariablen haben können.
+  class LiquidTemplateHandler #:nodoc:
+    def self.call(template)
+      template_id = LiquidTemplateRepository.compile(template)
+      "#{LiquidTemplateRepository}.render('#{template_id}', self)"
+    end
+
+  end
+
+end

data/lib/rails_connector/liquid_support/named_object_drop.rb

@@ -0,0 +1,14 @@
+require "singleton"
+
+module RailsConnector::LiquidSupport
+
+  # Dieser Drop realisiert den Zugriff auf Objekte, die per NamedLink referenziert werden
+  class NamedObjectDrop < Liquid::Drop #:nodoc:
+    include Singleton
+
+    def before_method(method)
+      RailsConnector::NamedLink.get_object(method)
+    end
+
+  end
+end

data/lib/rails_connector/liquid_support/obj_drop.rb

@@ -0,0 +1,43 @@
+module RailsConnector::LiquidSupport
+
+  # Dieser Drop kapselt ein Obj. Der Zugriff auf das Obj ist nur für [] und ausgewählte Methoden erlaubt.
+  class ObjDrop < Liquid::Drop #:nodoc:
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def __drop_content
+      @obj
+    end
+
+    def before_method(method)
+      raw_value = @obj[method]
+      if raw_value
+        value = if raw_value.kind_of?(Time)
+          raw_value
+        else
+          @context.registers[:action_view].display_value(raw_value)
+        end
+        if value.kind_of?(::RailsConnector::LinkList)
+          value
+        else
+          FieldValueDrop.new(@obj, method, value, use_edit_markers?)
+        end
+      else
+        @obj.__send__(method) if @obj.respond_to?(method)
+      end
+    end
+
+    private
+
+    def use_edit_markers?
+      if RailsConnector::Configuration.auto_liquid_editmarkers.nil?
+        true
+      else
+        RailsConnector::Configuration.auto_liquid_editmarkers
+      end
+    end
+
+  end
+
+end