fedux_org-stdlib 0.3.2 → 0.6.3

data/lib/fedux_org/stdlib/command/which.rb

@@ -1,67 +0,0 @@
-require 'pathname'
-
-begin
-  require 'active_support/core_ext/object/blank'
-rescue LoadError
-  $stderr.puts 'You need to install the "activesupport"-gem to make that rake task work.'
-  exit 1 
-end
-
-module FeduxOrg
-  module Stdlib
-    module Command
-      module Which
-
-        # Search for command
-        # @param [String] cmd
-        #    name of command or path to command (will be reduced to basename and then searched in PATH)
-        #
-        # @param [Array,String] paths
-        #   a string containing paths separated by "File::PATH_SEPARATOR" or an array of paths
-        #
-        # @param [Array,String] pathexts
-        #   a string containing pathexts separated by ";" or an array of pathexts
-        #   
-        # @return [String] 
-        #   path to command
-        def which(cmd, options={})
-          options = {
-            paths:                         ENV['PATH'].split(File::PATH_SEPARATOR),
-            pathexts:                      ENV['PATHEXT'].to_s.split( /;/ ),
-            raise_error_on_not_executable: false,
-            raise_error_on_not_found:      false,
-          }.merge options
-
-          cmd = Pathname.new(cmd)
-
-          paths                         = options[:paths]
-          pathexts                      = options[:pathexts]
-          raise_error_on_not_executable = options[:raise_error_on_not_executable]
-          raise_error_on_not_found      = options[:raise_error_on_not_found]
-
-          raise Exceptions::CommandNotFound if cmd.to_s.empty?
-          return nil if cmd.to_s.empty?
-
-          if cmd.absolute? 
-            return cmd.to_s if cmd.executable?
-            raise Exceptions::CommandNotFound if raise_error_on_not_found and not cmd.exist?
-            raise Exceptions::CommandNotExecutable if raise_error_on_not_executable and not cmd.executable?
-            return nil
-          end
-
-          pathexts = [''] if pathexts.blank?
-
-          Array( paths ).each do |path|
-            Array( pathexts ).each do |ext|
-              file = Pathname.new( File.join(path, "#{cmd.to_s}#{ext.to_s}") )
-              return file.to_s if file.executable?
-              raise Exceptions::CommandNotExecutable if raise_error_on_not_executable and not cmd.executable?
-            end
-          end                                                                                                                                                        
-          raise Exceptions::CommandNotFound if raise_error_on_not_found
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fedux_org/stdlib/environment.rb

@@ -1,31 +0,0 @@
-module FeduxOrg
-  module Stdlib
-    module Environment
-
-      # Set environment variable for code block
-      #
-      # @param [Hash] new_environment_variables
-      #   the variables which should be set for that environment
-      #
-      # @param [Hash] options
-      #   options for environment manipulation
-      #
-      # @option options [True,False] :clear
-      #   Should the environment clear before merge? 
-      #
-      # @yield
-      #   the block which should be run which the change environment
-      def isolated_environment(new_environment_variables, options={}, &block)
-        old_environment = ENV.to_hash
-
-        ENV.clear if options[:clear] == true
-        ENV.update new_environment_variables
-
-        block.call
-      ensure
-        ENV.clear 
-        ENV.update old_environment
-      end
-    end
-  end
-end

data/lib/fedux_org/stdlib/filesystem.rb

@@ -1,247 +0,0 @@
-require 'fileutils'
-require 'fedux_org/stdlib/filesystem/exceptions'
-
-# helper for file system
-module FeduxOrg
-  module Stdlib
-    module Filesystem
-
-      # The root directory of the project
-      #
-      # @return [String]
-      #   the root directory
-      def root_directory
-        #::File.expand_path('../../../', __FILE__)
-        raise Exceptions::InvalidUsageOfLibrary , "Sorry, but you need to define the root directory yourself"
-      end
-
-      # The temporary directory for the project
-      #
-      # @return [String]
-      #   the directory created for the tests 
-      def working_directory
-        ::File.join(root_directory, 'tmp', 'test')
-      end
-
-      # Create temporary directory
-      def create_working_directory
-        FileUtils.mkdir_p(working_directory) unless ::File.exists? working_directory
-      end
-
-      # Delete temporary directory
-      def delete_working_directory
-        FileUtils.rm_rf(working_directory) if ::File.exists? working_directory
-      end
-
-      # Clean up test directory
-      def cleanup_working_directory
-        delete_working_directory
-        create_working_directory
-      end
-
-      # Switch the current working directory to 
-      # the temporary one and execute code block
-      def switch_to_working_directory(&block)
-        Dir.chdir(working_directory, &block)
-      end
-      alias_method :in_working_directory, :switch_to_working_directory
-
-      # Create directory(ies)
-      #
-      # @param [String,Array] dirs
-      #   the directories to be created, multiple arguments are possible as well
-      #
-      # @return [String,Array] 
-      #   returns a string if there was only one file given, and an array with 
-      #   muliple files
-      def create_directory(*dirs)
-        raise_if_forbidden_path_for_create_operation(dirs)
-
-        directories = expand_path(dirs.flatten)
-        FileUtils.mkdir_p(directories)
-
-        if directories.size == 1
-          return directories.first
-        else
-          return directories
-        end
-      end
-
-      # Delete directory(ies)
-      #
-      # @param [String, Array] dirs
-      #   the directories to be deleted, multiple arguments are possible as well
-      #
-      # @return [String,Array] 
-      #   returns a string if there was only one file given, and an array with 
-      #   muliple files
-      def delete_directory(*dirs)
-        raise_if_forbidden_path_for_delete_operation(dirs)
-
-        directories = expand_path(dirs.flatten)
-        FileUtils.rm_r(directories)
-
-        if directories.size == 1
-          return directories.first
-        else
-          return directories
-        end
-      end
-
-      # Check existence of path(s)
-      #
-      # @param [String,Array] paths
-      #   which path(s) should be checked, multiple arguments are possible as well
-      #
-      # @return [TrueClass,FalseClass]
-      #   the result of all checks done
-      def path_exists?(*paths)
-        raise_if_forbidden_path_for_create_operation(paths)
-
-        paths_expanded = expand_path(paths.flatten)
-        paths_expanded.flatten.all? { |p| ::File.exists?(p) }
-      end
-
-      # Check absence of path(s)
-      #
-      # @param [String,Array] paths
-      #   which path(s) should be checked, multiple arguments are possible as well
-      #
-      # @return [TrueClass,FalseClass]
-      #   the result of all checks done
-      def path_does_not_exist?(*paths)
-        not path_exists?(paths)
-      end
-
-      # Create a single file
-      #
-      # @param [String] path
-      #   the path for the new file (can include directories)
-      #
-      # @param [String] content
-      #   the content written to the file
-      #
-      # @return [String]
-      #   the path to the created file
-      def create_file(path, content='', mode=0644)
-        raise_if_forbidden_path_for_create_operation(path)
-
-        file = expand_path(path).first
-        directory = ::File.dirname(file)
-
-        FileUtils.mkdir_p(directory) unless directory == '.'
-        ::File.open(file, "wb") do |f|
-          f.write content
-        end
-
-        FileUtils.chmod(mode, file)
-
-        file
-      end
-
-      # Delete a single file
-      #
-      # @param [String] files
-      #   the path for the new file (can include directories)
-      #
-      # @return [String]
-      #   the path to the deleted file
-      def delete_file(*files)
-        raise_if_forbidden_path_for_delete_operation(files)
-
-        files_to_be_deleted = expand_path(files.flatten)
-        FileUtils.rm(files_to_be_deleted)
-
-        if files_to_be_deleted.size == 1
-          return files_to_be_deleted.first
-        else
-          return files_to_be_deleted
-        end
-      end
-
-      # Read the content of a file
-      #
-      # @param [String] path
-      #   the path to the file
-      #
-      # @return [String,Binary] 
-      #   the content of the file
-      def read_file(path)
-        raise_if_forbidden_path_for_create_operation(path)
-
-        file_path = expand_path(path).first
-        return ::File.read(file_path)
-      end
-
-      # Expand path based on temporary directory
-      #
-      # @param [String, Array, Multiple Values] paths
-      #   the paths to be expanded
-      #
-      # @return [Array, String]
-      #   the expanded arrays
-      def expand_path(*paths)
-        raise_if_forbidden_path_for_create_operation(paths)
-
-        paths.flatten.map do |p| 
-          case p 
-          when /^~/
-            ::File.expand_path(p) 
-          else
-            ::File.join(working_directory, p ) 
-          end
-        end
-      end
-
-      # Check if path is forbidden for delete operation
-      # 
-      # @param [String, Array] paths
-      #   paths which should be checked
-      #
-      # @return [TrueClass, FalseClass]
-      #   true if path is forbidden, false if path is not forbidden
-      def raise_if_forbidden_path_for_create_operation(*paths)
-        flattend_paths = paths.flatten
-        strings = []
-        regex = %r[\.\.]
-
-        raise FileSystem::Exceptions::InvalidPath , "Sorry, but you cannot use paths matching \"#{strings.join(', ')}\"  or \"#{regex.inspect}\" here!" if path_matches?(strings, regex, flattend_paths)
-      end
-
-      # Check if path is forbidden for delete operation
-      #
-      # @param [String, Array] paths
-      #   paths which should be checked
-      #
-      # @return [TrueClass, FalseClass]
-      #   true if path is forbidden, false if path is not forbidden
-      def raise_if_forbidden_path_for_delete_operation(*paths)
-        flattend_paths = paths.flatten
-        strings = %w[ / ]
-        regex = %r[\.\.]
-
-        raise FileSystem::Exceptions::InvalidPath , "Sorry, but you cannot use paths matching \"#{strings.join(', ')}\"  or \"#{regex.to_s}\" here!" if path_matches?(strings, regex, flattend_paths)
-      end
-
-      # Check if path matches
-      #
-      # @param [Array, String] strings
-      #   strings which are checked against paths
-      #
-      # @param [Array, String] regex
-      #   regex which is checked against path
-      #
-      # @param [Array, String] paths
-      #   the paths to be checked
-      #
-      # @return [TrueClass, FalseClass] 
-      #   true if path is valid, false if invalid
-      def path_matches?(strings, regex, *paths)
-        flattend_paths = paths.flatten
-        flattend_strings = strings.flatten
-
-        flattend_paths.any? { |f|  f =~ regex or flattend_strings.include?(f) }
-      end
-    end
-  end
-end

data/lib/fedux_org/stdlib/filesystem/exceptions.rb

@@ -1,13 +0,0 @@
-module FeduxOrg
-  module Stdlib
-    module FileSystem
-      module Exceptions
-        # Raise if path with '..' given
-        class InvalidPath < Exception; end
-
-        #Raised if library is not used correctly
-        class InvalidUsageOfLibrary < Exception; end
-      end
-    end
-  end
-end

data/lib/fedux_org/stdlib/logging.rb

@@ -1,13 +0,0 @@
-require 'fedux_org/stdlib/logging/logger'
-
-module FeduxOrg
-  module Stdlib
-    def self.logger
-      @logger ||= FeduxOrg::Stdlib::Logging::Logger.new
-    end
-
-    def self.logger=(logger)
-      @logger = logger
-    end
-  end
-end

data/lib/fedux_org/stdlib/logging/logger.rb

@@ -1,79 +0,0 @@
-require 'logger'
-require 'forwardable'
-require 'fedux_org/stdlib/logging/severity'
-
-module FeduxOrg
-  module Stdlib
-    module Logging
-      class Logger
-
-        extend ::Forwardable
-        def_delegators :@logger, :fatal, :warn, :debug, :info, :error, :unknown
-
-        attr_reader :mode
-
-        # Create logger
-        #
-        # @param [Logger] logger (::Logger.new( $stderr ))
-        #   The logger with should be used to output data
-        def initialize(logger = ::Logger.new( $stderr ) )
-          @logger = logger
-          self.mode = :info
-        end
-
-        # Reset logger to ruby logger
-        def reset
-          @logger = ::Logger.new( $stderr )
-        end
-
-        # Change mode of logger: DEBUG, ... + Change the output format
-        #
-        # @param [Symbol] m
-        #   the mode: DEBUG, ...
-        def mode=(m)
-          @mode = m
-
-          case m
-          when :debug
-            @logger.level = ::Logger::DEBUG
-            format_debug
-          when :silent
-            @logger.level = ::Logger::SILENT
-          when :info
-            @logger.level = ::Logger::INFO
-            format_standard
-          else
-            @logger.level = ::Logger::INFO
-            format_standard
-          end
-        end
-
-        private
-
-        def format_debug
-          @logger.formatter = proc { |severity, datetime, progname , msg|
-            debug_msg("%s %s %s: %s\n" % [ datetime, severity, progname, msg ])
-          }
-        end
-
-        def format_standard
-          @logger.formatter = proc { |severity, datetime, _, msg|
-            info_msg( "%s %s: %s\n" % [ datetime, severity, msg ] )
-          }
-        end
-
-        def error_msg(msg)
-          ANSI.red(msg)
-        end
-
-        def info_msg(msg)
-          msg
-        end
-
-        def debug_msg(msg)
-          msg
-        end
-      end
-    end
-  end
-end