baltix 0.1.1

data/lib/baltix/space.rb

@@ -0,0 +1,424 @@
+require 'rubygems'
+
+require 'baltix/version'
+require 'baltix/log'
+require 'baltix/source'
+require 'baltix/spec'
+require 'baltix/cli'
+
+class Baltix::Space
+   include Baltix::Log
+
+   class InvalidSpaceFileError < StandardError; end
+
+   TYPES = {
+      sources: Baltix::Source
+   }
+
+   STATES = {
+      invalid: ->(_, source, _) { !source.valid? },
+      disabled: ->(space, source, _) { space.is_disabled?(source) },
+      duplicated: ->(_, _, dup) { dup },
+   }
+
+   TYPE_CHARS = {
+      fake: '·',
+      gem: '*',
+      gemfile: '&',
+      rakefile: '^',
+   }
+
+   STATUS_CHARS = {
+      invalid: 'X',
+      disabled: '-',
+      duplicated: '=',
+      valid: 'V',
+   }
+
+
+   Gem.load_yaml
+
+   @@space = {}
+   @@options = {}
+
+   # +options+ property returns the hash of the loaded options if any
+   #
+   # options #=> {...}
+   #
+   attr_reader :options, :state
+
+   # +name+ returns a default name of the space with a prefix if any. It returns name of a source when
+   # its root is the same as the space's root, or returns name defined in the spec if any.
+   # If no spec defined returns name of last folder in rootdir or "root" as a default main source name.
+   #
+   # space.name # => space-name
+   #
+   def name
+      return @name if @name
+
+      @name = spec&.name || main_source&.name
+   end
+
+   # +version+ returns a default version for the space. Returns version of a source when
+   # its root is the same as the space's root, or returns version defined in the spec if any,
+   # or returns default one.
+   #
+   # space.version # => 2.1.1
+   #
+   def version
+      return @version if @version
+
+      @version ||= main_source&.version || spec&.version
+   end
+
+   attr_writer :rootdir
+
+   # +rootdir+ returns the root dir for the space got from the options,
+   # defaulting to the current folder.
+   #
+   # rootdir #=> /root/dir/for/the/space
+   #
+   def rootdir
+      @rootdir ||= read_attribute(:rootdir) || Dir.pwd
+   end
+
+   # +main_source+ selects main source from the list of sources when source root dir is the space's one and
+   # source's name contains minimum name size among the matching sources
+   #
+   def main_source
+      return @main_source if @main_source
+
+      reals = valid_sources.select { |source| !source.is_a?(Baltix::Source::Fake) }
+      if spec && !spec.state.blank?
+         specen_source = reals.find { |real| spec.state["name"] === real.name }
+      end
+
+      root_source ||= valid_sources.sort {|x, y| x.name.size <=> y.name.size }.find { |source| source.rootdir == rootdir }
+      @main_source =
+         specen_source || root_source.is_a?(Baltix::Source::Fake) && reals.size == 1 && reals.first || root_source
+   end
+
+   def time_stamp
+      Time.now.strftime("%Y%m%d")
+   end
+
+   # +changes+ returns a list of open-struct formatted changes in the space or
+   # spec defined if any, otherwise returns blank array.
+   #
+   # space.changes # => []
+   #
+   def changes
+      @changes ||= spec&.changes || main_source&.respond_to?(:changes) && main_source.changes || []
+   end
+
+   # +summaries+ returns an open-struct formatted summaries with locales as keys
+   # in the space or spec defined if any, otherwise returns blank open struct.
+   #
+   # space.summaries # => #<OpenStruct en_US.UTF-8: ...>
+   #
+   def summaries
+      return @summaries if @summaries
+
+      if summaries = spec&.summaries || state.summaries
+         summaries
+      elsif summary = main_source&.summary
+         { Baltix::I18n.default_locale => summary }.to_os
+      end
+   end
+
+   # +licenses+ returns license list defined in all the valid sources found in the space.
+   #
+   # space.licenses => # ["MIT"]
+   #
+   def licenses
+      return @licenses if @licenses
+
+      licenses = valid_sources.map { |source| source.licenses rescue [] }.flatten.uniq
+
+      @licenses = !licenses.blank? && licenses || spec&.licenses || []
+   end
+
+   # +dependencies+ returns all the valid source dependencies list as an array of Gem::Dependency
+   # objects, otherwise returning blank array.
+   def dependencies
+      @dependencies ||= valid_sources.map do |source|
+         source.respond_to?(:dependencies) && source.dependencies || []
+      end.flatten.reject do |dep|
+         match_platform?(dep) || sources.any? do |s|
+            dep.name == s.name &&
+            dep.requirement.satisfied_by?(Gem::Version.new(s.version))
+         end
+      end
+   end
+
+   def match_platform? dep
+      if dep.respond_to?(:platforms)
+         (dep.platforms & options.skip_platforms).any?
+      end
+   end
+
+   def files
+      @files ||= valid_sources.map { |s| s.files rescue [] }.flatten.uniq
+   end
+
+   def executables
+      @executables ||= valid_sources.map { |s| s.executables rescue [] }.flatten.uniq
+   end
+
+   def docs
+      @docs ||= valid_sources.map { |s| s.docs rescue [] }.flatten.uniq
+   end
+
+   def compilables
+      @compilables ||= valid_sources.map { |s| s.extensions rescue [] }.flatten.uniq
+   end
+
+   # +sources+ returns all the sources in the space. It will load from the space sources,
+   # or by default will search sources in the provided folder or the current one.
+   #
+   # space.sources => # [#<Baltix::Source:...>, #<...>]
+   #
+   def sources
+      @sources ||= stat_sources.map { |x| x.first }
+   end
+
+   # +valid_sources+ returns all the valid sources based on the current source list.
+   #
+   # space.valid_sources => # [#<Baltix::Source:...>, #<...>]
+   #
+#   def valid_sources
+#      @valid_sources ||= sources.select do |source|
+#         source.valid? && is_regarded?(source)
+#      end
+#   end
+   def valid_sources
+      @valid_sources = stat_sources.map {|(source, status)| status == :valid && source || nil }.compact
+   end
+
+#   def is_regarded? source
+#      regarded_names.any? {|i| i === source.name } ||
+#         !ignored_names.any? {|i| i === source.name } &&
+#         !ignored_path_tokens.any? {|t| /\/#{t}\// =~ source.source_file }
+#   end
+
+   def ignored_names
+      @ignored_names ||= (read_attribute(:ignored_names) || [])
+   end
+
+   def regarded_names
+      @regarded_names ||= read_attribute(:regarded_names) || []
+   end
+
+   def ignored_path_tokens
+      @ignored_path_tokens ||= (read_attribute(:ignored_path_tokens) || [])
+   end
+
+   def spec_type
+      @spec_type ||= read_attribute(:spec_type) || spec && spec.class.to_s.split("::").last.downcase
+   end
+
+   def read_attribute attr
+      options.send(attr) || state.send(attr)
+   end
+
+   def options_for type
+      @@options[type] = type::OPTIONS.map do |option|
+         value = self.options[option] || self.respond_to?(option) && self.send(option) || nil
+
+         [ option, value ]
+      end.compact.to_os
+   end
+
+   # +spec+ property returns the hash of the loaded spec if any, it can be freely
+   # reassigned.
+   #
+   # spec #=> {...}
+   #
+   def spec
+      @spec ||= gen_spec
+   end
+
+   def spec= value
+      gen_spec(value)
+   end
+
+   def is_disabled? source
+      options.ignored_path_tokens.any? { |t| /\/#{t}\// =~ source.source_file } ||
+         options.regarded_names.all? { |i| !i.match?(source.name) } &&
+         options.ignored_names.any? { |i| i === source.name }
+   end
+
+   protected
+
+   def gen_spec spec_in = nil
+      spec_pre = spec_in || state.spec
+
+      @spec =
+         if spec_pre.is_a?(Baltix::Spec::Rpm)
+            spec_pre
+         elsif spec_pre.is_a?(String)
+            self.class.load(spec_pre)
+         elsif options&.spec_file
+            Baltix::Spec.load_from(source: IO.read(options.spec_file), options: options, space: self)
+         elsif @spec_type || options&.spec_type
+            Baltix::Spec.find(@spec_type || options.spec_type).new(options: options, space: self)
+         end
+
+      @spec.assign_space(self) if @spec
+
+      @spec
+   end
+
+   def initialize state_in = {}, options = {}
+      @options = Baltix::CLI::DEFAULT_OPTIONS.merge(options || {})
+      @state = (state_in || {}).to_os
+
+      baltix_log
+   end
+
+   # init log
+   def baltix_log
+      ios = DEFAULT_IO_NAMES.merge(%i(error warn info debug).map {|k| [k, options["#{k}_io"]]}.to_h)
+      Baltix::Log.setup(options.log_level.to_sym, ios)
+   end
+
+   def show_tree
+      info("Sources:")
+      stat_source_tree.each do |(path_in, stated_sources)|
+         stated_sources.each do |(source, status)|
+            path = source.source_path_from(rootdir) if source.source_file
+            stat = [STATUS_CHARS[status], TYPE_CHARS[source.type.to_sym]].join(" ")
+            namever = [source.name, source.version].compact.join(":")
+            info_in = "#{stat}#{namever} [#{path}]"
+
+            info(info_in)
+         end
+      end
+   end
+
+   # returns all the sources with their statuses, and sorted by a its rootdir value
+   #
+   def stat_sources &block
+      return @stat_sources if @stat_sources
+
+      @stat_sources =
+         read_attribute(:stat_sources) || Baltix::Source.search_in(rootdir, options).group_by do |x|
+            [x.name, x.version].compact.join(":")
+         end.map do |(full_name, v)|
+            sorten =
+               v.sort do |x,y|
+                  c0 = ::Baltix::Source.loaders.index(x.loader) <=> ::Baltix::Source.loaders.index(y.loader)
+                  c1 = c0 == 0 && x.name <=> y.name || c0
+                  c2 = c1 == 0 && y.version <=> x.version || c1
+                  c3 = c2 == 0 && y.platform <=> x.platform || c2
+                  c4 = c3 == 0 && y.source_names.grep(/gemspec/).count <=> x.source_names.grep(/gemspec/).count
+
+                  c2 == 0 && c3 == 0 && c4 == 0 && x.rootdir.size <=> y.rootdir.size || c4 != 0 && c4 || c3 != 0 && c3 || c2
+               end.reduce([[], 0]) do |(res, index), source|
+                  dup = source.valid? && index > 0
+                  dup_index = source.valid? && index + 1 || index
+
+                  [res | [[source, source_status(source, dup)]], dup_index]
+               end.first
+
+            sorten[1..-1].each { |x| sorten.first.first.alias_to(x.first) }
+
+            sorten
+         end.flatten(1).sort_by {|(x, _)| x.rootdir.size }.each do |(source, status)|
+            block[source, status] if block_given?
+         end
+
+      show_tree
+
+      @stat_sources
+   end
+
+   # returns source tree, and sorted, and then grouped by a its rootdir value
+   #
+   def stat_source_tree
+      @stat_source_tree ||=
+         stat_sources.group_by {|(x, _)| x.rootdir }.map do |(path, sources)|
+            [File.join('.', path[rootdir.size..-1] || ''), sources]
+         end.to_h
+   end
+
+   # returns status for the source for the project
+   #
+   def source_status source, dup
+      %i(valid duplicated disabled invalid).reduce() do |res, status|
+         STATES[status][self, source, dup] && status || res
+      end
+   end
+
+   def context
+      @context ||= options[:context] || spec&.context || {}
+   end
+
+   def method_missing method, *args
+      value =
+         instance_variable_get(:"@#{method}") ||
+         (spec.send(method) rescue nil) ||
+         options&.[](method) ||
+         spec&.options&.[](method.to_s) ||
+         state[method]
+
+      instance_variable_set(:"@#{method}", value || super)
+
+      value
+   end
+
+   class << self
+      def load string
+         if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("4.0.0")
+            YAML.load(string,
+               aliases: true,
+               permitted_classes: [
+                  Baltix::Source::Fake,
+                  Baltix::Source::Rakefile,
+                  Baltix::Source::Gemfile,
+                  Baltix::Source::Gem,
+                  Baltix::Spec::Rpm,
+                  Baltix::Spec::Rpm::Name,
+                  Baltix::Spec::Rpm::Secondary,
+                  Gem::Specification,
+                  Gem::Version,
+                  Gem::Dependency,
+                  Gem::Requirement,
+                  OpenStruct,
+                  Symbol,
+                  Time,
+                  Date
+               ])
+         else
+            YAML.load(string)
+         end
+      end
+
+      def load_from! state: Dir[".space"].first, options: {}
+#         system_path_check # TODO required to generate spec rubocop
+
+         state_tmp =
+            case state
+            when IO, StringIO
+               load(state.readlines.join(""))
+            when String
+               raise InvalidSpaceFileError.new(state: state) if !File.file?(state)
+
+               load(IO.read(state))
+            when NilClass
+            else
+               raise InvalidSpaceFileError
+            end.to_os
+
+         @@space[state_tmp.name] = self.new(state_tmp, options)
+      end
+
+      def load_from state: Dir[".space"].first, options: {}
+         load_from!(state: state, options: options)
+      rescue InvalidSpaceFileError
+         @@space[nil] = new(nil, options)
+      end
+   end
+end
+
+require 'baltix/space/spec'

data/lib/baltix/spec/rpm/name.rb

@@ -0,0 +1,155 @@
+class Baltix::Spec::Rpm::Name
+   class InvalidAdoptedNameError < StandardError; end
+   class UnsupportedMatchError < StandardError; end
+
+   PREFICES = %w(gem ruby rubygem)
+   RULE = /^(?<full_name>(?:(?<prefix>#{PREFICES.join('|')})-)?(?<name>.*?))(?:-(?<suffix>doc|devel))?$/
+
+   attr_reader :name, :kind, :suffix
+   attr_accessor :support_name
+
+   def aliases
+      @aliases ||= []
+   end
+
+   def prefix
+      @prefix ||= kind == "lib" && self.class.default_prefix || nil
+   end
+
+   def self.default_prefix
+      "gem"
+   end
+
+   def support_name= value
+      case @support_name = value
+      when NilClass
+         @kind = kind == "exec" && "app" || @kind
+      else
+         @kind = kind == "app" && "exec" || @kind
+      end
+   end
+
+   def eql? other, deep = false
+      case other
+      when self.class
+         self.eql_by?(:kind, other) && self.eql_by?(:name, other)
+      when String, Symbol
+         (([ autoname, fullname ] | [ aliases ].flatten) & self.class.parse(other).aliases).any?
+      else
+         other.to_s == self.fullname
+      end || deep && self.eql_by?(:support_name, other)
+   end
+
+   def == other
+      eql?(other)
+   end
+
+   def === other
+      eql?(other)
+   end
+
+   def =~ re
+      to_s =~ re
+   end
+
+   def to_s
+      fullname
+   end
+
+   def merge other
+      options =
+         %w(prefix suffix name support_name kind).map do |prop|
+            [ prop.to_sym, other.send(prop) || self.send(prop) ]
+         end.to_h
+
+      self.class.new(options.merge(aliases: self.aliases | other.aliases))
+   end
+
+   def eql_by? value, other
+      case value
+      when :name
+         ([ self.name, self.aliases ].flatten & [ other.name, other.aliases ].flatten).any?
+      when :kind
+         self.kind == other.kind
+      when :support_name
+         self.support_name === (other.is_a?(self.class) && other.support_name || other)
+      else
+         raise(UnsupportedMatchError.new)
+      end
+   end
+
+   # +fullname+ returns newly reconstructed adopted full name based on the storen data.
+   # All the "." and "_" is replaced with "-", and "ruby" prefix with "gem".
+   #
+   # name.fullname #=> "gem-foo-bar-baz-doc"
+   #
+   def fullname
+      [ autoprefix, autoname, autosuffix ].compact.join("-")
+   end
+
+   def original_fullname
+      [ prefix, name, suffix ].compact.join("-")
+   end
+
+   def autoprefix
+      %w(exec app).include?(kind) || %w(app).include?(support_name&.kind) ? nil : self.class.default_prefix
+   end
+
+   def autoname
+      name&.downcase&.gsub(/[\._]/, "-")
+   end
+
+   def autosuffix
+      %w(doc devel).include?(kind) && kind || nil
+   end
+
+   protected
+
+   def initialize options = {}
+      @aliases = options.fetch(:aliases, []) | options.fetch(:name, "").gsub(/[\.\_]+/, "-").split(",")
+      @prefix = options[:prefix]
+      @suffix = options[:suffix]
+      @name = options[:name]
+      @support_name = options[:support_name]
+      @kind = options[:kind] && options[:kind].to_s ||
+         @suffix ||
+         @prefix && "lib" ||
+         @support_name && "exec" || "app"
+   end
+
+   class << self
+      def parse name_in, options_in = {}
+         m, kind =
+            if name_in.is_a?(self)
+               [name_in.original_fullname.match(RULE), name_in.kind]
+            else
+               [name_in.match(RULE)]
+            end
+
+         aliases_in = (options_in[:aliases] || []).flatten.uniq
+         subaliases = aliases_in - [ m["full_name"] ]
+         #aliases = subaliases | [ m["full_name"] ]
+
+         raise(InvalidAdoptedNameError) if !m
+
+         prefixed = subaliases.size >= aliases_in.size
+         options = {
+            prefix: prefixed && m["prefix"] || nil,
+            #prefix: subaliases.blank? && m["prefix"] || nil,
+            #prefix: m["prefix"],
+            suffix: m["suffix"],
+            kind: kind,
+            #name: m["name"],
+            name: prefixed && m["name"] || m["full_name"],
+            #name: subaliases.blank? && m["name"] || m["full_name"],
+         }.merge(options_in).merge({
+            aliases: subaliases | [ m["full_name"] ]
+         })
+
+         options[:name] = options[:name].blank? && options[:aliases].first || options[:name]
+         #binding.pry if name_in =~ /ruby/
+
+         new(options)
+      end
+   end
+end