Class: Baltix::Spec::Rpm

Inherits:
Object
  • Object
show all
Includes:
I18n, SpecCore
Defined in:
lib/baltix/spec/rpm.rb

Defined Under Namespace

Modules: SpecCore Classes: Name, Parser, Secondary

Constant Summary collapse

OPTIONS = 
%w(source conflicts uri vcs maintainer_name maintainer_email
source_files patches build_pre_requires context comment
readme executables ignored_names main_source dependencies
valid_sources available_gem_list rootdir aliased_names
time_stamp devel_dep_setup use_gem_version_list use_gem_obsolete_list)
PARTS = 
{
   lib: nil,
   exec: :has_executables?,
   doc: :has_docs?,
   devel: :has_devel?,
}
STATE_CHANGE_NAMES = 
%w(name version summaries licenses group uri vcs
packager build_arch source_files build_pre_requires descriptions secondaries
prep build install check file_list)
STATE = 
{
   name: {
      seq: %w(of_options of_state of_source of_default _name _global_rename),
      default: "",
   },
   pre_name: {
      seq: %w(of_options of_state of_default _pre_name),
      default: "",
   },
   epoch: {
      seq: %w(of_options of_source of_state),
      default: nil,
   },
   version: {
      seq: %w(of_options of_source of_state of_default _version),
      default: ->(this) { this.options.time_stamp || 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 of_state of_source),
      default: ->(this) { t("spec.rpm.#{this.kind}.group") },
   },
   requires: {
      seq: %w(of_options of_state of_default _filter_out_obsolete _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: "",
   },
   licenses: {
      seq: %w(of_options of_state _licenses),
      default: [],
   },
   uri: {
      seq: %w(of_options of_state of_source),
      default: nil,
   },
   vcs: {
      seq: %w(of_options of_state of_source _vcs),
      default: nil,
   },
   packager: {
      seq: %w(of_options of_state),
      default: ->(this) do
         OpenStruct.new(
            name: this.options.maintainer_name || "Spec Author",
            email: this.options.maintainer_email || "[email protected]"
         )
      end
   },
   source_files: {
      seq: %w(of_options of_state of_default _source_files),
      default: { "0": "%name-%version.tar" }.to_os,
   },
   patches: {
      seq: %w(of_options of_state),
      default: {}.to_os,
   },
   build_dependencies: {
      seq: %w(of_options of_state of_default _build_dependencies _build_dependencies_sort),
      default: [],
   },
   build_requires: {
      seq: %w(of_options of_state of_default _filter_out_build_auto_requires _filter_out_obsolete _build_requires),
      default: [],
   },
   build_conflicts: {
      seq: %w(of_options of_state of_default _build_conflicts),
      default: [],
   },
   build_pre_requires: {
      seq: %w(of_options of_state of_default _build_pre_requires),
      default: [ "rpm-build-ruby" ],
   },
   changes: {
      seq: %w(of_options of_state of_source of_default _changes),
      default: ->(this) do
         version = this.version
         description = Baltix::I18n.t("spec.rpm.change.new", binding: binding)
         release = this.of_options(:release) || this.of_state(:release) || "alt1"

         [ OpenStruct.new(
            date: Date.today.strftime("%a %b %d %Y"),
            author: this.packager.name,
            email: this.packager.email,
            version: version,
            release: release,
            description: description) ]
      end,
   },
   prep: {
      seq: %w(of_options of_state),
      default: "%setup",
   },
   build: {
      seq: %w(of_options of_state),
      default: "%ruby_build",
   },
   install: {
      seq: %w(of_options of_state),
      default: "%ruby_install",
   },
   check: {
      seq: %w(of_options of_state),
      default: "%ruby_test",
   },
   secondaries: {
      seq: %w(of_options of_state of_default _secondaries),
      default: [],
   },
   context: {
      seq: %w(of_options of_state),
      default: {},
   },
   comment: {
      seq: %w(of_options of_state),
      default: nil,
   },
   spec_template: {
      seq: %w(of_options of_state),
      default: ->(_) { IO.read(File.join(File.dirname(__FILE__), "rpm.erb")) },
   },
   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: {}.to_os
   },
   valid_sources: {
      seq: %w(of_state of_space of_default),
      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: []
   },
   dependencies: {
      seq: %w(of_options of_state of_source),
      default: []
   },
   development_dependencies: {
      seq: %w(of_options of_state of_source),
      default: []
   },
   ruby_alias_names: {
      seq: %w(of_options of_state _ruby_alias_names _ruby_alias_names_local),
      default: []
   },
   gem_versionings: {
      seq: %w(of_options of_state _gem_versionings_with_use),
      default: []
   },
   ignored_names: {
      seq: %w(of_options of_state),
      default: []
   },
   aliased_names: {
      seq: %w(of_options of_state),
      default: []
   },
   available_gem_list: {
      seq: %w(of_options of_state _available_gem_list),
      default: {}
   },
   versioned_gem_list: {
      seq: %w(of_options of_state _versioned_gem_list),
      default: {}
   },
   available_gem_ranges: {
      seq: %w(of_options of_state _available_gem_ranges),
      default: {}.to_os
   },
   use_gem_version_list: {
      seq: %w(of_options of_state _use_gem_version_list),
      default: {}.to_os
   },
   use_gem_obsolete_list: {
      seq: %w(of_options of_state),
      default: {}.to_os
   },
   rootdir: {
      seq: %w(of_options of_state),
      default: nil
   },
   rake_build_tasks: {
      seq: %w(of_options of_source of_state of_default _rake_build_tasks),
      default: ""
   }
}.to_os(hash: true)

Constants included from SpecCore

SpecCore::URL_MATCHER

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from I18n

default_locale, defaulted_locales, is_default?, locale_tree, locale_trees, locales, t, #t, t!

Methods included from SpecCore

#[], #[]=, #evr, #executable_name, included, #of_default, #of_options, #of_source, #of_space, #of_state, #options, #options=, #prefix, #read_attribute, #state, #state=, #summary

Instance Attribute Details

#comment ⇒ Object (readonly)

Returns the value of attribute comment.



7
8
9
 
# File 'lib/baltix/spec/rpm.rb', line 7

def comment
  @comment
end

#space ⇒ Object (readonly)

Returns the value of attribute space.



7
8
9
 
# File 'lib/baltix/spec/rpm.rb', line 7

def space
  @space
end

#spec ⇒ Object (readonly)

Returns the value of attribute spec.



7
8
9
 
# File 'lib/baltix/spec/rpm.rb', line 7

def spec
  @spec
end

Class Method Details

.match?(source_in) ⇒ Boolean

Returns:

  • (Boolean) 


806
807
808
 
# File 'lib/baltix/spec/rpm.rb', line 806

def match? source_in
   Parser.match?(source_in)
end

.parse(source_in, options = {}.to_os, space = nil) ⇒ Object 



810
811
812
813
814
815
 
# File 'lib/baltix/spec/rpm.rb', line 810

def parse source_in, options = {}.to_os, space = nil
   state = Parser.new.parse(source_in, options)
   space ||= options[:space]

   Baltix::Spec::Rpm.new(state: state, options: options, space: space)
end

.render(space, spec_in = nil) ⇒ Object 



817
818
819
820
 
# File 'lib/baltix/spec/rpm.rb', line 817

def render space, spec_in = nil
   spec = space.spec || self.new(space: space)
   spec.render(spec_in)
end

Instance Method Details

#assign_space(space) ⇒ Object 



303
304
305
306
307
308
309
 
# File 'lib/baltix/spec/rpm.rb', line 303

def assign_space space
   @space = space

   #TODO clean variables

   space
end

#assign_state_to_sources(sources) ⇒ Object

assign_state_sources infers all the unassigned state to convert to sources main and secondaries from the state



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/baltix/spec/rpm.rb', line 312

def assign_state_to_sources sources
   packages = [ self ] | of_state(:secondaries)

   packages.map do |package|
      #   binding.pry
      package.options&.main_source ||
         case package.state_kind || package.name.kind || default_state_kind
         when "lib"
            spec = Gem::Specification.new do |s|
               s.name = package.name.autoname
               s.version, s.summary =
                  if package.state
                     [ package.state["version"], package.state["summaries"]&.[]("") ]
                  elsif package.source
                     [ package.source.version, package.source.summary ]
                  else
                     [ package.version, package.summaries&.[]("") ]
                  end
            end
            #   binding.pry

            Baltix::Source::Gem.new({"spec" => spec})
         when "app"
            #name = package.of_options(:name) ||
            #   package.of_state(:name) ||
            #   rootdir && rootdir.split("/").last
            name = package.pre_name

            Baltix::Source::Gemfile.new({
               "rootdir" => rootdir,
               "name" => name.to_s,
               "version" => of_options(:version) || of_state(:version)
            })
         end
   end.compact
end

#default_state_kind ⇒ Object 



299
300
301
 
# File 'lib/baltix/spec/rpm.rb', line 299

def default_state_kind
   "app"
end

#gem_build_conflicts ⇒ Object 



408
409
410
 
# File 'lib/baltix/spec/rpm.rb', line 408

def gem_build_conflicts
   build_conflicts.select {|r| r =~ /^gem\(.*\)/ }
end

#gem_build_requires ⇒ Object 



404
405
406
 
# File 'lib/baltix/spec/rpm.rb', line 404

def gem_build_requires
   build_requires.select {|r| r =~ /^gem\(.*\)/ }
end

#has_gem_build_conflicts? ⇒ Boolean

Returns:

  • (Boolean) 


416
417
418
 
# File 'lib/baltix/spec/rpm.rb', line 416

def has_gem_build_conflicts?
   gem_build_conflicts.any?
end

#has_gem_build_requires? ⇒ Boolean

Returns:

  • (Boolean) 


412
413
414
 
# File 'lib/baltix/spec/rpm.rb', line 412

def has_gem_build_requires?
   gem_build_requires.any?
end

#is_same_source?(source_in) ⇒ Boolean

Returns:

  • (Boolean) 


287
288
289
 
# File 'lib/baltix/spec/rpm.rb', line 287

def is_same_source? source_in
   source_in && source == source_in
end

#kind ⇒ Object 



291
292
293
 
# File 'lib/baltix/spec/rpm.rb', line 291

def kind
   @kind ||= source.is_a?(Baltix::Source::Gem) && :lib || :app
end

#macros(name) ⇒ Object 



283
284
285
 
# File 'lib/baltix/spec/rpm.rb', line 283

def macros name
   [ context.__macros[name] ].flatten(1).map { |x| "%#{name} #{x}" }.join("\n")
end

#pure_build_conflicts ⇒ Object 



400
401
402
 
# File 'lib/baltix/spec/rpm.rb', line 400

def pure_build_conflicts
   build_conflicts.select {|r| r !~ /^gem\(.*\)/ }
end

#pure_build_requires ⇒ Object 



396
397
398
 
# File 'lib/baltix/spec/rpm.rb', line 396

def pure_build_requires
   build_requires.select {|r| r !~ /^gem\(.*\)/ }
end

#render(spec = nil) ⇒ Object 



277
278
279
280
281
 
# File 'lib/baltix/spec/rpm.rb', line 277

def render spec = nil
   b = binding

   ERB.new(spec || spec_template, trim_mode: "<>-", eoutvar: "@spec").result(b).strip
end

#source ⇒ Object 



420
421
422
 
# File 'lib/baltix/spec/rpm.rb', line 420

def source
   @source ||= space&.main_source || sources.find {|source_in| pre_name == source_in.name }
end

#sources ⇒ Object 



424
425
426
427
428
429
430
431
 
# File 'lib/baltix/spec/rpm.rb', line 424

def sources
   @sources ||=
      state_sources.reduce(valid_sources) do |res, source_in|
         ignore = ignored_names.any? { |x| x === source_in.name }

         ignore || res.find { |x| Name.parse(x.name) == Name.parse(source_in.name) } ? res : res | [ source_in ]
      end
end

#state_kind ⇒ Object 



295
296
297
 
# File 'lib/baltix/spec/rpm.rb', line 295

def state_kind
   @state_kind ||= options.main_source.is_a?(Baltix::Source::Gem) && "lib" || state['file_list'].blank? && "app" || pre_name&.kind
end

#state_sources ⇒ Object 



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
 
# File 'lib/baltix/spec/rpm.rb', line 349

def state_sources
   packages = [ self ] | (of_state(:secondaries) || of_default(:secondaries))

   packages.map do |package|
      package.options&.main_source ||
         case package.state_kind || package.name.kind || default_state_kind
         when "lib"
            #binding.pry
            spec = Gem::Specification.new do |s|
               s.name = (package.is_a?(OpenStruct) ? package.name : package.pre_name).autoname
               s.version, s.summary =
                  if package.state
                     [ package.state["version"], package.state["summaries"]&.[]("") ]
                  elsif package.source
                     [ package.source.version, package.source.summary ]
                  else
                     [ package.version, package.summaries&.[]("") ]
                  end
            end
            # binding.pry

            Baltix::Source::Gem.new({"spec" => spec})
         when "app"
            #name = package.of_options(:name) ||
            #   package.of_state(:name) ||
            #   rootdir && rootdir.split("/").last
            name = package.pre_name

            if rootdir
               Baltix::Source::Gemfile.new({
                  "rootdir" => rootdir,
                  "name" => name.to_s,
                  "version" => of_options(:version) || of_state(:version)
               })
            elsif space&.valid_sources&.first
               space&.valid_sources&.first
            else
               Baltix::Source::Fake.new({
                  "rootdir" => rootdir,
                  "name" => name.to_s,
                  "version" => of_options(:version) || of_state(:version)
               })
            end
         end
   end.compact
end

#valid_secondaries ⇒ Object 



433
434
435
436
437
 
# File 'lib/baltix/spec/rpm.rb', line 433

def valid_secondaries
  @valid_secondaries ||= secondaries.select do |s|
     s.source&.source_file
  end
end