ruby-jobs 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6997cd1ced4df1ccabb37b460026977a393a06f
+  data.tar.gz: 9c8968f82980eaad85b4a1dcaa3693f39806bba6
+SHA512:
+  metadata.gz: 1f8575e84d7d2e454707a13b3623b1fffaefc578c56fdc91b1ecbed8953de5f2504fa49e9db17096f0fc34ec2afeb5c3aa5e2334ee193db2ae5727c72e60c32d
+  data.tar.gz: 5cb4943b59e93608959e94ca0ceead2dff728f43408ac3ebfb71cc7a013959e6290fb46582525019ad6ef866b089d87d6917402a13282e205d52f3fddd8f1a92

data/lib/job_base/job.rb

@@ -0,0 +1,228 @@
+require_relative 'job_logging'
+
+module RubyJobs
+  module JobBase
+    class Job
+      include JobLogging
+
+      @@bootstrapped = false
+      @@requires_rails = nil
+      @@puts_overridden = false
+
+      def initialize(defaults=nil)
+        @values = self.class.defaults.dup
+        @values.merge! defaults unless defaults.nil?
+      end
+
+      def instance
+        @instance
+      end
+
+      def job_name
+        self.class.name.gsub(/([^$])([A-Z])/, '\1_\2').downcase # underscore without rails
+      end
+
+      def run(values=nil, &block)
+        @running = true
+
+        puts_block = @puts_block || self.class.puts_block
+        if puts_block && !@@puts_overridden
+          @@puts_overridden = true
+          @puts_overridden = true
+
+          Kernel.send(:define_method, :puts) do |m|
+            puts_block.call m
+            nil
+          end
+        end
+
+        @values.merge! values unless values.nil?
+        if block_given?
+          block_values = instance_exec @values, &block
+          @values.merge! block_values if block_values.is_a? Hash
+        end
+
+        result = instance_exec @values, &self.class.block
+
+        @running = false
+
+        if @puts_overridden
+          Kernel.send :remove_method, :puts
+          Kernel.send :alias_method, :puts, :_puts
+          @puts_overridden = false
+          @@puts_overridden = false
+        end
+
+        result
+      end
+
+      class << self
+        def initialize
+          unless @initialized
+            @initialized = true
+            @defaults = {}
+            @default_blocks = {}
+            @instance_hashes = {}
+            @instance_blocks = {}
+            @loaded_rails = false
+            load_rails if @@requires_rails || @@requires_rails.nil?
+          end
+        end
+
+        def defaults
+          default_blocks = @default_blocks.dup
+          @default_blocks = {}
+          default_blocks.each do |k,b|
+            if k.nil?
+              b.call.each do |key, value|
+                @defaults[key] = value
+              end
+            else
+              @defaults[k] = b.call
+            end
+          end
+          @defaults
+        end
+
+        attr_reader :instance_hashes, :instance_blocks, :puts_block, :block
+
+        def run(instance_or_values=nil, &block)
+          initialize
+          if instance_or_values.is_a? Hash
+            values = instance_or_values
+            job = self.new
+            job.run values, &block
+          else
+            instance = instance_or_values
+            run = true
+            if block_given?
+              @block = block
+              if !@@bootstrapped && (!defined?(Rails) || @loaded_rails)
+                instance = ARGV.first || instance
+                @@bootstrapped = true
+              else
+                run = false
+              end
+            end
+
+            if run
+              job = self.new
+              job.load_instance instance.to_sym if instance
+              job.run
+            end
+          end
+        end
+
+        def rails
+          load_rails
+          return yield Rails if block_given?
+          Rails
+        end
+
+        def load_rails
+          initialize
+          begin
+            load_rails = require_relative File.expand_path('config/boot', APP_ROOT)
+            load_rails &&= require APP_PATH
+            if load_rails
+              puts "loading rails..."
+              Rails.application.require_environment!
+              return @loaded_rails = true
+            end
+            false
+          rescue Exception
+            false
+          end
+        end
+
+        def instance(name=nil, hash=nil, &block)
+          initialize
+          if name
+            @instance_hashes[name] = hash unless hash.nil?
+            @instance_blocks[name] = block
+          end
+        end
+
+        def default(key=nil, value=nil, &block)
+          initialize
+          if value.nil? && block_given?
+            @default_blocks[key] = block
+          else
+            if value.nil? && key.is_a?(Hash)
+              key.each do |key, value|
+                @defaults[key] = value
+              end
+            else
+              @defaults[key] = value
+            end
+          end
+        end
+
+        def requires_rails=(value)
+          @@requires_rails ||= value
+        end
+
+        def define_puts(&block)
+          initialize
+          @puts_block = block
+        end
+
+        def const_missing(const)
+          initialize
+          value = defaults[const.to_s.downcase.to_sym]
+          value.nil? ? Object.const_get(const) : value
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if method.to_s.end_with? "="
+          @values[method.to_s[0..-2].to_sym] = args.first
+        elsif @values.include? method
+          @values[method]
+        else
+          super
+        end
+      end
+
+      def const_missing(const)
+        @values[const.to_s.downcase.to_sym]
+      end
+
+      def define_puts(&block)
+        if block_given?
+          @puts_block = block
+          if @running && (!@@puts_overridden || @puts_overridden)
+            @@puts_overridden = true
+            @puts_overridden = true
+            Kernel.send(:define_method, :puts) do |m|
+              block.call m
+              nil
+            end
+          end
+        end
+      end
+      alias_method :def_puts, :define_puts
+
+      def _puts(message)
+        if @puts_overridden
+          super
+          message
+        else
+          puts(message)
+        end
+      end
+
+      def load_instance(instance, values={})
+        @values.merge! self.class.instance_hashes[instance].merge(values) if self.class.instance_hashes.include?(instance)
+        block = self.class.instance_blocks[instance]
+        if block
+          block_values = instance_exec @values, &block
+          @values.merge! block_values if block_values.is_a? Hash
+        end
+        @instance = instance
+      end
+
+      Kernel.send :alias_method, :_puts, :puts
+    end
+  end
+end

data/lib/job_base/job_logging.rb

@@ -0,0 +1,43 @@
+require_relative '../logging/plain_logger'
+require_relative '../logging/progress_logger'
+
+module RubyJobs
+  module JobBase
+    module JobLogging
+      def logger(type, logger_id=nil, logger_name=nil)
+        @loggers ||= {}
+        loggers_of_type = (@loggers[type] ||= {})
+
+        logger_class = "#{type}Logger"
+        logger_class[0] = logger_class[0].upcase
+
+        base_name = job_name
+        base_name += "_#{instance}" unless instance.nil? || instance.empty?
+        logger_name ||= (logger_id ? "#{base_name}_#{logger_id}" : base_name)
+        logger = (loggers_of_type[logger_id] ||= Logging.const_get(logger_class).new(logger_name))
+
+        if block_given?
+          yield logger
+        end
+
+        logger
+      end
+
+      def init_logger(id_or_name, name=nil, type=:plain)
+        logger(type, id_or_name.to_sym, name || id_or_name.to_s)
+      end
+
+      def log(*messages)
+        return logger(:plain) if messages.empty?
+        return logger(:plain, messages.first).log *messages.drop(1) if messages.first.is_a? Symbol || messages.first.nil?
+        logger(:plain).log *messages
+      end
+
+      def progress(*messages, &block)
+        return logger(:progress) if messages.empty?
+        return logger(:progress, messages.first).log *messages.drop(1) if messages.first.is_a? Symbol
+        block_given? ? logger(:progress).log(*messages, &block) : logger(:progress).log(*messages)
+      end
+    end
+  end
+end

data/lib/logging/plain_logger.rb

@@ -0,0 +1,92 @@
+require 'fileutils'
+
+module RubyJobs
+  module Logging
+    class PlainLogger
+      DEFAULT_PATH = "log/plain"
+
+      def initialize(*names)
+        @names = names.compact
+        @path = DEFAULT_PATH
+        @time_prefix = true
+        @print_timestamp = false
+        @write_file = true
+      end
+
+      attr_accessor :path, :time_prefix, :separator, :extension, :print_timestamp
+
+      def file(&block)
+        File.open(file_path, 'a+', &block)
+      end
+
+      def exist?
+        File.exist? file_path
+      end
+
+      def log_dir
+        dir = File.expand_path(@path, APP_ROOT)
+        FileUtils.mkpath dir
+        dir
+      end
+
+      def file_path
+        File.join(log_dir, file_name)
+      end
+
+      def file_name
+        return @file_name if @file_name
+
+        file_name = ""
+        if @time_prefix
+          file_name << Time.now.strftime("%Y%m%d%H%M%S")
+          file_name << "_"
+        end
+        file_name << @names.map{|w| w.to_s.gsub(/^[\W_]*|[\W_]*$/, '').gsub(/[\W_]+/, '_')}.join("_")
+        file_name << ".#{extension}" if extension
+        @file_name = file_name
+      end
+
+      def puts(message)
+        if @puts
+          if @clear_puts
+            @puts.call ((@last_message ? (("\b" * @last_message.length) + message) : message)), file_name
+          else
+            @puts.call @separator if @separater
+            @puts.call message, file_name
+          end
+          @last_message = message
+        end
+
+        if @write_file
+          file do |file|
+            file.puts @separator if @separater
+            file.puts message
+          end
+        end
+      end
+
+      def def_puts(write_file=false, clear=false, &block)
+        @clear_puts = clear
+        @write_file = write_file
+        if block_given?
+          @puts = block
+        else
+          @puts = clear ? Proc.new{|m| print m} : Proc.new{|m| Kernel.puts m}
+        end
+      end
+
+      def timestamp
+        "[#{Time.now.strftime "%Y-%m-%d %H:%M:%S"}]"
+      end
+
+      def log(*message)
+        message = message.map(&:to_s).join(" ")
+        message = "#{timestamp} - #{message}" if @print_timestamp
+
+        puts message
+
+        message
+      end
+    end
+  end
+end

data/lib/logging/progress_logger.rb

@@ -0,0 +1,52 @@
+module RubyJobs
+  module Logging
+    class ProgressLogger < PlainLogger
+      PATH = "log/progress"
+
+      def initialize(*names)
+        super
+        @path = PATH
+        @start = 0.0
+        @end = 100.0
+        @progress = 0.0
+        @progress_key = :count
+        @print_timestamp = true
+      end
+
+      attr_accessor :progress, :progress_key
+      attr_reader :start, :end
+
+      def start=(value)
+        @start = value.to_f
+      end
+
+      def end=(value)
+        @end = value.to_f
+      end
+
+      def log(progress, *message)
+        if progress.is_a?(Hash) && progress.include?(@progress_key)
+          @progress = (progress[@progress_key].to_f - @start) / (@end - @start) * 100.0
+          message = ([progress] + message)
+        elsif !progress.is_a?(String) && progress.respond_to?(:to_f)
+          @progress = (progress.to_f - @start) / (@end - @start) * 100.0
+          message = [progress] if message.empty?
+        else
+          message = ([progress] + message)
+        end
+
+        if @print_timestamp
+          @print_timestamp = false
+          messsage = super @progress.to_i, "%", timestamp, "-", *message
+          @print_timestamp = true
+        else
+          messsage = super @progress.to_i, "%", *message
+        end
+
+        yield @progress, message if block_given?
+
+        messsage
+      end
+    end
+  end
+end

data/lib/ruby-jobs.rb

@@ -0,0 +1,5 @@
+APP_ROOT ||= (Rails rescue nil).nil? ? Dir.pwd : Rails.root
+APP_PATH ||= File.expand_path('config/application', APP_ROOT)
+
+require_relative 'job_base/job.rb'
+

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: ruby-jobs
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Helge Holzmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-30 00:00:00.000000000 Z
+dependencies: []
+description: A simple way to run jobs, wether simple scripts or experiments for you
+  reserach. You can log results and progress without a hassle and experiment with
+  different configurations.
+email: helgeho@invelop.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/job_base/job.rb
+- lib/job_base/job_logging.rb
+- lib/logging/plain_logger.rb
+- lib/logging/progress_logger.rb
+- lib/ruby-jobs.rb
+homepage: https://github.com/helgeho/ruby-jobs
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Get your jobs done in ruby.
+test_files: []