fedux_org-stdlib 0.3.2 → 0.6.3

data/lib/fedux_org_stdlib/ci.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+# Running in continous integration mode
+def ci?
+  ENV.key? 'CI'
+end

data/lib/fedux_org_stdlib/colors/html_color.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module Colors
+    class HtmlColor
+      # @param [String] color
+      #   string in the html color format
+      def initialize( color )
+        @color = color
+        @validator_regex = /^#[a-f0-9]{6}$/
+      end
+
+      # @return [true,false] color string is valid
+      def valid?
+        @validator_regex === @color
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/command.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/command/run_command'
+require 'fedux_org_stdlib/command/which'
+
+module FeduxOrgStdlib
+  module Command
+    include RunCommand
+    include Which
+  end
+end

data/lib/fedux_org_stdlib/command/command_result.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module Command
+    class CommandResult
+      attr_accessor :stderr, :stdout, :status
+
+      def initialize
+        @stderr = ''
+        @stdout = ''
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/command/run_command.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ open3 }
+
+require 'fedux_org_stdlib/environment'
+require 'fedux_org_stdlib/command/command_result'
+
+module FeduxOrgStdlib
+  module Command
+    module RunCommand
+      include Environment
+
+      # Execute command
+      #
+      # @param [String] cmd
+      #   the command 
+      #
+      # @param [Hash] options
+      #   the options for command execution
+      #
+      # @option options [Hash] env ({])
+      #   the environment variables for the command ('VAR' => 'CONTENT')
+      #
+      # @option options [String] stdin (nil)
+      #   the string for stdin of the command
+      #
+      # @option options [TrueClass,FalseClass] binmode (false)
+      #   should the stdin be read a binary or not
+      #
+      # @return [CommandResult]
+      #   the result of the command execution
+      #
+      # @return [CommandResult]
+      #   the result of the command execution
+      def run_command(cmd,options={})
+        opts = {
+          env: nil,
+          stdin: nil,
+          binmode: false,
+          working_directory: Dir.getwd,
+        }.merge options
+
+        env = opts[:env] || ENV.to_hash
+        stdin = opts[:stdin] 
+        binmode = opts[:binmode]
+        working_directory = opts[:working_directory]
+
+        result = CommandResult.new
+        result.stdout, result.stderr, result.status = Open3.capture3(env, cmd, stdin_data: stdin, chdir: working_directory, binmode: binmode)
+
+        result
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/command/which.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ pathname active_support/core_ext/object/blank }
+
+module FeduxOrgStdlib
+  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

data/lib/fedux_org_stdlib/core_ext/array.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+class Array
+  def to_list
+    self.map { |l| format('"%s"', l) }.join(", ")
+  end
+end

data/lib/fedux_org_stdlib/core_ext/string.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+class String
+end

data/lib/fedux_org_stdlib/environment.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  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
+
+    alias_method :with_environment, :isolated_environment
+  end
+end

data/lib/fedux_org_stdlib/filesystem.rb

@@ -0,0 +1,248 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ fileutils }
+
+require 'fedux_org_stdlib/filesystem/exceptions'
+
+# helper for file system
+module FeduxOrgStdlib
+  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