fedux_org-stdlib 0.3.2 → 0.6.3

data/lib/fedux_org_stdlib/models/class_based_model.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ find active_support/core_ext/object/blank active_support/core_ext/string/inflections }
+
+require 'fedux_org_stdlib/models/filesystem_based_model'
+
+module FeduxOrgStdlib
+  module Models
+    # model for import action
+    module ClassBasedModel
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def require_path(name)
+          path = File.join( library_name.underscore , model_name.pluralize.underscore , name.to_s )
+          FeduxOrgStdlib.logger.debug(self) { "Path to instances of model \"#{name}\": #{path}" }
+
+          path
+        end
+
+        def exception_for_model
+          "#{library_name}::Exceptions::Invalid#{model_name}".constantize
+        rescue
+          raise FeduxOrgStdlib::Models::Exceptions::ExceptionNeedsToBeImplemented, "Exception \"#{library_name}::Exceptions::Invalid#{model_name}\" does not exist."
+        end
+
+        def check_klass( klass , *methods)
+          raise exception_for_model, "A valid \"#{model_name}\"-class needs to respond to \"#{ methods.flatten.join(", ") }\"." unless methods.flatten.all? { |m| klass.new.respond_to? m }
+        end
+
+        def build_class_constant(name)
+          "#{library_name}::#{model_name.pluralize}::#{name.to_s.camelcase}".constantize
+        rescue
+          raise exception_for_model , "Class \"#{library_name}::#{model_name.pluralize}::#{name.to_s.camelcase}\" cannot be found in file \"#{require_path(name)}\"."
+        end
+
+        def check_method
+          raise FeduxOrgStdlib::Models::Exceptions::MethodNeedsToBeImplemented, "Method \"check_method\" does not exist."
+        end
+
+        def suffix
+          '.rb'
+        end
+
+        def load_from_filesystem
+          files = find_files
+
+          FeduxOrgStdlib.logger.debug(self) { "Files found at path \"#{path_to_instances}\": #{ files.join(", ") }" }
+
+          raise FeduxOrgStdlib::Models::Exceptions::NoImplementationsForModelFound, "You might need to store files at \"#{File.dirname(path_to_instances)}\" to make the library work." if files.blank?
+
+          files.each do |f| 
+            instance_name = name( f )
+
+            require require_path( instance_name )
+
+            instance_klass = build_class_constant( instance_name )
+            check_klass( instance_klass, check_method )
+            create( instance_name , instance_klass.new )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/models/exceptions.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module Models
+    module Exceptions
+      #internal error
+      class InternalError < Exception; end
+
+      #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 one forgot to store files at `path_to_instances`
+      class NoImplementationsForModelFound < 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
+end

data/lib/fedux_org_stdlib/models/filesystem_based_model.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/models/base_model'
+
+module FeduxOrgStdlib
+  module Models
+    # model for import action
+    module FilesystemBasedModel
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        #initialize model
+        def init
+          load_from_filesystem
+        end
+
+        private
+
+        def module_name
+          name = fqcn
+          name.pop
+
+          name.join('::')
+        end
+
+        def fqcn
+          self.to_s.split(/::/)
+        end
+
+        def model_name
+          fqcn.last
+        end
+
+        def library_name
+          fqcn.first
+        end
+
+        def suffix
+          raise FeduxOrgStdlib::Models::Exceptions::MethodNeedsToBeImplemented, "Please defined the method \"suffix\" to make the library work."
+        end
+
+        def model_path
+          raise FeduxOrgStdlib::Models::Exceptions::MethodNeedsToBeImplemented, "Please defined the method \"model_path\" to make the library work."
+        end
+
+        def ignore
+          'BORING_STRING_WHICH_SHOULD_NEVER_MATCH'
+        end
+
+        def find_files
+          files = []
+          Find.find(path_to_instances) do |path|
+            next unless File.file? path
+            next if suffix and path !~/#{suffix}$/
+            next if path =~ /^\.\.?/
+            next if path =~ %r{#{ignore}}
+
+            files << path
+          end
+
+          files
+        rescue
+          raise FeduxOrgStdlib::Models::Exceptions::NoImplementationsForModelFound, "You might need to create the directory\"#{File.dirname(path_to_instances)}\"."
+        end
+
+        def path_to_instances
+          return_path = ::File.expand_path("../../#{model_name.pluralize.underscore}", model_path )
+
+          FeduxOrgStdlib.logger.debug(self) { "Path to instances of model: #{return_path}" }
+
+          return_path
+        end
+
+        def name(path)
+          name = File.basename(path, suffix ).to_sym
+          raise FeduxOrgStdlib::Models::Exceptions::UnauthorizedUseOfKeyword if forbidden_keywords.include? name
+
+          FeduxOrgStdlib.logger.debug(self) { "Name of model: #{name}" }
+
+          name
+        end
+
+        def load_from_filesystem
+          raise FeduxOrgStdlib::Models::Exceptions::MethodNeedsToBeImplemented
+        end
+
+        def forbidden_keywords
+          [ ]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fedux_org_stdlib/project.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/project/logger'
+require 'fedux_org_stdlib/project/plan'
+require 'fedux_org_stdlib/project/report'
+require 'fedux_org_stdlib/project/generators/taskjuggler'
+

data/lib/fedux_org_stdlib/project/generators/taskjuggler.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ command_exec }
+
+require 'fedux_org_stdlib/logging/logger'
+
+module FeduxOrgStdlib
+  module Project
+    module Generators
+      class Taskjuggler
+        def generate_report(directory, plan)
+          FeduxOrgStdlib::Project.logger.debug "Start generating report."
+
+          begin
+            command = CommandExec::Command.new(:tj3 , 
+                                               :parameter          => "-o #{directory} #{plan}",
+                                               :error_detection_on => [:return_code],
+                                               :error_indicators   => {
+                                                 :allowed_return_code => [0],
+                                               },
+                                               :on_error_do => :raise_error,
+                                              )
+            command.run
+          rescue CommandExec::Exceptions::CommandExecutionFailed
+            FeduxOrgStdlib::Project.logger.fatal "Failed to generate report:\n\n#{ command.result.stderr.join( "\n" ) }"
+            exit 1
+          end
+
+          FeduxOrgStdlib::Project.logger.info "Generating report succeeded."
+        end
+      end
+
+    end
+  end
+end

data/lib/fedux_org_stdlib/project/logger.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logging/logger'
+
+module FeduxOrgStdlib
+  module Project
+    class << self
+      def logger
+        @logger ||= FeduxOrgStdlib::Logging::Logger.new
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/project/plan.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module Project
+    class Plan
+
+      private
+
+      attr_reader :main_file, :additional_files
+
+      public
+
+      def initialize(main_file: File.join(Dir.getwd, 'plan.tjp'), additional_files: [])
+        @main_file        = main_file
+        @additional_files = Array(additional_files)
+      end
+
+      def needs_to_be_compiled?(base_file)
+        (Array(main_file) + additional_files).any? { |f| File.mtime(f) > File.mtime(base_file) }
+      end
+
+      def to_s
+        main_file
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/project/report.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ fileutils launchy }
+
+require 'fedux_org_stdlib/logging/logger'
+require 'fedux_org_stdlib/project/logger'
+require 'fedux_org_stdlib/project/generators/taskjuggler'
+
+
+module FeduxOrgStdlib
+  module Project
+    class Report
+
+      attr_reader :directory, :file
+
+      private
+
+      attr_reader :output_file, :plan, :output_directory, :generator
+
+      public
+
+      def initialize(
+        plan:, 
+        output_file:,
+        generator: FeduxOrgStdlib::Project::Generators::Taskjuggler.new
+      )
+        @plan             = plan
+        @output_directory = File.dirname(output_file)
+        @output_file      = output_file
+        @generator        = generator
+      end
+
+      def generate
+        prepare_environment
+
+        if output_file_does_not_exist? or plan_is_newer_than_output_file?
+          generator.generate_report(output_directory, plan) 
+        else
+          FeduxOrgStdlib::Project.logger.warn "No need to re-generate report. The plan file \"#{plan.to_s}\" is NOT newer than output \"#{@output_file}\"."
+        end
+      end
+
+      def open
+        Launchy.open(output_file)
+      end
+
+      private
+
+      def prepare_environment
+        FileUtils.mkdir_p output_directory
+      end
+
+      def output_file_does_not_exist?
+        !File.exists? output_file
+      end
+
+      def plan_is_newer_than_output_file?
+        plan.needs_to_be_compiled? output_file
+      end
+    end
+
+  end
+end

data/lib/fedux_org_stdlib/rake.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/rake/terminal'
+require 'fedux_org_stdlib/rake/version'
+require 'fedux_org_stdlib/rake/travis'
+require 'fedux_org_stdlib/rake/tests'
+require 'fedux_org_stdlib/rake/console'
+require 'fedux_org_stdlib/rake/documentation'
+require 'fedux_org_stdlib/rake/gems'

data/lib/fedux_org_stdlib/rake/exceptions.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module Rake
+    module Exceptions
+      # If no version file can be found
+      class VersionFileNotFound; end
+    end
+  end
+end

data/lib/{fedux_org/stdlib → fedux_org_stdlib}/rake/project.rb

@@ -1,9 +1,10 @@
-require 'fedux_org/stdlib/project'
+# encoding: utf-8
+require 'fedux_org_stdlib/project'
 
 namespace :report do
 
-  plan   = FeduxOrg::Stdlib::Project::Plan.new
-  report = FeduxOrg::Stdlib::Project::Report.new( plan )
+  plan   = FeduxOrgStdlib::Project::Plan.new
+  report = FeduxOrgStdlib::Project::Report.new( plan )
 
   desc "Generate report"
   task :generate do
@@ -14,5 +15,4 @@ namespace :report do
   task :show => :generate do
     report.open
   end
-
 end

data/lib/fedux_org_stdlib/rake/project_task.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/rake/task'
+require 'fedux_org_stdlib/project'
+
+module FeduxOrgStdlib
+  module Rake
+    # Project Task
+    #
+    # @see Rakefile
+    class ProjectTask < Task
+
+      # @!attribute [r] report
+      #   The report to be generated
+      attr_reader :report
+
+      def initialize(
+        report_file: File.join(Dir.getwd, 'reports', 'Overview.html'),
+        plan_file: File.join(Dir.getwd, 'plan.tjp'),
+        additional_files: [],
+        **args
+      )
+        super(**args)
+
+        plan    = FeduxOrgStdlib::Project::Plan.new(main_file: plan_file, additional_files: additional_files)
+        @report = FeduxOrgStdlib::Project::Report.new(plan: plan, output_file: report_file)
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/rake/shell_task.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/rake/task'
+require 'fedux_org_stdlib/require_files'
+require_library %w{ erubis }
+
+module FeduxOrgStdlib
+  module Rake
+    # Shell Task
+    #
+    # @see Rakefile
+    class ShellTask < Task
+      # @!attribute [r] command
+      #   The command to be executed
+      attr_reader :command
+
+      # @!attribute [r] use_bundler
+      #   Use bundler to run command
+      attr_reader :use_bundler
+
+      def initialize(command:, use_bundler: false, **args)
+        super(**args)
+
+        @use_bundler = use_bundler
+        @command     = command
+      end
+
+      # @private
+      def run_task(verbose)
+        logger.warn 'Gemfile does not exist. Running bundler will fail. I am going to run the command without `bundle exec`.' unless gemfile_exists?
+
+        cmd = []
+        cmd << 'bundle exec' if use_bundler and gemfile_exists?
+        cmd << command
+
+        sh Erubis::Eruby.new(cmd.join(' ')).result(get_binding)
+      end
+
+      private
+
+      def gemfile_exists?
+        !Dir.glob('Gemfile').blank?
+      end
+    end
+  end
+end