baltix 0.1.1

data/lib/baltix/loader/mast.rb

@@ -0,0 +1,139 @@
+module Baltix::Loader::Mast
+   PROPS = {
+      name: :name,
+      version: :version,
+      date: :date,
+      authors: :authors,
+      email: ->(this) do
+         /(?<email>[^\s<]+@[^\s>]+)/ =~ this["contact"]
+         email
+      end,
+      summary: :summary,
+      description: :description,
+      homepage: :"resources.home", #->(this) { this["resources"]["home"] }
+      "metadata.homepage_uri": [
+         :"resources.code",
+         ->(this) { this['resources'].select {|x| x['type'] == 'home'}.first['uri'] if this['resources'].is_a?(Array) }
+      ],
+      "metadata.allowed_push_host": "https://rubygems.org",
+      "metadata.source_code_uri": [
+         :"resources.repo",
+         ->(this) { this['resources'].select {|x| x['type'] == 'code'}.first['uri'] if this['resources'].is_a?(Array) }
+      ],
+      files: ->(this) { this["manifest"].grep(/^[^#]/) },
+      bindir: "bin",
+      executables: ->(this) { this["manifest"].grep(/^bin\//).map {|b| b.split("/").last } },
+      require_paths: ["lib"],
+      extra_rdoc_files: ->(this) { this["manifest"].grep(/\.(rdoc|md)$/) },
+      licenses: ->(this) do
+         if license = this["manifest"].grep(/LICENSE/).first
+            lic = IO.read(license).split("\n")
+            if type = lic.reduce(nil) { |r, l| r || /(?<type>Apache|MIT)/ =~ l && type }
+               version = lic.reduce(nil) { |r, l| r || /Version (?<version>[\d\.]+)/ =~ l && version }
+               [[ type, version ].compact.join("-") ]
+            end
+         end
+      end,
+      test_files: ->(this) { this["manifest"].grep(/^(test|spec|feature)\//) },
+      required_ruby_version: nil,
+      _add_development_dependency: ->(this) do
+         if this['requires']
+            this["requires"].map { |line| [/^(?<req>[^\s(]+)/.match(line)["req"]] }
+         end
+      end,
+      _add_dependency_with_type: ->(this) do
+         if this['requirements']
+            this["requirements"].map do |dep|
+               [dep['name'], dep['development'] ? :development : :runtime, [transform_version(dep['version'])].compact]
+            end
+         end
+      end
+   }
+
+   def value_for value_in, data_in
+      case value_in
+      when Symbol
+         value_in.to_s.split(".").reduce(data_in) {|r, n|  r.is_a?(Hash) || r.is_a?(Array) && n.is_a?(Integer) ? r[n] : nil }
+      when Proc
+         value_in[data_in]
+      when NilClass
+      when Array
+         value_in.reduce(nil) { |r, v| r || value_for(v, data_in) }
+      else
+         value_in
+      end
+   end
+
+   def manifest file_in
+      spec = nil
+      dir = File.dirname(file_in)
+      file1 = File.join(dir, "meta", "package")
+      file2 = File.join(dir, "meta", "profile")
+      file3 = File.join(dir, ".index")
+
+      if File.file?(file1) && File.file?(file2) || File.file?(file3)
+         spec=
+         Dir.chdir(dir) do
+            Gem::Specification.new do |s|
+               data =
+                  if File.file?(file1) && File.file?(file2)
+                     Kernel.yaml_load(IO.read(file1)).merge(
+                     Kernel.yaml_load(IO.read(file2))).merge(
+                        "manifest" => IO.read(file_in).split("\n"))
+                  else
+                     Kernel.yaml_load(IO.read(file3)).merge(
+                        "manifest" => IO.read(file_in).split("\n"))
+                  end
+
+               PROPS.each do |name, value_in|
+                  if value = value_for(value_in, data)
+                     method_name = /^(?:_(?<mname>[^\.]+)|(?<subname>[^\.]+\..+)|.*)/ =~ name.to_s
+                     if mname
+                        if value.is_a?(Array)
+                           value.each { |v| s.send(mname, *v) }
+                        else
+                           s.send(mname, value)
+                        end
+                     elsif subname
+                        path = subname.split(".")
+                        path[0..-2].reduce(s) {|r, n| r.send(n) }.send(:[]=, path[-1], value)
+                     else
+                        s.send("#{name}=", value)
+                     end
+                  end
+               end
+            end
+         end
+
+         file = Tempfile.new(spec.name)
+         file.puts(spec.to_ruby)
+         file.close
+         res = app_file(file.path)
+         file.unlink
+         res
+      end
+   rescue Exception => e
+      $stderr.puts "WARN [#{e.class}]: #{e.message}"
+   end
+
+   class << self
+      def transform_version version
+         if version
+            /(?<number>[\d]+)(?<approx>[~><=])?/ =~ version
+            part1 =
+               case approx
+               when '~'
+                  '~> '
+               when '>'
+                  '>= '
+               when '<'
+                  '<= '
+               when '='
+                  '= '
+               end
+
+            [part1, number].join(' ')
+         end
+      end
+   end
+end

data/lib/baltix/loader/pom.rb

@@ -0,0 +1,27 @@
+# POM xml based valid gemspec environment generation module
+# example: "ovirt-engine-sdk" gem
+# requires "xmllint" to work
+#
+module Baltix::Loader::Pom
+   def pom propfile
+      dir = File.dirname(propfile)
+
+      specfile = Dir.glob(File.join(dir, '*.gemspec')).first
+
+      re = /require.*?(?<version_file>[^"']+version[^"']*)/
+      version_line = Dir.glob(File.join(dir, '**', '*.rb')).map { |x| IO.read(x).split("\n").grep(re).first }.compact.first
+      return nil if !version_line or !specfile
+      version_file = re.match(version_line)[:version_file]
+      re_V = /(?<klass>[^\"\'\(\s]+)::VERSION/
+      match = re_V.match(IO.read(specfile).split("\n").grep(re_V).first.to_s)
+      if match
+         klass = match[:klass]
+         version = `xmllint pom.xml --xpath "/*[name()='project']/*[name()='version']/text()"`.strip
+         if version != ""
+            modtext = "module #{klass};VERSION = '#{version}';end"
+            File.open(File.join(dir, "lib", version_file), "w+") {|f| f.puts(modtext) }
+         end
+      end
+   rescue Errno::ENOENT
+   end
+end

data/lib/baltix/loader/rookbook.rb

@@ -0,0 +1,26 @@
+# Rookbook based gemspec detection module
+#
+module Baltix::Loader::Rookbook
+   def rookbook propfile
+      dir = File.dirname(propfile)
+
+      props = IO.read(propfile)
+                .split("\n")
+                .map do |line|
+                     /^(?<key>[^:]+):\s*(?<value>.*)$/ =~ line
+                     [ key, value ]
+                  end
+                .to_h
+
+      specfile = Dir.glob(File.join(dir, '**', '*.gemspec')).first
+
+      # fix specfile
+      oldspec = IO.read(specfile)
+      newspec = oldspec.split("\n").map do |x|
+         props.reduce(x) { |x, (key, value)| x.gsub(/\$#{key}[: ]*\$/i, value) }
+      end
+      if oldspec != newspec
+         File.open(specfile, 'w+') {|file| file.puts newspec }
+      end
+   end
+end

data/lib/baltix/loader/yaml.rb

@@ -0,0 +1,18 @@
+# yaml gemspec generator based
+# example: "lemon" gem
+#
+module Baltix::Loader::Yaml
+   def yaml file
+      spec = Gem::Specification.from_yaml(IO.read(file))
+
+      file = Tempfile.new(spec.name)
+      file.puts(spec.to_ruby)
+      file.close
+      res = app_file(file.path)
+      file.unlink
+      res
+   rescue => e
+      nil
+   end
+end
+

data/lib/baltix/loader.rb

@@ -0,0 +1,192 @@
+require 'rake'
+
+require 'baltix'
+require 'baltix/log'
+
+module Baltix::Loader
+   include Baltix::Log
+
+   module Certain
+      include Baltix::Log
+      include Rake::DSL
+
+      attr_reader :object_hash, :object_ids
+
+      alias_method :require_orig, :require
+
+      def require *args
+         require_orig(*args)
+      rescue LoadError
+         true
+      end
+
+      def store_object_hash type_hash
+         object_hash =
+            type_hash.map do |(klass, types)|
+               objects = types.split(',').map do |type|
+                  begin
+                     ObjectSpace.each_object(type.constantize).map { |h| h }
+                  rescue NameError
+                     []
+                  end
+               end.flatten
+
+               [klass, objects]
+            end.to_h
+
+         if @object_hash
+            @object_ids = object_hash.map do |(k, oh)|
+               [k, oh.map {|h| h.__id__ } - @object_hash[k].map {|h| h.__id__ }]
+            end.to_h
+         end
+
+         @object_hash = object_hash
+      end
+
+      def load_file file, type_hash
+         # NOTE this forces not to share namespace but avoid exception when calling
+         # main space methods, see Rakefile of racc gem
+         # also named module is required instead of anonymous one to allow root level defined methods access
+         store_object_hash(type_hash)
+         value = nil
+
+         begin
+            push
+            Dir.chdir(File.dirname(file)) do
+               _file = File.basename(file).untaint
+               code = File.read(file, mode: 'r:UTF-8:-')
+               code.untaint
+
+               value =
+                  begin
+                     # evaluation required not to lost loaded object,
+                     # the instance_eval is used in favor of eval to avoid lost predefined vars
+                     # like for chef-utils gem
+                     instance_eval(code, _file)
+                  rescue Exception
+                     # thrown for setup gem
+                     load(File.basename(file), true)
+                  end
+            end
+         rescue Exception => e
+            raise e
+         ensure
+            debug("value: #{value.inspect}")
+            pop
+            store_object_hash(type_hash)
+         end
+
+         self
+      rescue Exception => e
+         debug("[#{e.class}]: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+
+         self
+      end
+
+      def push
+         @paths = $:.dup
+         debug("Stored paths are: " + @paths.join("\n\t"))
+      end
+
+      def pop
+         debug("Subtract paths: " + ($: - @paths).join("\n\t"))
+         # NOTE this sequency of merging is required to correct loading libs leads
+         # to show warning and break building rdoc documentation
+         $:.replace(@paths | $:)
+         debug("Replaced paths with: " + $:.join("\n\t"))
+      end
+   end
+
+   def self.extended_list
+      @extended_list ||= []
+   end
+
+   def self.extended kls
+      extended_list << kls
+   end
+
+   def type_hash
+      @type_hash ||=
+         Baltix::Loader.extended_list.map do |kls|
+            type =
+               begin
+                  kls.const_get('TYPE')
+               rescue
+                  nil
+               end
+
+            [kls, type]
+         end.select {|(_, type)| type }.to_h
+   end
+
+   def pre_loaders
+      @pre_loaders ||=
+         Baltix::Loader.extended_list.map do |kls|
+            begin
+               kls.const_get('PRELOAD_MATCHER')&.map do |k, v|
+                  [k, v.is_a?(Symbol) && kls.singleton_method(v) || v]
+               end.to_h || {}
+            rescue
+               {}
+            end
+         end.reduce {|res, hash| res.merge(hash) }
+   end
+
+   def mods
+      @@mods ||= {}
+   end
+
+   def load_file file
+      debug("Loading file: #{file}")
+      stdout = $stdout
+      stderr = $stderr
+      $stdout = $stderr = Tempfile.new('loader')
+
+      pre_loaders.each do |(m, preload_method)|
+         if file =~ m
+            args = [file][0...preload_method.arity]
+            preload_method[*args]
+         end
+      end
+
+      module_name = "M" + Random.srand.to_s
+      mod_code = <<-END
+         module #{module_name}
+            extend(::Baltix::Loader::Certain)
+         end
+      END
+
+      mod = module_eval(mod_code)
+      mod.load_file(file, type_hash)
+      $stdout.rewind
+      $stderr.rewind
+      log = $stdout.readlines
+      errlog = $stderr.readlines
+
+      OpenStruct.new(mod: mod, log: log, errlog: errlog, object_hash: mod.object_hash, diff_ids: mod.object_ids)
+   rescue Exception => e
+      warn(e.message)
+
+      OpenStruct.new(mod: mod, object_hash: {}, log: log, errlog: errlog, diff_ids: [])
+   ensure
+      $stderr = stderr
+      $stdout = stdout
+   end
+
+   def app_file file, &block
+      mods[file] ||= load_file(file)
+
+      mod = mods[file].dup
+      objects = mod.diff_ids[self]&.map {|id| ObjectSpace._id2ref(id) }
+
+      debug("Object ids for '#{file}' are: #{mod.diff_ids[self].inspect}")
+      debug("Objects for '#{file}' are: #{objects.inspect}")
+
+      if block_given?
+         objects = [yield(objects)].flatten.compact
+      end
+      mod.objects = objects || []
+
+      mod
+   end
+end

data/lib/baltix/log.rb

@@ -0,0 +1,73 @@
+module Baltix::Log
+   DEFAULT_IO_NAMES = {
+      none: nil,
+      error: 'stderr',
+      warn: 'stderr',
+      info: 'stderr',
+      debug: 'stderr',
+   }
+
+   DEFAULT_IO_NAMES.keys.each do |key|
+      define_method(key) {|message| log(key, message) if level_match(key) }
+   end
+
+   def log kind, message
+      Baltix::Log.ios[kind].puts("#{Baltix::Log.prefix[kind]}#{message}")
+   end
+
+   def level_match kind
+      Baltix::Log.ios[kind] && Baltix::Log.ios.keys.index(kind) <= Baltix::Log.ios.keys.index(Baltix::Log.level)
+   end
+
+   class << self
+      def prefix_for kind, prefix
+         @@prefix[kind] = prefix
+      end
+
+      def prefix
+         @@prefix ||= default_prefix(ios)
+      end
+
+      def default_prefix ios
+         ios.keys.map {|kind| [kind, "[baltix][#{kind.upcase}]> " ] }.to_h
+      end
+
+      def setup_kind kind, io
+         ios[kind] = io
+      end
+
+      def ios
+         @@ios ||= io_name_parse(DEFAULT_IO_NAMES)
+      end
+
+      def level
+         @@level ||= :info
+      end
+
+      def setup level = :info, io_names = DEFAULT_IO_NAMES, prefix = nil
+         @@ios = io_name_parse(io_names)
+         @@level = level
+         @@prefix = prefix || default_prefix(ios)
+      end
+
+      def io_name_parse io_names
+         io_names.map do |(kind, io_name)|
+            io =
+               case io_name
+               when '-', 'stdout'
+                  $stdout
+               when '--', 'stderr'
+                  $stderr
+               when '', nil
+                  nil
+               else
+                  File.open(io_name, 'a+')
+               end
+
+            [kind, io]
+         end.to_h
+      end
+
+      at_exit { (@@ios rescue {}).values.each {|v| v.close if v.is_a?(File) } }
+   end
+end

data/lib/baltix/rake.rb

@@ -0,0 +1,57 @@
+# used in digest-crc gem as an extension compiler
+#
+require 'baltix/loader'
+
+class Baltix::Rake
+   extend ::Baltix::Loader
+
+   class InvalidRakefileError < StandardError; end
+
+   TYPE = 'Rake::Application'
+   PRELOAD_MATCHER = { /\/rakefile(.rb)?$/i => :preload }
+
+   attr_reader :app, :rakefile, :options
+
+   def blank?
+      !@app
+   end
+
+   def present?
+      !!@app
+   end
+
+   def tasks
+      @tasks ||= @app&.tasks || []
+   end
+
+   def run_task task_name
+      if @app
+         Rake.instance_variable_set(:@application, @app)
+
+         Dir.chdir(@app.original_dir) do
+            @app.invoke_task(task_name)
+         end
+      end
+   rescue Exception => e
+      warn "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+   end
+
+   def initialize rakefile, options = {}
+      raise InvalidRakefileError unless File.file?(rakefile)
+
+      @rakefile = rakefile
+      @options = options
+      @app = self.class.load(rakefile).objects.first
+   end
+
+   class << self
+      # preload callback
+      def preload
+         Rake.instance_variable_set(:@application, nil)
+      end
+
+      def load rakefile
+         app_file(rakefile)
+      end
+   end
+end

data/lib/baltix/scheme.erb.yaml

@@ -0,0 +1,20 @@
+---
+ - match: \.so$
+   proc:
+    - context:
+         source_dir: <%= File.join(target.source.root, dir) %>
+         target_dir: <%= target.dldir %>
+         target_prefix: <%= File.expand_path(config.install_prefix) %>
+         file: <%= file %>
+      actor: copy
+    - context:
+         source_dir: <%= target.dldir %>
+         target_dir: <%= File.join(target.require_libdir) %>
+         target_prefix: <%= File.expand_path(config.install_prefix) %>
+         file: <%= file %>
+      actor: link
+    - context:
+         target_dir: <%= target.dldir %>
+         target_prefix: <%= File.expand_path(config.install_prefix) %>
+         file: <%= File.join(File.dirname(file), 'gem.build_complete') %>
+      actor: touch