baltix 0.1.1

data/lib/baltix/extensions.rb

@@ -0,0 +1,536 @@
+module Extensions
+   module Object
+      def self.const_get c, inherit = true
+         super
+      rescue Exception => e
+         begin
+           require c.to_s.downcase
+         rescue Exception => e
+         end
+
+         super
+      end
+
+      def blank?
+         case self
+         when ::NilClass, ::FalseClass
+            true
+         when ::TrueClass
+            false
+         when ::Hash, ::Array
+            !self.any?
+         else
+            self.to_s == ""
+         end
+      end
+
+      def to_os hash: false, array: false
+         value =
+           self.to_h.map do |(x, y_in)|
+              y =
+                 if hash && y_in.is_a?(Hash) || array && y_in.is_a?(Array)
+                    y_in.to_os(hash: hash, array: array)
+                 else
+                    y_in
+                 end
+
+              [x.to_s, y]
+            end.to_h
+
+         ::OpenStruct.new(value)
+      end
+   end
+
+   module Array
+      # actjoin(array) => [<pre_match1>, <pre_match2>, <pre_match3>, <post_match>]; array = [match1, match2, match3]
+      #
+      def actjoin array
+         self.map.with_index { |x, i| [ x, array[i] ].compact }.flatten.join
+      end
+   end
+
+   module Hash
+#      def deep_merge other, options_in = {}
+#         return self if other.nil? or other.blank?
+#
+#         options = { mode: :append }.merge(options_in)
+#
+#         other_hash = other.is_a?(Hash) && other || { nil => other }
+#         common_keys = self.keys & other_hash.keys
+#         base_hash = (other_hash.keys - common_keys).reduce({}) do |res, key|
+#            res[key] = other_hash[key]
+#            res
+#         end
+#
+#         self.reduce(base_hash) do |res, (key, value)|
+#            new =
+#            if common_keys.include?(key)
+#               case value
+#               when ::Hash, ::OpenStruct
+#                  value.deep_merge(other_hash[key])
+#               when ::Array
+#                  value.concat([ other_hash[key] ].compact.flatten(1))
+#               when ::NilClass
+#                  other_hash[key]
+#               else
+#                  value_out =
+#                     if options[:mode] == :append
+#                        [other_hash[key], value].compact.flatten(1)
+#                     elsif options[:mode] == :prepend
+#                        [value, other_hash[key]].compact.flatten(1)
+#                     else
+#                        value
+#                     end
+#
+#                  if value_out.is_a?(Array) && options[:dedup]
+#                     value_out.uniq
+#                  else
+#                     value_out
+#                  end
+#               end
+#            else
+#               value
+#            end
+#
+#            res[key] = new
+#            res
+#         end
+#      end
+   end
+
+   module OpenStruct
+      def to_os
+         self
+      end
+
+      def merge_to other
+         ::OpenStruct.new(other.to_h.deep_merge(self.to_h))
+      end
+
+      def merge other
+         ::OpenStruct.new(self.to_h.deep_merge(other.to_h))
+      end
+
+      def map *args, &block
+         res = self.class.new
+
+         self.each_pair do |key, value|
+            res[key] = block[key, value]
+         end
+
+         res
+      end
+
+      def select &block
+         res = self.class.new
+
+         self.each_pair do |key, value|
+            res[key] = value if block[key, value]
+         end
+
+         res
+      end
+
+      def compact
+         select { |_, value| !value.blank? }
+      end
+
+      def each *args, &block
+         self.each_pair(*args, &block)
+      end
+
+      def reduce default = nil, &block
+         res = default
+
+         self.each_pair do |key, value|
+            res = block[res, key, value]
+         end
+
+         res
+      end
+
+      def find &block
+         select(&block).first
+      end
+
+      def replace new_os
+         self.to_h.keys.each {|x| self[x] = nil }
+
+         new_os.to_os.each {|x, v| self[x] = v }
+
+         self
+      end
+
+      def deep_dup
+         self.reduce({}.to_os) do |r, x, y|
+            r[x] = y.respond_to?(:deep_dup) ? y.deep_dup : y.dup
+
+            r
+         end
+      end
+
+      # +deep_merge+ deeply merges the Open Struct hash structure with the +other_in+ enumerating it key by key.
+      # +options+ are the options to change behaviour of the method. It allows two keys: :mode, and :dedup
+      # :mode key can be :append, :prepend, or :replace, defaulting to :append, when mode is to append, it combines duplicated
+      # keys' values into an array, when :prepend it prepends an other value before previously stored one unlike for :append mode,
+      # when :replace it replace duplicate values with a last ones.
+      # :dedup key can be true, or false. It allows to deduplicate values when appending or prepending values.
+      # Examples:
+      #    open_struct.deep_merge(other_open_struct)
+      #    open_struct.deep_merge(other_open_struct, :prepend)
+      #
+      def deep_merge other_in, options_in = {}
+         return self if other_in.nil? or other_in.blank?
+
+         options = { mode: :append }.merge(options_in)
+
+         other =
+            if other_in.is_a?(::OpenStruct)
+               other_in.deep_dup
+            elsif other_in.is_a?(::Hash)
+               other_in.to_os
+            else
+               ::OpenStruct.new(nil => other_in)
+            end
+
+         other.reduce(self.to_os) do |res, key, value|
+            res[key] =
+               if res.table.keys.include?(key)
+                  case value
+                  when ::Hash
+                     value.deep_merge(res[key].to_h, options)
+                  when ::OpenStruct
+                     value.deep_merge(res[key].to_os, options)
+                  when ::Array
+                     value.concat([res[key]].compact.flatten(1))
+                  when ::NilClass
+                     res[key]
+                  else
+                     value_out =
+                        if options[:mode] == :append
+                           [value, res[key]].compact.flatten(1)
+                        elsif options[:mode] == :prepend
+                           [res[key], value].compact.flatten(1)
+                        else
+                           value
+                        end
+
+                     if value_out.is_a?(Array) && options[:dedup]
+                        value_out.uniq
+                     else
+                        value_out
+                     end
+                  end
+               else
+                  value
+               end
+
+            res
+         end
+      end
+   end
+
+   module GemRequirement
+      INVALID_DEP = ["<", Gem::Version.new(0)] #:nodoc:
+
+      AND_RELAS = { #:nodoc:
+         [ "=", ">=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "=", ">=", 1 ] => ->(l, r) { [["=", l]] },
+         [ "=", "<=", -1 ] => ->(l, r) { [["=", l]] },
+         [ "=", "<=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "=", ">", 1 ] => ->(l, r) { [["=", l]] },
+         [ "=", "<", -1 ] => ->(l, r) { [["=", l]] },
+         [ "=", "=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "=", "~>", 0 ] => ->(l, r) { [["=", l]] },
+         [ "=", "~>", ->(l, r) { l > r && l < r.bump } ] => ->(l, r) { [["=", l]] },
+         [ "!=", "=", -1 ] => ->(l, r) { [["=", r]] },
+         [ "!=", "=", 1 ] => ->(l, r) { [["=", r]] },
+         [ "!=", "!=", -1 ] => ->(l, r) { [["!=", l]] },
+         [ "!=", "!=", 0 ] => ->(l, r) { [["!=", l]] },
+         [ "!=", "!=", 1 ] => ->(l, r) { [["!=", l]] },
+         [ "!=", ">", -1 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">", 0 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">", 1 ] => ->(l, r) { [[">", r], ["<", l]] },
+         [ "!=", "<", -1 ] => ->(l, r) { [[">", l], ["<", r]] },
+         [ "!=", "<", 0 ] => ->(l, r) { [["<", r]] },
+         [ "!=", "<", 1 ] => ->(l, r) { [["<", r]] },
+         [ "!=", ">=", -1 ] => ->(l, r) { [[">=", r]] },
+         [ "!=", ">=", 0 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">=", 1 ] => ->(l, r) { [[">=", r], ["<", l]] },
+         [ "!=", "<=", -1 ] => ->(l, r) { [[">", l], ["<=", r]] },
+         [ "!=", "<=", 0 ] => ->(l, r) { [["<", r]] },
+         [ "!=", "<=", 1 ] => ->(̀r, l) { [["<=", r]] },
+         [ "!=", "~>", -1 ] => ->(l, r) { [[">=", r], ["<", r.bump]] },
+         [ "!=", "~>", 0 ] => ->(l, r) { [[">", r], ["<", r.bump]] },
+         [ "!=", "~>", ->(l, r) { l > r && l < r.bump } ] => ->(l, r) { [[">", l], ["<", r.bump]] },
+         [ "!=", "~>", ->(l, r) { l >= r.bump } ] => ->(l, r) { [[">=", l]] },
+         [ ">", "=", -1 ] => ->(l, r) { [["=", r]] },
+         [ ">", "!=", -1 ] => ->(l, r) { [[">", l], ["<", r]] },
+         [ ">", "!=", 0 ] => ->(l, r) { [[">", l]] },
+         [ ">", "!=", 1 ] => ->(l, r) { [[">", l]] },
+         [ ">", ">", -1 ] => ->(l, r) { [[">", [r, l].max]] },
+         [ ">", ">=", -1 ] => ->(l, r) { [[">=", l]] },
+         [ ">", ">=", 0 ] => ->(l, r) { [[">", l]] },
+         [ ">", ">=", 1 ] => ->(l, r) { [[">", l]] },
+         [ ">", "<=", -1 ] => ->(l, r) { [[">", l], ["<=", r]] },
+         [ ">", "~>", -1 ] => ->(l, r) { [[">=", l], ["<", r.bump]] },
+         [ ">", "~>", 0 ] => ->(l, r) { [[">", l], ["<", r.bump]] },
+         [ ">", "~>", ->(l, r) { l > r && l < r.bump } ] => ->(l, r) { [[">", l], ["<", r.bump]] },
+         [ ">", "~>", ->(l, r) { l >= r.bump } ] => ->(l, r) { [[">", l]] },
+         [ "<", "=", 1 ] => ->(l, r) { [["=", r]] },
+         [ "<", "!=", -1 ] => ->(l, r) { [["<", l]] },
+         [ "<", "!=", 0 ] => ->(l, r) { [["<", l]] },
+         [ "<", "!=", 1 ] => ->(l, r) { [[">=", r], ["<", l]] },
+         [ "<", ">", 1 ] => ->(l, r) { [[">", r], ["<", l]] },
+         [ "<", "<", nil ] => ->(l, r) { [["<", [r, l].min]] },
+         [ "<", ">=", 1 ] => ->(l, r) { [[">=", r], ["<", l]] },
+         [ "<", "~>", 1 ] => ->(l, r) { [[">=", r], ["<", [l, r.bump].min]] },
+         [ ">=", "=", -1 ] => ->(l, r) { [["=", r]] },
+         [ ">=", "=", 0 ] => ->(l, r) { [["=", r]] },
+         [ ">=", "!=", -1 ] => ->(l, r) { [[">=", l], ["<", r]] },
+         [ ">=", "!=", 0 ] => ->(l, r) { [[">", l]] },
+         [ ">=", "!=", 1 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", ">", -1 ] => ->(l, r) { [[">", r]] },
+         [ ">=", ">", 0 ] => ->(l, r) { [[">", r]] },
+         [ ">=", ">", 1 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", "<", -1 ] => ->(l, r) { [[">=", l], ["<", r]] },
+         [ ">=", ">=", nil ] => ->(l, r) { [[">=", [r, l].max]] },
+         [ ">=", "<=", -1 ] => ->(l, r) { [[">=", l], ["<=", r]] },
+         [ ">=", "<=", 0 ] => ->(l, r) { [["=", l]] },
+         [ ">=", "~>", ->(l, r) { l < r.bump } ] => ->(l, r) { [[">=", [r, l].max], ["<", r.bump]] },
+         [ "<=", "=", 0 ] => ->(l, r) { [["=", r]] },
+         [ "<=", "=", 1 ] => ->(l, r) { [["=", r]] },
+         [ "<=", "!=", -1 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "!=", 0 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "!=", 1 ] => ->(l, r) { [[">", r], ["<=", l]] },
+         [ "<=", ">", 1 ] => ->(l, r) { [[">", r], ["<=", l]] },
+         [ "<=", "<", -1 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "<", 0 ] => ->(l, r) { [["<", l]] },
+         [ "<=", "<", 1 ] => ->(l, r) { [["<", r]] },
+         [ "<=", ">=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "<=", ">=", 1 ] => ->(l, r) { [[">=", r], ["<=", l]] },
+         [ "<=", "~>", ->(l, r) { r.bump > l } ] => ->(l, r) { [[">=", r], ["<", r.bump]] },
+         [ "<=", "~>", ->(l, r) { r >= l && r.bump <= l } ] => ->(l, r) { [[">=", r], ["<=", l]] },
+         [ "~>", "=", 0 ] => ->(l, r) { [["=", r]] },
+         [ "~>", "=", ->(l, r) { l.bump > r } ] => ->(l, r) { [["=", r]] },
+         [ "~>", "!=", ->(l, r) { l.bump >= r } ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", "!=", ->(l, r) { l > r && l.bump < r } ] => ->(l, r) { [[">=", l], ["<", r]] },
+         [ "~>", "!=", 0 ] => ->(l, r) { [[">", l], ["<", l.bump]] },
+         [ "~>", "!=", 1 ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", ">", ->(l, r) { l < r && l.bump >= r } ] => ->(l, r) { [[">", r], ["<", l.bump]] },
+         [ "~>", ">", 0 ] => ->(l, r) { [[">", l], ["<", l.bump]] },
+         [ "~>", ">", 1 ] => ->(l, r) { [[">=", l], ["<", l.bump]]},
+         [ "~>", "<", nil ] => ->(l, r) { [[">=", l], ["<", [r, l.bump].max]] },
+         [ "~>", ">=", ->(l, r) { l < r && l.bump >= r } ] => ->(l, r) { [[">=", r], ["<", l.bump]] },
+         [ "~>", ">=", 0 ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", ">=", 1 ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", "<=", ->(l, r) { l < r && l.bump >= r } ] => ->(l, r) { [[">=", l], ["<=", r]] },
+         [ "~>", "<=", ->(l, r) { l.bump < r } ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", "<=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "~>", "~>", ->(l, r) { l.bump >= r && l < r.bump || r.bump >= l && r < l.bump } ] => ->(l, r) { [[">=", [r, l].max], ["<", [r.bump, l.bump].min]] }
+      }.freeze
+
+      OR_RELAS = { #:nodoc:
+         [ "=", ">=", nil ] => ->(l, r) { [[">=", [r, l].min]] },
+         [ "=", "<=", -1 ] => ->(l, r) { [["<=", r]] },
+         [ "=", "<=", 0 ] => ->(l, r) { [["<=", r]] },
+         [ "=", ">", 0 ] => ->(l, r) { [[">=", r]] },
+         [ "=", ">", 1 ] => ->(l, r) { [[">", r]] },
+         [ "=", "<", -1 ] => ->(l, r) { [["<", r]] },
+         [ "=", "<", 0 ] => ->(l, r) { [["<=", r]] },
+         [ "=", "=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "=", "~>", nil ] => ->(l, r) { [[">=", [r, l].min], ["<", r.bump]] },
+         [ "!=", "=", -1 ] => ->(l, r) { [["=", r], ["!=", l]] },
+         [ "!=", "=", 0 ] => ->(l, r) { [] },
+         [ "!=", "=", 1 ] => ->(l, r) { [["=", r], ["!=", l]] },
+         [ "!=", "!=", 0 ] => ->(l, r) { [["!=", l]] },
+         [ "!=", ">", -1 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">", 0 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">", 1 ] => ->(l, r) { [[">", r], ["!=", l]] },
+         [ "!=", "<", -1 ] => ->(l, r) { [["<", r], ["!=", l]] },
+         [ "!=", "<", 0 ] => ->(l, r) { [["<", r]] },
+         [ "!=", "<", 1 ] => ->(l, r) { [["<", r]] },
+         [ "!=", ">=", -1 ] => ->(l, r) { [[">=", r]] },
+         [ "!=", ">=", 0 ] => ->(l, r) { [[">", r]] },
+         [ "!=", ">=", 1 ] => ->(l, r) { [[">=", r], ["!=", l]] },
+         [ "!=", "<=", -1 ] => ->(l, r) { [["<=", r], ["!=", l]] },
+         [ "!=", "<=", 0 ] => ->(l, r) { [["<", r]] },
+         [ "!=", "<=", 1 ] => ->(̀r, l) { [["<=", r]] },
+         [ "!=", "~>", -1 ] => ->(l, r) { [[">=", r], ["<", r.bump], ["!=", l]] },
+         [ "!=", "~>", 0 ] => ->(l, r) { [[">", r], ["<", r.bump]] },
+         [ "!=", "~>", 1 ] => ->(l, r) { [[">=", r], ["<", r.bump], ["!=", l]] },
+         [ ">", "=", 0 ] => ->(l, r) { [[">=", l]] },
+         [ ">", "=", 1 ] => ->(l, r) { [[">", l]] },
+         [ ">", "!=", 0 ] => ->(l, r) { [[">", l]] },
+         [ ">", "!=", 1 ] => ->(l, r) { [[">", l]] },
+         [ ">", ">", nil ] => ->(l, r) { [[">", [r, l].min]] },
+         [ ">", "<", 0 ] => ->(l, r) { [] },
+         [ ">", "<", 1 ] => ->(l, r) { [] },
+         [ ">", ">=", -1 ] => ->(l, r) { [[">", l]] },
+         [ ">", ">=", 0 ] => ->(l, r) { [[">=", r]] },
+         [ ">", ">=", 1 ] => ->(l, r) { [[">=", r]] },
+         [ ">", "<=", 0 ] => ->(l, r) { [] },
+         [ ">", "<=", 1 ] => ->(l, r) { [] },
+         [ ">", "~>", -1 ] => ->(l, r) { [[">", l], ["<", r.bump]] },
+         [ ">", "~>", 0 ] => ->(l, r) { [[">=", r], ["<", r.bump]] },
+         [ ">", "~>", 1 ] => ->(l, r) { [[">=", r], ["<", r.bump]] },
+         [ "<", "=", 0 ] => ->(l, r) { [["<=", l]] },
+         [ "<", "=", 1 ] => ->(l, r) { [["<", l]] },
+         [ "<", "!=", -1 ] => ->(l, r) { [["<", l]] },
+         [ "<", "!=", 0 ] => ->(l, r) { [["<", l]] },
+         [ "<", ">", -1 ] => ->(l, r) { [] },
+         [ "<", ">", 0 ] => ->(l, r) { [] },
+         [ "<", ">", 1 ] => ->(l, r) { [[">", r], ["<", l]] },
+         [ "<", "<", nil ] => ->(l, r) { [["<", [r, l].max]] },
+         [ "<", ">=", -1 ] => ->(l, r) { [] },
+         [ "<", ">=", 0 ] => ->(l, r) { [] },
+         [ "<", ">=", 1 ] => ->(l, r) { [[">=", r], ["<", l]] },
+         [ "<", "~>", nil ] => ->(l, r) { [[">=", r], ["<", [l, r.bump].max]] },
+         [ ">=", "=", 0 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", "=", -1 ] => ->(l, r) { [[">=", l], ["=", r]] },
+         [ ">=", "!=", 0 ] => ->(l, r) { [[">", l]] },
+         [ ">=", "!=", 1 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", ">", -1 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", ">", 0 ] => ->(l, r) { [[">=", l]] },
+         [ ">=", ">", 1 ] => ->(l, r) { [[">", r]] },
+         [ ">=", "<", 0 ] => ->(l, r) { [] },
+         [ ">=", "<", 1 ] => ->(l, r) { [] },
+         [ ">=", ">=", nil ] => ->(l, r) { [[">=", [r, l].min]] },
+         [ ">=", "<=", 0 ] => ->(l, r) { [["=", l]] },
+         [ ">=", "<=", 1 ] => ->(l, r) { [] },
+         [ ">=", "~>", nil ] => ->(l, r) { [[">=", [r, l].min], ["<", r.bump]] },
+         [ "<=", "=", 0 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "=", 1 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "!=", -1 ] => ->(l, r) { [["<", l]] },
+         [ "<=", "!=", 0 ] => ->(l, r) { [["<", l]] },
+         [ "<=", ">", -1 ] => ->(l, r) { [] },
+         [ "<=", ">", 0 ] => ->(l, r) { [] },
+         [ "<=", ">", 1 ] => ->(l, r) { [[">", r], ["<=", l]] },
+         [ "<=", "<", -1 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "<", 0 ] => ->(l, r) { [["<=", l]] },
+         [ "<=", "<", 1 ] => ->(l, r) { [["<", r]] },
+         [ "<=", ">=", -1 ] => ->(l, r) { [] },
+         [ "<=", ">=", 0 ] => ->(l, r) { [["=", l]] },
+         [ "<=", ">=", 1 ] => ->(l, r) { [[">=", r], ["<=", l]] },
+         [ "<=", "~>", ->(l, r) { r.bump > l } ] => ->(l, r) { [[">=", r], ["<", r.bump]] },
+         [ "<=", "~>", ->(l, r) { r.bump <= l } ] => ->(l, r) { [[">=", r], ["<=", l]] },
+         [ "~>", "=", nil ] => ->(l, r) { [[">=", [l, r].min], ["<", l.bump]] },
+         [ "~>", "!=", -1 ] => ->(l, r) { [[">=", l], ["<", l.bump], ["!=", r]] },
+         [ "~>", "!=", 0 ] => ->(l, r) { [[">", l], ["<", l.bump]] },
+         [ "~>", "!=", 1 ] => ->(l, r) { [[">=", l], ["<", l.bump], ["!=", r]] },
+         [ "~>", ">", -1 ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", ">", 0 ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", ">", 1 ] => ->(l, r) { [[">", r], ["<", l.bump]]},
+         [ "~>", "<", nil ] => ->(l, r) { [[">=", l], ["<", [r, l.bump].max]] },
+         [ "~>", ">=", nil ] => ->(l, r) { [[">=", [l, r].min], ["<", l.bump]] },
+         [ "~>", "<=", ->(l, r) { l.bump > r } ] => ->(l, r) { [[">=", l], ["<", l.bump]] },
+         [ "~>", "<=", ->(l, r) { l.bump <= r } ] => ->(l, r) { [[">=", l], ["<=", r]] },
+         [ "~>", "~>", nil ] => ->(l, r) { [[">=", [r, l].min], ["<", [r.bump, l.bump].max]] }
+      }.freeze
+
+      def | other_requirement
+         self.expand_requirements(self.requirements | other_requirement.requirements)
+      end
+
+      def expand
+         self.expand_requirements(self.requirements)
+      end
+
+      def expand_requirements requirements
+         reqs_in = []
+         res = requirements.dup
+
+         #binding.pry
+         while reqs_in != res do
+            reqs_in = res
+            reqs = reqs_in.dup
+            res = []
+
+            #binding.pry
+            while !reqs.empty? do
+               op1, ver1 = reqs.shift
+               op2, ver2 = reqs.shift || [op1, ver1]
+
+               prc =
+                  Gem::Requirement::OR_RELAS.find do |((left, right, comp), _)|
+                     match = op1 == left && op2 == right &&
+                        case comp
+                        when NilClass
+                           true
+                        when Integer
+                           comp == (ver1 <=> ver2)
+                        when Proc
+                           comp[ver1, ver2]
+                        end
+                  end
+
+               #binding.pry
+               res =
+                  if prc
+                     res.concat(prc.last[ver1, ver2])
+                  elsif reqs.empty?
+                     res.concat([[op1, ver1], [op2, ver2]])
+                  else
+                     #binding.pry
+                     reqs.unshift([op2, ver2])
+                     res.concat([[op1, ver1]])
+                  end
+            end
+         end
+
+         #binding.pry
+         Gem::Requirement.new(res.map {|x|x.join(" ")})
+      end
+
+      # merging gem requirement with others strictizing the conditions
+      def merge other_requirement
+         reqs_pre = self.requirements | other_requirement.requirements
+         reqs_tmp = []
+
+         while reqs_tmp != reqs_pre
+            reqs_tmp = reqs_pre
+            reqs_pre =
+               reqs_tmp[1..-1].reduce([reqs_tmp.first]) do |res, req|
+                  op1, ver1 = res.last
+                  op2, ver2 = req
+
+                  prc =
+                     Gem::Requirement::AND_RELAS.find do |((left, right, comp), _)|
+                        match = op1 == left && op2 == right &&
+                           case comp
+                           when NilClass
+                              true
+                           when Integer
+                              comp == (ver1 <=> ver2)
+                           when Proc
+                              comp[ver1, ver2]
+                           end
+                     end
+
+                  res[0...-1] | prc ? prc.last[ver1, ver2] : [INVALID_DEP]
+            end
+         end
+
+         # binding.pry
+         Gem::Requirement.new(reqs_pre.map {|x|x.join(" ")})
+      end
+   end
+
+   module Kernel
+      def yaml_load text
+         if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("4.0.0")
+            YAML.load(text, aliases: true, permitted_classes:
+               [Gem::Specification,
+                Gem::Version,
+                Gem::Dependency,
+                Gem::Requirement,
+                Symbol,
+                OpenStruct,
+                Time,
+                Date])
+         else
+            YAML.load(text)
+         end
+      end
+   end
+end

data/lib/baltix/i18n.rb

@@ -0,0 +1,64 @@
+require 'baltix/version'
+
+module Baltix::I18n
+   class << self
+      def locale_trees
+         @locale_trees ||= {}
+      end
+
+      def default_locale
+         @default_locale ||= locales.sort do |x, y|
+            x == "en_US.UTF-8" && -1 || y == "en_US.UTF-8" && 1 || 0
+         end.first
+      end
+
+      def locales
+         @locales ||= Dir[File.join(File.dirname(__FILE__), "..", "..", "locale", "*.yaml")].map do |file|
+            File.basename(file, ".yaml")
+         end
+      end
+
+      def defaulted_locales
+         @defaulted_locales ||= locales.map { |locale| locale == default_locale && "" || locale }
+      end
+
+      def locale_tree locale
+         return locale_trees[locale] if locale_trees[locale]
+
+         file = File.join(File.dirname(__FILE__), "..", "..", "locale", "#{locale}.yaml")
+
+         YAML.load(IO.read(file))
+      end
+
+      def t! path, options = {}
+         parts = path.to_s.split(".")
+         locale = options[:locale].blank? && default_locale || options[:locale]
+         #binding.pry
+         line = parts.reduce(locale_tree(locale)) { |r, part| [ r[part] ].flatten.first }
+
+         line.gsub(/%\w+/) do |str|
+            /%(?<name>\w+)/ =~ str
+
+            if options[:binding].local_variable_defined?(name)
+               options[:binding].local_variable_get(name)
+            elsif options[:binding].instance_variable_defined?("@#{name}")
+               options[:binding].instance_variable_get(:"@#{name}")
+            end
+         end
+      end
+
+      def is_default? locale
+         default_locale == locale.to_s
+      end
+
+      def t path, options = {}
+         t!(path, options)
+      rescue NoMethodError
+         nil
+      end
+   end
+
+   def t path, options = {}
+      Baltix::I18n.t(path, options)
+   end
+end

data/lib/baltix/loader/cmake.rb

@@ -0,0 +1,11 @@
+# Cmake based compilable gemspec detection, no gemspec is actually returned
+# Sample gem is: hiredis
+#
+module Baltix::Loader::Cmake
+   def cmake file
+      log_in = `cmake .`
+      debug(log_in)
+   rescue Errno::ENOENT
+      error "Error: cmake is required to properly detect the gem"
+   end
+end

data/lib/baltix/loader/git-version-gen.rb

@@ -0,0 +1,36 @@
+# GIT-VERSION-GEN version generator based gemspec preparser
+# example: "kgio" gem
+#
+module Baltix::Loader::GitVersionGen
+   def git_version_gen execfile
+      IO.popen(execfile) do |io|
+         debug(io.readlines)
+      end
+
+      dir = File.dirname(execfile)
+      version_line = IO.read(File.join(dir, "GIT-VERSION-FILE"))
+      if /=(?<version>.*)/ =~ version_line
+         ENV["VERSION"] = version.strip
+      end
+
+      # dot manifest generation
+      files = Dir["*/**/*"].select {|x| File.file?(x) }
+      File.open(".manifest", "w+") {|f| f.puts(files.join("\n"))}
+
+      # make documentaion
+      if File.directory?('Documentation')
+         `make -C Documentation`
+      end
+
+      if !File.exist?('.manifest') || !File.exist?('.gem-manifest')
+         files = Dir.glob("**/*", File::FNM_DOTMATCH).reject do |f|
+            /\/\.git/ =~ f || File.directory?(f)
+         end
+
+         File.open(File.join('.gem-manifest'), "w") { |f| f.puts files }
+         FileUtils.cp('.gem-manifest', '.manifest')
+      end
+
+      nil
+   end
+end