teuton-get 0.1.0

data/lib/teuton-get/repo/local_repo.rb

@@ -0,0 +1,70 @@
+require_relative "../application"
+require_relative "../writer/file_writer"
+require_relative "../writer/terminal_writer"
+
+class LocalRepo
+  def initialize(args)
+    @repoindex_writer = args[:repoindex_writer]
+    @dev = args[:progress_writer]
+  end
+
+  def self.new_by_default
+    LocalRepo.new(
+      repoindex_writer: FileWriter.new,
+      progress_writer: TerminalWriter.new
+    )
+  end
+
+  def create(dirpath)
+    infofilename = Application::INFOFILENAME
+    infofiles = Dir.glob(File.join(dirpath, "**", infofilename))
+    return if infofiles.size.zero?
+
+    @dev.writeln "\n==> Creating repository", color: :light_yellow
+    data = read_files(infofiles)
+
+    filepath = File.join(dirpath, Application::INDEXFILENAME)
+    @repoindex_writer.open(filepath)
+    @repoindex_writer.write data.to_yaml
+    @repoindex_writer.close
+
+    @dev.writeln "    Created file #{filepath} with #{data.keys.size} tests.", color: :white
+    true
+  end
+
+  private
+
+  def read_files(infofiles)
+    data = {}
+    infofiles.each do |filepath|
+      cleanpath = filepath
+      if cleanpath.start_with? "./"
+        # delete 2 chars at the begining. Example: "./"
+        cleanpath[0, 2] = ""
+      end
+      infodata = LocalInfo.new(@dev).read(cleanpath)
+      dirpath = File.dirname(cleanpath)
+      data[dirpath] = infodata
+    end
+    data
+  end
+
+  def copyfile(target, dest)
+    if File.exist? dest
+      @dev.write "    WARN: exits file "
+      @dev.writeln dest, color: :light_yellow
+      return true
+    end
+    begin
+      FileUtils.cp(target, dest)
+      @dev.write "===> Created file "
+      @dev.writeln dest, color: :light_green
+      true
+    rescue => e
+      @dev.write "    ERROR: Creating file "
+      @dev.writeln dest, color: :light_red
+      puts e
+      false
+    end
+  end
+end

data/lib/teuton-get/repo/repo_config.rb

@@ -0,0 +1,92 @@
+require "fileutils"
+require_relative "../application"
+require_relative "../reader/inifile_reader"
+require_relative "../writer/terminal_writer"
+
+class RepoConfig
+  attr_reader :data
+
+  def initialize(args)
+    @reader = args[:config_reader]
+    @data = @reader.read
+    @dev = args[:progress_writer]
+
+    @config_dirpath = args[:config_dirpath] || ""
+    @config_filepath = File.join(@config_dirpath, Application::CONFIGFILE)
+  end
+
+  def self.new_by_default
+    config_filepath = Application.instance.get(:config_filepath)
+
+    RepoConfig.new(
+      config_reader: IniFileReader.new(config_filepath),
+      progress_writer: TerminalWriter.new,
+      config_dirpath: Application.instance.get(:config_dirpath)
+    )
+  end
+
+  def create
+    @dev.writeln "\n==> Creating configuration files", color: :light_yellow
+    create_dir
+    create_ini_file
+  end
+
+  def show_list
+    rows = []
+    rows << ["E", "NAME", "DESCRIPTION"]
+    rows << :separator
+
+    @data.each_pair do |key, value|
+      enable = "\u{2714}"
+      enable = " " unless value["enable"]
+      description = value["description"] || "?"
+      rows << [enable, key, description]
+    end
+    @dev.writeln "Repository list"
+    @dev.write_table(rows)
+    @dev.write "Config: "
+    @dev.writeln "#{@reader.source}\n", color: :white
+  end
+
+  private
+
+  def create_dir
+    dirpath = @config_dirpath
+    if Dir.exist? dirpath
+      @dev.write "    \u{2716} Exists dir!      : "
+      @dev.writeln dirpath, color: :yellow
+    else
+      begin
+        FileUtils.mkdir_p(dirpath)
+        @dev.write "    \u{2714} Create dir       : "
+        @dev.writeln dirpath, color: :green
+      rescue => e
+        @dev.write "    \u{2716} Create dir  ERROR: "
+        @dev.writeln dirpath, color: :red
+        puts e
+      end
+    end
+  end
+
+  def create_ini_file
+    src = File.join(File.dirname(__FILE__), "..", "files", Application::CONFIGFILE)
+    copyfile(src, @config_filepath)
+  end
+
+  def copyfile(target, dest)
+    if File.exist? dest
+      @dev.write "    \u{2716} Exists file!     : "
+      @dev.writeln dest, color: :yellow
+      return true
+    end
+    begin
+      FileUtils.cp(target, dest)
+      @dev.write "    \u{2714} Create file      : "
+      @dev.writeln dest, color: :green
+    rescue => e
+      @dev.write "    \u{2716} Create file ERROR: "
+      @dev.writeln dest, color: :red
+      puts e
+    end
+  end
+end

data/lib/teuton-get/repo/repo_data.rb

@@ -0,0 +1,126 @@
+require "yaml"
+require_relative "../application"
+require_relative "../reader/url_reader"
+require_relative "../reader/inifile_reader"
+require_relative "../reader/yaml_reader"
+
+class RepoData
+  attr_reader :data
+
+  def initialize(args)
+    @reader = args[:config_reader]
+    @data = @reader.read
+    @dev = args[:progress_writer]
+    @cache_dirpath = args[:cache_dirpath]
+  end
+
+  def self.new_by_default
+    config_filepath = Application.instance.get(:config_filepath)
+    RepoData.new(
+      config_reader: IniFileReader.new(config_filepath),
+      progress_writer: TerminalWriter.new,
+      cache_dirpath: Application.instance.get(:cache_dirpath)
+    )
+  end
+
+  def refresh
+    @database = {}
+    dirpath = @cache_dirpath
+    FileUtils.rm_r(dirpath) if Dir.exist? dirpath
+
+    @dev.writeln "\n==> Refreshing active repos", color: :light_yellow
+    @data.keys.sort.each do |key|
+      refresh_repo key
+    end
+    save_database
+  end
+
+  def get(test_id)
+    reponame, id = test_id.split(Application::SEPARATOR)
+    database = YamlReader.new.read(database_filename)
+    return {} if database[reponame].nil?
+    database[reponame][id]
+  end
+
+  def show_testinfo(item)
+    return unless item
+    @dev.writeln ""
+    ["name", "author", "date", "desc"].each do |key|
+      @dev.write "#{key.ljust(7)} : ", color: :white
+      @dev.writeln item[key].to_s
+    end
+    ["tags", "files"].each do |key|
+      next if item[key].nil?
+      @dev.write "#{key.ljust(7)} : ", color: :white
+      @dev.writeln item[key].join(", ")
+    end
+  end
+
+  def database_filename
+    # REVISE: Used by teutonget search... replace by #get()
+    File.join(@cache_dirpath, "database.yaml")
+  end
+
+  private
+
+  def refresh_repo(reponame)
+    unless enabled? reponame
+      @dev.writeln "    \u{2716} Skiping repo #{reponame}"
+      return false
+    end
+    dirpath = File.join(@cache_dirpath)
+    ok1 = create_dir(dirpath)
+    ok2 = get_database(reponame)
+
+    @dev.writeln "    \u{2714} Repo #{reponame} (#{ok2.size} tests)"
+
+    true && ok1 && ok2
+  end
+
+  def enabled?(reponame)
+    @data[reponame]["enable"] == true
+  end
+
+  def create_dir(dirpath)
+    unless Dir.exist? dirpath
+      begin
+        FileUtils.mkdir_p(dirpath)
+        return true
+      rescue => e
+        @dev.write "* Create dir  ERROR => "
+        @dev.writeln dirpath, color: :red
+        puts e
+        return false
+      end
+    end
+    false
+  end
+
+  def get_database(reponame)
+    data = @data[reponame]
+
+    @database[reponame] = if data["URL"].start_with? "http"
+      get_remote_database(data["URL"])
+    else
+      get_local_database(data["URL"])
+    end
+  end
+
+  def get_local_database(dirpath)
+    filepath = File.join(dirpath, Application::INDEXFILENAME)
+    @reader.read(filepath)
+  end
+
+  def get_remote_database(url_repo)
+    url_file = "#{url_repo}/#{Application::INDEXFILENAME}"
+    content_page = URLReader.new(url_file).read
+    YAML.safe_load(
+      content_page,
+      permitted_classes: [Array, Date, Hash, Symbol]
+    )
+  end
+
+  def save_database
+    File.write(database_filename, @database.to_yaml)
+  end
+end

data/lib/teuton-get/searcher/result.rb

@@ -0,0 +1,21 @@
+require_relative "../application"
+
+class Result
+  attr_accessor :score
+  attr_reader :reponame
+  attr_reader :testname
+
+  def initialize(args)
+    @score = args[:score] || 0
+    @reponame = args[:reponame] || "???"
+    @testname = args[:testname] || "???"
+  end
+
+  def id
+    "#{reponame}#{Application::SEPARATOR}#{testname}"
+  end
+
+  def to_h
+    {score: @score, id: id, reponame: @reponame, testname: @testname}
+  end
+end

data/lib/teuton-get/searcher.rb

@@ -0,0 +1,142 @@
+require_relative "application"
+require_relative "reader/yaml_reader"
+require_relative "repo/repo_data"
+require_relative "searcher/result"
+require_relative "writer/terminal_writer"
+
+class Searcher
+  def initialize(args)
+    @dev = args[:writer]
+
+    @repodata = args[:repodata]
+    filename = @repodata.database_filename
+
+    @reader = args[:reader]
+    @database = @reader.read(filename)
+
+    @results = {}
+  end
+
+  def self.new_by_default
+    Searcher.new(
+      writer: TerminalWriter.new,
+      repodata: RepoData.new_by_default,
+      reader: YamlReader.new
+    )
+  end
+
+  def get(input)
+    reponame_filter, filters = parse_input(input)
+    search_inside(reponame_filter, filters)
+  end
+
+  def show(result)
+    @results.each do |i|
+      @dev.write "(x#{i[:score]}) ", color: :white
+      @dev.writeln "#{i[:reponame]}#{Application::SEPARATOR}#{i[:testname]}"
+    end
+  end
+
+  private
+
+  def parse_input(input)
+    reponame_filter = :all
+    filter = :all
+    options = input.split(Application::SEPARATOR)
+    if options.size == 1
+      reponame_filter = :all
+      filter = options[0]
+    elsif options[0] == ""
+      reponame_filter = :all
+      filter = options[1]
+    elsif options.size == 2
+      reponame_filter = options[0]
+      filter = options[1]
+    end
+    reponame_filter = :all if reponame_filter == "ALL"
+    filters = if filter == "ALL"
+      :all
+    else
+      filter.split(",")
+    end
+    [reponame_filter, filters]
+  end
+
+  def search_inside(reponame_filter, filters)
+    @results = {}
+    if reponame_filter == :all
+      @database.keys.each { |reponame| search_inside_repo(reponame, filters) }
+    else
+      @database.keys.each do |reponame|
+        search_inside_repo(reponame, filters) if reponame.include? reponame_filter
+      end
+    end
+    sort_results
+  end
+
+  def search_inside_repo(reponame, filters)
+    return if reponame != :all && @database[reponame].nil?
+
+    @database[reponame].each do |testname, data|
+      result = Result.new(
+        score: 0,
+        reponame: reponame,
+        testname: testname
+      )
+      if filters == :all
+        add_result(result)
+        next
+      end
+      score = 0
+      filters.each do |filter|
+        score += evaluate_test(
+          testname: testname,
+          data: data,
+          filter: filter
+        )
+        if score > 0
+          result.score = score
+          add_result result
+        end
+      end
+    end
+  end
+
+  def evaluate_test(args)
+    testname = args[:testname]
+    data = args[:data]
+    filter = args[:filter]
+
+    score = 0
+    data.each_pair do |key, value|
+      if value.instance_of? String
+        score += 1 if value.downcase.include? filter
+      elsif value.instance_of? Date
+        score += 1 if value.to_s.include? filter
+      elsif value.instance_of? Array
+        score += 1 if value.include? filter
+      end
+    end
+    score += 1 if testname.include? filter
+    score
+  end
+
+  def add_result(result)
+    key = result.id
+    if @results[key].nil?
+      @results[key] = result
+      return
+    end
+    @results[key].score += result.score
+  end
+
+  def sort_results
+    results = []
+    @results.each_pair { |key, value| results += [value.to_h] }
+
+    results.sort_by! do |i|
+      [(Application::MAGICNUMBER - i[:score]), i[:id]]
+    end
+    @results = results
+  end
+end

data/lib/teuton-get/version.rb

@@ -0,0 +1,6 @@
+module Version
+  NAME = "teuton-get"
+  EXECUTABLE = "teutonget"
+  VERSION = "0.1.0"
+  HOMEPAGE = "https://github.com/teuton-software/#{NAME}"
+end

data/lib/teuton-get/writer/file_writer.rb

@@ -0,0 +1,19 @@
+require_relative "writer"
+
+class FileWriter < Writer
+  def open(filepath)
+    @file = File.open(filepath, "w")
+  end
+
+  def write(text)
+    @file.write text
+  end
+
+  def writeln(text)
+    @file.write text
+  end
+
+  def close
+    @file.close
+  end
+end

data/lib/teuton-get/writer/null_writer.rb

@@ -0,0 +1,15 @@
+require_relative "writer"
+
+class NullWriter < Writer
+  def write(text = "", args = {})
+    # Nothing
+  end
+
+  def writeln(text = "", args = {})
+    # Nothing
+  end
+
+  def write_table(rows)
+    # Nothing
+  end
+end

data/lib/teuton-get/writer/terminal_writer.rb

@@ -0,0 +1,20 @@
+require "colorize"
+require "tty-table"
+require_relative "writer"
+
+class TerminalWriter < Writer
+  def write(text = "", args = {})
+    color = args[:color] || :silver
+    print text.colorize(color)
+  end
+
+  def writeln(text = "", args = {})
+    write("#{text}\n", args)
+  end
+
+  def write_table(rows)
+    table = TTY::Table.new(rows)
+    # puts table.render(:basic)
+    puts table.render(:ascii)
+  end
+end

data/lib/teuton-get/writer/writer.rb

@@ -0,0 +1,9 @@
+class Writer
+  def write(data)
+    raise "Define method"
+  end
+
+  def writeln(data)
+    raise "Define method"
+  end
+end

data/lib/teuton-get.rb

@@ -0,0 +1,45 @@
+require_relative "teuton-get/repo/local_info"
+require_relative "teuton-get/repo/local_repo"
+require_relative "teuton-get/repo/repo_config"
+require_relative "teuton-get/repo/repo_data"
+require_relative "teuton-get/searcher"
+require_relative "teuton-get/downloader"
+
+module TeutonGet
+  def self.create_info(testpath)
+    LocalInfo.new.user_create(testpath)
+  end
+
+  def self.create_repo(dirpath)
+    LocalRepo.new_by_default.create(dirpath)
+  end
+
+  def self.init
+    RepoConfig.new_by_default.create
+    refresh # Auto repo refresh
+  end
+
+  def self.refresh
+    RepoData.new_by_default.refresh
+  end
+
+  def self.show_repo_list
+    RepoConfig.new_by_default.show_list
+  end
+
+  def self.show_info(test_id)
+    repo_data = RepoData.new_by_default
+    info = repo_data.get(test_id)
+    repo_data.show_testinfo(info) unless info == {}
+  end
+
+  def self.search(filter)
+    searcher = Searcher.new_by_default
+    result = searcher.get(filter)
+    searcher.show(result)
+  end
+
+  def self.download(test_id)
+    Downloader.new.run(test_id)
+  end
+end