kxi 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a376bd573bfb44dbeae16f773f883a1f55daedd7
-  data.tar.gz: 4cbb2897d3c73fe15b882a26d79f8d3bdc387244
+  metadata.gz: 78e859a6e89e40dbab305b79851a257dfd2ddf68
+  data.tar.gz: aedb9bc1385418141e79d90d64fe688c00e529d4
 SHA512:
-  metadata.gz: 7d040d8a1a051f68268ba981ea84e69fcf5bd547f801c3411511bcb3b3edd2da4e23befcb9171fe6b43655bdd2adca2ef6b8de387fa5874f8d8b76b79cbabac7
-  data.tar.gz: c35695494016d0625076379ffcc9370e5c4299cc47cc19f4979d10ee0cd4f9ac01c3d4f3e27051f1c2859c18a4099aa830324545fb1ef0d0ab45ec671c405ed8
+  metadata.gz: 856340dde06a8e744284dfb3060eb69a053f90868338ce3b7034163750c566f8c0f60cbc67c59b73ee0c9666b18cbe1e808afcb22d84cba58a0f49593c5517ce
+  data.tar.gz: 10ee0e919f19ea968f65220714bc2a5be7a42cc4f2d59999c40b5c02ab0300da8974c54b814b977b9e7ff7cd86c2df0a7137e9110066169c499f618cf64b3702

data/lib/kxi/application/config.rb

@@ -0,0 +1,178 @@
+# Created by Matyáš Pokorný on 2018-01-24.
+
+module KXI
+	module Application
+		# Represents configuration file
+		class Config
+			# Gets configuration file
+			# @return [String] Path to configuration file
+			def file
+				@file
+			end
+			
+			# Instantiates the {KXI::Application::Config} file
+			# @param file [String] Configuration file to read
+			# @param reader [KXI::Application::ConfigReader] Readers used to parse configuration
+			def initialize(file, reader)
+				@file = file
+				@obj  = reader.parse(File.read(file))
+				@pth  = ''
+				@def  = false
+			end
+			
+			# Gets current context
+			# @return [Object] Current context
+			def context
+				@obj
+			end
+			
+			# Gets path of current context
+			# @return [String] Path of current context
+			def path
+				@pth
+			end
+			
+			# Gets value or default from current context
+			# @param key [String] Name of value
+			# @param default [Object, nil] Default value
+			# @yield [val] Validator function
+			# @yieldparam val [Object, nil] Value to validate
+			# @return [Object, nil] Value or default
+			def get(key, default = nil, &validator)
+				if not @def and @obj.key?(key)
+					ctx = @obj[key]
+					return ctx if validator == nil
+					return validate(key, ctx, &validator)
+				else
+					return default
+				end
+			end
+			
+			# Gets value from current context
+			# @param key [String] Name of value
+			# @yield [val] Validator function
+			# @yieldparam val [Object, nil] Value to validate
+			# @return [Object, nil] Value
+			# @raise [KXI::Exceptions::ConfigurationException] Raised when field is not found
+			def get!(key, &validator)
+				if not @def and @obj.key?(key)
+					ctx = @obj[key]
+					return ctx if validator == nil
+					return validate(key, ctx, &validator)
+				else
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Field is mandatory!'))
+				end
+			end
+			
+			# Enters named section of configuration file
+			# @param key [String] Name of section
+			# @param man [Bool] Determines whether this section is mandatory
+			# @yield [] Block of actions for entered context
+			def inside(key, man = false, &block)
+				if not @def and @obj.key?(key)
+					ctx = @obj[key]
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Field must be object!')) unless ctx.is_a?(Hash)
+					enter(key, ctx) do
+						block.call
+					end
+				elsif man
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Object is mandatory!'))
+				else
+					enter(key, nil) do
+						if @def
+							block.call
+						else
+							@def = true
+							block.call
+							@def = false
+						end
+					end
+				end
+			end
+			
+			# Enters mandatory named section of configuration file
+			# @param key [String] Name of section
+			# @yield [] Block of actions for entered context
+			def inside!(key, &block)
+				inside(key, true) { block.call }
+			end
+			
+			# Iterates through collection
+			# @param key [String] Name of collection
+			# @param man [Bool] Determines whether this section is mandatory
+			# @yield [] Block of actions for entered context
+			def each_index(key, man = false, &block)
+				if not @def and @obj.key?(key)
+					ctx = @obj[key]
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Field must be array!')) unless ctx.is_a?(Array)
+					ctx.each_with_index do |itm, idx|
+						enter("#{key}[#{idx}]", itm) do
+							block.call
+						end
+					end
+				elsif man
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Array is mandatory!'))
+				end
+			end
+			
+			# Iterates through mandatory collection
+			# @param key [String] Name of collection
+			# @yield [] Block of actions for entered context
+			def each_index!(key, &block)
+				each_index(key, true) { block.call }
+			end
+			
+			# Iterates through fields of object
+			# @param key [String] Name of object
+			# @param man [Bool] Determines whether this section is mandatory
+			# @yield [idx] Block of actions for entered context
+			# @yieldparam idx [String] Name of field
+			def each_field(key, man = false, &block)
+				if not @def and @obj.key?(key)
+					ctx = @obj[key]
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Field must be object!')) unless ctx.is_a?(Hash)
+					ctx.each_pair do |idx, itm|
+						enter("#{key}/#{idx}", itm) do
+							block.call(idx)
+						end
+					end
+				elsif man
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", 'Object is mandatory!'))
+				end
+			end
+			
+			# Iterates through fields of mandatory object
+			# @param key [String] Name of object
+			# @yield [idx] Block of actions for entered context
+			# @yieldparam idx [String] Name of field
+			def each_field!(key, &block)
+				each_field(key, true) { |itm| block.call(itm) }
+			end
+			
+			def enter(key, ctx, &block)
+				obj  = @obj
+				pth  = @pth
+				@obj = ctx
+				@pth = "#{@pth}/#{key}"
+				block.call
+			ensure
+				@pth = pth
+				@obj = obj
+			end
+			
+			def validate(key, ctx, &validator)
+				begin
+					enter(key, ctx) do
+						validator.call(ctx)
+					end
+					return ctx
+				rescue Exception => ex
+					raise(KXI::Exceptions::ConfigurationException.new(@file, "#{@pth}/#{key}", ex.message))
+				end
+			end
+			
+			protected :context, :path, :get, :get!, :inside, :inside!, :each_index, :each_index!, :each_field, :each_field!
+			private :enter, :validate
+		end
+	end
+end

data/lib/kxi/application/config_reader.rb

@@ -0,0 +1,17 @@
+# Created by Matyáš Pokorný on 2018-01-24.
+
+module KXI
+	module Application
+		# Parses configuration
+		# @abstract
+		class ConfigReader
+			# Parses configuration from file
+			# @param str [String] Data to parse
+			# @return [Hash] Parsed configuration
+			# @abstract
+			def parse(str)
+				raise(KXI::Exceptions::AbstractException.new(KXI::Application::ConfigReader))
+			end
+		end
+	end
+end

data/lib/kxi/application/event.rb

@@ -0,0 +1,36 @@
+# Created by Matyáš Pokorný on 2018-01-26.
+
+module KXI
+	module Application
+		# Event handler
+		class Event
+			# Adds hook to handler
+			# @return [Number] Id of hook
+			# @yield [sender, *args] Action block of hook
+			# @yieldparam sender [Object] Invoker of event
+			# @yieldparam args [Array<Object, nil>] Arguments of invocation
+			def add(&block)
+				@hooks.push(block)
+				return @hooks.length - 1
+			end
+			
+			# Removes hook from handler
+			# @param id [Number] Id of hook to remove
+			def remove(id)
+				@hooks.delete_at(id)
+			end
+			
+			# Instantiates the {KXI::Application::Event} class
+			def initialize
+				@hooks = []
+			end
+			
+			# Invokes all hooks
+			# @param sender [Object] Invoker of event
+			# @param args [Array<Object, nil>] Arguments of invocation
+			def fire(sender, *args)
+				@hooks.each { |h| h.call(sender, *args) }
+			end
+		end
+	end
+end

data/lib/kxi/application/logger.rb

@@ -0,0 +1,156 @@
+# Created by Matyáš Pokorný on 2018-01-26.
+
+module KXI
+	module Application
+		# Allows simple unstructured (time-independent) logging
+		class Logger
+			# Gets the message event
+			# @return [KXI::Application::Event] Message event
+			def on_message
+				@event
+			end
+			
+			# Attaches action to message event
+			# @param min [KXI::Application::Logger::Message::Severity] Minimal severity of message
+			# @yield [msg] Event action
+			# @yieldparam msg [KXI::Application::Logger::Message] Logger message
+			# @return [Number] Id of event hook
+			def attach(min = Message::Severity::COMMAND, &block)
+				return @event.add { |s, msg| block.call(msg) if msg.severity.level >= min.level }
+			end
+			
+			# Instantiates the {KXI::Application::Logger} class
+			def initialize
+				@event = KXI::Application::Event.new
+				@start = DateTime.now
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::COMMAND} severity
+			# @param cmd [String] Executed command
+			def command(cmd)
+				log(Message::Severity::COMMAND, cmd)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::TRACE} severity
+			# @param msg [String] Text of message
+			def trace(msg)
+				log(Message::Severity::TRACE, msg)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::DEBUG} severity
+			# @param msg [String] Text of message
+			def debug(msg)
+				log(Message::Severity::DEBUG, msg)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::INFO} severity
+			# @param msg [String] Text of message
+			def info(msg)
+				log(Message::Severity::INFO, msg)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::WARNING} severity
+			# @param msg [String] Text of message
+			def warning(msg)
+				log(Message::Severity::WARNING, msg)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::ERROR} severity
+			# @param msg [String] Text of message
+			def error(msg)
+				log(Message::Severity::ERROR, msg)
+			end
+			
+			# Logs message with the {KXI::Application::Logger::Message::Severity::FATAL} severity
+			# @param msg [String] Text of message
+			def fatal(msg)
+				log(Message::Severity::FATAL, msg)
+			end
+			
+			def log(severity, msg)
+				now = DateTime.now
+				@event.fire(self, Message.new(severity, now - @start, now, msg))
+			end
+			
+			private :log
+			
+			# Represents a log message
+			class Message
+				# Represents severity of message
+				class Severity
+					# Gets the name of severity
+					# @return [String] Name of severity
+					def name
+						@name
+					end
+					
+					# Gets the level of severity
+					# @return [Number] Level of severity
+					def level
+						@lvl
+					end
+					
+					# Instantiates the [KXI::Application::Logger::Message::Severity] class
+					# @param nm [String] Name of severity
+					# @param lvl [Number] Level of severity
+					def initialize(nm, lvl)
+						@name = nm
+						@lvl  = lvl
+					end
+					
+					
+					# Severity of messages that log execution of external commands
+					COMMAND = Severity.new('command', 0)
+					# Severity of messages that allow tracing of execution paths
+					TRACE = Severity.new('trace', 1)
+					# Severity of messages used for debugging
+					DEBUG = Severity.new('debug', 2)
+					# Severity of messages that user should know about
+					INFO = Severity.new('info', 3)
+					# Severity of messages that notify about something that might lead in future to problems
+					WARNING = Severity.new('warning', 4)
+					# Severity of messages that notify about problems that application can recover from
+					ERROR = Severity.new('error', 5)
+					# Severity of messages that notify about problems that application cannot recover from
+					FATAL = Severity.new('fatal', 6)
+				end
+				
+				# Gets the severity of message
+				# @return [KXI::Application::Logger::Message:Severity] Severity of message
+				def severity
+					@sev
+				end
+				
+				# Gets time at which the message was created
+				# @return [DateTime] Time of creation
+				def absolute_time
+					@ttime
+				end
+				
+				# Gets time, relative to creation of logger, at which the message was created
+				# @return [DateTime] Relative time of creation
+				def relative_time
+					@rtime
+				end
+				
+				# Gets the text message
+				# @return [String] Message
+				def message
+					@msg
+				end
+				
+				# Instantiates the {KXI::Application::Logger::Message} class
+				# @param severity [KXI::Application::Logger::Message::Severity] Severity of message
+				# @param rtime [DateTime] Relative time of message
+				# @param ttime [DateTime] Absolute time of message
+				# @param message [String] Text of message
+				def initialize(severity, rtime, ttime, message)
+					@sev   = severity
+					@rtime = rtime
+					@ttime = ttime
+					@msg   = message
+				end
+			end
+		end
+	end
+end

data/lib/kxi/application/version.rb

@@ -0,0 +1,75 @@
+# Created by Matyáš Pokorný on 2018-01-27.
+
+module KXI
+	module Application
+		class Version
+			def major
+				@major
+			end
+			
+			def minor
+				@minor
+			end
+			
+			def patch
+				@patch
+			end
+			
+			def identifier
+				@id
+			end
+			
+			def metadata
+				@meta
+			end
+			
+			def initialize(major, minor = 0, patch = 0, id = nil, meta = nil)
+				@major = major
+				@minor = minor
+				@patch = patch
+				@id    = id
+				@meta  = meta
+			end
+			
+			def to_s
+				"#{@major}.#{@minor}.#{@patch}#{@id == nil ? '' : "-#{@id}"}#{@meta == nil ? '' : "+#{@meta}"}"
+			end
+			
+			def ==(other)
+				return false unless other.is_a?(KXI::Application::Version)
+				return (@major == other.major and @minor == other.minor and @patch == other.patch and @id == other.identifier)
+			end
+			
+			def <(other)
+				raise(KXI::Exceptions::InvalidOperationException.new("Can't compare version to #{other.class.name}!")) unless other.is_a?(KXI::Application::Version)
+				return true if @major < other.major or @minor < other.minor or @patch < other.patch
+				return true if @id != nil and other.identifier == nil
+				return true if @id != nil and other.identifier != nil and @id < other.identifier
+				return false
+			end
+			
+			def <=(other)
+				raise(KXI::Exceptions::InvalidOperationException.new("Can't compare version to #{other.class.name}!")) unless other.is_a?(KXI::Application::Version)
+				return true if self == other
+				return true if @major < other.major or @minor < other.minor or @patch < other.patch
+				return true if @id != nil and other.identifier == nil
+				return true if @id != nil and other.identifier != nil and @id < other.identifier
+				return false
+			end
+			
+			def >(other)
+				return (not self <= other)
+			end
+			
+			def >=(other)
+				return (not self < other)
+			end
+			
+			def self.parse(str)
+				m = /^\s*(?'ma'\d+)\s*(\.\s*(?'mi'\d+))?\s*(\.\s*(?'pt'\d+))?\s*(-\s*(?'id'[0-9A-Z\-.]+))?\s*(\+\s*(?'mt'[0-9A-Z\-.]+))?\s*$/mi.match(str)
+				raise(KXI::Exceptions::ParseException.new('version', str)) if m == nil
+				return Version.new(m['ma'].to_i, m['mi'] != nil ? m['mi'].to_i : 0, m['pt'] != nil ? m['pt'].to_i : 0, m['id'], m['mt'])
+			end
+		end
+	end
+end

data/lib/kxi/application/version_expression.rb

@@ -0,0 +1,70 @@
+# Created by Matyáš Pokorný on 2018-01-27.
+
+module KXI
+	module Application
+		class VersionExpression
+			COMP_EQ  = '='
+			COMP_LEQ = '<='
+			COMP_LT  = '<'
+			COMP_GEQ = '>='
+			COMP_GT  = '>'
+			COMP_AT  = '~>'
+			
+			def comparison
+				@comp
+			end
+			
+			def major
+				@major
+			end
+			
+			def minor
+				@minor
+			end
+			
+			def patch
+				@patch
+			end
+			
+			def initialize(comp, major, minor = nil, patch = nil)
+				@comp   = comp
+				@major  = major
+				@minor  = minor
+				@patch  = patch
+				@target = KXI::Application::Version.new(major, minor == nil ? 0 : minor, patch == nil ? 0 : patch)
+			end
+			
+			# @param ver [KXI::Application::Version]
+			def matches?(ver)
+				case @comp
+					when COMP_EQ
+						return (
+						ver.major == @major and
+							ver.minor == (@minor == nil ? 0 : @minor) and
+							ver.patch == (@patch == nil ? 0 : @patch)
+						)
+					when COMP_AT
+						return (
+						ver.major == @major and
+							(@minor == nil or ver.minor == @minor) and
+							(@patch == nil or ver.patch == @patch)
+						)
+					when COMP_GEQ
+						return ver >= @target
+					when COMP_LEQ
+						return ver <= @target
+					when COMP_GT
+						return ver > @target
+					when COMP_LT
+						return ver < @target
+				end
+			end
+			
+			def self.parse(str)
+				m = /^\s*(?'cm'>|<|>=|<=|=|~>)\s*(?'mj'\d+)\s*(\.\s*(?'mi'\d+))?\s*(\.\s*(?'pt'\d+))?\s*?$/m.match(str)
+				raise(KXI::Exceptions::ParseException.new('version expression', str)) if m == nil
+				return VersionExpression.new(m['cm'], m['mj'].to_i, m['mi']&.to_i, m['pt']&.to_i)
+			end
+		end
+	end
+end

data/lib/kxi/cli/argument_values.rb

@@ -42,13 +42,13 @@ module KXI
 			# Gets value of argument
 			# @param index [String, Symbol, KXI::CLI::Argument] Name of argument
 			# @return [String] Value of argument
-			def []=(index)
+			def [](index)
 				if index.is_a?(Symbol)
 					index = index.to_s
 				elsif index.is_a?(KXI::CLI::Argument)
 					index = index.name
 				end
-				raise(Exception.new("Undefined argument #{index}!")) if @vals[index] == nil
+				raise(Exception.new("Undefined argument '#{index}'!")) unless @vals.include?(index)
 				return @vals[index][:value]
 			end
 			
@@ -65,7 +65,7 @@ module KXI
 			# Validates variadic arguments and checks for minimal argument requirements
 			def finish
 				@args.each do |arg|
-					if @vals[arg.name] != nil
+					if @vals.include?(arg.name)
 						unless arg.is_a?(KXI::CLI::FlagArgument)
 							begin
 								arg.validate(@vals[arg.name][:value])
@@ -75,7 +75,7 @@ module KXI
 						end
 					else
 						raise(KXI::Exceptions::ArgumentException.new(arg.name, 'Argument is mandatory!')) if arg.required?
-						@vals[arg.name] = arg.default
+						@vals[arg.name] = { :argument => arg, :value => arg.default }
 					end
 				end
 			end

data/lib/kxi/cli/property_list.rb

@@ -0,0 +1,49 @@
+# Created by Matyáš Pokorný on 2018-01-24.
+
+module KXI
+	module CLI
+		class PropertyList
+			def initialize
+				@align = 0
+				@data = {}
+			end
+			
+			def field(name, value)
+				@data[name] = value
+				@align = name.length if name.length > @align
+			end
+			
+			def render(cols = 4)
+				@data.each_pair do |k, v|
+					if v.kind_of?(Array)
+						print("#{pad(k)}: ")
+						v.each_index do |idx|
+							if idx > 0 and idx % cols == 0
+								puts('')
+								print(' ' * (@align + 2))
+							elsif idx > 0
+								print(', ')
+							end
+							print(v[idx])
+						end
+						puts('')
+					else
+						puts("#{pad(k)}: #{v}")
+					end
+				end
+			end
+	
+			def pad(key)
+				d = false
+				p = ''
+				(@align - key.length).times do |i|
+					p = (d ? '.' : ' ') + p
+					d = (not d)
+				end
+				return key + p
+			end
+			
+			private :pad
+		end
+	end
+end

data/lib/kxi/cli/table.rb

@@ -0,0 +1,63 @@
+# Created by Matyáš Pokorný on 2018-01-24.
+
+module KXI
+	module CLI
+		class Table
+			def initialize
+				@cols = KXI::Collections::ArrayCollection.new
+				@rows = 0
+				yield(self) if block_given?
+			end
+			
+			def column(name)
+				col = Column.new(name)
+				@cols.add(col)
+				return col
+			end
+			
+			def row(e)
+				e.each_key { |c| @cols.first { |i| i.name == c }&.row(e[c].to_s.strip.chomp) }
+				@rows += 1
+			end
+			
+			def render
+				@rows.times do |row|
+					f = true
+					@cols.foreach do |col|
+						print(' ') unless f
+						f = false
+						col.write(row)
+					end
+					puts
+				end
+			end
+			
+			class Column
+				def align
+					@align
+				end
+				
+				def name
+					@name
+				end
+				
+				def initialize(name)
+					@name  = name
+					@align = 0
+					@data  = []
+				end
+				
+				def row(str)
+					@align = str.length if @align < str.length
+					@data.push(str)
+				end
+				
+				def write(row)
+					str = @data[row]
+					str = '' if str == nil
+					print(str.ljust(@align))
+				end
+			end
+		end
+	end
+end

data/lib/kxi/cli/verb.rb

@@ -129,9 +129,9 @@ module KXI
 			
 			# Parses and executes action of verb
 			# @param args [Array<String>] Given arguments
-			def act(*args)
-				args = ARGV if args.length == 0
-				hf = args.include?('-h') or args.include?('--help') or args.include?('-?')
+			def act(args = nil)
+				args = ARGV if args == nil
+				hf   = (args.include?('-h') or args.include?('--help') or args.include?('-?'))
 				if @verbs.count > 0
 					v = args.shift
 					if @help and (v == 'help' or hf)
@@ -142,14 +142,14 @@ module KXI
 							if verb == nil
 								help
 							else
-								verb.act(*args)
+								verb.act(args)
 							end
 						end
 					else
 						raise(KXI::Exceptions::VerbExpectedException.new(@verbs.select { |i| i.name }.to_array)) if v == nil
 						verb = @verbs.first { |i| i.name == v.downcase }
 						raise(KXI::Exceptions::VerbExpectedException.new(@verbs.select { |i| i.name }.to_array)) if verb == nil
-						verb.act(*args)
+						verb.act(args)
 					end
 				else
 					if @help and hf
@@ -178,7 +178,7 @@ module KXI
 								else
 									raise(KXI::Exceptions::ArgumentException.new(val, 'Expected short argument name!')) if val.length == 1
 									nm  = val[1]
-									arg = @args.first { |i| i.shortcut == nm }
+									arg = @args.of_type(KXI::CLI::ExplicitArgument).first { |i| i.shortcut == nm }
 									raise(KXI::Exceptions::ArgumentException.new(nm, 'No such argument exists!')) if arg == nil
 									if arg.is_a?(KXI::CLI::FlagArgument)
 										vals.set(arg, true)
@@ -198,14 +198,14 @@ module KXI
 									an = anon.first
 									raise(KXI::Exceptions::NoArgumentException.new(val)) if an == nil
 									vals.set(an, val)
-									anon.remove_at(0)
+									anon.remove_at(0) unless an.variadic?
 								end
 							end
 						end
+						vals.finish
 						if @action == nil
 							raise(KXI::Exceptions::NotImplementedException.new)
 						else
-							vals.finish
 							@action.call(vals)
 						end
 					end

data/lib/kxi/exceptions/configuration_exception.rb

@@ -0,0 +1,26 @@
+# Created by Matyáš Pokorný on 2018-01-24.
+
+module KXI
+	module Exceptions
+		class ConfigurationException < Exception
+			def file
+				@file
+			end
+			
+			def path
+				@path
+			end
+			
+			def error_message
+				@msg
+			end
+			
+			def initialize(file, path, msg = nil)
+				super("Invalid configuration <#{path}> in file '#{file}'!#{msg != nil ? ": #{msg}" : ''}")
+				@file = file
+				@path = path
+				@msg = msg
+			end
+		end
+	end
+end

data/lib/kxi/exceptions/invalid_operation_exception.rb

@@ -0,0 +1,11 @@
+# Created by Matyáš Pokorný on 2018-01-27.
+
+module KXI
+	module Exceptions
+		class InvalidOperationException < Exception
+			def initialize(msg)
+				super(msg)
+			end
+		end
+	end
+end

data/lib/kxi/exceptions/parse_exception.rb

@@ -0,0 +1,21 @@
+# Created by Matyáš Pokorný on 2018-01-27.
+
+module KXI
+	module Exceptions
+		class ParseException < Exception
+			def value
+				@val
+			end
+			
+			def parser
+				@par
+			end
+			
+			def initialize(parser, val)
+				super("Failed to parse value '#{val.to_s}' as #{parser}!")
+				@par = parser
+				@val = val
+			end
+		end
+	end
+end

data/lib/kxi/math/polynomial.rb

@@ -0,0 +1,102 @@
+# Created by Matyáš Pokorný on 2018-01-26.
+
+module KXI
+	module Math
+		class Polynomial
+			def degree
+				@cfs.length - 1
+			end
+			
+			def coefficients
+				@cfs
+			end
+			
+			def initialize(*cfs)
+				cfs.shift while cfs[0] == 0
+				@cfs = cfs.collect { |i| i.to_f }
+			end
+			
+			def to_s
+				ret = nil
+				foreach do |k, d|
+					if d > 0
+						if k != 0
+							if ret == nil
+								ret = k >= 0 ? '' : '-'
+							else
+								ret += k >= 0 ? ' + ' : ' - '
+							end
+							ret += (k >= 0 ? k : -k).to_s if k != 1 and k != -1
+							ret += "x#{d > 1 ? "^#{d.to_s}" : ''}"
+						end
+					else
+						if ret == nil
+							ret = k >= 0 ? '' : '-'
+						else
+							ret += k >= 0 ? ' + ' : ' - '
+						end
+						ret += (k >= 0 ? k : -k).to_s
+					end
+				end
+				return ret
+			end
+			
+			def derivative
+				cfs = []
+				foreach do |k, d|
+					if d > 0
+						cfs.push(k * d)
+					end
+				end
+				return Polynomial.new(*cfs)
+			end
+			
+			def integral
+				cfs = []
+				foreach do |k, d|
+					cfs.push(k / (d + 1))
+				end
+				cfs.push(0)
+				return Polynomial.new(*cfs)
+			end
+			
+			def integrate(x1, x2)
+				min = x1 > x2 ? x2 : x1
+				max = x1 > x2 ? x1 : x2
+				i   = integral
+				return i.at(max) - i.at(min)
+			end
+			
+			def at(x)
+				sum = 0
+				foreach do |k, d|
+					sum += k * (x ** d)
+				end
+				return sum
+			end
+			
+			def foreach
+				d = degree
+				@cfs.each do |k|
+					yield(k, d)
+					d -= 1
+				end
+			end
+			
+			def *(other)
+				if other.is_a?(Polynomial)
+					cfs = [0] * (degree + other.degree)
+					foreach do |k1, d1|
+						other.foreach do |k2, d2|
+							cfs[d1 + d2] += k1 * k2
+						end
+					end
+					return Polynomial.new(*cfs)
+				elsif other.is_a?(Numeric)
+					return @cfs.collect { |k| k * other }
+				end
+				raise(Exception.new('Polynomial multiplication error!'))
+			end
+		end
+	end
+end

data/lib/kxi/platform.rb

@@ -0,0 +1,58 @@
+# Created by Matyáš Pokorný on 2018-01-28.
+
+module KXI
+	class Platform
+		def name
+			@name
+		end
+		
+		def version
+			@version
+		end
+		
+		def library_extensions
+			@libs
+		end
+		
+		def path_separator
+			@ps
+		end
+		
+		def initialize(nm, ver, ps, *libs)
+			@name    = nm
+			@version = KXI::Application::Version.parse(ver)
+			@ps      = ps
+			@libs    = libs
+		end
+		
+		def self.this
+			if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
+				return Platform.new('windows', `wmic os get Version /value`.split('=').last.strip.chomp, ';', 'dll')
+			elsif /darwin/ =~ RUBY_PLATFORM
+				return Platform.new('osx', `defaults read loginwindow SystemVersionStampAsString`, ':', 'dylib')
+			else
+				return Platform.new('linux', `uname -r`.split('-')[0], ':', 'so')
+			end
+		end
+		
+		def exec(name, *dir)
+			dir = Platform.env('path').split(@ps) if dir.length == 0
+			ext = Platform.env('pathext')
+			(ext != nil ? ext.split(@ps) + [''] : ['']).each do |e|
+				dir.each do |d|
+					f = File.join(d, "#{name}#{e}")
+					return f if File.exists?(f)
+				end
+			end
+			return nil
+		end
+		
+		def self.env(key)
+			key = key.downcase
+			ENV.each_pair do |k, v|
+				return v if k.downcase == key
+			end
+			return nil
+		end
+	end
+end

data/lib/kxi/reflection/stack_frame.rb

@@ -32,7 +32,7 @@ module KXI
 			def method
 				return nil if @block != nil and @block[0] == '<' and @block[@block.length - 1] == '>'
 				return @block unless @block == nil
-				return nil if @context[0] == '<' and @context[@context.length - 1] == '>'
+				return nil if @context != nil and @context[0] == '<' and @context[@context.length - 1] == '>'
 				@context
 			end
 			

data/lib/kxi/version.rb

@@ -1,4 +1,4 @@
-module KXI
-	# Version of KXI
-  VERSION = '1.0.0'
-end
+module KXI
+	# Version of KXI
+  VERSION = '1.0.1'
+end

data/lib/kxi.rb

@@ -1,3 +1,7 @@
+# Ruby
+require 'date'
+
+# KXI
 require 'kxi/version'
 require 'kxi/exceptions/abstract_exception'
 require 'kxi/exceptions/collection_exception'
@@ -7,6 +11,9 @@ require 'kxi/exceptions/argument_exception'
 require 'kxi/exceptions/no_argument_exception'
 require 'kxi/exceptions/verb_expected_exception'
 require 'kxi/exceptions/invalid_type_exception'
+require 'kxi/exceptions/configuration_exception'
+require 'kxi/exceptions/parse_exception'
+require 'kxi/exceptions/invalid_operation_exception'
 require 'kxi/reflection/stack_frame'
 require 'kxi/collections/enumerator'
 require 'kxi/collections/enumerable'
@@ -20,3 +27,13 @@ require 'kxi/cli/flag_argument'
 require 'kxi/cli/named_argument'
 require 'kxi/cli/argument_values'
 require 'kxi/cli/verb'
+require 'kxi/cli/table'
+require 'kxi/cli/property_list'
+require 'kxi/application/config_reader'
+require 'kxi/application/config'
+require 'kxi/application/event'
+require 'kxi/application/logger'
+require 'kxi/application/version'
+require 'kxi/application/version_expression'
+require 'kxi/math/polynomial'
+require 'kxi/platform'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kxi
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Matyáš Pokorný
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-23 00:00:00.000000000 Z
+date: 2018-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,12 +116,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/kxi.rb
+- lib/kxi/application/config.rb
+- lib/kxi/application/config_reader.rb
+- lib/kxi/application/event.rb
+- lib/kxi/application/logger.rb
+- lib/kxi/application/version.rb
+- lib/kxi/application/version_expression.rb
 - lib/kxi/cli/anonymous_argument.rb
 - lib/kxi/cli/argument.rb
 - lib/kxi/cli/argument_values.rb
 - lib/kxi/cli/explicit_argument.rb
 - lib/kxi/cli/flag_argument.rb
 - lib/kxi/cli/named_argument.rb
+- lib/kxi/cli/property_list.rb
+- lib/kxi/cli/table.rb
 - lib/kxi/cli/verb.rb
 - lib/kxi/collections/array_collection.rb
 - lib/kxi/collections/enumerable.rb
@@ -131,11 +139,16 @@ files:
 - lib/kxi/exceptions/abstract_exception.rb
 - lib/kxi/exceptions/argument_exception.rb
 - lib/kxi/exceptions/collection_exception.rb
+- lib/kxi/exceptions/configuration_exception.rb
+- lib/kxi/exceptions/invalid_operation_exception.rb
 - lib/kxi/exceptions/invalid_type_exception.rb
 - lib/kxi/exceptions/no_argument_exception.rb
 - lib/kxi/exceptions/not_implemented_exception.rb
 - lib/kxi/exceptions/out_of_range_exception.rb
+- lib/kxi/exceptions/parse_exception.rb
 - lib/kxi/exceptions/verb_expected_exception.rb
+- lib/kxi/math/polynomial.rb
+- lib/kxi/platform.rb
 - lib/kxi/reflection/stack_frame.rb
 - lib/kxi/version.rb
 homepage: https://github.com/cryocz/kxi