kanrisuru 0.10.0 → 0.12.1

data/lib/kanrisuru/os_package.rb

@@ -1,247 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
-module Kanrisuru
-  module OsPackage
-    module Define
-      def self.extended(base)
-        base.instance_variable_set(:@os_method_properties, {})
-        base.instance_variable_set(:@os_methods, Set.new)
-      end
-
-      def os_define(os_name, method_name, options = {})
-        unique_method_name = options[:alias] || method_name
-
-        @os_methods.add(method_name)
-
-        if @os_method_properties.key?(unique_method_name)
-          params = {
-            os_name: os_name.to_s,
-            method_name: method_name,
-            options: options
-          }
-
-          @os_method_properties[unique_method_name].prepend(params)
-        else
-          @os_method_properties[unique_method_name] = [{
-            os_name: os_name.to_s,
-            method_name: method_name,
-            options: options
-          }]
-        end
-      end
-    end
-
-    module Collection
-      def os_collection(mod, opts = {})
-        os_method_properties = mod.instance_variable_get(:@os_method_properties)
-        os_method_names = os_method_properties.keys
-
-        namespace          = opts[:namespace]
-        namespace_instance = nil
-
-        if namespace
-          ## Define the namespace as an eigen class instance on the host.
-          ## Namespaced instances will access core host methods
-          ## with @host instance variable.
-
-          if Kanrisuru::Remote::Cluster.instance_variable_defined?("@#{namespace}")
-            namespace_class = Kanrisuru::Remote::Cluster.const_get(Kanrisuru::Util.camelize(namespace))
-            namespace_instance = instance_variable_get("@#{namespace}")
-          else
-            namespace_class    = Kanrisuru::Remote::Cluster.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
-            namespace_instance = Kanrisuru::Remote::Cluster.instance_variable_set("@#{namespace}", namespace_class.new)
-
-            class_eval do
-              define_method namespace do
-                namespace_instance.instance_variable_set(:@cluster, self)
-                namespace_instance
-              end
-            end
-          end
-
-          namespace_class.class_eval do
-            os_method_names.each do |method_name|
-              define_method method_name do |*args, &block|
-                cluster = namespace_instance.instance_variable_get(:@cluster)
-                hosts = cluster.instance_variable_get(:@hosts)
-                hosts.map do |host_addr, host|
-                  { host: host_addr, result: host.send(namespace).send(method_name, *args, &block) }
-                end
-              end
-            end
-          end
-        else
-          class_eval do
-            os_method_names.each do |method_name|
-              define_method method_name do |*args, &block|
-                @hosts.map do |host_addr, host|
-                  { host: host_addr, result: host.send(method_name, *args, &block) }
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    module Include
-      def os_include(mod, opts = {})
-        os_method_properties = mod.instance_variable_get(:@os_method_properties)
-        os_method_names = os_method_properties.keys
-
-        ## Need to encapsulate any helper methods called in the module
-        ## to bind to the host instance. This acts as a psudeo module include.
-        os_methods        = mod.instance_variable_get(:@os_methods)
-
-        public_methods    = mod.instance_methods(false) - os_methods.to_a
-        private_methods   = mod.private_instance_methods(false)
-        protected_methods = mod.protected_instance_methods(false)
-        include_methods   = (public_methods + protected_methods + private_methods).flatten
-
-        include_method_bindings = proc do
-          include_methods.each do |method_name|
-            define_method method_name do |*args, &block|
-              unbound_method = mod.instance_method(method_name)
-              bind_method(unbound_method, *args, &block)
-            end
-          end
-
-          private_methods.each { |method_name| private(method_name) }
-          protected_methods.each { |method_name| protected(method_name) }
-
-          private
-          if RUBY_VERSION < '2.7'
-            define_method 'bind_method' do |unbound_method, *args, &block|
-              unbound_method.bind(self).call(*args, &block)
-            end
-          else
-            define_method 'bind_method' do |unbound_method, *args, &block|
-              unbound_method.bind_call(self, *args, &block)
-            end
-          end
-        end
-
-        namespace          = opts[:namespace]
-        namespace_class    = nil
-        namespace_instance = nil
-
-        if namespace
-          ## Define the namespace as an eigen class instance within the host class.
-          ## Namespaced instances will access core host methods
-          ## with @host instance variable.
-
-          ## Check to see if the namespace was defined. If so, additional methods will be appended to the
-          ## existing namespace class definition, otherwise, a new namespace class and instance will be
-          ## defined with the methods added.
-          if Kanrisuru::Remote::Host.instance_variable_defined?("@#{namespace}")
-            namespace_class = Kanrisuru::Remote::Host.const_get(Kanrisuru::Util.camelize(namespace))
-            namespace_instance = Kanrisuru::Remote::Host.instance_variable_get("@#{namespace}")
-          else
-            namespace_class    = Kanrisuru::Remote::Host.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
-            namespace_instance = Kanrisuru::Remote::Host.instance_variable_set("@#{namespace}", namespace_class.new)
-
-            class_eval do
-              define_method namespace do
-                namespace_instance.instance_variable_set(:@host, self)
-                namespace_instance
-              end
-            end
-          end
-
-          namespace_class.class_eval(&include_method_bindings)
-        else
-          class_eval(&include_method_bindings)
-        end
-
-        class_eval do
-          os_method_names.each do |method_name|
-            if namespace
-              namespace_class.class_eval do
-                define_method method_name do |*args, &block|
-                  unbound_method = nil
-
-                  host = namespace_instance.instance_variable_get(:@host)
-                  os_method_cache = host.instance_variable_get(:@os_method_cache) || {}
-
-                  if os_method_cache.key?("#{namespace}.#{method_name}")
-                    unbound_method = os_method_cache["#{namespace}.#{method_name}"]
-                  else
-                    ## Find the correct method to resolve based on the OS for the remote host.
-                    defined_method_name = host.resolve_os_method_name(os_method_properties, method_name)
-                    unless defined_method_name
-                      raise NoMethodError, "undefined method `#{method_name}' for #{self.class}"
-                    end
-
-                    ## Get reference to the unbound method defined in module
-                    unbound_method = mod.instance_method(defined_method_name)
-                    raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless unbound_method
-
-                    ## Cache the unbound method on this host instance for faster resolution on
-                    ## the next invocation of this method
-                    os_method_cache["#{namespace}.#{method_name}"] = unbound_method
-                    host.instance_variable_set(:@os_method_cache, os_method_cache)
-                  end
-
-                  ## Bind the method to host instance and
-                  ## call it with args and block
-                  bind_method(unbound_method, *args, &block)
-                end
-              end
-            else
-              define_method method_name do |*args, &block|
-                unbound_method = nil
-
-                host = self
-                os_method_cache = host.instance_variable_get(:@os_method_cache) || {}
-
-                if os_method_cache.key?(method_name)
-                  unbound_method = os_method_cache[method_name]
-                else
-                  ## Find the correct method to resolve based on the OS for the remote host.
-                  defined_method_name = host.resolve_os_method_name(os_method_properties, method_name)
-                  raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless defined_method_name
-
-                  ## Get reference to the unbound method defined in module
-                  unbound_method = mod.instance_method(defined_method_name)
-                  raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless unbound_method
-
-                  ## Cache the unbound method on this host instance for faster resolution on
-                  ## the next invocation of this method
-                  os_method_cache[method_name] = unbound_method
-                  host.instance_variable_set(:@os_method_cache, os_method_cache)
-                end
-
-                ## Bind the method to host instance and
-                ## call it with args and block
-                bind_method(unbound_method, *args, &block)
-              end
-            end
-          end
-
-          def resolve_os_method_name(properties, method_name)
-            kernel  = os.kernel.downcase
-            release = os.release.downcase
-
-            properties[method_name].each do |property|
-              os_name = property[:os_name]
-              strict = property[:options] ? property[:options][:strict] : false
-              except = property[:options] ? property[:options][:except] : ''
-
-              next if except && (except == release || except.include?(release))
-
-              if release == os_name || kernel == os_name ||
-                 (Kanrisuru::Util::OsFamily.family_include_distribution?(os_name, release) && !strict) ||
-                 (Kanrisuru::Util::OsFamily.upstream_include_distribution?(os_name, release) && !strict)
-                return property[:method_name]
-              end
-            end
-
-            nil
-          end
-        end
-      end
-    end
-  end
-end
+require_relative 'os_package/collection'
+require_relative 'os_package/define'
+require_relative 'os_package/include'

data/lib/kanrisuru/remote/cpu.rb

@@ -27,6 +27,10 @@ module Kanrisuru
         load_average[2]
       end
 
+      def architecture
+        @cpu_architecture.architecture
+      end
+
       def sockets
         @cpu_architecture.sockets
       end
@@ -103,7 +107,7 @@ module Kanrisuru
         @cpu_architecture.flags
       end
 
-        def hyperthreading?
+      def hyperthreading?
         threads_per_core > 1
       end
 

data/lib/kanrisuru/remote/fstab.rb

@@ -161,7 +161,7 @@ module Kanrisuru
 
           if Kanrisuru::Util.present?(@line) && @line.instance_of?(String)
             parse_line!
-          elsif Kanrisuru::Util.present?(@opts) && @opts.instance_of?(String) || @opts.instance_of?(Hash)
+          elsif (Kanrisuru::Util.present?(@opts) && @opts.instance_of?(String)) || @opts.instance_of?(Hash)
             @opts = Kanrisuru::Remote::Fstab::Options.new(@type, @opts)
           end
         end
@@ -255,7 +255,7 @@ module Kanrisuru
           end
 
           result = @host.blkid(device: @device)
-          @uuid = result.success? ? result.uuid : nil
+          @uuid = result.success? ? result[0].uuid : nil
         end
 
         def parse_uuid(fsline)
@@ -269,15 +269,15 @@ module Kanrisuru
           end
 
           result = @host.blkid(device: @device)
-          @label = result.success? ? result.label : nil
+          @label = result.success? ? result[0].label : nil
         end
 
         def parse_dev(fsline)
           @device = fsline
           result = @host.blkid(device: @device)
 
-          @label = result.success? ? result.label : nil
-          @uuid = result.success? ? result.uuid : nil
+          @label = result.success? ? result[0].label : nil
+          @uuid = result.success? ? result[0].uuid : nil
         end
       end
 

data/lib/kanrisuru/result.rb

@@ -40,13 +40,14 @@ module Kanrisuru
     end
 
     def to_i
-      if @data.instance_of?(Integer)
+      case @data
+      when Integer
         @data
-      elsif @data.instance_of?(String)
+      when String
         @data.to_i
-      elsif @data.instance_of?(Array)
+      when Array
         @data.map(&:to_i)
-      elsif @data.instance_of?(NilClass)
+      when NilClass
         nil
       else
         raise NoMethodError, "(undefined method `to_i' for Kanrisuru::Result)"

data/lib/kanrisuru/util.rb

@@ -24,7 +24,7 @@ module Kanrisuru
       Kanrisuru.logger.info do
         'DEPRECATION WARNING: string_join_array will be removed in the upcoming major release. Use array_join_string instead.'
       end
-      
+
       array = arg.instance_of?(String) ? [arg] : arg
       array.join(field)
     end

data/lib/kanrisuru/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanrisuru
-  VERSION = '0.10.0'
+  VERSION = '0.12.1'
 end

data/spec/functional/core/apt_spec.rb

@@ -22,10 +22,9 @@ RSpec.describe Kanrisuru::Core::Apt do
   it 'prepares apt list command' do
     expect_command(host.apt('list'), 'apt list')
     expect_command(host.apt('list',
-      installed: true,
-      upgradeable: true,
-      all_versions: true,
-    ), 'apt list --installed --upgradeable --all-versions')
+                            installed: true,
+                            upgradeable: true,
+                            all_versions: true), 'apt list --installed --upgradeable --all-versions')
 
     expect_command(host.apt('list', package_name: 'nginx'), 'apt list -a nginx')
   end
@@ -43,28 +42,22 @@ RSpec.describe Kanrisuru::Core::Apt do
   end
 
   it 'prepares apt install command' do
-    expect_command(host.apt('install', 
-        packages: 'nginx'
-      ),
-      'apt-get install -y nginx'
-    )
-
-    expect_command(host.apt('install', 
-        packages: 'monit',
-        no_upgrade: true,
-        reinstall: true
-      ),
-      'apt-get install -y --no-upgrade --reinstall monit'
-    )
-
-    expect_command(host.apt('install', 
-        packages: ['build-essential', 'manpages-dev'],
-        only_upgrade: true,
-      ),
-      'apt-get install -y --only-upgrade build-essential manpages-dev'
-    )
+    expect_command(host.apt('install',
+                            packages: 'nginx'),
+                   'apt-get install -y nginx')
+
+    expect_command(host.apt('install',
+                            packages: 'monit',
+                            no_upgrade: true,
+                            reinstall: true),
+                   'apt-get install -y --no-upgrade --reinstall monit')
+
+    expect_command(host.apt('install',
+                            packages: %w[build-essential manpages-dev],
+                            only_upgrade: true),
+                   'apt-get install -y --only-upgrade build-essential manpages-dev')
   end
-  
+
   it 'prepares apt remove command' do
     expect_command(host.apt('remove', packages: ['python']), 'apt-get remove -y python')
   end
@@ -82,15 +75,14 @@ RSpec.describe Kanrisuru::Core::Apt do
   end
 
   it 'prepares apt show command' do
-    expect_command(host.apt('show', packages: 'ruby'), 'apt show -a ruby') 
-  end 
+    expect_command(host.apt('show', packages: 'ruby'), 'apt show -a ruby')
+  end
 
   it 'prepares apt clean command' do
-    expect_command(host.apt('clean'), 'apt-get clean') 
+    expect_command(host.apt('clean'), 'apt-get clean')
   end
 
   it 'prepares apt autoclean command' do
-    expect_command(host.apt('autoclean'), 'apt-get autoclean') 
+    expect_command(host.apt('autoclean'), 'apt-get autoclean')
   end
-
 end