infopark_reactor 1.26.1 → 1.27.0.rc10

data/lib/reactor/tools/smart_xml_logger.rb

@@ -1,8 +1,6 @@
-# -*- encoding : utf-8 -*-
-require 'nokogiri'
+require "nokogiri"
 
 class SmartXmlLogger
-
   def initialize(forward_to, method = nil)
     @logger = forward_to
     @method = method
@@ -15,6 +13,7 @@ class SmartXmlLogger
 
   def log(text)
     return unless @logger
+
     @logger.send(@method, text)
   end
 
@@ -27,41 +26,40 @@ class SmartXmlLogger
 
     node_set = options[:xpath] ? dom.xpath(options[:xpath]) : dom
 
-    self.log(if node_set.respond_to?(:each)
-      node_set.map{|node| self.print_node(node, options[:start_indent] || 0)}.join
-    else
-      self.print_node(node_set, options[:start_indent] || 0)
+    log(if node_set.respond_to?(:each)
+          node_set.map { |node| print_node(node, options[:start_indent] || 0) }.join
+        else
+          print_node(node_set, options[:start_indent] || 0)
     end)
   end
 
-  #private
+  # private
 
   def print_node(node, indent = 0)
-    return '' if node.text?
+    return "" if node.text?
 
     empty = node.children.empty?
-    has_text = node.children.detect{|child| child.text?}
+    has_text = node.children.detect { |child| child.text? }
 
-    out = ' ' * indent
+    out = " " * indent
 
-    attrs = node.attributes.values.map{|attr| %|#{attr.name}="#{(attr.value)}"|}.join(' ')
+    attrs = node.attributes.values.map { |attr| %(#{attr.name}="#{attr.value}") }.join(" ")
     attrs = " #{attrs}" if attrs.present?
 
-    out << "<#{(node.name)}#{attrs}#{'/' if empty}>"
+    out << "<#{node.name}#{attrs}#{"/" if empty}>"
 
-    if has_text
-      out << "#{(node.text)}"
-    else
-      out << "\n"
-    end
+    out << if has_text
+             node.text.to_s
+           else
+             "\n"
+           end
 
     node.children.each do |child|
-      out << self.print_node(child, indent + 2)
+      out << print_node(child, indent + 2)
     end
 
-    out << ' ' * indent unless has_text || empty
-    out << "</#{(node.name)}>\n" unless empty
+    out << " " * indent unless has_text || empty
+    out << "</#{node.name}>\n" unless empty
     out
   end
-
 end

data/lib/reactor/tools/sower.rb

@@ -1,15 +1,13 @@
-# -*- encoding : utf-8 -*-
 module Reactor
-
   class Sower
     def initialize(filename)
       @filename = filename
     end
+
     def sow
       require @filename
     end
   end
-
 end
 
 class SeedObject < RailsConnector::AbstractObj
@@ -17,15 +15,15 @@ end
 
 module RailsConnector
   class AbstractObj
-
     attr_accessor :keep_edited
 
     def self.plant(path, &block)
       obj = Obj.find_by_path(path)
-      raise ActiveRecord::RecordNotFound.new('plant: Ground not found:' +path) if obj.nil?
-      #obj.objClass = 'Container' # TODO: enable it!
-      #obj.save!
-      #obj.release!
+      raise ActiveRecord::RecordNotFound, "plant: Ground not found:" + path if obj.nil?
+
+      # obj.objClass = 'Container' # TODO: enable it!
+      # obj.save!
+      # obj.release!
       obj.send(:reload_attributes)
       obj.instance_eval(&block) if block_given?
       # ActiveRecord is incompatible with changing the obj class, therefore you get RecordNotFound
@@ -41,39 +39,41 @@ module RailsConnector
     # executes a block on it (instance_eval)
     # saves and releases (unless keep_edited = true was called)
     # the object afterwards
-    def obj(name, objClass = 'Container', &block)
-      obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+    def obj(name, objClass = "Container", &block)
+      obj = Obj.find_by_path(File.join(path.to_s, name.to_s))
       if obj.nil?
-        obj = Obj.create(:name => name, :parent => self.path, :obj_class => objClass)
+        obj = Obj.create(name: name, parent: path, obj_class: objClass)
       else
-        obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+        obj = Obj.find_by_path(File.join(path.to_s, name.to_s))
         if obj.obj_class != objClass
           obj.obj_class = objClass
           begin
             obj.save!
           rescue ActiveRecord::RecordNotFound
           end
-          obj = Obj.find_by_path(File.join(self.path.to_s, name.to_s))
+          obj = Obj.find_by_path(File.join(path.to_s, name.to_s))
         end
       end
       obj.send(:reload_attributes, objClass)
       obj.instance_eval(&block) if block_given?
       obj.save!
-      obj.release unless obj.keep_edited || !Obj.last.edited?
+      obj.release unless obj.keep_edited || !obj.reload.edited?
       obj
     end
 
-    def self.with(path, objClass = 'Container', &block)
-      splitted_path = path.split('/')
+    def self.with(path, objClass = "Container", &block)
+      splitted_path = path.split("/")
       name = splitted_path.pop
       # ensure path exists
-      (splitted_path.length).times do |i|
-        subpath = splitted_path[0,(i+1)].join('/').presence || '/'
-        subpath_parent = splitted_path[0,i].join('/').presence || '/'
+      splitted_path.length.times do |i|
+        subpath = splitted_path[0, (i + 1)].join("/").presence || "/"
+        subpath_parent = splitted_path[0, i].join("/").presence || "/"
         subpath_name = splitted_path[i]
-        create(:name => subpath_name, :parent => subpath_parent, :obj_class => 'Container') unless Obj.find_by_path(subpath) unless subpath_name.blank?
+        unless subpath_name.blank? || Obj.find_by_path(subpath)
+          create(name: subpath_name, parent: subpath_parent, obj_class: "Container")
+        end
       end
-      parent_path = splitted_path.join('/').presence || '/'
+      parent_path = splitted_path.join("/").presence || "/"
       parent = Obj.find_by_path(parent_path)
       parent.obj(name, objClass, &block)
     end
@@ -82,9 +82,8 @@ module RailsConnector
       @keep_edited = true
     end
 
-    def t(key, opts={})
+    def t(key, opts = {})
       I18n.t(key, opts)
     end
-
   end
 end

data/lib/reactor/tools/uploader.rb

@@ -1,8 +1,6 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module Tools
     class Uploader
-
       attr_reader :cm_obj
 
       def initialize(cm_obj)
@@ -24,7 +22,7 @@ module Reactor
       # the upload may fail randomly. For this platform
       # and this case fallback to memory streaming is used.
       def upload(data_or_io, extension)
-        if (data_or_io.kind_of?IO)
+        if data_or_io.is_a? IO
           io = data_or_io
           begin
             ticket_id = stream_io(io, extension)
@@ -46,7 +44,7 @@ module Reactor
         end
 
         cm_obj.set(:contentType, extension)
-        cm_obj.set(:blob, {ticket_id=>{:encoding=>'stream'}})
+        cm_obj.set(:blob, { ticket_id => { encoding: "stream" } })
 
         ticket_id
       end
@@ -58,8 +56,8 @@ module Reactor
       # Stream into CM from memory. Used in cases when the file
       # has already been read into memory
       def stream_data(data, extension)
-        response = (Net::HTTP.new(self.class.streaming_host, self.class.streaming_port).post('/stream', data,
-          {'Content-Type' => self.class.content_type_for_ext(extension)}))
+        response = Net::HTTP.new(self.class.streaming_host, self.class.streaming_port).post("/stream", data,
+                                                                                            { "Content-Type" => self.class.content_type_for_ext(extension) })
         ticket_id = response.body
 
         handle_response(response, ticket_id)
@@ -68,12 +66,13 @@ module Reactor
       # Stream directly an IO object into CM. Uses minimal memory,
       # as the IO is read in 1024B-Blocks
       def stream_io(io, extension)
-        request = Net::HTTP::Post.new('/stream')
+        request = Net::HTTP::Post.new("/stream")
         request.body_stream = io
         request.content_length = read_io_content_length(io)
         request.content_type = self.class.content_type_for_ext(extension)
 
-        response, ticket_id = nil, nil
+        response = nil
+        ticket_id = nil
         Net::HTTP.start(self.class.streaming_host, self.class.streaming_port) do |http|
           http.read_timeout = Reactor::Cm::XmlRequest.timeout
           response = http.request(request)
@@ -85,11 +84,7 @@ module Reactor
 
       # Returns ticket_id if response if one of success (success or redirect)
       def handle_response(response, ticket_id)
-        if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
-          ticket_id
-        else
-          nil
-        end
+        ticket_id if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
       end
 
       # Returns the size of the IO stream.
@@ -97,9 +92,9 @@ module Reactor
       # the :stat method or be able to seek to
       # random position
       def read_io_content_length(io)
-        if (io.respond_to?(:stat))
+        if io.respond_to?(:stat)
           # For files it is easy to read the filesize
-          return io.stat.size
+          io.stat.size
         else
           # For streams it is not. We seek to end of
           # the stream, read the position, and rewind
@@ -125,8 +120,8 @@ module Reactor
       # mime type for given extension. But since the CM
       # accepts 'application/octet-stream', no extra logic
       # or external dependency is required.
-      def self.content_type_for_ext(extension)
-        'application/octet-stream'
+      def self.content_type_for_ext(_extension)
+        "application/octet-stream"
       end
     end
   end

data/lib/reactor/tools/versioner.rb

@@ -1,7 +1,6 @@
-# -*- encoding : utf-8 -*-
-require 'base64'
-require 'yaml'
-require 'singleton'
+require "base64"
+require "yaml"
+require "singleton"
 
 module Reactor
   # Class responsible for interfacing with version-storing mechanism
@@ -29,38 +28,39 @@ module Reactor
       def exists?
         begin
           request = Reactor::Cm::XmlRequest.prepare do |xml|
-            xml.where_key_tag!(base_name, 'name', name)
-            xml.get_key_tag!(base_name, 'name')
+            xml.where_key_tag!(base_name, "name", name)
+            xml.get_key_tag!(base_name, "name")
           end
           response = request.execute!
-          return response.ok?
-        rescue
-          return false
+          response.ok?
+        rescue StandardError
+          false
         end
       end
 
       def load
-        create if not exists?
+        create unless exists?
         request = Reactor::Cm::XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', name)
-          xml.get_key_tag!(base_name, 'recordSetCallback')
+          xml.where_key_tag!(base_name, "name", name)
+          xml.get_key_tag!(base_name, "recordSetCallback")
         end
         response = request.execute!
         base64 = response.xpath("//recordSetCallback").text.to_s
-        yaml = Base64::decode64(base64)
-        data = YAML::load(yaml)
-        return [] if data.nil? or data == false
-        return data.to_a
+        yaml = Base64.decode64(base64)
+        data = YAML.load(yaml)
+        return [] if data.nil? || (data == false)
+
+        data.to_a
       end
 
       def store(data)
-        create if not exists?
+        create unless exists?
         yaml = data.to_yaml
-        base64 = Base64::encode64(yaml).gsub("\n", '').gsub("\r", '')
-        content = '#' + base64
+        base64 = Base64.encode64(yaml).delete("\n").delete("\r")
+        content = "#" + base64
         request = Reactor::Cm::XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', name)
-          xml.set_key_tag!(base_name, 'recordSetCallback', content)
+          xml.where_key_tag!(base_name, "name", name)
+          xml.set_key_tag!(base_name, "recordSetCallback", content)
         end
         response = request.execute!
         response.ok?
@@ -69,11 +69,11 @@ module Reactor
       def create
         request = Reactor::Cm::XmlRequest.prepare do |xml|
           xml.create_tag!(base_name) do
-            xml.tag!('name') do
+            xml.tag!("name") do
               xml.text!(name)
             end
-            xml.tag!('objType') do
-              xml.text!('document')
+            xml.tag!("objType") do
+              xml.text!("document")
             end
           end
         end
@@ -105,17 +105,16 @@ module Reactor
     end
 
     def remove(version)
-      not @versions.delete(version.to_s).nil?
+      !@versions.delete(version.to_s).nil?
     end
 
-    def versions
-      @versions
-    end
+    attr_reader :versions
 
     def current_version
-      current = @versions.sort.reverse.first
+      current = @versions.max
       return 0 if current.nil?
-      return current
+
+      current
     end
   end
 end

data/lib/reactor/tools/where_query.rb

@@ -2,32 +2,29 @@ module Reactor
   module WhereQuery
     def where(key, value)
       request = Cm::XmlRequest.prepare do |xml|
-        xml.where_tag!(self.base_name) do
+        xml.where_tag!(base_name) do
           xml.tag!(key) do
-            if value
-              xml.text!(value)
-            end
+            xml.text!(value) if value
           end
         end
 
-        xml.get_tag!(self.base_name) do
-          self.attributes.each do |_, xml_attribute|
+        xml.get_tag!(base_name) do
+          attributes.each do |_, xml_attribute|
             xml.tag!(xml_attribute.name)
           end
         end
       end
 
       response = request.execute!
-      result = response.xpath("//#{self.base_name}")
-      result = [result] unless result.kind_of?(Array)
+      result = response.xpath("//#{base_name}")
+      result = [result] unless result.is_a?(Array)
       result.map do |elem|
-        values = {}
-        values = self.response_handler.multiple(elem, self.attributes.values)
-        instance  = self.new
-        values.each do |name, value|
-          pair = self.attributes.find {|n, a| a.name.to_sym == name.to_sym }
+        values = response_handler.multiple(elem, attributes.values)
+        instance = new
+        values.each do |name, response_value|
+          pair = attributes.find { |_n, a| a.name.to_sym == name.to_sym }
           attribute = pair[0]
-          instance.send(:"#{attribute}=", value)
+          instance.send(:"#{attribute}=", response_value)
         end
         instance
       end

data/lib/reactor/tools/workflow_generator.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module Tools
     class WorkflowGenerator
@@ -10,8 +9,8 @@ module Reactor
         @users      = @editors + @correctors
         @groups     = personal_groups(@users)
         @class_name = options[:obj_class] || generate_obj_class_name
-        @workflow_name  = options[:workflow_name] || generate_workflow_name
-        @obj_name   = options[:obj_name] || generate_obj_name
+        @workflow_name = options[:workflow_name] || generate_workflow_name
+        @obj_name = options[:obj_name] || generate_obj_name
       end
 
       def generate!
@@ -45,7 +44,7 @@ module Reactor
       end
 
       def personal_groups(users)
-        users.map {|user| personal_group(user) }
+        users.map { |user| personal_group(user) }
       end
 
       def create_groups
@@ -53,20 +52,20 @@ module Reactor
           if Reactor::Cm::Group.exists?(group)
             Reactor::Cm::Group.get(group)
           else
-            Reactor::Cm::Group.create(:name => group)
+            Reactor::Cm::Group.create(name: group)
           end
         end
       end
 
       def create_users
         @users.each do |user|
-          if Reactor::Cm::User::Internal.exists?(user)
-            internal_user = Reactor::Cm::User::Internal.get(user)
-          else
-            internal_user = Reactor::Cm::User::Internal.create(user, personal_group(user))
-          end
+          internal_user = if Reactor::Cm::User::Internal.exists?(user)
+                            Reactor::Cm::User::Internal.get(user)
+                          else
+                            Reactor::Cm::User::Internal.create(user, personal_group(user))
+                          end
 
-          internal_user.change_password('thepasswordispassword')
+          internal_user.change_password("thepasswordispassword")
         end
       end
 
@@ -76,21 +75,21 @@ module Reactor
         @users.each do |user|
           signature = personal_signature(user)
           if Reactor::Cm::Attribute.exists?(signature)
-            #Reactor::Cm::Attribute.get(signature)
+            # Reactor::Cm::Attribute.get(signature)
             @signatures[user] = signature
           else
-            Reactor::Cm::Attribute.create(signature, 'signature')
+            Reactor::Cm::Attribute.create(signature, "signature")
             @signatures[user] = signature
           end
         end
       end
 
       def create_workflow
-        if Reactor::Cm::Workflow.exists?(@workflow_name)
-          @workflow = Reactor::Cm::Workflow.get(@workflow_name)
-        else
-          @workflow = Reactor::Cm::Workflow.create(@workflow_name)
-        end
+        @workflow = if Reactor::Cm::Workflow.exists?(@workflow_name)
+                      Reactor::Cm::Workflow.get(@workflow_name)
+                    else
+                      Reactor::Cm::Workflow.create(@workflow_name)
+                    end
 
         # set up workflow steps
         @workflow.edit_groups = personal_groups(@editors)
@@ -98,8 +97,8 @@ module Reactor
         serialized_signatures = []
         @correctors.each do |corrector|
           signature = {
-            :group => personal_group(corrector),
-            :attribute => @signatures[corrector]
+            group: personal_group(corrector),
+            attribute: @signatures[corrector]
           }
           serialized_signatures << signature
         end
@@ -110,15 +109,15 @@ module Reactor
       end
 
       def create_obj_class
-        @obj_class  = if Reactor::Cm::ObjClass.exists?(@class_name)
-          Reactor::Cm::ObjClass.get(@class_name)
-        else
-          Reactor::Cm::ObjClass.create(@class_name, 'publication')
+        @obj_class = if Reactor::Cm::ObjClass.exists?(@class_name)
+                       Reactor::Cm::ObjClass.get(@class_name)
+                     else
+                       Reactor::Cm::ObjClass.create(@class_name, "publication")
         end
       end
 
       def create_obj
-        @obj = Reactor::Cm::Obj.create(@obj_name, '/', @class_name)
+        @obj = Reactor::Cm::Obj.create(@obj_name, "/", @class_name)
         @obj.set(:workflowName, @workflow_name)
         @obj.save!
       end
@@ -187,10 +186,9 @@ module Reactor
       end
 
       def generate_token
-        characters = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
-        token = 8.times.map { characters[rand(characters.length)] }.join
+        characters = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a
+        Array.new(8) { characters[rand(characters.length)] }.join
       end
-
     end
   end
 end