Class: Baltix::Deps

Inherits:
Object
  • Object
show all
Defined in:
lib/baltix/deps.rb

Constant Summary collapse

REQS = 
{
   'lib' => {
      proc { |target| target.source.compilable? }               => proc { |this| this.deps_ruby_version },
      proc { |target| target.source.valid? }                    => proc { |this, target| this.deps_dyno(target.source, 'lib', :dsl) },
   },
   'bin' => {
      proc { |target| target.public_executables.any? }          => proc { |this, target| this.deps_ruby_exec(target) },
      proc { |target| target.source.exefiles.any? &&
                      target.source.is_a?(Baltix::Source::Gem) } => proc { |this, target| this.deps_dyno(target.source, 'bin', :dsl) },
   },
   'doc' => {
      proc { |target| target.source.is_a?(Baltix::Source::Gem) } => proc { |this, target| this.deps_dyno(target.source, 'doc') },
   },
   'devel' => {
      proc { |target|
         target.source.is_a?(Baltix::Source::Gem) &&
        (target.source.inctree.any? ||
         target.source.dsl.original_deps.any?) }                => proc { |this, target| this.deps_dyno(target.source, 'devel', :dsl) },
   }
}
PROVS = 
{
   'lib' => {
      proc { |target| target.source.is_a?(Baltix::Source::Gem) } => proc { |this, target| this.deps_gem_ext(target.source) },
   },
   'bin' => {
      proc { |target| target.public_executables.any? }          => proc { |this, target| this.deps_execs(target) },
   },
}
MERGE_CONDS =

TODO for requirement merge enstricts requirement >= 4 & >= 5 => >= 5 > 5 ^ > 4 => > 5

> 5 & >= 4 => > 5 > 4 & >= 4 => > 4 > 4 & >= 4.x => >= 4.x

>= 4 & > 4 => > 4 >= 4 & > 5 => > 5 >= 5 & > 4 => >= 5

{
   ">=" => {
      code: -1,
   }
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#project ⇒ Object (readonly)

Returns the value of attribute project.



4
5
6
 
# File 'lib/baltix/deps.rb', line 4

def project
  @project
end

Class Method Details

.debound(req) ⇒ Object

TODO for requirement debound crop upper limitation bound from the requirement rule



200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/baltix/deps.rb', line 200

def debound req
   ver = Gem::Version.new("#{req[1]}".gsub(/x/, '0'))

   case req[0]
   when "~>"
      ['>=', ver.release]
   when ">=", ">", "="
      [req[0], ver.release]
   when "!="
      ['>', ver.release]
   else
      nil
   end
end

.lower_to_rpm(req) ⇒ Object 



185
186
187
188
189
 
# File 'lib/baltix/deps.rb', line 185

def lower_to_rpm req
   req.requirements.reduce([]) do |res, r|
      merge(res, debound(r))
   end
end

.merge(req1, req2) ⇒ Object 



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/baltix/deps.rb', line 252

def merge req1, req2
   return req1 if req2.blank?
   return req2 if req1.blank?

   m = [req1[1], req2[1]].max

   if req1[0] == req2[0]
      [req1[0], m]
   elsif req1[0] == ">="
      req1[1] <= req2[1] ? [">", m] : [">=", m]
   elsif req1[0] == ">"
      req1[1] >= req2[1] ? [">", m] : [">=", m]
   elsif %w(= < <=).include?(req1[0])
      # unsupported
      req2
   else
      # unsupported
      req1
   end
end

.negate(req) ⇒ Object

TODO for requirement negate megates requirement rule



218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/baltix/deps.rb', line 218

def negate req
   ver = Gem::Version.new("#{req[1]}".gsub(/x/, '0'))

   case req[0]
   when "~>"
      ['>=', ver.bump]
   when "<"
      ['>=', ver.release]
   when "<="
      ['>', ver.release]
   else
      nil
   end
end

.upper_negate_to_rpm(req) ⇒ Object 



191
192
193
194
195
 
# File 'lib/baltix/deps.rb', line 191

def upper_negate_to_rpm req
   req.requirements.reduce([]) do |res, r|
      merge(res, negate(r))
   end
end

Instance Method Details

#deps(type, set = nil) ⇒ Object

common



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/baltix/deps.rb', line 155

def deps type, set = nil
   $stderr.puts "* #{type} ->"

   method = method("target_#{type}")

   deps = targets.map do |target|
      $stderr.puts "  - [#{target.source.name}]"

      target_deps = method[target, set].each do |set, deps|
         if !deps.empty?
            $stderr.puts "    [#{set}]:"
            deps.each do |dep|
               $stderr.puts "      #{dep}"
            end
         end
      end

      [ target.source.name, target_deps ]
   end.to_h
end

#deps_dyno(source, set, kind = nil) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/baltix/deps.rb', line 118

def deps_dyno source, set, kind = nil
   root = project.config.dep_sources[set]
   name = (root[source.name] || root[nil]).first
   if name == 'auto'
      kind == :dsl && deps_gem_dsl(source.dsl, set) || deps_gem(source)
   else
      project.select_source(name).map do |source|
         deps_gem_dsl(source.dsl)
      end
   end
end

#deps_execs(target) ⇒ Object 



150
151
152
 
# File 'lib/baltix/deps.rb', line 150

def deps_execs target
   target.public_executables
end

#deps_gem(source) ⇒ Object 



108
109
110
 
# File 'lib/baltix/deps.rb', line 108

def deps_gem source
   ["gem(#{source.name})", source.version].compact.join(' = ')
end

#deps_gem_dsl(dsl, set = 'lib') ⇒ Object

deps



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/baltix/deps.rb', line 72

def deps_gem_dsl dsl, set = 'lib'
   deps =
      case set
      when 'bin'
         dsl.runtime_deps(:gemfile)
      when 'devel'
         dsl.development_deps(:gemspec)
      else
         dsl.runtime_deps(:gemspec)
      end

   list = []

   deps.each do |dep|
      list << (["#{prefix}(#{dep.name})"] | self.class.lower_to_rpm(dep.requirement)).join(" ")
   end

   if /lib|bin/ =~ set
      list |=
         dsl.required_ruby_version.requirements.map do |(cond, ver)|
            self.class.lower_to_rpm(Gem::Requirement.new("#{cond} #{ver}"))
         end.reject {|x| x.blank? }.map do |req|
            [dsl.required_ruby] | req
         end.map {|x| x.join(" ") }
      list << "rubygems #{dsl.required_rubygems_version}"
   end

   list
end

#deps_gem_ext(source) ⇒ Object 



112
113
114
115
116
 
# File 'lib/baltix/deps.rb', line 112

def deps_gem_ext source
   %w(gem).map do |kind|
      "#{kind}(#{source.name}) = #{source.version}"
   end
end

#deps_ruby_exec(target) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/baltix/deps.rb', line 130

def deps_ruby_exec target
   target.public_executables.map do |file|
      File.join(target.root, file)
   end.map do |file|
      if File.symlink?(file)
         realfile = File.readlink(file)
         IO.read(File.join(target.root, realfile), mode: 'rb').split("\n").first
      elsif File.exist?(file)
         IO.read(file, mode: 'rb').split("\n").first
      end
   end.compact.uniq.map do |line|
      if match = /#!\s*(?<exec>\S+)/.match(line)
         match[:exec]
      else
         $stderr.puts "Invalid shebang line '#{line}'"
         nil
      end
   end.uniq
end

#deps_ruby_version ⇒ Object 



102
103
104
105
106
 
# File 'lib/baltix/deps.rb', line 102

def deps_ruby_version
   # TODO enable when fix for new version ruby rebuld
   #"ruby(#{RbConfig::CONFIG['ruby_version']})"
   ""
end

#provs ⇒ Object 



180
181
182
 
# File 'lib/baltix/deps.rb', line 180

def provs
   deps 'provs', project.config.current_set
end

#reqs ⇒ Object 



176
177
178
 
# File 'lib/baltix/deps.rb', line 176

def reqs
   deps 'reqs', project.config.current_set
end

#target_provs(target, sets_in = nil) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/baltix/deps.rb', line 44

def target_provs target, sets_in = nil
   sets = sets_in && [ sets_in ].flatten || PROVS.keys

   PROVS.select { |set, _| sets.include?(set) }.map do |set, data|
      provs = data.map do |cond_in, prov_in|
         cond = cond_in.is_a?(Proc) ? cond_in[target] : cond_in
         cond && (prov_in.is_a?(Proc) && prov_in[self, target] || prov_in) || []
      end.flatten

      [ set, provs ]
   end.to_h
end

#target_reqs(target, sets_in = nil) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/baltix/deps.rb', line 57

def target_reqs target, sets_in = nil
   sets = sets_in && [ sets_in ].flatten || REQS.keys

   #require 'pry'; binding.pry
   REQS.select { |set, _| sets.include?(set) }.map do |set, data|
      reqs = data.map do |cond_in, req_in|
         cond = cond_in.is_a?(Proc) ? cond_in[target] : cond_in
         cond && (req_in.is_a?(Proc) && req_in[self, target] || req_in) || []
      end.flatten

      [ set, reqs.uniq ]
   end.to_h
end

#targets ⇒ Object 



36
37
38
39
40
41
42
 
# File 'lib/baltix/deps.rb', line 36

def targets
   if name = project.config.current_package_name
      project.targets.select { |target| target.source.has_name?(name) }
   else
      project.targets
   end
end