baltix 0.1.1

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

@@ -0,0 +1,412 @@
+class Baltix::Spec::Rpm::Parser
+   MATCHER = /^Name:\s+([^\s]+)/i
+
+   SCHEME = {
+      name: {
+         non_contexted: true,
+         regexp: /^Name:\s+([^\s]+)/i,
+         parse_func: :parse_name
+      },
+      version: {
+         non_contexted: true,
+         regexp: /Version:\s+([^\s]+)/i,
+         parse_func: :parse_version,
+         mode: :replace
+      },
+      epoch: {
+         non_contexted: true,
+         regexp: /Epoch:\s+([^\s]+)/i,
+         mode: :replace
+      },
+      release: {
+         non_contexted: true,
+         regexp: /Release:\s+([^\s]+)/i,
+         mode: :replace
+      },
+      summaries: {
+         regexp: /Summary(?:\(([^\s:]+)\))?:\s+([^\s].+)/i,
+         parse_func: :parse_summary,
+         mode: :replace
+      },
+      licenses: {
+         non_contexted: true,
+         regexp: /License:\s+([^\s].+)/i,
+         parse_func: :parse_license
+      },
+      group: /Group:\s+([^\s]+)/i,
+      uri: /Url:\s+([^\s]+)/i,
+      vcs: /Vcs:\s+([^\s]+)/i,
+      packager: {
+         non_contexted: true,
+         regexp: /Packager:\s+(.*)\s*(?:<(.*)>)$/i,
+         parse_func: :parse_packager
+      },
+      build_arch: /BuildArch:\s+([^\s]+)/i,
+      patches: {
+         non_contexted: true,
+         regexp: /Patch(\d+)?:\s+([^\s]+)/i,
+         parse_func: :parse_file
+      },
+      source_files: {
+         non_contexted: true,
+         regexp: /Source(\d+)?:\s+([^\s]+)/i,
+         parse_func: :parse_file
+      },
+      build_pre_requires: {
+         non_contexted: true,
+         regexp: /(?:BuildPreReq|BuildRequires\(pre\)):\s+([\w\s<=>\.\-_]+)/i,
+         parse_func: :parse_dep
+      },
+      build_requires: {
+         non_contexted: true,
+         regexp: /^BuildRequires:\s*([^#]+)/i,
+         parse_func: :parse_dep
+      },
+      obsoletes: {
+         regexp: /^Obsoletes:\s*([^#]+)/i,
+         parse_func: :parse_dep
+      },
+      provides: {
+         regexp: /^Provides:\s*([^#]+)/i,
+         parse_func: :parse_dep
+      },
+      requires: {
+         regexp: /^Requires:\s*([^#]+)/i,
+         parse_func: :parse_dep
+      },
+      conflicts: {
+         regexp: /^Conflicts:\s*([^#]+)/i,
+         parse_func: :parse_dep
+      },
+      ignored_names: {
+         non_contexted: true,
+         regexp: /(^%ruby_ignore|--ignore=)\s*([^\s$]+)/i,
+         parse_func: :parse_ignore
+      },
+      descriptions: {
+         regexp: /^%description\s*([^\s].*)?/i,
+         parse_func: :parse_description
+      },
+      secondaries: {
+         non_contexted: true,
+         regexp: /^%package\s+(.+)/i,
+         parse_func: :parse_secondary
+      },
+      prep: {
+         non_contexted: true,
+         regexp: /^%prep/i,
+         parse_func: :parse_plain_section
+      },
+      build: {
+         non_contexted: true,
+         regexp: /^%build/i,
+         parse_func: :parse_plain_section
+      },
+      install: {
+         non_contexted: true,
+         regexp: /^%install/i,
+         parse_func: :parse_plain_section
+      },
+      check: {
+         non_contexted: true,
+         regexp: /^%check/i,
+         parse_func: :parse_plain_section
+      },
+      file_list: {
+         regexp: /^%files\s*([^\s].*)?/i,
+         parse_func: :parse_file_list
+      },
+      changes: {
+         non_contexted: true,
+         regexp: /^%changelog/i,
+         parse_func: :parse_changes
+      },
+      context: {
+         non_contexted: true,
+         regexp: /^%(?:(?:global|define)|((?!description|package|files)[^\s]+))\s+(?:([^\s]+)\s+([^\s].*)|(.*))/i,
+         parse_func: :parse_context
+      },
+      comment: {
+         non_contexted: true,
+         parse_func: :parse_comment
+      }
+   }.to_os(hash: true)
+
+   def source source_in
+      if source_in.respond_to?(:readlines)
+         source_in.rewind
+         source_in.readlines
+      else
+         source_in.split("\n")
+      end
+   end
+
+   def parse source_in, options = {}
+      context = {}.to_os
+      matched = {}.to_os
+      match = nil
+      state_in = {
+         "context" => {
+            "__options" => options.to_os,
+            "__custom" => { 'gemname' => '%pkgname' }.to_os
+         }
+      }.to_os(hash: true)
+
+      state = source(source_in).reduce(state_in) do |state, line|
+         SCHEME.find do |key, rule|
+            match = rule.is_a?(Regexp) && rule.match(line) ||
+                    rule.is_a?(OpenStruct) && rule[:regexp] && rule[:regexp].match(line)
+
+            if match
+               if matched.name
+                  if matched.name != key
+   #               binding.pry if matched[:match][0] =~ /description/
+                     store_value(state, matched[:match], matched[:name], matched[:flow], context)
+                     matched = { name: key.to_s, flow: "", match: match }.to_os
+                  end
+               else
+                  matched = { name: key.to_s, flow: "", match: match }.to_os
+               end
+            end
+         end
+
+         if matched.name
+            if matched.flow
+               matched.flow << line + "\n"
+            else
+               matched.flow = line + "\n"
+            end
+         else
+            matched = { name: "comment", flow: line + "\n", match: [] }.to_os
+         end
+
+         state
+      end
+
+      store_value(state, matched.match, matched.name, matched.flow, context)
+
+      #binding.pry
+      state
+   end
+
+   def store_value opts, match, key, flow, context
+      data = SCHEME[key]
+      rule = data.is_a?(OpenStruct) && data.rule || data
+      parse_func = data.is_a?(OpenStruct) && data.parse_func || :parse_default
+      non_contexted = data.is_a?(OpenStruct) && data.non_contexted
+      reflown = reeval(flow, opts)
+      rematched = match.to_a.map { |x| x.is_a?(String) && reeval(x, opts) || x }
+      value = method(parse_func)[rematched, reflown, opts, context]
+      mode = data.is_a?(OpenStruct) && data.mode || :append
+      copts = !non_contexted && context.name && opts.secondaries.find do |sec|
+         #binding.pry
+         sec.name == Baltix::Spec::Rpm::Name.parse(
+            context.name,
+            support_name: opts.name,
+            aliases: aliased_names(opts))
+      end || opts
+      #binding.pry if key =~ /summar/
+      #binding.pry if context[:kind]
+      if !non_contexted && context.kind && context.kind.to_s != copts["name"].kind
+         copts["name"] =
+            Baltix::Spec::Rpm::Name.parse(copts["name"].original_fullname,
+               kind: context.kind,
+               support_name: copts["name"].support_name)
+      end
+
+      copts[key] =
+      case copts[key]
+      when NilClass
+         value
+      when Array
+         copts[key] | [ value.is_a?(OpenStruct) && value || value ].flatten
+      when OpenStruct
+         copts[key].deep_merge(value, mode: mode)
+      else
+         value
+      end
+
+      #binding.pry if key =~ /summar/
+      opts
+   end
+
+   def secondary_for_context opts, context
+      opts.secondaries.find do |sec|
+      #binding.pry
+         sec.name == Baltix::Spec::Rpm::Name.parse(
+            context.name,
+            support_name: opts.name,
+            aliases: aliased_names(opts))
+      end
+   end
+
+   def reeval flow, opts
+      #binding.pry if flow =~ /%gemname/
+      [opts.context.__options, opts.context.__macros, opts, opts.context.__custom].compact.reduce(flow) do |reflown_in, source|
+         source.table.keys.sort_by {|x|x.size}.reverse.reduce(reflown_in) do |reflown, name|
+            next reflown if /context|__macros|__options/ =~ name
+            value = source[name]
+            #binding.pry if flow =~ /%gemname/ && name =~ /%gemname/
+            r = reflown.dup
+            r.gsub!(/%({#{name}}|#{name})/, value.to_s) && value.is_a?(String) && /^%/ =~ value ? reeval(r, opts) : r
+         end
+      end || raise #flow
+   end
+
+   def parse_name match, *_
+      Baltix::Spec::Rpm::Name.parse(match[1])
+   end
+
+   def parse_comment match, flow, *_
+      flow
+   end
+
+   def parse_file match, *_
+      { match[1] || "0" => match[2] }.to_os
+   end
+
+   def parse_file_list match, flow, opts, context
+      kind = {
+         lib: /ruby_gemspec|ruby_gemlibdir/,
+         doc: /ruby_gemdocdir/,
+         exec: /_bindir/,
+      }.find { |(k, re)| re =~ flow }&.[](0)
+      context.replace(parse_context_line(match[1], opts).merge(kind: kind))
+      splitten_flow(flow)
+   end
+
+   def parse_changes _, flow, *_
+      rows = flow.split("\n* ").map { |p| p.strip }.compact.map { |p| p.split("\n") }
+
+      rows[1..-1].map do |row|
+         /(?<date>^\w+\s+\w+\s+\w+\s+\w+)\s+(?<author>.*)\s*(?:<(?<email>.*)>)\s+(?:(?<epoch>[0-9]+):)?(?<version>[\w\.]+)(?:-(?<release>[\w\._]+))?$/ =~ row[0]
+
+         {
+            date: date,
+            author: author.strip,
+            email: email,
+            version: Gem::Version.new(version),
+            release: release,
+            epoch: epoch,
+            description: row[1..-1].join("\n")
+         }.to_os
+      end.reverse
+   end
+
+   def parse_dep match, *_
+      deps = match[1].scan(/[^\s]+(?:\s+[<=>]+\s+[^\s]+)?/)
+      deps.reject {|d| /^(gem|rubygem|ruby-gem)\(/ =~ d }
+   end
+
+   def parse_ignore match, *_
+      match[2].split(/,/).map {|x| x =~ /^\/(.*)/ && /#{$1}/ || x }
+   end
+
+   def parse_default match, *_
+      match[1]
+   end
+
+   def parse_plain_section _, flow, *_
+      splitten_flow(flow)
+   end
+
+   # secondary without suffix by default has kind of lib
+   def parse_secondary match, flow, opts, context
+      context.replace(parse_context_line(match[1], opts))
+      name = Baltix::Spec::Rpm::Name.parse(context.name, support_name: opts.name, aliases: aliased_names(opts))
+
+      [{ "name" => name, "version" => opts.version, "release" => opts.release, "summaries" => opts.summaries.dup }.to_os ]
+   end
+
+   def parse_description match, flow, opts, context
+      context.replace(parse_context_line(match[1], opts))
+      { context.cp || Baltix::I18n.default_locale => splitten_flow(flow) }.to_os
+   end
+
+   def parse_license match, *_
+      match[1].split(/(?: or |\/)/).map(&:strip)
+   end
+
+   def parse_summary match, _, opts, *_
+      opts.summary = match[2]
+      { match[1] || Baltix::I18n.default_locale => match[2] }.to_os
+   end
+
+   def parse_context match, *_
+      if match[1]
+         {
+            "__macros" => {
+               match[1] => match[4]&.strip || [match[2], match[3]].compact.join(" ").strip
+            }
+         }.to_os(hash: true)
+      elsif match[2]
+         {
+            "__macros" => {
+               match[2] => match[5]&.strip || [match[3], match[4]].compact.join(" ").strip
+            }
+         }.to_os(hash: true)
+      else
+         { match[3] => match[4] }.to_os
+      end
+   end
+
+   def parse_version match, *_
+      Gem::Version.new(match[1])
+   end
+
+   def parse_packager match, *_
+      OpenStruct.new(name: match[1]&.strip, email: match[2]&.strip)
+   end
+
+   def parse_context_line line, opts
+      key = nil
+      context = line.to_s.split(/\s+/).reduce({}.to_os) do |res, arg|
+      #binding.pry
+         case arg
+         when '-l'
+            key = :cp
+         when '-n'
+            key = :fullname
+         else
+            case key
+            when :cp
+               res.cp = arg
+            when :fullname
+               res.name = arg
+            else
+               res.name = "#{opts.name}-#{arg}"
+            end
+         end
+
+         res
+      end
+
+      if context.name
+         opts.secondaries ||= []
+#         name = Baltix::Spec::Rpm::Name.parse(context[:name])
+#      binding.pry
+#         sel = opts["secondaries"].select { |sec| sec.name == name }
+
+#            opts["secondaries"] << { "name" => name }.to_os if sel.blank?
+      end
+#      binding.pry
+
+      context
+   end
+
+   def aliased_names opts
+      opts.context.__options&.aliased_names
+   end
+
+   protected
+
+   def splitten_flow flow
+      (flow.split("\n")[1..-1] || []).join("\n")
+   end
+
+   class << self
+      def match? source_in
+         MATCHER =~ source_in
+      end
+   end
+end

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

@@ -0,0 +1,170 @@
+class Baltix::Spec::Rpm::Secondary
+   attr_reader :source, :spec, :host, :source
+
+   STATE = {
+      name: {
+         seq: %w(of_options of_source of_state of_default _name _local_rename),
+         default: "",
+      },
+      pre_name: {
+         seq: %w(of_options of_state of_default _pre_name),
+         default: "",
+      },
+      epoch: {
+         seq: %w(of_options of_state),
+         default: nil,
+      },
+      version: {
+         seq: %w(of_options of_source of_state of_default _version),
+         default: ->(_) { Time.now.strftime("%Y%m%d") },
+      },
+      release: {
+         seq: %w(of_options of_state _release),
+         default: "alt1",
+      },
+      build_arch: {
+         seq: %w(of_options of_state of_source),
+         default: "noarch",
+      },
+      summaries: {
+         seq: %w(of_options of_state of_source of_default _summaries),
+         default: ""
+      },
+      group: {
+         seq: %w(of_options _group),
+         default: ->(this) { Baltix::I18n.t("spec.rpm.#{this.kind}.group") },
+      },
+      requires: {
+         seq: %w(of_options of_state of_default _requires_plain_only _requires),
+         default: [],
+      },
+      conflicts: {
+         seq: %w(of_options of_state of_default _conflicts_plain_only _conflicts),
+         default: [],
+      },
+      provides: {
+         seq: %w(of_options of_state of_default _provides),
+         default: [],
+      },
+      obsoletes: {
+         seq: %w(of_options of_state of_default _obsoletes),
+         default: [],
+      },
+      file_list: {
+         seq: %w(of_options of_state of_source),
+         default: "",
+      },
+      compilables: {
+         seq: %w(of_options of_state of_source),
+         default: [],
+      },
+      descriptions: {
+         seq: %w(of_options of_state of_source of_default _proceed_description _descriptions _format_descriptions),
+         default: {}
+      },
+      readme: {
+         seq: %w(of_options of_source _readme of_state),
+         default: nil,
+      },
+      executables: {
+         seq: %w(of_options of_source of_state),
+         default: [],
+      },
+      docs: {
+         seq: %w(of_options _docs of_state),
+         default: nil,
+      },
+      devel: {
+         seq: %w(of_options _devel of_state),
+         default: nil,
+      },
+      devel_requires: {
+         seq: %w(of_options of_state _devel_requires),
+         default: nil,
+      },
+      devel_conflicts: {
+         seq: %w(of_options of_state _devel_conflicts),
+         default: nil,
+      },
+      devel_sources: {
+         seq: %w(of_options _devel_sources of_state),
+         default: [],
+      },
+      files: {
+         seq: %w(of_options _files of_state),
+         default: []
+      },
+      context: {
+         seq: %w(of_options of_state),
+         default: {},
+      },
+      dependencies: {
+         seq: %w(of_options of_state of_source),
+         default: []
+      },
+      gem_versionings: {
+         seq: %w(of_options of_state _gem_versionings),
+         default: []
+      },
+      available_gem_list: {
+         seq: %w(of_options of_state _available_gem_list),
+         default: {}
+      },
+      available_gem_ranges: {
+         seq: %w(of_options of_state _available_gem_ranges),
+         default: {}
+      },
+      use_gem_obsolete_list: {
+         seq: %w(of_options of_state),
+         default: {}.to_os
+      },
+      rootdir: {
+         seq: %w(of_options of_state),
+         default: nil
+      }
+   }.to_os(hash: true)
+
+   include Baltix::Spec::Rpm::SpecCore
+
+   def resourced_from secondary
+      @kind = secondary.kind.to_sym
+      @spec = secondary.spec
+      @source = secondary.source
+
+      self
+   end
+
+   def state_kind
+      return @state_kind if @state_kind
+
+      # binding.pry
+      @state_kind ||= options.source.is_a?(Baltix::Source::Gem) && "lib" || file_list.blank? && "app" || pre_name&.kind
+   end
+
+   def default_state_kind
+      "app"
+   end
+
+   def kind
+      @kind ||= source.is_a?(Baltix::Source::Gem) && :lib || :app
+   end
+
+   protected
+
+   def _group value_in
+      value_in || (is_exec? || is_app?) && of_state(:group)
+   end
+
+   def _release _value_in
+      spec.changes.last.release
+   end
+
+   def initialize spec: raise, source: nil, host: nil, kind: nil, state: {}, options: {}
+      @source = source
+      @spec = spec
+      @host = host
+      @kind = kind&.to_sym || self.kind
+      @state = state.to_os
+      @options = options.to_os
+   end
+end