infopark_reactor 1.25.0 → 1.27.0.rc4

data/lib/reactor/cm/obj_class.rb

@@ -1,7 +1,6 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/cm/xml_request'
-require 'reactor/cm/xml_response'
-require 'reactor/cm/xml_request_error'
+require "reactor/cm/xml_request"
+require "reactor/cm/xml_response"
+require "reactor/cm/xml_request_error"
 
 module Reactor
   module Cm
@@ -9,15 +8,15 @@ module Reactor
       def self.exists?(name)
         klass = ObjClass.new
         begin
-          return klass.send(:get, name).ok?
-        rescue
-          return false
+          klass.send(:get, name).ok?
+        rescue StandardError
+          false
         end
       end
 
       def self.create(name, type)
         klass = ObjClass.new
-        klass.send(:create,name, type)
+        klass.send(:create, name, type)
         klass
       end
 
@@ -29,17 +28,17 @@ module Reactor
 
       def self.rename(current_name, new_name)
         request = XmlRequest.prepare do |xml|
-          xml.tag!('objClass-where') do
-            xml.tag!('name', current_name)
+          xml.tag!("objClass-where") do
+            xml.tag!("name", current_name)
           end
-          xml.tag!('objClass-set') do
-            xml.tag!('name', new_name)
+          xml.tag!("objClass-set") do
+            xml.tag!("name", new_name)
           end
         end
         request.execute!
       end
 
-      def set(key, value, options={})
+      def set(key, value, options = {})
         @params_options[key.to_sym] = (!options.nil? && !options.empty? && options) || {}
         @params[key.to_sym] = value
       end
@@ -50,28 +49,27 @@ module Reactor
 
       def preset_attributes
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
-          xml.get_key_tag!(base_name, 'presetAttributes')
+          xml.where_key_tag!(base_name, "name", @name)
+          xml.get_key_tag!(base_name, "presetAttributes")
         end
         response = request.execute!
-        result = response.xpath('//dictitem')
-        result = [result] unless result.kind_of?(Array)
+        result = response.xpath("//dictitem")
+        result = [result] unless result.is_a?(Array)
         result.map do |dictitem|
-          key = dictitem.children.detect {|c| c.name == 'key'}.text
-          raw_value = dictitem.children.detect {|c| c.name == 'value'}
-          if raw_value.children.detect {|c| c.kind_of?(::REXML::Text) }
-            value = raw_value.text
-          else
-            value = raw_value.children.map {|c| c.text }
-          end
-          {key => value}
+          key = dictitem.children.detect { |c| c.name == "key" }.text
+          raw_value = dictitem.children.detect { |c| c.name == "value" }
+          value = if raw_value.children.detect { |c| c.is_a?(::REXML::Text) }
+                    raw_value.text
+                  else
+                    raw_value.children.map { |c| c.text }
+                  end
+          { key => value }
         end.inject({}, &:merge)
       end
 
-
       def save!
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.set_tag!(base_name) do
             @params.each do |key, value|
               if @params_options[key][:cdata]
@@ -83,17 +81,17 @@ module Reactor
               end
             end
             unless @preset.empty?
-              all_preset = (preset_attributes.merge(@preset))
-              xml.tag!('presetAttributes') do
+              preset_attributes.merge(@preset)
+              xml.tag!("presetAttributes") do
                 @preset.each do |key, value|
-                  xml.tag!('dictitem') do
-                    xml.tag!('key') do
+                  xml.tag!("dictitem") do
+                    xml.tag!("key") do
                       xml.text!(key.to_s)
                     end
-                    xml.tag!('value') do
-                      if value.kind_of?(Array)
+                    xml.tag!("value") do
+                      if value.is_a?(Array)
                         value.each do |item|
-                          xml.tag!('listitem') do
+                          xml.tag!("listitem") do
                             xml.text!(item.to_s)
                           end
                         end
@@ -107,7 +105,7 @@ module Reactor
             end
           end
         end
-        response = request.execute!
+        request.execute!
       end
 
       def has_attribute?(attr_name)
@@ -115,35 +113,36 @@ module Reactor
       end
 
       def attributes
-        __attributes_get('attributes')
+        __attributes_get("attributes")
       end
 
       def attributes=(attr_arr)
-        __attributes_set('attributes', attr_arr)
+        __attributes_set("attributes", attr_arr)
       end
 
       def mandatory_attributes
-        __attributes_get('mandatoryAttributes')
+        __attributes_get("mandatoryAttributes")
       end
 
       def mandatory_attributes=(attr_arr)
-        __attributes_set('mandatoryAttributes', attr_arr)
+        __attributes_set("mandatoryAttributes", attr_arr)
       end
 
       def delete!
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.tag!("#{base_name}-delete")
         end
-        response = request.execute!
+        request.execute!
       end
 
       protected
+
       def base_name
-        'objClass'
+        "objClass"
       end
 
-      def initialize(name=nil)
+      def initialize(name = nil)
         @name = name
         @params = {}
         @params_options = {}
@@ -152,8 +151,8 @@ module Reactor
 
       def get(name)
         request = 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!
         @name = name
@@ -163,10 +162,10 @@ module Reactor
       def create(name, type)
         request = XmlRequest.prepare do |xml|
           xml.create_tag!(base_name) do |xml|
-            xml.tag!('name') do
+            xml.tag!("name") do
               xml.text!(name)
             end
-            xml.tag!('objType') do
+            xml.tag!("objType") do
               xml.text!(type)
             end
           end
@@ -177,23 +176,25 @@ module Reactor
       end
 
       private
+
       def __attributes_get(field)
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.get_key_tag!(base_name, field)
         end
         response = request.execute!
         items = response.xpath("//listitem/text()")
-        return [items.to_s] unless items.kind_of?(Array)
+        return [items.to_s] unless items.is_a?(Array)
+
         items.map(&:to_s)
       end
 
       def __attributes_set(field, attr_arr)
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.set_key_tag!(base_name, field, attr_arr)
         end
-        response = request.execute!
+        request.execute!
       end
     end
   end

data/lib/reactor/cm/object_base.rb

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/tools/xml_attributes'
+require "reactor/tools/xml_attributes"
 
 module Reactor
   module Cm
@@ -12,7 +11,7 @@ module Reactor
 
       # Default base_name is lowercased class name (without namespaces)
       def self.base_name
-        self.name.split('::').last.downcase
+        name.split("::").last.downcase
       end
 
       def base_name
@@ -24,9 +23,9 @@ module Reactor
       #       set_base_name 'obj'
       #     end
       def self.set_base_name(base_name_value)
-         # we us evaluation of a string in this case, because
+        # we us evaluation of a string in this case, because
         # define_method cannot handle default values
-        self.class_eval <<-EOH
+        class_eval <<-EOH
           def self.base_name
             '#{base_name_value}'
           end
@@ -50,7 +49,7 @@ module Reactor
         response = request.execute!
 
         self.class.attributes.each do |attr_name, attr_def|
-          self.send(:"#{attr_name}=", self.class.response_handler.get(response, attr_def))
+          send(:"#{attr_name}=", self.class.response_handler.get(response, attr_def))
         end
 
         self
@@ -62,23 +61,24 @@ module Reactor
           xml.where_key_tag!(base_name, primary_key, primary_key_value)
           xml.set_tag!(base_name) do
             self.class.attributes(:set).each do |name, xml_attribute|
-              value = self.send(name)
+              value = send(name)
               serialize_attribute_to_xml(xml, xml_attribute, value)
             end
           end
         end
 
         response = request.execute!
-
         response.ok?
       end
 
       # Alias for #save!
-      def save ; save! ; end
+      def save
+        save!
+      end
 
       # Proxy method. @see .delete!(login)
       def delete!
-        self.class.delete!(self.primary_key_value)
+        self.class.delete!(primary_key_value)
       end
 
       def serialize_attribute_to_xml(xml, xml_attribute, value)
@@ -99,10 +99,9 @@ module Reactor
 
         response = request.execute!
 
-        return response.ok?
-
-      rescue XmlRequestError => e
-        return false
+        response.ok?
+      rescue XmlRequestError
+        false
       end
 
       # Returns an instance of the class for object with given primary key
@@ -122,43 +121,49 @@ module Reactor
           xml.delete_tag!(base_name)
         end
 
-        return request.execute!.ok?
+        request.execute!.ok?
       end
+
       # Alias for #delete!
-      def delete ; delete! ; end
+      def delete
+        delete!
+      end
 
       class << self
         # This method should never be called directly. It should always be overriden!
         # pk_value is the value of primary key, it should have its double in attributes hash
         # attributes is a hash of attributes set on creation {:name => 'value'}
+
         protected
+
         def create(pk_value, attributes)
           request = XmlRequest.prepare do |xml|
             xml.create_tag!(base_name) do
               attributes.each do |attr_name, attr_value|
-                #serialize_attribute_to_xml(xml, xml_attribute, value)
+                # serialize_attribute_to_xml(xml, xml_attribute, value)
                 xml.value_tag!(attr_name, attr_value)
               end
             end
           end
 
-          response = request.execute!
+          request.execute!
 
-          return get(pk_value)
+          get(pk_value)
         end
       end
 
       protected
+
       def primary_key
         self.class.primary_key
       end
 
       def primary_key_value
-        instance_variable_get("@#{self.primary_key}")
+        instance_variable_get("@#{primary_key}")
       end
 
       def primary_key_value_set(value)
-        instance_variable_set("@#{self.primary_key}", value)
+        instance_variable_set("@#{primary_key}", value)
       end
     end
   end

data/lib/reactor/cm/permissions.rb

@@ -3,27 +3,27 @@ module Reactor
     module Permissions
       def self.included(base)
         base.instance_eval do
-          attribute :global_permissions, :name => :globalPermissions, :type => :list
+          attribute :global_permissions, name: :globalPermissions, type: :list
         end
       end
 
       # Returns true, if a global permission with the given +name+ exists, false otherwise.
       def global_permission?(name)
-        self.global_permissions.include?(name.to_s)
+        global_permissions.include?(name.to_s)
       end
 
       # Add the given +permissions+ to the current set of group permissions.
       def grant_global_permissions!(permissions)
-        permissions = permissions.kind_of?(Array) ? permissions : [permissions]
-        permissions = self.global_permissions | permissions
+        permissions = permissions.is_a?(Array) ? permissions : [permissions]
+        permissions = global_permissions | permissions
 
         set_global_permissions!(permissions)
       end
 
       # Take away the given +permissions+ from the current set of group permissions.
       def revoke_global_permissions!(permissions)
-        permissions = permissions.kind_of?(Array) ? permissions : [permissions]
-        permissions = self.global_permissions - permissions
+        permissions = permissions.is_a?(Array) ? permissions : [permissions]
+        permissions = global_permissions - permissions
 
         set_global_permissions(permissions)
       end
@@ -31,7 +31,7 @@ module Reactor
       # Set the group permissions to the given +permissions+.
       def set_global_permissions!(permissions)
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.where_key_tag!(base_name, self.class.primary_key, name)
           xml.set_key_tag!(base_name, self.class.xml_attribute(:global_permissions).name, permissions)
         end
 

data/lib/reactor/cm/user.rb

@@ -1,40 +1,36 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/cm/object_base'
-require 'reactor/configuration'
-require 'reactor/cm/language'
-require 'reactor/tools/xml_attributes'
-require 'reactor/tools/where_query'
+require "reactor/cm/object_base"
+require "reactor/configuration"
+require "reactor/cm/language"
+require "reactor/tools/xml_attributes"
+require "reactor/tools/where_query"
 
-require 'reactor/cm/permissions'
+require "reactor/cm/permissions"
 
 module Reactor
-
   module Cm
-
     class User
-
       class Internal < Reactor::Cm::ObjectBase
-        set_base_name 'user'
+        set_base_name "user"
 
         # Attribute definitions
-        attribute :login,         :except => [:set]
-        attribute :super_user,    :except => [:set], :name => :isSuperUser
-        attribute :default_group, :name => :defaultGroup
-        attribute :groups,        :type => :list
-        attribute :real_name,     :name => :realName
+        attribute :login,         except: [:set]
+        attribute :super_user,    except: [:set], name: :isSuperUser
+        attribute :default_group, name: :defaultGroup
+        attribute :groups,        type: :list
+        attribute :real_name,     name: :realName
         attribute :email
 
         include Permissions
 
         def name
-          self.login
+          login
         end
 
         def change_password(new_password)
           request = XmlRequest.prepare do |xml|
             xml.where_key_tag!(base_name, primary_key, primary_key_value)
             xml.set_tag!(base_name) do
-              xml.tag!('password', :verifyNewPassword => new_password) do
+              xml.tag!("password", verifyNewPassword: new_password) do
                 xml.text!(new_password)
               end
             end
@@ -46,79 +42,81 @@ module Reactor
         end
 
         def has_password?(password)
-          ::Reactor::Cm::User.new(self.login).has_password?(password)
+          ::Reactor::Cm::User.new(login).has_password?(password)
         end
 
         primary_key :login
 
         # Returns true if user is root, false otherwise
         def super_user?
-          super_user == '1'
+          super_user == "1"
         end
 
         # Creates a user with given login and sets its default group
         # Returns instance of the class for user with given login
-       def self.create(login, default_group)
-          super(login, {:login => login, :defaultGroup => default_group})
-        end
-
+        def self.create(login, default_group)
+          super(login, { login: login, defaultGroup: default_group })
+         end
       end
 
       include XmlAttributes
       extend WhereQuery
 
       attribute :login
-      attribute :groups, :type => :list
-      attribute :global_permissions, :name => :globalPermissions, :type => :list
+      attribute :groups, type: :list
+      attribute :global_permissions, name: :globalPermissions, type: :list
       attribute :email
-      attribute :default_group, :name => :defaultGroup
-      attribute :real_name, :name => :realName
+      attribute :default_group, name: :defaultGroup
+      attribute :real_name, name: :realName
 
-      primary_key 'login'
+      primary_key "login"
 
       def initialize(name = nil)
         @login = name
       end
 
       def name
-        self.login
+        login
       end
 
       def self.all(match = nil)
-        self.where("userText", match)
+        where("userText", match)
       end
 
       def has_password?(password)
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.login)
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
           xml.get_tag!(base_name) do |xml3|
-            xml3.tag!('hasPassword', :password => password)
+            xml3.tag!("hasPassword", password: password)
           end
         end
         response = request.execute!
-        response.xpath('//hasPassword/text()') == '1'
+        response.xpath("//hasPassword/text()") == "1"
       end
 
       def is_root?
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.login)
-          xml.get_key_tag!(base_name, 'isSuperUser')
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
+          xml.get_key_tag!(base_name, "isSuperUser")
         end
 
         response = request.execute!
 
-        response.xpath('//isSuperUser/text()') == '1'
+        response.xpath("//isSuperUser/text()") == "1"
       end
 
       def language
-        Reactor::Cm::Language.get(self.login)
+        Reactor::Cm::Language.get(login)
       end
 
       def global_permissions
+        val = instance_variable_get(:@global_permissions)
+        return val unless val.nil?
+
         xml_attribute = self.class.xml_attribute(:global_permissions)
 
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.login)
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
           xml.get_key_tag!(base_name, xml_attribute.name)
         end
 
@@ -128,10 +126,13 @@ module Reactor
       end
 
       def groups
+        val = instance_variable_get(:@groups)
+        return val unless val.nil?
+
         xml_attribute = self.class.xml_attribute(:groups)
 
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.login)
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
           xml.get_key_tag!(base_name, xml_attribute.name)
         end
 
@@ -141,10 +142,29 @@ module Reactor
       end
 
       def email
+        val = instance_variable_get(:@email)
+        return val unless val.nil?
+
         xml_attribute = self.class.xml_attribute(:email)
 
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, self.class.primary_key, self.login)
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
+          xml.get_key_tag!(base_name, xml_attribute.name)
+        end
+
+        response = request.execute!
+
+        self.class.response_handler.get(response, xml_attribute)
+      end
+
+      def real_name
+        val = instance_variable_get(:@real_name)
+        return val unless val.nil?
+
+        xml_attribute = self.class.xml_attribute(:real_name)
+
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, login)
           xml.get_key_tag!(base_name, xml_attribute.name)
         end
 
@@ -154,17 +174,14 @@ module Reactor
       end
 
       protected
+
       def base_name
         self.class.base_name
-        
       end
 
       def self.base_name
-        'userProxy'
+        "userProxy"
       end
-
     end
-
   end
-
 end