elch_scan 0.1.0

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -0,0 +1,92 @@
+module ActiveSupport
+  module NumberHelper
+    class NumberToRoundedConverter < NumberConverter # :nodoc:
+      self.namespace      = :precision
+      self.validate_float = true
+
+      def convert
+        precision = options.delete :precision
+        significant = options.delete :significant
+
+        case number
+        when Float, String
+          @number = BigDecimal(number.to_s)
+        when Rational
+          if significant
+            @number = BigDecimal(number, digit_count(number.to_i) + precision)
+          else
+            @number = BigDecimal(number, precision)
+          end
+        else
+          @number = number.to_d
+        end
+
+        if significant && precision > 0
+          digits, rounded_number = digits_and_rounded_number(precision)
+          precision -= digits
+          precision = 0 if precision < 0 # don't let it be negative
+        else
+          rounded_number = number.round(precision)
+          rounded_number = rounded_number.to_i if precision == 0
+          rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
+        end
+
+        formatted_string =
+          case rounded_number
+          when BigDecimal
+            s = rounded_number.to_s('F') + '0'*precision
+            a, b = s.split('.', 2)
+            a + '.' + b[0, precision]
+          else
+            "%01.#{precision}f" % rounded_number
+          end
+
+        delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)
+        format_number(delimited_number)
+      end
+
+      private
+
+        def digits_and_rounded_number(precision)
+          if zero?
+            [1, 0]
+          else
+            digits = digit_count(number)
+            multiplier = 10 ** (digits - precision)
+            rounded_number = calculate_rounded_number(multiplier)
+            digits = digit_count(rounded_number) # After rounding, the number of digits may have changed
+            [digits, rounded_number]
+          end
+        end
+
+        def calculate_rounded_number(multiplier)
+          (number / BigDecimal.new(multiplier.to_f.to_s)).round * multiplier
+        end
+
+        def digit_count(number)
+          (Math.log10(absolute_number(number)) + 1).floor
+        end
+
+        def strip_insignificant_zeros
+          options[:strip_insignificant_zeros]
+        end
+
+        def format_number(number)
+          if strip_insignificant_zeros
+            escaped_separator = Regexp.escape(options[:separator])
+            number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+          else
+            number
+          end
+        end
+
+        def absolute_number(number)
+          number.respond_to?(:abs) ? number.abs : number.to_d.abs
+        end
+
+        def zero?
+          number.respond_to?(:zero?) ? number.zero? : number.to_d.zero?
+        end
+    end
+  end
+end

data/lib/banana/logger.rb

@@ -0,0 +1,258 @@
+module Banana
+  # This class provides a simple logger which maintains and displays the runtime of the logger instance.
+  # It is intended to be used with the colorize gem but it brings its own colorization to eliminate a
+  # dependency. You should initialize the logger as soon as possible to get an accurate runtime.
+  #
+  # @example
+  #   logger = Banana::Logger.new
+  #   logger.log "foo"
+  #   logger.prefix = "[a] "
+  #   logger.debug "bar"
+  #   sleep 2
+  #   logger.ensure_prefix("[b] ") { logger.warn "baz" }
+  #   logger.log("rab!", :abort)
+  #
+  #   # Result:
+  #   # [00:00:00.000 INFO]     foo
+  #   # [00:00:00.000 DEBUG]    [a] bar
+  #   # [00:00:02.001 WARN]     [b] baz
+  #   # [00:00:02.001 ABORT]    [a] rab!
+  #
+  # @!attribute [r] startup
+  #   @return [DateTime] Point of time where the logger was initiated.
+  # @!attribute [r] channel
+  #   @return [Object] The object where messages are getting send to.
+  # @!attribute [r] method
+  #   @return [Object] The method used to send messages to {#channel}.
+  # @!attribute [r] logged
+  #   @return [Integer] Amount of messages send to channel.
+  #   @note This counter starts from 0 in every {#ensure_method} or {#log_with_print} block but gets
+  #     added to the main counter after the call.
+  # @!attribute timestr
+  #   @return [Boolean] Set to false if the runtime indicator should not be printed (default: true).
+  # @!attribute colorize
+  #   @return [Boolean] Set to false if output should not be colored (default: true).
+  # @!attribute prefix
+  #   @return [String] Current prefix string for logged messages.
+  class Logger
+    attr_reader :startup, :channel, :method, :logged
+    attr_accessor :colorize, :prefix
+
+    # Foreground color values
+    COLORMAP = {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+    }
+
+    # Initializes a new logger instance. The internal runtime measurement starts here!
+    #
+    # There are 4 default log levels: info (yellow), warn & abort (red) and debug (blue).
+    # All are enabled by default. You propably want to {#disable disable(:debug)}.
+    #
+    # @param scope Only for backward compatibility, not used
+    # @todo add option hash
+    def initialize scope = nil
+      @startup = Time.now.utc
+      @colorize = true
+      @prefix = ""
+      @enabled = true
+      @timestr = true
+      @channel = ::Kernel
+      @method = :puts
+      @logged = 0
+      @levels = {
+        info: { color: "yellow", enabled: true },
+        warn: { color: "red", enabled: true },
+        abort: { color: "red", enabled: true },
+        debug: { color: "blue", enabled: true },
+      }
+    end
+
+    # The default channel is `Kernel` which is Ruby's normal `puts`.
+    # Attach it to a open file with write access and it will write into
+    # the file. Ensure to close the file in your code.
+    #
+    # @param channel Object which responds to puts and print
+    def attach channel
+      @channel = channel
+    end
+
+    # Print raw message onto {#channel} using {#method}.
+    #
+    # @param [String] msg Message to send to {#channel}.
+    # @param [Symbol] method Override {#method}.
+    def raw msg, method = @method
+      @channel.send(method, msg)
+    end
+
+    # Add additional log levels which are automatically enabled.
+    # @param [Hash] levels Log levels in the format `{ debug: "red" }`
+    def log_level levels = {}
+      levels.each do |level, color|
+        @levels[level.to_sym] ||= { enabled: true }
+        @levels[level.to_sym][:color] = color
+      end
+    end
+
+    # Calls the block with the given prefix and ensures that the prefix
+    # will be the same as before.
+    #
+    # @param [String] prefix Prefix to use for the block
+    # @param [Proc] block Block to call
+    def ensure_prefix prefix, &block
+      old_prefix, @prefix = @prefix, prefix
+      block.call
+    ensure
+      @prefix = old_prefix
+    end
+
+    # Calls the block after changing the output method.
+    # It also ensures to set back the method to what it was before.
+    #
+    # @param [Symbol] method Method to call on {#channel}
+    def ensure_method method, &block
+      old_method, old_logged = @method, @logged
+      @method, @logged = method, 0
+      block.call
+    ensure
+      @method = old_method
+      @logged += old_logged
+    end
+
+    # Calls the block after changing the output method to `:print`.
+    # It also ensures to set back the method to what it was before.
+    #
+    # @param [Boolean] clear If set to true and any message was printed inside the block
+    #   a \n newline character will be printed.
+    def log_with_print clear = true, &block
+      ensure_method :print do
+        begin
+          block.call
+        ensure
+          puts if clear && @logged > 0
+        end
+      end
+    end
+
+    # Calls the block after disabling the runtime indicator.
+    # It also ensures to set back the old setting after execution.
+    def log_without_timestr &block
+      timestr, @timestr = @timestr, false
+      block.call
+    ensure
+      @timestr = timestr
+    end
+
+    # @return [Boolean] returns true if the log level format :debug is enabled.
+    def debug?
+      enabled? :debug
+    end
+
+    # If a `level` is provided it will return true if this log level is enabled.
+    # If no `level` is provided it will return true if the logger is enabled generally.
+    #
+    # @return [Boolean] returns true if the given log level is enabled
+    def enabled? level = nil
+      level.nil? ? @enabled : @levels[level.to_sym][:enabled]
+    end
+
+    # Same as {#enabled?} just negated.
+    def disabled? level = nil
+      !enabled?(level)
+    end
+
+    # Same as {#enable} just negated.
+    #
+    # @param [Symbol, String] level Loglevel to disable.
+    def disable level = nil
+      if level.nil?
+        @enabled = false
+      else
+        @levels[level.to_sym][:enabled] = false
+      end
+    end
+
+    # Enables the given `level` or the logger generally if no `level` is given.
+    # If the logger is disabled no messages will be printed. If it is enabled
+    # only messages for enabled log levels will be printed.
+    #
+    # @param [Symbol, String] level Loglevel to enable.
+    def enable level = nil
+      if level.nil?
+        @enabled = true
+      else
+        @levels[level.to_sym][:enabled] = true
+      end
+    end
+
+    # Colorizes the given string with the given color. It uses the build-in
+    # colorization feature. You may want to use the colorize gem.
+    #
+    # @param [String] str The string to colorize
+    # @param [Symbol, String] color The color to use (see {COLORMAP})
+    # @raise [ArgumentError] if color does not exist in {COLORMAP}.
+    def colorize str, color
+      ccode = COLORMAP[color.to_sym] || raise(ArgumentError, "Unknown color #{color}!")
+      "\e[#{ccode}m#{str}\e[0m"
+    end
+
+    def colorize?
+      @colorize
+    end
+
+    # This method is the only method which sends the message `msg` to `@channel` via `@method`.
+    # It also increments the message counter `@logged` by one.
+    #
+    # This method instantly returns nil if the logger or the given log level `type` is disabled.
+    #
+    # @param [String] msg The message to send to the channel
+    # @param [Symbol] type The log level
+    def log msg, type = :info
+      return if !@enabled || !@levels[type][:enabled]
+      if @levels[type.to_sym] || !@levels.key?(type.to_sym)
+        time = Time.at(Time.now.utc - @startup).utc
+        timestr = @timestr ? "[#{time.strftime("%H:%M:%S.%L")} #{type.to_s.upcase}]\t" : ""
+
+        if @colorize
+          msg = "#{colorize(timestr, @levels[type.to_sym][:color])}" <<
+                "#{@prefix}" <<
+                "#{colorize(msg, @levels[type.to_sym][:color])}"
+        else
+          msg = "#{timestr}#{@prefix}#{msg}"
+        end
+        @logged += 1
+        @channel.send(@method, msg)
+      end
+    end
+    alias_method :info, :log
+
+    # Shortcut for {#log #log(msg, :debug)}
+    #
+    # @param [String] msg The message to send to {#log}.
+    def debug msg
+      log(msg, :debug)
+    end
+
+    # Shortcut for {#log #log(msg, :warn)} but sets channel method to "warn".
+    #
+    # @param [String] msg The message to send to {#log}.
+    def warn msg
+      ensure_method(:warn) { log(msg, :warn) }
+    end
+
+    # Shortcut for {#log #log(msg, :abort)} but sets channel method to "warn".
+    #
+    # @param [String] msg The message to send to {#log}.
+    # @param [Integer] exit_code Exits with given code or does nothing when falsy.
+    def abort msg, exit_code = false
+      ensure_method(:warn) { log(msg, :abort) }
+      exit(exit_code) if exit_code
+    end
+  end
+end

data/lib/elch_scan/application/dispatch.rb

@@ -0,0 +1,190 @@
+module ElchScan
+  class Application
+    module Dispatch
+      def dispatch action = (@opts[:dispatch] || :help)
+        case action
+          when :help then @optparse.to_s.split("\n").each(&method(:log))
+          when :version, :info then dispatch_info
+          else
+            if respond_to?("dispatch_#{action}")
+              send("dispatch_#{action}")
+            else
+              abort("unknown action #{action}", 1)
+            end
+        end
+      end
+
+      def dispatch_generate_config
+        if File.exist?(@config_src)
+          log "Configuration already exists, please delete it do generate another one."
+        else
+          FileUtils.cp("#{ROOT}/doc/config.yml", @config_src)
+          log "Sample configuration created!"
+          log "You will need to add at least 1 one movie directory."
+          answer = ask("Do you want to open the configuration file now? [Yes/no]")
+          if ["", "y", "yes"].include?(answer.downcase)
+            if RUBY_PLATFORM.include?("darwin")
+              exec("open #{@config_src}")
+            else
+              system "#{cfg :application, :editor} #{@config_src}"
+            end
+          end
+        end
+      end
+
+      def dispatch_info
+        logger.log_without_timestr do
+          log ""
+          log "     Your version: #{your_version = Gem::Version.new(ElchScan::VERSION)}"
+
+          # get current version
+          logger.log_with_print do
+            log "  Current version: "
+            if cfg("application.check_version")
+              require "net/http"
+              log c("checking...", :blue)
+
+              begin
+                current_version = Gem::Version.new Net::HTTP.get_response(URI.parse(ElchScan::UPDATE_URL)).body.strip
+
+                if current_version > your_version
+                  status = c("#{current_version} (consider update)", :red)
+                elsif current_version < your_version
+                  status = c("#{current_version} (ahead, beta)", :green)
+                else
+                  status = c("#{current_version} (up2date)", :green)
+                end
+              rescue
+                status = c("failed (#{$!.message})", :red)
+              end
+
+              logger.raw "#{"\b" * 11}#{" " * 11}#{"\b" * 11}", :print # reset cursor
+              log status
+            else
+              log c("check disabled", :red)
+            end
+          end
+
+          # more info
+          log ""
+          log "  ElchScan is brought to you by #{c "bmonkeys.net", :green}"
+          log "  Contribute @ #{c "github.com/2called-chaos/elch_scan", :cyan}"
+          log "  Eat bananas every day!"
+          log ""
+        end
+      end
+
+      def dispatch_edit_script
+        record_filter(filter_script(@opts[:select_script]))
+      end
+
+      def dispatch_index
+        if cfg(:movies).empty?
+          log "You will need at least 1 one movie directory defined in your configuration."
+          answer = ask("Do you want to open the file now? [Yes/no]")
+          if ["", "y", "yes"].include?(answer.downcase)
+            if RUBY_PLATFORM.include?("darwin")
+              exec("open #{@config_src}")
+            else
+              system "#{cfg :application, :editor} #{@config_src}"
+            end
+          end
+        else
+          movies = _index_movies(cfg(:movies))
+          old_count = movies.count
+          return log("No movies found :(") if old_count.zero?
+          log(
+            "We have found " << c("#{movies.count}", :magenta) <<
+            c(" movies in ") << c("#{cfg(:movies).count}", :magenta) << c(" directories")
+          )
+
+          if @opts[:console]
+            log "You have access to the collection with " << c("movies", :magenta)
+            log "Apply existent select script with " << c("apply_filter(movies, 'filter_name')", :magenta)
+            log "Type " << c("exit", :magenta) << c(" to leave the console.")
+            binding.pry(quiet: true)
+          else
+            # ask to filter
+            if !@opts[:quiet] && @opts[:select_scripts].empty?
+              answer = ask("Do you want to filter the results? [yes/No]")
+              if ["y", "yes"].include?(answer.downcase)
+                movies = apply_filter(movies, record_filter)
+                old_count = movies.count
+                collection_size_changed old_count, movies.count, "custom filter"
+              end
+            end
+
+            # filter
+            @opts[:select_scripts].each do |filter|
+              movies = apply_filter(movies, filter_script(filter))
+              collection_size_changed old_count, movies.count, "filter: #{filter}"
+              old_count = movies.count
+            end
+
+            # permute
+            permute_script(movies) if @opts[:permute]
+
+            # ask to save
+            if !@opts[:quiet] && !@opts[:output_file]
+              answer = ask("Enter filename to save output or leave blank to print to STDOUT:")
+              if !answer.empty?
+                @opts[:output_file] = answer
+              end
+            end
+
+            # format results
+            begin
+              formatter = "ElchScan::Formatter::#{@opts[:formatter]}".constantize.new(self)
+            rescue LoadError
+              warn "Unknown formatter " << c("#{@opts[:formatter]}", :magenta) << c(", using Plain...", :red)
+              formatter = "ElchScan::Formatter::Plain".constantize.new(self)
+            end
+            results = formatter.format(movies)
+
+            # save
+            if @opts[:output_file]
+              File.open(@opts[:output_file], "w+") {|f| f.write(results.join("\n")) }
+            else
+              logger.log_without_timestr do
+                results.each {|line| log line }
+              end
+            end
+          end
+        end
+      end
+
+      def collection_size_changed cold, cnew, reason = nil
+        if cold != cnew
+          log(
+            "We have filtered " << c("#{cnew}", :magenta) <<
+            c(" movies") << c(" (#{cnew - cold})", :red) <<
+            c(" from originally ") << c("#{cold}", :magenta) <<
+            (reason ? c(" (#{reason})", :blue) : "")
+          )
+        end
+      end
+
+      def _index_movies directories
+        directories.each_with_object({}) do |dir, result|
+          if FileTest.directory?(dir)
+            Find.find(dir) do |path|
+              # calculate depth
+              depth = path.scan(?/).count - dir.scan(?/).count
+              depth -= 1 unless File.directory?(path)
+
+              if depth == 1 && File.directory?(path)
+                result[File.basename(path)] = Movie.new(
+                  self,
+                  dir: dir,
+                  path: path,
+                )
+              end
+            end
+          else
+            log(c("Directory unreadable, skipping ", :red) << c("#{dir}", :magenta))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elch_scan/application/filter.rb

@@ -0,0 +1,34 @@
+module ElchScan
+  module Filter
+    def filter_script name
+      "#{ROOT}/tmp/#{name}.esss"
+    end
+
+    def apply_filter collection, file
+      app = @app
+      eval File.read(file), binding, file
+      collection
+    end
+
+    def permute_script collection, file = nil
+      file ||= "#{Dir.tmpdir}/#{SecureRandom.urlsafe_base64}"
+      FileUtils.mkdir(File.dirname(file)) if !File.exist?(File.dirname(file))
+      if !File.exist?(file) || File.read(file).strip.empty?
+        File.open(file, "w") {|f| f.puts("# Permute your collection, same as with the selector script filters.") }
+      end
+      system "#{cfg :application, :editor} #{file}"
+      eval File.read(file), binding, file
+      collection
+    end
+
+    def record_filter file = nil
+      file ||= "#{Dir.tmpdir}/#{SecureRandom.urlsafe_base64}"
+      FileUtils.mkdir(File.dirname(file)) if !File.exist?(File.dirname(file))
+      if !File.exist?(file) || File.read(file).strip.empty?
+        FileUtils.cp("#{ROOT}/doc/filter.rb", file)
+      end
+      system "#{cfg :application, :editor} #{file}"
+      file
+    end
+  end
+end

data/lib/elch_scan/application.rb

@@ -0,0 +1,125 @@
+module ElchScan
+  # Logger Singleton
+  MAIN_THREAD = ::Thread.main
+  def MAIN_THREAD.app_logger
+    MAIN_THREAD[:app_logger] ||= Banana::Logger.new
+  end
+
+  class Application
+    include Dispatch
+    include Filter
+
+    # =========
+    # = Setup =
+    # =========
+    def self.dispatch *a
+      new(*a) do |app|
+        app.load_config "~/.elch_scan.yml"
+        app.apply_config
+        app.parse_params
+        app.dispatch
+      end
+    end
+
+    def initialize env, argv
+      @env, @argv = env, argv
+      @opts = {
+        dispatch: :index,
+        quiet: false,
+        output_file: nil,
+        formatter: "Plain",
+        select_scripts: [],
+      }
+      yield(self)
+    end
+
+    def parse_params
+      @optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: elch_scan [options]"
+
+        opts.on("--generate-config", "Generate sample configuration file in ~/.elch_scan.yml") { @opts[:dispatch] = :generate_config }
+        opts.on("-h", "--help", "Shows this help") { @opts[:dispatch] = :help }
+        opts.on("-v", "--version", "Shows version and other info") { @opts[:dispatch] = :info }
+        opts.on("-f", "--formatter HTML", "Use formatter") {|f| @opts[:formatter] = f }
+        opts.on("-o", "--output FILENAME", "Write formatted results to file") {|f| @opts[:output_file] = f }
+        opts.on("-e", "--edit SELECT_SCRIPT", "Edit selector script") {|s| @opts[:dispatch] = :edit_script; @opts[:select_script] = s }
+        opts.on("-s", "--select [WITH_SUBS,NO_NFO]", Array, "Filter movies with saved selector scripts") {|s| @opts[:select_scripts] = s }
+        opts.on("-p", "--permute", "Open editor to write permutation code for collection") {|s| @opts[:permute] = true }
+        opts.on("-q", "--quiet", "Don't ask to filter or save results") { @opts[:quiet] = true }
+        opts.on("-c", "--console", "Start console to play around with the collection") {|f| @opts[:console] = true }
+      end
+
+      begin
+        @optparse.parse!(@argv)
+      rescue OptionParser::ParseError => e
+        abort(e.message)
+        dispatch(:help)
+        exit 1
+      end
+    end
+
+    def load_config file
+      @config_src = File.expand_path(file)
+      @config = YAML.load_file(@config_src)
+      raise "empty config" if !@config || @config.empty? || !@config.is_a?(Hash)
+      @config = @config.with_indifferent_access
+    rescue Exception => e
+      if e.message =~ /no such file or directory/i
+        if @argv.include?("--generate-config")
+          @config = { application: { logger: { colorize: true } } }.with_indifferent_access
+        else
+          log "Please create or generate a configuration file."
+          log(
+            c("Use ") << c("elch_scan --generate-config", :magenta) <<
+            c(" or create ") << c("~/.elch_scan.yml", :magenta) << c(" manually.")
+          )
+          abort "No configuration file found.", 1
+        end
+      elsif e.message =~ //i
+        abort "Configuration file is invalid.", 1
+      else
+        raise
+      end
+    end
+
+    def apply_config
+      logger.colorize = cfg(:application, :logger, :colorize)
+      (cfg(:formatters) || []).each do |f|
+        begin
+          require File.expand_path(f)
+        rescue LoadError
+          abort "The custom formatter file wasn't found: " << c("#{f}", :magenta)
+        end
+      end
+    end
+
+    def cfg *keys
+      keys = keys.flatten.join(".").split(".")
+      keys.inject(@config) {|cfg, skey| cfg.try(:[], skey) }
+    end
+
+    # ==========
+    # = Logger =
+    # ==========
+    [:log, :warn, :abort, :debug].each do |meth|
+      define_method meth, ->(*a, &b) { Thread.main.app_logger.send(meth, *a, &b) }
+    end
+
+    def logger
+      Thread.main.app_logger
+    end
+
+    # Shortcut for logger.colorize
+    def c str, color = :yellow
+      logger.colorize? ? logger.colorize(str, color) : str
+    end
+
+    def ask question
+      logger.log_with_print(false) do
+        log c("#{question} ", :blue)
+        STDOUT.flush
+        gets.chomp
+      end
+    end
+  end
+end