infopark_cloud_connector 6.8.0.beta.200.621.4c8e1b0

data/README

@@ -0,0 +1,71 @@
+= Infopark Rails Connector
+
+Infopark Rails Connector allows you to integrate a number of ready-to-run features into your Rails application.
+
+== Configuring Access to CMS Data
+
+Place a file named <tt>rails_connector.yml</tt> into your Rails application's <tt>config</tt> directory.
+The file should contain the following data:
+
+    cms_database_url: "http://<user>:<password>@<db_host>:<db_port>/<db_name>"
+    aws_access_key_id: "<amazon access key id>"
+    aws_secret_access_key: "<amazon secret access key>"
+    s3_bucket_name: "<s3_bucket_name>"
+    search: "http://<user>:<password>@<search_host>:<search_port>"
+
+
+== Enabling Addons
+Here is how all available addons would be enabled in the <tt>rails_connector.rb</tt> initializer file of your application:
+
+  RailsConnector::Configuration.enable(
+    :comments,
+    :google_analytics,
+    :infopark_tracking,
+    :omc,
+    :pdf_generator,
+    :ratings,
+    :rss,
+    :search,
+    :seo_sitemap,
+    :time_machine
+  )
+
+== Layout Helpers
+Some of those functions depend on html or javascript code being included in the application layout.
+For example, Google Analytics does only track pageviews if their javascript snippet is included
+at the bottom of the html body.
+
+Rails Connector provides two helpers which manage that kind of layout code,
+switching on or off parts depending on what features are enabled or not:
+
+  rails_connector_header_tags
+
+This helper needs to be called inside the html head tag.
+
+  rails_connector_after_content_tags
+
+That helper is to be put right before the closing body tag.
+
+== Generators
+Infopark Rails Connector comes with three generators to help you get up and running quickly:
+
+<tt>rails generate rails_connector:install</tt>
+
+Adds Time machine assets, a +rails_connector.rb+ initializer and rake tasks specific to the gem to your application.
+
+<tt>rails generate rails_connector:comments</tt>
+
+Specific to the +comments+ feature. Adds a comments migration to your application.
+
+<tt>rails generate rails_connector:ratings</tt>
+
+Specific to the +ratings+ feature. Adds a ratings migration to your application as well as an example stylesheet and background image.
+
+== Infopark Tracking
+
+If you enable the infopark_tracking, please refer to the OMC documentation for further details,
+e.g. Apache logging options.
+
+== Seo Sitemap
+
+The default implementation for the seo sitemap will feature all files from your CMS in the generated <tt>sitemap.xml</tt>. For a large number of files, this can slow down your server. Please refer to <tt>RailsConnector::SEO::ClassMethods#find_all_for_sitemap</tt> for advise on optimization.

data/lib/infopark_cloud_connector.rb

@@ -0,0 +1,19 @@
+require 'rails_connector/rack_middlewares'
+require 'rails_connector/couchdb_views_source_path'
+require 'rails_connector/core_extensions'
+require "rails_connector/errors"
+
+module RailsConnector
+  def self.autoload_all_sources
+    source_files = Dir.glob(File.expand_path("../rails_connector/*.rb", __FILE__)).map do |file|
+      File.basename(file)
+    end
+
+    source_files.each do |file|
+      name = file.gsub(".rb", "")
+      autoload name.camelcase, "rails_connector/#{name}"
+    end
+  end
+
+  autoload_all_sources
+end

data/lib/rails_connector/attribute.rb

@@ -0,0 +1,35 @@
+#:enddoc:
+module RailsConnector
+
+  class Attribute < CmsBaseModel
+    def self.type_of(name)
+      attribute = attribute_cache[name.to_s]
+      attribute.type if attribute
+    end
+
+    def self.reset_cache
+      @attribute_cache = nil
+    end
+
+    def name
+      attribute_name
+    end
+
+    def type
+      attribute_type.to_sym
+    end
+
+    module ClassMethods
+      private
+
+      def attribute_cache
+        @attribute_cache ||= find(:all).each_with_object({}) do |attr, map|
+          map[attr.name] = attr
+        end
+      end
+    end
+
+    extend ClassMethods
+  end
+
+end

data/lib/rails_connector/blob.rb

@@ -0,0 +1,66 @@
+require "aws-sdk"
+
+module RailsConnector
+
+class Blob
+
+  def self.find(id, options)
+    new(blob_class.find(id, options))
+  end
+
+  def self.config
+    @config or raise "Blob storage has not been configured yet"
+  end
+
+  def self.configure(spec)
+    @config = spec.symbolize_keys
+  end
+
+  def self.blob_class
+    @blob_class ||= blob_class_from_config
+  end
+
+  # for testing purposes
+  def self.reset_blob_class_cache # :nodoc:
+    @blob_class = nil
+  end
+
+  def self.blob_class_from_config
+    blob_class =
+        case config[:type]
+        when "s3"
+          S3Blob
+        when "couch"
+          CouchBlob
+        else
+          raise "Unsupported blob storage type #{config[:type]}"
+        end
+    blob_class.configure(config)
+    blob_class
+  end
+
+  attr_reader :instance
+
+  def initialize(blob_instance)
+    @instance = blob_instance
+  end
+
+  def id
+    instance.id
+  end
+
+  def url
+    instance.url
+  end
+
+  def content_type
+    instance.content_type
+  end
+
+  def length
+    instance.length
+  end
+
+end
+
+end # module RailsConnector

data/lib/rails_connector/cache.rb

@@ -0,0 +1,35 @@
+#:enddoc:
+module RailsConnector
+
+class Cache
+  @cache = {}
+  @context = false
+
+  def self.begin_context
+    @context = true
+  end
+
+  def self.end_context
+    @context = false
+    reset
+  end
+
+  def self.in_context?
+    @context
+  end
+
+  def self.load(key)
+    @cache[key]
+  end
+
+  def self.store(key, value)
+    @cache[key] = value if @context
+  end
+
+  def self.reset
+    @cache.clear
+  end
+end
+
+end # module RailsConnector
+

data/lib/rails_connector/cache_middleware.rb

@@ -0,0 +1,17 @@
+#:enddoc:
+module RailsConnector
+
+class CacheMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    Cache.begin_context
+    @app.call(env)
+  ensure
+    Cache.end_context
+  end
+end
+
+end # module RailsConnector

data/lib/rails_connector/chain.rb

@@ -0,0 +1,177 @@
+#:enddoc:
+module RailsConnector
+
+class Chain
+  # the id of the content cache to use, or nil
+  attr_reader :content_cache
+
+  # a chain of patch operations that can be used to construct the target workspace
+  # each chain member is an array with two elements.
+  # the first element denotes the patch type (-1, 1), where
+  # 1 => apply the workspace
+  # -1 => revert the workspace
+  # and the second element is the workspace.
+  attr_reader :patches
+
+  def self.build_for(workspace, content_cache = nil)
+    if content_cache && content_cache.workspace
+      patches = patches_to(workspace, content_cache.workspace)
+
+      if content_cache.transfer_target
+        if patches.present? && patches.first.second == content_cache.transfer_target
+          # the transfer target is already included in the chain - no extra patch needed!
+        else
+          patches.unshift([-1, content_cache.transfer_target])
+        end
+      end
+
+      new(content_cache, patches)
+    else
+      new(nil, patches_to(workspace))
+    end
+  end
+
+  def self.query_counter
+    @query_counter || 0
+  end
+
+  def self.count_query
+    @query_counter = query_counter + 1
+  end
+
+  def initialize(content_cache, patches)
+    @content_cache = content_cache
+    @patches = patches
+  end
+
+  # performs a workspace aware query on the cms database.
+  #
+  # returns a hash of results from the query.
+  # the keys are the criterion by which the query results are grouped (typically the OBJ ID).
+  # the values are tuples where
+  # the first element denotes the diff type and
+  # the second the document rows as returned by couchdb.
+  def query(index, key, is_compound_index)
+    self.class.count_query
+    result_map = perform_queries(index, key, is_compound_index)
+    version_map = result_map.merge(result_map) do |ignore, results|
+      results.map {|row| Version.new(row) }
+    end
+    workspace_aware_results(version_map)
+  end
+
+  private
+
+  # calculate a list of patches to get to the destionation workspace.
+  # if origin is given, the list will start at origin.
+  # otherwise the list will start at the initial workspace.
+  def self.patches_to(destination, origin = nil)
+    if destination.nil? && origin.nil?
+      []
+    elsif origin.nil? || origin.generation < destination.generation
+      patches_to(destination.base_workspace, origin) + [[1, destination]]
+    elsif destination.nil? || origin.generation > destination.generation
+      [[-1, origin]] + patches_to(destination, origin.base_workspace)
+    elsif origin != destination
+      [[-1, origin]] + patches_to(destination.base_workspace, origin.base_workspace) + [[1, destination]]
+    else # origin == destination
+      []
+    end
+  end
+
+  def perform_queries(index, key, is_compound_index)
+    result_map = {}
+
+    query_options = {
+      :hash_value => key,
+    }
+    query_options[:range_value_extender] = "/" if is_compound_index
+
+    if content_cache.present?
+      result_map[:content_cache] = CmsBaseModel.query_index(:obj, index, query_options.merge({
+        :range_value => "cc/#{content_cache.id}",
+      }))
+    end
+    if patches.present?
+      result_map[:patches] = CmsBaseModel.query_index(:obj, index, query_options.merge({
+        :range_value => workspace_range,
+      }))
+    end
+
+    result_map
+  end
+
+  # filter out those results that aren't on the chain.
+  # order the remaining results according to their chain position
+  def order_results_by_chain(result_map)
+    results = []
+
+    if result_map[:content_cache].present?
+      results << [1, result_map[:content_cache]]
+    end
+    if result_map[:patches].present?
+      results_by_workspace = result_map[:patches].group_by do |version|
+        version.workspace_id
+      end
+      patches.each do |(patch_diff_type, workspace)|
+        results_for_workspace = results_by_workspace[workspace.id]
+        results << [patch_diff_type, results_for_workspace] if results_for_workspace
+      end
+    end
+
+    results
+  end
+
+  # group the results by obj id
+  # i.e. calculate a separate chain for each obj
+  def group_results(result_map)
+    results_by_chain = order_results_by_chain(result_map)
+
+    result_index = {}
+    results_by_chain.each do |(patch_diff_type, versions)|
+      versions.each do |version|
+        id = version.obj_id
+        result_index[id] ||= []
+        result_index[id] << [patch_diff_type, version]
+      end
+    end
+
+    result_index
+  end
+
+  # apply the diff chain for each of obj
+  # to determine which of them are included in the final workspace
+  def workspace_aware_results(result_map)
+    result_index = {}
+
+    # note: using merge as a map function for hashes
+    group_results(result_map).each do |id, apply_chain|
+      final_existance = apply_chain.inject(0) do |temp_existance, (patch_diff_type, version)|
+        # remember: -1 (revert) multiplied with -1 (revert) equals 1 (apply)
+        # and: +1 (create) added to -1 (delete) equals 0 (not existant)
+        temp_existance + patch_diff_type * version.diff
+      end
+      if final_existance > 0
+        patch_diff, version = apply_chain.last
+        result_index[id] = version.obj_data(patch_diff)
+      end
+    end
+
+    result_index
+  end
+
+  private
+
+  def workspace_range
+    @workspace_range ||=
+      begin
+        sorted_keys = patches.map do |(type, workspace)|
+          "#{"%010d" % workspace.generation}/#{workspace.id}"
+        end.sort
+        Range.new(sorted_keys.first, sorted_keys.last)
+      end
+  end
+
+end
+
+end # module RailsConnector

data/lib/rails_connector/cms_base_model.rb

@@ -0,0 +1,61 @@
+require "kvom"
+require "kvom/adapter/couchdb_adapter"
+require "kvom/adapter/dynamodb_adapter"
+
+module RailsConnector
+
+  # This is the abstract class from which all CMS models derive.
+  #
+  class CmsBaseModel < Kvom::Base #:nodoc:
+    class << self
+      def instance_name=(ignore) # :nodoc:
+        # this method is here only for compatibility with the fiona connector.
+      end
+
+      def adapter
+        @@cms_database_adapter
+      end
+
+      def configure_database(connection_spec)
+        @@cms_database_adapter =
+            case connection_spec["type"]
+            when "couch"
+              Kvom::Adapter::CouchdbAdapter.new(connection_spec)
+            when "dynamo"
+              Kvom::Adapter::DynamodbAdapter.new(connection_spec)
+            else
+              raise "Unexpected database type #{connection_spec["type"]}"
+            end
+      end
+
+      def query_index(model, index, params = {})
+        hash_value = "#{model}/#{index}/#{params[:hash_value]}"
+        range_value = params[:range_value] || ""
+        range_value_extender = params[:range_value_extender]
+
+        # up to this point: backend independent
+
+        # this may be backend dependent (suffix character)
+        if range_value_extender
+          start_key, end_key =
+              case range_value
+              when Range
+                [range_value.begin, range_value.end]
+              else
+                [range_value, range_value]
+              end
+          range_value = Range.new(start_key + range_value_extender, end_key + range_value_extender + "~")
+        end
+
+        adapter.query(hash_value, range_value)
+      end
+
+    end
+
+    def save
+      raise "CmsBaseModel is read-only"
+    end
+
+  end
+
+end

data/lib/rails_connector/content_cache.rb

@@ -0,0 +1,24 @@
+#:enddoc:
+module RailsConnector
+
+class ContentCache < CmsBaseModel
+  self.key_prefix = "cc"
+
+  property :workspace_id
+  property :transferring_to
+
+  # returns the workspace that is represented by this content cache.
+  # returns nil if the workspace cannot be found.
+  def workspace
+    @workspace ||= Workspace.find_by_id(workspace_id)
+  end
+
+  # returns the workspace that this content cache is currently transferring to.
+  # returns nil if no transfer is taking place or if the workspace cannot be found.
+  def transfer_target
+    @transfer_target ||= transferring_to ? Workspace.find_by_id(transferring_to) : nil
+  end
+end
+
+end # module RailsConnector
+

data/lib/rails_connector/controller_runtime.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module RailsConnector
+
+module ControllerRuntime
+  extend ActiveSupport::Concern
+
+protected
+
+  attr_internal :rc_runtime
+
+  def cleanup_view_runtime
+    rc_rt_before_render = RailsConnector::LogSubscriber.reset_runtime
+    runtime = super
+    rc_rt_after_render = RailsConnector::LogSubscriber.reset_runtime
+    self.rc_runtime = rc_rt_before_render + rc_rt_after_render
+    runtime - rc_rt_after_render
+  end
+
+  def append_info_to_payload(payload)
+    super
+    payload[:rc_runtime] = rc_runtime
+  end
+
+  module ClassMethods
+    def log_process_action(payload)
+      messages, rc_runtime = super, payload[:rc_runtime]
+      messages << ("RailsConnector: %.1fms" % rc_runtime.to_f)
+      messages
+    end
+  end
+end
+
+end # module RailsConnector
+

data/lib/rails_connector/couch_blob.rb

@@ -0,0 +1,44 @@
+module RailsConnector
+
+class CouchBlob
+
+  def self.find(id, options)
+    cache_key = [:blob, id]
+    attachment = Cache.load(cache_key)
+    unless attachment
+      ActiveSupport::Notifications.instrumenter.instrument("cms_load.rails_connector",
+        :name => "Blob Load", :index => "blobs", :keys => [options[:context]]
+      ) do
+        attachment = CmsBaseModel.adapter.blob_attachment(id)
+        Cache.store(cache_key, attachment)
+      end
+    end
+    new(id, attachment)
+  end
+
+  def self.configure(spec)
+    # connection is taken from CmsBaseModel on demand
+  end
+
+  attr_reader :id, :attachment
+
+  def initialize(id, attachment)
+    @id = id
+    @attachment = attachment
+  end
+
+  def url
+    CmsBaseModel.adapter.blob_url(id)
+  end
+
+  def content_type
+    attachment["content_type"]
+  end
+
+  def length
+    attachment['length']
+  end
+
+end
+
+end # module RailsConnector

data/lib/rails_connector/couchdb_views_source_path.rb

@@ -0,0 +1,7 @@
+#:enddoc:
+module RailsConnector
+  # returns the filesystem path where the sources for the rails connector's couchdb views are stored.
+  def self.couchdb_views_source_path
+    File.expand_path("../../../db/views", __FILE__)
+  end
+end

data/lib/rails_connector/date_attribute.rb

@@ -0,0 +1,28 @@
+module RailsConnector
+
+  # Adds support for string columns which contain ISO dates
+  module DateAttribute #:nodoc: all
+    module ClassMethods
+      def date_attribute(*names)
+        names.each do |name|
+          module_eval %Q!
+            def #{name}
+              DateAttribute.parse(#{name}_before_type_cast) unless #{name}_before_type_cast.nil?
+            end
+          !
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.parse(iso_date_time)
+      Time.from_iso(iso_date_time).localtime
+    rescue ArgumentError
+      raise "The value is not a valid ISO date time: #{iso_date_time.inspect}"
+    end
+  end
+
+end

data/lib/rails_connector/default_search_request.rb

@@ -0,0 +1,6 @@
+module RailsConnector
+  # This class provides a default implementation for accessing the search server.
+  # It is used by DefaultSearchController.
+  class DefaultSearchRequest < ElasticsearchRequest
+  end
+end