cuboid 0.0.0 → 0.0.1alpha

data/lib/cuboid/ui/output_interface/implemented.rb

@@ -0,0 +1,58 @@
+module Cuboid
+module UI
+module OutputInterface
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Implemented
+
+    # Prints the backtrace of an exception as error messages.
+    #
+    # @param    [Exception] e
+    def print_error_backtrace( e )
+        e.backtrace.each { |line| print_error( line ) }
+    end
+
+    def print_exception( e )
+        print_error "[#{e.class}] #{e}"
+        print_error_backtrace( e )
+    end
+
+    def print_debug_level_1( str = '' )
+        print_debug( str, 1 )
+    end
+
+    def print_debug_level_2( str = '' )
+        print_debug( str, 2 )
+    end
+
+    def print_debug_level_3( str = '' )
+        print_debug( str, 3 )
+    end
+
+    def print_debug_level_4( str = '' )
+        print_debug( str, 4 )
+    end
+
+    def print_debug_exception( e, level = 1 )
+        return if !debug?
+
+        print_debug( "[#{e.class}] #{e}", level )
+        print_debug_backtrace( e, level )
+    end
+
+    # Prints the backtrace of an exception as debugging messages.
+    #
+    # @param    [Exception] e
+    #
+    # @see #debug?
+    # @see #debug
+    def print_debug_backtrace( e, level = 1 )
+        return if !debug?
+        e.backtrace.each { |line| print_debug( line, level ) }
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/ui/output_interface/personalization.rb

@@ -0,0 +1,62 @@
+module Cuboid
+module UI
+module OutputInterface
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Personalization
+
+    def included( base )
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def personalize_output!
+            @personalize_output = true
+        end
+
+        def personalize_output?
+            @personalize_output
+        end
+    end
+
+    private
+
+    def personalize_output( message )
+        return message if !self.class.respond_to?( :personalize_output? )
+
+        self.class.personalize_output? ?
+            "#{self.class.name.split('::').last}: #{message}" : message
+    end
+
+    def output_root
+        @output_root ||=
+            File.expand_path( File.dirname( __FILE__ ) + '/../../../../' ) + '/'
+    end
+
+    def caller_location
+        file = nil
+        line = nil
+        caller_method = nil
+        Kernel.caller.each do |c|
+            file, line, method = *c.scan( /(.*):(\d+):in `(?:.*\s)?(.*)'/ ).flatten
+            next if file == output_provider_file
+
+            caller_method = method
+            break
+        end
+
+        file.gsub!( output_root, '' )
+
+        context = nil
+        if caller_method
+            context = "[#{file}##{caller_method}:#{line}]"
+        end
+
+        context
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/utilities.rb

@@ -0,0 +1,155 @@
+require 'securerandom'
+require 'digest/sha2'
+require 'cgi'
+
+module Cuboid
+
+# Includes some useful methods for the system.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Utilities
+
+    # @return   [String]
+    #   Filename (without extension) of the caller.
+    def caller_name
+        File.basename( caller_path( 3 ), '.rb' )
+    end
+
+    # @return   [String]
+    #   Filepath of the caller.
+    def caller_path( offset = 2 )
+        ::Kernel.caller[offset].split( /:(\d+):in/ ).first
+    end
+
+    # @return   [String]    random HEX (SHA2) string
+    def random_seed
+        @@random_seed ||= generate_token
+    end
+
+    # @return   [Fixnum]
+    #   Random available port number.
+    def available_port( range = nil )
+        available_port_mutex.synchronize do
+            loop do
+                port = self.rand_port( range )
+                return port if port_available?( port )
+            end
+        end
+    end
+
+    def self.available_port_mutex
+        @available_port_mutex ||= Mutex.new
+    end
+    available_port_mutex
+
+    # @return   [Integer]
+    #   Random port within the user specified range.
+    def rand_port( range = nil )
+        range ||= [1025, 65535]
+        first, last = range
+        range = (first..last).to_a
+
+        range[ rand( range.last - range.first ) ]
+    end
+
+    def generate_token
+        SecureRandom.hex
+    end
+
+    # Checks whether the port number is available.
+    #
+    # @param    [Fixnum]  port
+    #
+    # @return   [Bool]
+    def port_available?( port )
+        begin
+            socket = ::Socket.new( :INET, :STREAM, 0 )
+            socket.bind( ::Socket.sockaddr_in( port, '127.0.0.1' ) )
+            socket.close
+            true
+        rescue Errno::EADDRINUSE, Errno::EACCES
+            false
+        end
+    end
+
+    # @param    [String, Float, Integer]    seconds
+    #
+    # @return    [String]
+    #   Time in `00:00:00` (`hours:minutes:seconds`) format.
+    def seconds_to_hms( seconds )
+        seconds = seconds.to_i
+        [seconds / 3600, seconds / 60 % 60, seconds % 60].
+            map { |t| t.to_s.rjust( 2, '0' ) }.join( ':' )
+    end
+
+    def hms_to_seconds( time )
+        a = [1, 60, 3600] * 2
+        time.split( /[:\.]/ ).map { |t| t.to_i * a.pop }.inject(&:+)
+    rescue
+        0
+    end
+
+    def bytes_to_megabytes( bytes )
+        (bytes / 1024.0 / 1024.0).round( 3 )
+    end
+
+    def bytes_to_kilobytes( bytes )
+        (bytes / 1024.0 ).round( 3 )
+    end
+
+    # Wraps the `block` in exception handling code and runs it.
+    #
+    # @param    [Bool]  raise_exception
+    #   Re-raise exception?
+    # @param    [Block]     block
+    def exception_jail( raise_exception = true, &block )
+        block.call
+    rescue => e
+        if respond_to?( :print_error ) && respond_to?( :print_exception )
+            print_exception e
+            print_error
+            print_error 'Parent:'
+            print_error  self.class.to_s
+            print_error
+            print_error 'Block:'
+            print_error block.to_s
+            print_error
+            print_error 'Caller:'
+            ::Kernel.caller.each { |l| print_error l }
+            print_error '-' * 80
+        end
+
+        raise e if raise_exception
+
+        nil
+    end
+
+    def regexp_array_match( regexps, str )
+        regexps = [regexps].flatten.compact.
+            map { |s| s.is_a?( Regexp ) ? s : Regexp.new( s.to_s ) }
+        return true if regexps.empty?
+
+        cnt = 0
+        regexps.each { |filter| cnt += 1 if filter.match? str }
+        cnt == regexps.size
+    end
+
+    def remove_constants( mod, skip = [] )
+        return if skip.include?( mod )
+        return if !(mod.is_a?( Class ) || mod.is_a?( Module )) ||
+            !mod.to_s.start_with?( 'Cuboid' )
+
+        parent = Object
+        mod.to_s.split( '::' )[0..-2].each do |ancestor|
+            parent = parent.const_get( ancestor.to_sym )
+        end
+
+        mod.constants.each { |m| mod.send( :remove_const, m ) }
+        nil
+    end
+
+    extend self
+
+end
+
+end

data/lib/cuboid/version.rb

@@ -1,5 +1,6 @@
-# frozen_string_literal: true
-
 module Cuboid
-  VERSION = "0.0.0"
+
+    # the universal system version
+    VERSION = IO.read( File.dirname( __FILE__ ) + '/../version' ).strip
+
 end

data/lib/version

@@ -0,0 +1 @@
+0.0.1alpha

data/spec/cuboid/application/parts/data_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Cuboid::Application::Parts::Data do
+    include_examples 'application'
+
+    describe '#data' do
+        it "returns #{Cuboid::Data::Application}" do
+            expect(subject.data).to be_kind_of Cuboid::Data::Application
+        end
+    end
+
+end

data/spec/cuboid/application/parts/report_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Cuboid::Application::Parts::Report do
+    include_examples 'application'
+
+end

data/spec/cuboid/application/parts/state_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Cuboid::Application::Parts::State do
+    include_examples 'application'
+
+    describe '#running?' do
+        it "delegates to #{Cuboid::State::Application}#scanning?" do
+            allow(subject.state).to receive(:running?) { :stuff }
+            expect(subject.running?).to eq(:stuff)
+        end
+    end
+
+    describe '#done?' do
+        it "delegates to #{Cuboid::State::Application}#done?" do
+            allow(subject.state).to receive(:done?) { :stuff }
+            expect(subject.done?).to eq(:stuff)
+        end
+    end
+
+    describe '#paused?' do
+        it "delegates to #{Cuboid::State::Application}#paused?" do
+            allow(subject.state).to receive(:paused?) { :stuff }
+            expect(subject.paused?).to eq(:stuff)
+        end
+    end
+
+    describe '#state' do
+        it "returns #{Cuboid::State::Application}" do
+            expect(subject.state).to be_kind_of Cuboid::State::Application
+        end
+    end
+
+    describe '#abort!' do
+        it 'sets #status to :aborting' do
+            MockApp.safe do |f|
+                t = Thread.new do
+                    f.run
+                end
+
+                sleep 1 while f.status == :ready
+
+                f.abort!
+                expect(f.status).to eq(:aborted)
+
+                t.join
+            end
+        end
+    end
+
+    describe '#suspend!' do
+        it 'suspends the system' do
+            snapshot = nil
+            MockApp.safe do |f|
+                t = Thread.new do
+                    f.run
+                end
+
+                sleep 1 while f.status != :running
+
+                snapshot = f.suspend!
+                expect(f.status).to eq(:suspended)
+
+                t.join
+            end
+
+            expect(Cuboid::Snapshot.load( snapshot )).to be_truthy
+        end
+
+        context "when #{Cuboid::OptionGroups::Paths}#snapshots" do
+            context 'is a directory' do
+                it 'stores the snapshot under it' do
+                    Cuboid::Options.snapshot.path = Dir.tmpdir
+
+                    snapshot = nil
+                    MockApp.safe do |f|
+                        t = Thread.new do
+                            f.run
+                        end
+
+                        sleep 0.1 while f.status != :running
+
+                        snapshot = f.suspend!
+                        t.join
+                    end
+
+                    expect(File.dirname( snapshot )).to eq(Dir.tmpdir)
+                    expect(Cuboid::Snapshot.load( snapshot )).to be_truthy
+                end
+            end
+
+            context 'is a file path' do
+                it 'stores the snapshot there' do
+                    Cuboid::Options.snapshot.path = "#{Dir.tmpdir}/snapshot"
+
+                    snapshot = nil
+                    MockApp.safe do |f|
+                        t = Thread.new do
+                            f.run
+                        end
+
+                        sleep 0.1 while f.status != :running
+
+                        snapshot = f.suspend!
+                        t.join
+                    end
+
+                    expect(snapshot).to eq("#{Dir.tmpdir}/snapshot")
+                    expect(Cuboid::Snapshot.load( snapshot )).to be_truthy
+                end
+            end
+        end
+    end
+
+    describe '#restore!' do
+        it 'restores options' do
+            options_hash = nil
+
+            snapshot = nil
+            MockApp.safe do |f|
+                Cuboid::Options.datastore.my_custom_option = 'my custom value'
+
+                t = Thread.new { f.run }
+                sleep 0.1 while f.status != :running
+
+                snapshot = f.suspend!
+
+                t.join
+            end
+
+            MockApp.restore!( snapshot ) do |f|
+                opts = Cuboid::Options.to_h
+                expect(opts[:datastore][:my_custom_option]).to eq('my custom value')
+            end
+        end
+    end
+
+    describe '#pause!' do
+        it 'pauses the system' do
+            MockApp.safe do |f|
+                t = Thread.new do
+                    f.run
+                end
+                sleep 0.1 while f.status != :running
+
+                f.pause!
+                expect(f.status).to eq(:paused)
+                expect(f.running?).to be_truthy
+
+                f.resume!
+                t.join
+            end
+        end
+    end
+
+    describe '#resume!' do
+        it 'resumes the scan' do
+            MockApp.safe do |f|
+                t = Thread.new do
+                    f.run
+                end
+                sleep( 1 ) while f.status == :ready
+
+                f.pause!
+                expect(f.status).to eq(:paused)
+
+                f.resume!
+                Timeout.timeout 5 do
+                    sleep 0.1 while f.status != :done
+                end
+
+                t.join
+            end
+        end
+    end
+
+    describe '#clean_up' do
+        it 'sets the status to cleanup' do
+            MockApp.safe do |f|
+                f.clean_up
+                expect(f.status).to eq(:cleanup)
+            end
+        end
+
+        it 'sets #running? to false' do
+            MockApp.safe do |f|
+                f.clean_up
+                expect(f).not_to be_running
+            end
+        end
+    end
+
+end