falkor 0.1.0

data/lib/falkor/extract/gem.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Falkor
+  module Extract
+    class Gem
+      def initialize(file_name)
+        @file_name = file_name
+      end
+
+      def extract
+        ::Gem::Package::FileSource.new(file_name).with_read_io do |io|
+          ::Gem::Package::TarReader.new(io).each do |entry|
+            next if entry.full_name != "data.tar.gz"
+
+            write_tar_file(entry.read)
+
+            remove_file
+            break # ignore further entries
+          end
+        end
+
+        tar_file_name
+      end
+
+      private
+
+      attr_reader :file_name
+
+      def write_tar_file(contents)
+        File.open(tar_file_name, "wb") do |file|
+          file.write contents
+        end
+      end
+
+      def tar_file_name
+        File.join(
+          File.dirname(file_name), File.basename(file_name, ".gem") + ".tar.gz"
+        )
+      end
+
+      def remove_file
+        FileUtils.rm file_name
+      end
+    end
+  end
+end

data/lib/falkor/extract/tar_gz.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "falkor/concerns/trackable_progress"
+
+module Falkor
+  module Extract
+    class TarGz
+      include TrackableProgress
+
+      TAR_LONGLINK = "././@LongLink"
+
+      def initialize(file_name, has_root_dir: false)
+        @file_name = file_name
+        @extraction_destination =
+          if has_root_dir
+            File.dirname(file_name)
+          else
+            source_destination
+          end
+      end
+
+      def extract
+        return source_destination if Dir.exist? source_destination
+
+        FileUtils.mkdir_p extraction_destination
+
+        block = block_given? ? Proc.new : proc {}
+
+        report_progress(:write_each_tarfile, open_file(&:count), &block)
+        FileUtils.rm file_name
+        source_destination
+      end
+
+      private
+
+      attr_reader :file_name, :extraction_destination
+
+      def source_destination
+        @source_destination ||= File.join(
+          File.dirname(file_name), File.basename(file_name, ".tar.gz")
+        )
+      end
+
+      def write_each_tarfile
+        open_file do |tar|
+          current_destination = nil
+          tar.each do |tarfile|
+            current_destination =
+              handle_longlink_or_write(tarfile, current_destination)
+            yield(1)
+          end
+        end
+      end
+
+      def open_file
+        File.open(file_name, "rb") do |file|
+          return_value = nil
+          Zlib::GzipReader.wrap(file) do |gz|
+            ::Gem::Package::TarReader.new(gz) do |tar|
+              return_value = yield tar
+            end
+          end
+          return_value
+        end
+      end
+
+      def write_tarfile(tarfile, current_destination)
+        current_destination ||=
+          File.join extraction_destination, tarfile.full_name
+
+        if directory?(tarfile)
+          write_directory(tarfile, current_destination)
+        elsif file?(tarfile)
+          write_file(tarfile, current_destination)
+        elsif tarfile.header.typeflag == "2" # Symlink
+          File.symlink tarfile.header.linkname, current_destination
+        end
+        nil
+      end
+
+      def directory?(file)
+        file.directory? || file.full_name.end_with?("/")
+      end
+
+      def file?(file)
+        file.file? || !file.full_name.end_with?("/")
+      end
+
+      def write_directory(file, dest)
+        File.delete dest if File.file? dest
+        FileUtils.mkdir_p dest, mode: file.header.mode, verbose: false
+      end
+
+      def write_file(file, dest)
+        if File.directory? dest
+          FileUtils.rm_rf dest
+        else
+          FileUtils.mkdir_p(File.dirname(dest))
+        end
+
+        File.open dest, "wb" do |f|
+          f.print file.read
+        end
+        FileUtils.chmod file.header.mode, dest, verbose: false
+      end
+
+      def handle_longlink_or_write(tarfile, dest)
+        if tarfile.full_name == TAR_LONGLINK
+          File.join extraction_destination, tarfile.read.strip
+        else
+          write_tarfile(tarfile, dest)
+        end
+      end
+    end
+  end
+end

data/lib/falkor/gem.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "falkor/concerns/installable"
+require "gems"
+
+module Falkor
+  class Gem
+    include Installable
+
+    attr_reader :name, :info, :version, :created_at, :project_uri
+
+    class << self
+      def search(query)
+        return [] if query.nil? || query.empty?
+
+        Gems.search(query).map do |gem|
+          new(**gem.transform_keys(&:to_sym))
+        end
+      end
+
+      def find(query, version = nil)
+        gem_info =
+          if version.nil?
+            Gems.info(query)
+          else
+            rubygems_v2_info(query, version)
+          end
+
+        new(**gem_info.transform_keys(&:to_sym))
+      end
+
+      private
+
+      def rubygems_v2_info(gem_name, version)
+        response = Gems::Client.new.get(
+          "/api/v2/rubygems/#{gem_name}/versions/#{version}.json"
+        )
+        JSON.parse(response)
+      rescue JSON::ParserError
+        {}
+      end
+    end
+
+    def initialize(**attrs)
+      @name        = attrs[:name]
+      @info        = attrs[:info]
+      @created_at  = attrs[:created_at] && Time.parse(attrs[:created_at])
+      @project_uri = attrs[:homepage_uri]
+      @version     = ::Gem::Version.new(attrs[:version])
+    end
+
+    def other_versions
+      @other_versions ||= Gems.versions(name).map do |payload|
+        next if payload["number"] == version
+
+        self.class.new(
+          name: name,
+          info: payload["summary"],
+          version: payload["number"],
+          created_at: payload["created_at"]
+        )
+      end.compact
+    end
+
+    %i(root class method module constant classvariable macro).each do |type|
+      define_method("#{type}_objects") do
+        store.values_for_type(type)
+      end
+    end
+
+    private
+
+    def file_name
+      "#{name}-#{version}.gem"
+    end
+
+    def url
+      "https://rubygems.org/gems/#{file_name}"
+    end
+
+    def yard_filepath
+      File.join(Dir.pwd, "tmp", File.basename(file_name, ".gem") + ".falkor")
+    end
+
+    def extract(file_path)
+      Falkor::Extract::TarGz.new(
+        Falkor::Extract::Gem.new(file_path).extract
+      ).extract do |progress|
+        yield :extracting, progress
+      end
+    end
+  end
+end

data/lib/falkor/progress.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Falkor
+  class Progress
+    def initialize(total)
+      @total = total
+      @current = 0
+      @previous = 0
+    end
+
+    def increment!(amount, description)
+      self.previous, self.current = current, current + amount
+
+      return if percentage(previous) == percentage(current) && !description
+
+      yield percentage(current), description
+    end
+
+    private
+
+    attr_reader :total
+    attr_accessor :current, :previous
+
+    def percentage(amount)
+      (amount.to_f / total * 100).to_i
+    end
+  end
+end

data/lib/falkor/ruby.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "falkor/concerns/installable"
+
+module Falkor
+  class Ruby
+    class NotFound < StandardError; end
+
+    include Installable
+
+    RELEASES = "https://raw.githubusercontent.com/ruby/www.ruby-lang.org/"\
+               "master/_data/releases.yml"
+
+    class << self
+      def search(query)
+        versions.keys.map do |version|
+          new(version) if version.include? query
+        end.compact
+      end
+
+      alias :find :new
+
+      def versions
+        YAML.
+          load_file(Download.new(RELEASES, "ruby_releases.yml").download {}).
+          select { |release| release.dig("url", "gz") }.
+          map { |release| [release["version"], release.dig("url", "gz")] }.
+          to_h
+      end
+    end
+
+    def initialize(version)
+      raise NotFound if self.class.versions[version].nil?
+
+      @version = version
+    end
+
+    def other_versions
+      self.class.versions.keys.map do |number|
+        next if number == version
+
+        self.class.new(number)
+      end.compact
+    end
+
+    %i(root class method module constant classvariable macro).each do |type|
+      define_method("#{type}_objects") do
+        store.values_for_type(type)
+      end
+    end
+
+    private
+
+    attr_reader :version
+
+    def file_name
+      "ruby-#{version}.tar.gz"
+    end
+
+    def url
+      self.class.versions[version]
+    end
+
+    def yard_filepath
+      File.join(Dir.pwd, "tmp", File.basename(file_name, ".tar.gz") + ".falkor")
+    end
+  end
+end

data/lib/falkor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Falkor
+  VERSION = "0.1.0"
+end

data/lib/falkor/yard/documentation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "falkor/concerns/trackable_progress"
+require "falkor/yard/parser"
+require "yard"
+
+module Falkor
+  module Yard
+    class Documentation
+      include TrackableProgress
+
+      FILE_GLOB =
+        YARD::Parser::SourceParser::DEFAULT_PATH_GLOB + ["*.c", "ext/**/*.rb"]
+
+      def initialize(source_dir, yardoc_file = ".yardoc")
+        @source_dir = source_dir
+        @yardoc_file = yardoc_file
+      end
+
+      def generate
+        in_source_dir do
+          with_yardoc_file do
+            YARD::Registry.lock_for_writing do
+              report_progress(:parse_files, files.size, &Proc.new)
+              YARD::Registry.save(true)
+            end
+          end
+        end
+
+        yardoc_file
+      end
+
+      private
+
+      attr_accessor :source_dir, :yardoc_file
+
+      def files
+        @files ||=
+          FILE_GLOB.map do |path|
+            path = "#{path}/**/*.{rb,c,cc,cxx,cpp}" if File.directory?(path)
+            path = Dir[path].sort_by { |d| [d.length, d] } if path.include?("*")
+
+            path
+          end.flatten.select { |p| File.file?(p) }
+      end
+
+      def in_source_dir
+        Dir.chdir(source_dir) { yield }
+      end
+
+      def with_yardoc_file
+        YARD::Registry.clear
+        YARD::Logger.instance.io = IO.new(IO.sysopen("/dev/null", "w+"))
+        YARD::Registry.yardoc_file = yardoc_file
+        yield
+        YARD::Registry.yardoc_file = nil
+        YARD::Logger.instance.io = STDOUT
+      end
+
+      def parse_files
+        Parser.new(nil, files).parse do |count, description|
+          yield count, description
+        end
+      end
+    end
+  end
+end

data/lib/falkor/yard/parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "falkor/yard/parser/global_state"
+require "yard"
+
+module Falkor
+  module Yard
+    class Parser
+      attr_accessor :files, :global_state
+
+      def initialize(global_state, files)
+        @global_state = global_state || GlobalState.new(self, 0)
+
+        @files = files.dup
+      end
+
+      def parse
+        global_state.block = Proc.new if block_given?
+
+        until files.empty?
+          file = files.shift
+          YARD::Parser::SourceParser.new(
+            YARD::Parser::SourceParser.parser_type, global_state
+          ).parse(file)
+
+          global_state.processed(file)
+        end
+      end
+    end
+  end
+end