infopark_reactor 1.26.1 → 1.27.0.rc10

data/lib/reactor/session/observers.rb

@@ -1,22 +1,20 @@
-# -*- encoding : utf-8 -*-
-
 module Reactor
   class Session
     module Observers
       class PermissionCacheInvalidator
-        def update(user_name, new_login=false)
+        def update(user_name, new_login = false)
           Reactor::Cache::Permission.instance.invalidate(user_name) if new_login
         end
       end
 
       class UserCacheInvalidator
-        def update(user_name, new_login=false)
+        def update(user_name, new_login = false)
           Reactor::Cache::User.instance.invalidate(user_name) if new_login
         end
       end
 
       class CmsAccessDataPropagator
-        def update(user_name, new_login=false)
+        def update(user_name, _new_login = false)
           Reactor::Configuration.xml_access[:username] = user_name
         end
       end

data/lib/reactor/session/user.rb

@@ -1,17 +1,16 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/cm/user'
+require "reactor/cm/user"
 
 module Reactor
   class Session
     class User
       def initialize(user_name)
         # Rails.logger.debug "Reading user #{user_name} from CM"
-        user      = Reactor::Cm::User.new(user_name)
-        @user_name= user_name
-        @groups   = user.groups
+        user = Reactor::Cm::User.new(user_name)
+        @user_name = user_name
+        @groups = user.groups
         @language = user.language
-        @superuser= user.is_root?
-        @email    = user.email
+        @superuser = user.is_root?
+        @email = user.email
       end
 
       def to_s

data/lib/reactor/session_helper/auth_filter.rb

@@ -0,0 +1,9 @@
+module Reactor
+  module SessionHelper
+    module AuthFilter
+      def self.included(base)
+        base.__send__(:before_action, :rsession_auth)
+      end
+    end
+  end
+end

data/lib/reactor/session_helper/auth_helper.rb

@@ -0,0 +1,24 @@
+module Reactor
+  module SessionHelper
+    module AuthHelper
+      def rsession_auth
+        if RailsConnector::Configuration.mode == :editor && (jsessionid = cookies["JSESSIONID"]).present?
+          # Why the gsub? It's a dirty hack! Reason: JSESSIONIDs are unescaped
+          # when read through Rails and hence all + are converted into spaces.
+          # CM Kernel though stores escaped IDs.
+          # From the possible generated characters only the + seems to be
+          # problematic.
+          # CGI.escape would be the solution, but it's deprecated
+          # URI.escape does too much
+          jsessionid.tr!(" ", "+")
+
+          Rails.logger.info "Trying to log in at #{Reactor::Configuration.xml_access[:host]}:#{Reactor::Configuration.xml_access[:port]} with JSESSIONID=#{jsessionid}."
+          rsession.login(jsessionid)
+          Rails.logger.info %(Logged in as "#{rsession.user_name}".) if rsession.user?
+        else
+          rsession.destroy
+        end
+      end
+    end
+  end
+end

data/lib/reactor/session_helper/rsession_helper.rb

@@ -0,0 +1,16 @@
+module Reactor
+  module SessionHelper
+    module RsessionHelper
+      def rsession
+        @__rsession ||= RsessionHelper.from_session(session)
+      end
+
+      def self.from_session(session)
+        Reactor::Session.new(
+          # This passes the very powerfull rails session object
+          SessionState.new(session)
+        )
+      end
+    end
+  end
+end

data/lib/reactor/session_helper/session_state.rb

@@ -0,0 +1,31 @@
+module Reactor
+  module SessionHelper
+    class SessionState < Reactor::Session::State
+      USER_NAME_KEY  = "rsession$user_name".freeze
+      SESSION_ID_KEY = "rsession$session_id".freeze
+
+      def initialize(session)
+        self.session = session
+        super(session[USER_NAME_KEY], session[SESSION_ID_KEY])
+      end
+
+      def user_name=(new_user_name)
+        super
+        # this is a little bit of magic: it will trigger
+        # the the session serialization routine, and will
+        # persist the new information after processing the request
+        session[USER_NAME_KEY] = new_user_name
+      end
+
+      def session_id=(new_session_id)
+        super
+        # see above
+        session[SESSION_ID_KEY] = new_session_id
+      end
+
+      protected
+
+      attr_accessor :session
+    end
+  end
+end

data/lib/reactor/streaming_upload.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module StreamingUpload
     module Base

data/lib/reactor/sudo.rb

@@ -1,13 +1,12 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module Sudo
-    def self.su(other_user_name, &block)
+    def self.su(other_user_name)
       rsession           = Reactor::Session.instance
       current_user_name  = rsession.user_name
       rsession.user_name = other_user_name
       yield
     ensure
-      rsession.user_name = current_user_name || 'root'
+      rsession.user_name = current_user_name || "root"
     end
   end
 end

data/lib/reactor/support/link_matcher.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module Support
     class LinkMatcher
@@ -11,27 +10,29 @@ module Reactor
         (match[:action] == "index") &&
           (match[:controller] == "rails_connector/cms_dispatch") &&
           ((match[:id].present? && RailsConnector::AbstractObj.exists?(match[:id].to_i)) ||
-          (match[:permalink].present? && RailsConnector::AbstractObj.exists?(:permalink => match[:permalink])))
+          (match[:permalink].present? && RailsConnector::AbstractObj.exists?(permalink: match[:permalink])))
       rescue ActionController::RoutingError
-        return false
+        false
       end
 
       def rewrite_url
         match = match_url
 
         if match[:permalink].present?
-          append_fragment_and_query RailsConnector::AbstractObj.find_by_permalink(match[:permalink]).path 
+          append_fragment_and_query RailsConnector::AbstractObj.find_by_permalink(match[:permalink]).path
         elsif match[:id].present?
           append_fragment_and_query RailsConnector::AbstractObj.find(match[:id].to_i).path
         end
       end
 
       private
+
       def match_url
-        return {} if @url.match(/\A[a-z0-9]*:/) # ignore fully qualified urls
-        relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
+        return {} if /\A[a-z0-9]*:/.match?(@url) # ignore fully qualified urls
+
+        relative_url_root = ENV["RAILS_RELATIVE_URL_ROOT"]
         url = @url.clone
-        url.gsub!(/^#{Regexp.escape(relative_url_root)}/, '') if relative_url_root.present?
+        url.gsub!(/^#{Regexp.escape(relative_url_root)}/, "") if relative_url_root.present?
         Rails.application.routes.recognize_path(url)
       end
 

data/lib/reactor/tools/migrator.rb

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/tools/versioner'
+require "reactor/tools/versioner"
 
 module Reactor
   # Class responsible for running a single migration, a helper for Migrator
@@ -18,47 +17,42 @@ module Reactor
 
     def run
       return down if @direction.to_sym == :down
-      return up
+
+      up
     end
 
     def up
-      if @versioner.applied?(@version) then
+      if @versioner.applied?(@version)
         puts "Migrating up: #{@name} (#{@filename}) already applied, skipping"
-        return true
+        true
       else
         result = class_name.send(:up) and @versioner.add(@version)
-        class_name.contained.each do |version|
-          puts "#{class_name.to_s} contains migration #{version}"
-          #@versioner.add(version) # not neccesary!
-        end if result
+        if result
+          class_name.contained.each do |version|
+            puts "#{class_name} contains migration #{version}"
+            # @versioner.add(version) # not neccesary!
+          end
+        end
         result
       end
     end
 
     def down
       result = class_name.send(:down) and @versioner.remove(@version)
-      class_name.contained.each do |version|
-        puts "#{class_name.to_s} contains migration #{version}"
-        @versioner.remove(version)
-      end if result
+      if result
+        class_name.contained.each do |version|
+          puts "#{class_name} contains migration #{version}"
+          @versioner.remove(version)
+        end
+      end
       result
     end
 
     def class_name
-      return Kernel.const_get(@name)
+      Kernel.const_get(@name)
     end
 
-    def name
-      @name
-    end
-
-    def version
-      @version
-    end
-
-    def filename
-      @filename
-    end
+    attr_reader :name, :version, :filename
   end
 
   # Migrator is responsible for running migrations.
@@ -77,10 +71,10 @@ module Reactor
     # and target_version (an integer or nil).
     #
     # Used by a rake task.
-    def initialize(migrations_path, target_version=nil)
+    def initialize(migrations_path, target_version = nil)
       @migrations_path = migrations_path
       @target_version = target_version.to_i unless target_version.nil?
-      @target_version = 99999999999999 if target_version.nil?
+      @target_version = 99_999_999_999_999 if target_version.nil?
       @versioner = Versioner.instance
     end
 
@@ -88,25 +82,26 @@ module Reactor
     # Ouputs current version when done
     def migrate
       return up if @target_version.to_i > current_version.to_i
-      return down
+
+      down
     end
 
     def up
-      rem_migrations = migrations.reject do |version, name, file|
+      rem_migrations = migrations.reject do |version, _name, _file|
         version.to_i > @target_version.to_i or applied?(version)
       end
       run(rem_migrations, :up)
     end
 
     def down
-      rem_migrations = migrations.reject do |version, name, file|
-        version.to_i <= @target_version.to_i or not applied?(version)
+      rem_migrations = migrations.reject do |version, _name, _file|
+        version.to_i <= @target_version.to_i or !applied?(version)
       end
       run(rem_migrations.reverse, :down)
     end
 
     def migrations
-      files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort.collect do |file|
+      Dir["#{@migrations_path}/[0-9]*_*.rb"].sort.collect do |file|
         version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
         [version, name, file]
       end
@@ -124,12 +119,12 @@ module Reactor
       begin
         rem_migrations.each do |version, name, file|
           migration = MigrationProxy.new(@versioner, name.camelize, version, direction, file)
-          puts "Migrating #{direction.to_s}: #{migration.name} (#{migration.filename})"
-          migration.load_migration and migration.run or raise "Migrating #{direction.to_s}: #{migration.name} (#{migration.filename}) failed"
+          puts "Migrating #{direction}: #{migration.name} (#{migration.filename})"
+          migration.load_migration and migration.run or raise "Migrating #{direction}: #{migration.name} (#{migration.filename}) failed"
         end
       ensure
         puts "At version: " + @versioner.current_version.to_s
-        puts "WARNING: Could not store applied migrations!" if not @versioner.store
+        puts "WARNING: Could not store applied migrations!" unless @versioner.store
       end
     end
   end

data/lib/reactor/tools/response_handler/xml_attribute.rb

@@ -1,13 +1,9 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/tools/xpath_extractor'
+require "reactor/tools/xpath_extractor"
 module Reactor
-
   module ResponseHandler
-    
     class XmlAttribute
-      attr_accessor :response
-      attr_accessor :context
-      
+      attr_accessor :response, :context
+
       def get(response, attribute)
         @response = response
         @context = context
@@ -17,13 +13,13 @@ module Reactor
 
         method_name = "extract_#{type}"
 
-        self.send(method_name, name)
+        send(method_name, name)
       end
 
       def multiple(elem, attributes)
         values = {}
         attributes.each do |attribute|
-          values[attribute.name] = self.get(elem, attribute)
+          values[attribute.name] = get(elem, attribute)
         end
         values
       end
@@ -32,18 +28,18 @@ module Reactor
 
       # Extracts a string value with the given +name+ and returns a string.
       def extract_string(name)
-        result = self.xpath(".//#{name}/text()")
-        if result.kind_of?(Array)
-          return result.first
+        result = xpath(".//#{name}/text()")
+        if result.is_a?(Array)
+          result.first
         else
-          return result.to_s
+          result.to_s
         end
       end
 
       # Extracts a list value with the given +name+ and returns an array of strings.
       def extract_list(name)
-        result = self.xpath(".//#{name}/listitem/text()")
-        result = result.kind_of?(Array) ? result : [result]
+        result = xpath(".//#{name}/listitem/text()")
+        result = result.is_a?(Array) ? result : [result]
 
         result.map(&:to_s)
       end
@@ -51,38 +47,39 @@ module Reactor
       # This shit will break with the slightest change of the CM.
       def extract_signaturelist(name)
         signatures = []
-        self.xpath(".//#{name}/").each do |potential_signature|
-          if (potential_signature.name.to_s == "listitem")
-            attribute = potential_signature.children.first.text.to_s
-            group = potential_signature.children.last.text.to_s
-            signatures << {:attribute => attribute, :group => group}
-          end
+        xpath(".//#{name}/").each do |potential_signature|
+          next unless potential_signature.name.to_s == "listitem"
+
+          attribute = potential_signature.children.first.text.to_s
+          group = potential_signature.children.last.text.to_s
+          signatures << { attribute: attribute, group: group }
         end
         signatures
       end
 
       protected
+
       def node
         # TODO: clean up this bullshit
-        if self.response.kind_of?(Reactor::Cm::XmlResponse)
-          self.response.xml
+        if response.is_a?(Reactor::Cm::XmlResponse)
+          response.xml
         else
-          self.response
+          response
         end
       end
 
       def xpath(expr)
-        Reactor::XPathExtractor.new(self.node).match(expr)
+        Reactor::XPathExtractor.new(node).match(expr)
       end
 
       def extract_schedule(name)
         schedule_entries = []
-        self.response.xpath("//#{name}/listitem").each do |potential_schedule|
+        response.xpath("//#{name}/listitem").each do |potential_schedule|
           entry = {}
-          potential_schedule.children.find_all {|c| c.name == "dictitem" }.each do |item|
-            key = item.children.find {|c| c.name == "key" }.text
-            values_item = item.children.find {|c| c.name == "value" }
-            values = values_item.children.find_all { |c| c.name == "listitem" }.map {|i| i.text.to_s }
+          potential_schedule.children.find_all { |c| c.name == "dictitem" }.each do |item|
+            key = item.children.find { |c| c.name == "key" }.text
+            values_item = item.children.find { |c| c.name == "value" }
+            values = values_item.children.find_all { |c| c.name == "listitem" }.map { |i| i.text.to_s }
             entry[key.to_sym] = values
           end
           schedule_entries << entry
@@ -90,9 +87,6 @@ module Reactor
 
         schedule_entries
       end
-
     end
-    
   end
-
 end