fedux_org-stdlib 0.0.1 → 0.0.2

data/Gemfile

@@ -1,4 +1,31 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in fedux_org-stdlib.gemspec
-gemspec
+gemspec 
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'simplecov'
+  gem 'aruba'
+  gem 'fuubar'
+  gem 'ffaker'
+end
+
+group :documentation do
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup'
+end
+
+group :development do
+  gem 'tmrb'
+  gem 'debugger'
+  gem 'pry'
+  gem 'pry-doc'
+  gem 'pry-debugger'
+  gem 'debugger-completion'
+  gem 'awesome_print'
+  gem 'travis-lint'
+  gem 'fuubar'
+  gem 'churn'
+end

data/Rakefile

@@ -1 +1,94 @@
-require "bundler/gem_tasks"
+#!/usr/bin/env rake
+
+unless ENV['TRAVIS_CI'] == 'true'
+  namespace :gem do
+    require 'bundler/gem_tasks'
+  end
+
+  require 'yard'
+  require 'rubygems/package_task'
+  require 'active_support/core_ext/string/strip'
+end
+
+YARD::Rake::YardocTask.new() do |y|
+# y.options << '--verbose'
+end
+
+desc 'start tmux'
+task :terminal do
+  sh "script/terminal"
+end
+
+task :term => :terminal
+task :t => :terminal
+
+namespace :version do
+  version_file = Dir.glob('lib/**/version.rb').first
+
+  desc 'bump version of library to new version'
+  task :bump do
+
+    new_version = ENV['VERSION'] || ENV['version']
+
+    raw_module_name = File.open(version_file, "r").readlines.grep(/module/).first
+    module_name = raw_module_name.chomp.match(/module\s+(\S+)/) {$1}
+
+    version_string = %Q{#main #{module_name}
+module #{module_name}
+VERSION = '#{new_version}'
+end}
+
+    File.open(version_file, "w") do |f|
+      f.write version_string.strip_heredoc
+    end
+
+    sh "git add #{version_file}"
+    sh "git commit -m 'version bump to #{new_version}'"
+    #project = 'the_array_comparator'
+    #sh "git tag #{project}-v#{new_version}"
+  end
+
+  desc 'show version of library'
+  task :show do
+    raw_version = File.open(version_file, "r").readlines.grep(/VERSION/).first
+
+    if raw_version
+      version = raw_version.chomp.match(/VERSION\s+=\s+["']([^'"]+)["']/) { $1 }
+      puts version
+    else
+      warn "Could not parse version file \"#{version_file}\""
+    end
+
+  end
+
+  desc 'Restore version file from git repository'
+  task :restore do
+    sh "git checkout #{version_file}"
+  end
+
+end
+
+namespace :travis do
+  desc 'Runs travis-lint to check .travis.yml'
+  task :check do
+    sh 'travis-lint'
+  end
+end
+
+namespace :test do
+  desc 'Run specs'
+  task :specs do
+    sh 'bundle exec rspec spec'
+  end
+
+  desc 'Run tests in "travis mode"'
+  task :travis_specs do
+    ENV['TRAVIS_CI'] = 'true'
+    sh 'rspec spec'
+    sh 'cucumber -p all'
+  end
+end
+
+task :console do
+  sh 'script/console'
+end

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

@@ -0,0 +1,14 @@
+module FeduxOrg
+  module Stdlib
+    module Command
+      class CommandResult
+        attr_accessor :stderr, :stdout, :status
+
+        def initialize
+          @stderr = ''
+          @stdout = ''
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org/stdlib/command.rb

@@ -0,0 +1,51 @@
+require 'open3'
+
+require 'fedux_org/stdlib/environment'
+require 'fedux_org/stdlib/command/command_result'
+
+module FeduxOrg
+  module Stdlib
+    module Command
+      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,
+        }.merge options
+
+        env = opts[:env] || ENV.to_hash
+        stdin = opts[:stdin] 
+        binmode = opts[:binmode]
+
+        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/environment.rb

@@ -0,0 +1,29 @@
+module FeduxOrg
+  module Stdlib
+    module Environment
+
+      # Set environment variable for code block
+      #
+      # @param [Hash] variables
+      #   the variables which should be set for that environment
+      #
+      # @yield
+      #   the block which should be run which the change environment
+      def isolated_environment(variables, &block)
+        #backup
+        old_env = ENV.to_hash
+        #change env
+        ENV.update variables
+
+        block_result = block.call
+
+        #cleanup
+        ENV.clear 
+        #install backuped information
+        ENV.update old_env
+
+        block_result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+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/filesystem.rb

@@ -0,0 +1,247 @@
+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
+
+      # Create directory(ies)
+      #
+      # @param [String,Array] dir
+      #   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] dir
+      #   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] file_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='')
+        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
+
+        file
+      end
+
+      # Delete a single file
+      #
+      # @param [String] file_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 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] file_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.to_s}\" 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
+      #
+      # @result [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/logger.rb

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

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

@@ -0,0 +1,66 @@
+module FeduxOrg
+  module Stdlib
+    module Logging
+      class Logger
+
+        extend ::Forwardable
+        def_delegators :@logger, :fatal, :warn, :debug, :info, :error, :unknown
+
+        attr_reader :mode
+
+        def initialize
+          @logger = ::Logger.new($stderr)
+          self.mode = :info
+        end
+
+        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
+
+class ::Logger
+  SILENT = 9999
+end

data/lib/fedux_org/stdlib/models/{base.rb → base_model.rb}

@@ -94,20 +94,20 @@ module FeduxOrg
 
           #finds all instances
           def find_all( criteria={} )
-            PuppetGenerator::Models.logger.debug(self) { "Criteria for search: #{ criteria }" }
+            FeduxOrg::Stdlib.logger.debug(self) { "Criteria for search: #{ criteria }" }
             criteria = { name: criteria.to_sym } if criteria.kind_of? Symbol or criteria.kind_of? String
 
-            PuppetGenerator::Models.logger.debug(self) { "Instances to be searched for: #{ @instances.map { |i| "#{i.name} (#{i.class})" }.join(", ") }" }
+            FeduxOrg::Stdlib.logger.debug(self) { "Instances to be searched for: #{ @instances.map { |i| "#{i.name} (#{i.class})" }.join(", ") }" }
             @instances.find_all do |i| 
               criteria.all? do |c,v|
 
-                PuppetGenerator::Models.logger.debug(self) { "Check method for search: #{ c }" }
+                FeduxOrg::Stdlib.logger.debug(self) { "Check method for search: #{ c }" }
                 i.send( "#{c}?".to_sym , v )
               end
             end
 
           rescue NameError => e
-            raise Exceptions::InvalidSearchCriteria, e.message
+            raise FeduxOrg::Stdlib::Models::Exceptions::InvalidSearchCriteria, e.message
           end
         end
 

data/lib/fedux_org/stdlib/models/class_based_model.rb

@@ -11,13 +11,13 @@ module FeduxOrg
         module ClassMethods
 
           def require_path(name)
-            File.join( PuppetGenerator.gem_load_path, model_name.pluralize.underscore , name.to_s )
+            File.join( module_name.underscore , model_name.pluralize.underscore , name.to_s )
           end
 
           def exception_for_model
-            "PuppetGenerator::Exceptions::Invalid#{model_name.singularize}".constantize
+            "#{library_name}::Exceptions::Invalid#{model_name.singularize}".constantize
           rescue
-            raise Exceptions::ExceptionNeedsToBeImplemented, "Exception \"Exceptions::Invalid#{model_name}\" does not exist."
+            raise FeduxOrg::Stdlib::Models::Exceptions::ExceptionNeedsToBeImplemented, "Exception \"#{library_name}::Exceptions::Invalid#{model_name}\" does not exist."
           end
 
           def check_klass( klass , method)
@@ -25,13 +25,13 @@ module FeduxOrg
           end
 
           def build_class_constant(name)
-            "PuppetGenerator::#{model_name.pluralize}::#{name.to_s.camelcase}".constantize
+            "#{library_name}::#{model_name.pluralize}::#{name.to_s.camelcase}".constantize
           rescue
             raise exception_for_model , "The filename needs to be snakecase and needs to be convertible to the action class name: filename in camelcase."
           end
 
           def check_method
-            raise Exceptions::MethodNeedsToBeImplemented, "Method \"check_method\" does not exist."
+            raise FeduxOrg::Stdlib::Models::Exceptions::MethodNeedsToBeImplemented, "Method \"check_method\" does not exist."
           end
 
           def suffix

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

@@ -0,0 +1,32 @@
+module PuppetGenerator
+  module Exceptions
+
+    #raised if one tries to delete an instance which
+    #does not exist
+    class InstanceNotFound < InternalError; end
+    
+    #raised if one tries to use a keyword whose use
+    #is restricted
+    class UnauthorizedUseOfKeyword < InternalError; end
+
+    #raised if one uses invalid search criteria
+    class InvalidSearchCriteria < InternalError; end
+    
+    #raised if the code which defines an import filter
+    #is malformed
+    class MethodNeedsToBeImplemented < InternalError; end
+    
+    #raised if one tries to use an unimplemented exception
+    class ExceptionNeedsToBeImplemented < InternalError; end
+
+    #raised if an file system error occured
+    class FilesystemError < Exception ; end
+
+    #raise if a directory does not exist in filesystem
+    class DirectoryDoesNotExist < FilesystemError; end
+    
+    #raise if a file does not exist in filesystem
+    class FileDoesNotExist < FilesystemError; end
+
+  end
+end

data/lib/fedux_org/stdlib/models/filesystem_based_model.rb

@@ -32,8 +32,12 @@ module FeduxOrg
             fqcn.last
           end
 
+          def library_name
+            fqcn.first
+          end
+
           def suffix
-            raise Exceptions::MethodNeedsToBeImplemented
+            raise FeduxOrg::Stdlib::Models::Exceptions::MethodNeedsToBeImplemented
           end
 
           def path_to_instances
@@ -44,13 +48,13 @@ module FeduxOrg
 
           def name(path)
             name = File.basename(path, suffix ).to_sym
-            raise Exceptions::UnauthorizedUseOfKeyword if forbidden_keywords.include? name
+            raise FeduxOrg::Stdlib::Models::Exceptions::UnauthorizedUseOfKeyword if forbidden_keywords.include? name
 
             name
           end
 
           def load_from_filesystem
-            raise Exceptions::MethodNeedsToBeImplemented
+            raise FeduxOrg::Stdlib::Models::Exceptions::MethodNeedsToBeImplemented
           end
 
           def forbidden_keywords

data/lib/fedux_org/stdlib/models.rb

@@ -0,0 +1,5 @@
+require 'fedux_org/stdlib/models/exceptions'
+require 'fedux_org/stdlib/models/base_model'
+require 'fedux_org/stdlib/models/class_based_model'
+require 'fedux_org/stdlib/models/filesystem_based_model'
+require 'fedux_org/stdlib/logger'

data/lib/fedux_org/stdlib/version.rb

@@ -1,5 +1,6 @@
+#main FeduxOrg
 module FeduxOrg
   module Stdlib
-    VERSION = "0.0.1"
+    VERSION = '0.0.2'
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+#encoding: utf-8
+$LOAD_PATH << File.expand_path( '../../lib', __FILE__ )
+
+unless ENV['TRAVIS_CI'] == 'true'
+  require 'pry'
+  require 'debugger'
+  require 'ap'
+  require 'benchmark'
+end
+
+unless ENV['TRAVIS_CI'] == 'true'
+  require 'simplecov'
+  SimpleCov.start
+  SimpleCov.command_name 'rspec'
+end
+
+require 'puppet_generator'
+include PuppetGenerator
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+end
+
+def examples_dir
+  File.expand_path( '../examples', __FILE__ )
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fedux_org-stdlib
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -57,10 +57,20 @@ files:
 - Rakefile
 - fedux_org-stdlib.gemspec
 - lib/fedux_org/stdlib.rb
-- lib/fedux_org/stdlib/models/base.rb
+- lib/fedux_org/stdlib/command.rb
+- lib/fedux_org/stdlib/command/command_result.rb
+- lib/fedux_org/stdlib/environment.rb
+- lib/fedux_org/stdlib/filesystem.rb
+- lib/fedux_org/stdlib/filesystem/exceptions.rb
+- lib/fedux_org/stdlib/logger.rb
+- lib/fedux_org/stdlib/logging/logger.rb
+- lib/fedux_org/stdlib/models.rb
+- lib/fedux_org/stdlib/models/base_model.rb
 - lib/fedux_org/stdlib/models/class_based_model.rb
+- lib/fedux_org/stdlib/models/exceptions.rb
 - lib/fedux_org/stdlib/models/filesystem_based_model.rb
 - lib/fedux_org/stdlib/version.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -86,5 +96,6 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: collection of use full libraries
-test_files: []
+test_files:
+- spec/spec_helper.rb
 has_rdoc: