infopark_fiona_connector 6.8.0.beta.200.891.647580e

data/README

@@ -0,0 +1,5 @@
+= Infopark Fiona Connector
+
+Infopark Fiona Connector integrates the Infopark Rails Connector with the Infopark CMS Fiona.
+
+

data/lib/comment.rb

@@ -0,0 +1,4 @@
+# The Comment model inherits all of its behavior from
+# RailsConnector::DefaultComment.
+class Comment < RailsConnector::DefaultComment
+end

data/lib/infopark_fiona_connector.rb

@@ -0,0 +1,23 @@
+require 'rails_connector/rack_middlewares'
+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
+
+  autoload :AttrValueProvider, "rails_connector/attr_value_provider_loader"
+end
+
+autoload :Comment, "comment"
+autoload :Rating, "rating"

data/lib/rails_connector/attr_dict.rb

@@ -0,0 +1,146 @@
+require 'mime/types'
+require 'ostruct'
+
+module RailsConnector
+
+  # The page related and custom data belonging to a CMS object
+  #
+  # [editor] The login of the current editor of the edited content, if set
+  #
+  # Any custom Attribute can be accessed directly or via [].
+  class AttrDict #:nodoc:
+    include DateAttribute
+
+    def initialize(object, keys_and_values = {}, defs = {})
+      @object = object
+      @blob_dict = keys_and_values.symbolize_keys
+      @attr_defs = defs.symbolize_keys
+      @attr_cache = {}
+    end
+
+    def empty?
+      @blob_dict.empty? && @attr_defs.empty?
+    end
+
+    # Returns the title of the content - an HtmlString
+    def title
+      raw = @blob_dict[:title]
+      StringTagging.tag_as_html(raw, self)
+    end
+
+    def sort_keys #:nodoc:
+      [sort_key1, sort_key2, sort_key3]
+    end
+
+    # The body attribute may contain binary data for Obj.binary? or be an HtmlString.
+    def body
+      if object.binary?
+        binary_body.data if binary_body
+      else
+        StringTagging.tag_as_html(textual_body, self)
+      end
+    end
+
+    def body_length
+      if binary_body
+        binary_body.length
+      elsif body
+        body.length
+      else
+        0
+      end
+    end
+
+    # Ensures the body data is in a file and returns its file system path.
+    def body_data_path
+      # TODO: Braucht/will jemand Text gestreamt?
+      return nil unless object.binary?
+      binary_body.path_of_stored_data(object.last_changed) if binary_body
+    end
+
+    def [](key)
+      send key
+    end
+
+    def permitted_groups
+      permission_live_server_read
+    rescue NoMethodError
+      []
+    end
+
+    def permissions
+      @permissions ||= OpenStruct.new({ :live => permitted_groups })
+    end
+
+    def respond_to?(method_id, include_private=false)
+      super || has_attribute(method_id)
+    end
+
+    private
+
+    def object
+      @object
+    end
+
+    def blob_dict
+      @blob_dict
+    end
+
+    def attr_defs
+      @attr_defs
+    end
+
+    def textual_body
+      return nil if object.binary?
+      blob_dict[:blob]
+    end
+
+    def binary_body
+      return nil unless object.binary? && has_attribute(:blob)
+      @binary_body ||= Blob.find(blob)
+    rescue RailsConnector::ResourceNotFound
+      nil
+    end
+
+    def method_missing(method_id, *args)
+      raise NoMethodError.new("missing method - #{method_id}") unless args.empty?
+      return attribute_value(method_id.to_s)
+    rescue UnknownAttributeError
+      raise NoMethodError.new("missing method - #{method_id}")
+    end
+
+    def attribute_value(key)
+      raise UnknownAttributeError.new unless has_attribute(key)
+
+      key = key.to_sym
+      raw = blob_dict[key]
+      @attr_cache[key] ||= case type_of(key)
+        when :markdown
+          StringTagging.tag_as_markdown(raw, self)
+        when :html
+          StringTagging.tag_as_html(raw, self)
+        when :date
+          DateAttribute.parse raw if raw
+        when :linklist
+          LinkList.new(raw)
+        else
+          raw
+      end
+    end
+
+    def has_attribute(key)
+      key = key.to_sym
+      !(blob_dict[key] || attr_defs[key]).nil?
+    end
+
+    def type_of(key)
+      key = key.to_sym
+      return :linklist if key == :text_links
+      attr_defs[key]['type'].to_sym rescue nil
+    end
+  end
+
+  class UnknownAttributeError < StandardError # :nodoc:
+  end
+
+end

data/lib/rails_connector/attr_value_provider_loader.rb

@@ -0,0 +1,11 @@
+begin
+  require "rails_connector/attr_value_provider64"
+rescue LoadError => e1
+  begin
+    require "rails_connector/attr_value_provider"
+  rescue LoadError => e2
+    raise "Could neither load attr_value_provider (#{e2.message}) " +
+        "nor attr_value_provider64 (#{e1.message})."
+  end
+end
+

data/lib/rails_connector/blob.rb

@@ -0,0 +1,67 @@
+module RailsConnector
+
+  # A binary containing the blob data of a Content or CMS management
+  # data of Attribute (fields), ObjClass (object classes), for example.
+  class Blob < CmsBaseModel #:nodoc:
+    self.primary_key = "blob_name"
+
+    class << self
+      # Does not retrieve the column blob_data.
+      def find_with_excluded_blob_data(*args)
+        args << Hash.new unless Hash === args.last
+        args.last[:select] = 'blob_name, blob_length'
+        find_without_excluded_blob_data(*args)
+      end
+
+      alias_method_chain :find, :excluded_blob_data
+    end
+
+    def length
+      blob_length
+    end
+
+    def data
+      @data ||= self.class.find_without_excluded_blob_data(id).blob_data
+    end
+
+    def path_of_stored_data(use_cached_file_if_older_than = Time.now)
+      store_data if !File.exists?(path) || use_cached_file_if_older_than > File.mtime(path)
+      path
+    end
+
+    def self.cache_dir
+      File.join(Rails.root, %w(tmp cache))
+    end
+
+    def self.initialize_blob_streaming_for(adapter_name)
+      # Redefines store_data:
+      case adapter_name
+      when /mysql/i:
+        require "rails_connector/blob_mysql"
+        include BlobMysql
+      when /oracle/i:
+        require "rails_connector/blob_oracle"
+        include BlobOracle
+      end
+    end
+
+    private
+
+    def path
+      "#{Blob.cache_dir}/#{id}"
+    end
+
+    def store_data
+      store_data_atomically do |f|
+        f << data
+      end
+    end
+
+    def store_data_atomically(&block)
+      tmp_file = "#{path}.#{Process.pid}"
+      File.open(tmp_file, "w", &block)
+      File.rename(tmp_file, path)
+    end
+  end
+
+end

data/lib/rails_connector/blob_mysql.rb

@@ -0,0 +1,42 @@
+require 'mysql'
+require 'mysql_blob_streaming'
+
+module RailsConnector
+
+  module BlobMysql #:nodoc:
+    def self.included(base)
+      base.instance_eval do
+        define_method :store_data do
+          store_data_atomically {|f| fetch_into_file(f)}
+        end
+      end
+    end
+
+    def fetch_into_file(file)
+      mysql = connection.instance_variable_get '@connection'
+      stmt = mysql.prepare("SELECT blob_data FROM #{self.class.table_name} WHERE #{self.class.primary_key}=?")
+
+      class << stmt
+        include MysqlBlobStreaming
+
+        attr_accessor :file
+        attr_accessor :logger
+
+        def handle_data(data)
+          @file << data
+          data = nil
+          GC.start
+        end
+      end
+
+      stmt.logger = ActiveRecord::Base.logger
+      stmt.logger.debug "Streaming blob from MySQL into #{file.path}"
+      stmt.file = file
+      stmt.execute(id)
+      stmt.stream(1.megabyte)
+    ensure
+      stmt.close if stmt
+    end
+  end
+
+end

data/lib/rails_connector/blob_oracle.rb

@@ -0,0 +1,39 @@
+module RailsConnector
+
+  module BlobOracle #:nodoc:
+    def self.included(base)
+      base.instance_eval do
+        define_method :store_data do
+          store_data_atomically {|f| fetch_into_file(f)}
+        end
+      end
+    end
+
+    def fetch_into_file(file)
+      blob = blob_handle
+      while data = blob.read(buff_size ||= 1.megabyte)
+        file <<  data
+        data = nil
+        GC.start
+      end
+    ensure
+      blob.close if blob
+    end
+
+    private
+
+    def sql
+      %{
+        SELECT blob_data
+        FROM #{self.class.table_name}
+        WHERE #{self.class.primary_key} = :1
+      }
+    end
+
+    def blob_handle
+      con = connection.instance_variable_get '@connection'
+      con.exec(sql, id).fetch.first
+    end
+  end
+
+end

data/lib/rails_connector/cache_middleware.rb

@@ -0,0 +1,13 @@
+module RailsConnector
+  class CacheMiddleware #:nodoc:
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      CmsBaseModel.cache do
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rails_connector/cms_base_model.rb

@@ -0,0 +1,45 @@
+module RailsConnector
+
+  # This is the abstract class from which all CMS models derive.
+  # The database connection is set to "infopark_rails_connector_${RAILS_ENV}" and the table prefix is
+  # determined from the instance_name.
+  #
+  # [instance_name] the name of the CMS instance
+  class CmsBaseModel < ActiveRecord::Base #:nodoc:
+    @@instance_name = 'default'
+    cattr_accessor :instance_name
+    self.abstract_class = true
+
+    def self.configure_database(db_connection_spec)
+      establish_connection(db_connection_spec)
+      Blob.initialize_blob_streaming_for(connection.adapter_name)
+    end
+
+    # Returns :table_name_with_underscore. All CMS models use this kind of primary key naming.
+    def self.primary_key_prefix_type
+      :table_name_with_underscore
+    end
+
+    # CmsBaseModel and all of its descendants are model classes that can access CMS contents.
+    def self.cms_model?
+      true
+    end
+
+    def readonly?
+      true
+    end
+
+    class << self
+      # The prefix of the table name is determined by using the instance name followed by an underscore.
+      # Set the instance_name in your environment to the CMS instance name (defaults to 'default').
+      #
+      #   CmsBaseModel.instance_name = 'default'
+      #
+      # ActiveRecord::Base::primary_key_prefix_type has no effect here.
+      def table_name_prefix
+        @@instance_name.blank? ? '' : (@@instance_name + '_')
+      end
+    end
+  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