Class: Baltix::DSL

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

Overview

DSL service for baltix.

Constant Summary collapse

GROUP_MAPPING =

group to kind mapping

{
   default: :development,
   integration: :development,
   development: :development,
   test: :development,
   debug: :development,
   production: :runtime,
   true => :runtime,
}.reduce(Hash.new(:development)) {|r,(k,v)| r.merge(k => v) }

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#append_list ⇒ Object (readonly)

attributes



21
22
23
 
# File 'lib/baltix/dsl.rb', line 21

def append_list
  @append_list
end

#replace_list ⇒ Object (readonly)

attributes



21
22
23
 
# File 'lib/baltix/dsl.rb', line 21

def replace_list
  @replace_list
end

#skip_list ⇒ Object (readonly)

attributes



21
22
23
 
# File 'lib/baltix/dsl.rb', line 21

def skip_list
  @skip_list
end

#source_file ⇒ Object (readonly)

attributes



21
22
23
 
# File 'lib/baltix/dsl.rb', line 21

def source_file
  @source_file
end

#spec ⇒ Object (readonly)

attributes



21
22
23
 
# File 'lib/baltix/dsl.rb', line 21

def spec
  @spec
end

Class Method Details

.filter_dependencies(type, *depses) ⇒ Object 



191
192
193
 
# File 'lib/baltix/dsl.rb', line 191

def filter_dependencies type, *depses
   depses.map { |deps| deps.select {|x|x.type == type }}
end

.merge_dependencies(*depses) ⇒ Object 



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/baltix/dsl.rb', line 174

def merge_dependencies *depses
   depses.reduce({}) do |res, deps|
      deps.reduce(res.dup) do |r, x|
         r[x.name] =
            if r[x.name]
               req = r[x.name].requirement.merge(x.requirement)

               r[x.name].class.new(x.name, req, "type" => r[x.name].type)
            else
               x
            end

         r
      end
   end.values
end

Instance Method Details

#defined_groups_for(kinds_in = nil) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/baltix/dsl.rb', line 162

def defined_groups_for kinds_in = nil
   no_groups =
      [kinds_in].compact.flatten.map do |k|
         GROUP_MAPPING.map do |(g, k_in)|
            k_in != k && g || nil
         end.compact
      end.flatten

   definition.groups - no_groups
end

#definition ⇒ Object 



107
108
109
110
111
112
113
114
 
# File 'lib/baltix/dsl.rb', line 107

def definition
   @definition ||=
      Dir.mktmpdir do
         FileUtils.touch("Gemfile")

         edsl.to_definition("./Gemfile", {})
      end
end

#dependencies(type = nil) ⇒ Object 



196
197
198
199
200
201
202
 
# File 'lib/baltix/dsl.rb', line 196

def dependencies type = nil
   if type
      self.class.merge_dependencies(*self.class.filter_dependencies(type, definition.dependencies, spec.dependencies))
   else
      self.class.merge_dependencies(definition.dependencies, spec.dependencies)
   end
end

#deps ⇒ Object 



204
205
206
 
# File 'lib/baltix/dsl.rb', line 204

def deps
   deps_but(original_deps) | gemspec_deps
end

#deps_for(kinds_in = nil) ⇒ Object 



215
216
217
 
# File 'lib/baltix/dsl.rb', line 215

def deps_for kinds_in = nil
   deps_but(original_deps_for(kinds_in)) | gemspec_deps
end

#development_deps(kind = :gemspec) ⇒ Object 



158
159
160
 
# File 'lib/baltix/dsl.rb', line 158

def development_deps kind = :gemspec
   deps_but(original_deps_for(:development))
end

#dsl ⇒ Object 



71
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
 
# File 'lib/baltix/dsl.rb', line 71

def dsl
   @dsl ||= (
      begin
         dsl =
            Dir.chdir(File.dirname(source_file)) do
               dsl = Bundler::Dsl.new
               dsl.eval_gemfile(original_gemfile)
               dsl
            end
      rescue LoadError,
             TypeError,
             Bundler::GemNotFound,
             Bundler::GemfileNotFound,
             Bundler::VersionConflict,
             Bundler::Dsl::DSLError,
             Errno::ENOENT,
             ::Gem::InvalidSpecificationException => e

         dsl = Bundler::Dsl.new
         dsl.instance_variable_set(:@gemfiles, [Pathname.new(fake_gemfile_path)])
         dsl.to_definition(fake_gemlock_path, {})
         Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", nil

         dsl
      end)
end

#edsl ⇒ Object 



98
99
100
101
102
103
104
105
 
# File 'lib/baltix/dsl.rb', line 98

def edsl
   @edsl ||= (
      begin
         edsl = dsl.dup
         edsl.dependencies = deps_but(dsl.dependencies)
         edsl
      end)
end

#extracted_gemspec_deps ⇒ Object 



140
141
142
 
# File 'lib/baltix/dsl.rb', line 140

def extracted_gemspec_deps
   gemspecs.map { |gs| gs.dependencies }.flatten.uniq
end

#extracted_gemspec_runtime_deps ⇒ Object 



144
145
146
147
148
 
# File 'lib/baltix/dsl.rb', line 144

def extracted_gemspec_runtime_deps
   gemspecs.map do |gs|
      gs.dependencies.select {|dep|dep.runtime?}
   end.flatten.uniq
end

#fake_gemfile_path ⇒ Object 



49
50
51
52
53
54
55
56
57
58
 
# File 'lib/baltix/dsl.rb', line 49

def fake_gemfile_path
   if !@fake_gemfile && @fake_gemfile ||= Tempfile.create('Gemfile')
      @fake_gemfile_path = @fake_gemfile.path

      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", @fake_gemfile_path
      @fake_gemfile.close
   end

   @fake_gemfile_path
end

#fake_gemlock_path ⇒ Object 



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

def fake_gemlock_path
   if !@fake_gemlock && @fake_gemlock ||= Tempfile.create('Gemfile.lock')
      @fake_gemlock_path = @fake_gemlock.path

      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", @fake_gemlock_path
      @fake_gemlock.close
   end

   @fake_gemlock_path
end

#find_gemfile ⇒ Object 



43
44
45
46
47
 
# File 'lib/baltix/dsl.rb', line 43

def find_gemfile
   gemfile = source_file && Dir[File.join(File.dirname(source_file), '{Gemfile,gemfile}')].first

   gemfile && Pathname.new(gemfile) || nil
end

#gemfile ⇒ Object 



31
32
33
 
# File 'lib/baltix/dsl.rb', line 31

def gemfile
   gemfiles.first || original_gemfile || fake_gemfile_path
end

#gemfiles ⇒ Object 



23
24
25
26
27
28
29
 
# File 'lib/baltix/dsl.rb', line 23

def gemfiles
   return @gemfiles if @gemfiles

   gemfiles = dsl.instance_variable_get(:@gemfiles) || []

   @gemfiles = gemfiles.map {|g| g.is_a?(Pathname) && g || Pathname.new(g) }
end

#gemspec_deps ⇒ Object 



208
209
210
211
212
213
 
# File 'lib/baltix/dsl.rb', line 208

def gemspec_deps
   gemspecs.map do |gs|
      version = gs.version || Gem::Version.new(0)
      Gem::Dependency.new(gs.name, Gem::Requirement.new(["= #{version}"]), :development)
   end
end

#gemspecs ⇒ Object 



136
137
138
 
# File 'lib/baltix/dsl.rb', line 136

def gemspecs
   spec ? [spec] : dsl.gemspecs
end

#is_source_gemfile ⇒ Object 



39
40
41
 
# File 'lib/baltix/dsl.rb', line 39

def is_source_gemfile
   source_file =~ /Gemfile$/i
end

#merge_in(other_dsl) ⇒ Object 



271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/baltix/dsl.rb', line 271

def merge_in other_dsl
   if original_gemfile.to_s != other_dsl.original_gemfile.to_s
      hodeps = other_dsl.original_deps.map {|dep| [dep.name, dep] }.to_h
      original_deps.map {|dep| [dep.name, dep] }.to_h.deep_merge(hodeps).values.map do |dep|
         if dep.is_a?(Array)
            dep.reduce { |res, dep_in| res.merge(dep_in) }
         else
            dep
         end
      end
   end

   self
end

#original_deps ⇒ Object 



126
127
128
129
130
131
132
133
134
 
# File 'lib/baltix/dsl.rb', line 126

def original_deps
   @original_deps ||= definition.dependencies.map do |dep|
      type = dep.groups.map {|g| GROUP_MAPPING[g]}.compact.uniq.sort.first || dep.type
      dep.instance_variable_set(:@type, type)
      valid = !dep.source.is_a?(Bundler::Source::Path)

      valid && dep || nil
   end.compact
end

#original_deps_for(kinds_in = nil) ⇒ Object 



116
117
118
119
120
121
122
123
124
 
# File 'lib/baltix/dsl.rb', line 116

def original_deps_for kinds_in = nil
   groups = defined_groups_for(kinds_in)

   original_deps.select do |dep|
      (dep.groups & groups).any? &&
       dep.should_include? # &&
      # (dep.autorequire || [ true ]).all? { |r| r }
   end
end

#original_gemfile ⇒ Object 



35
36
37
 
# File 'lib/baltix/dsl.rb', line 35

def original_gemfile
   @original_gemfile ||= is_source_gemfile && Pathname.new(source_file) || find_gemfile
end

#required_ruby ⇒ Object 



267
268
269
 
# File 'lib/baltix/dsl.rb', line 267

def required_ruby
   @required_ruby ||= dsl.instance_variable_get(:@ruby_version)&.engine || "ruby"
end

#required_ruby_version ⇒ Object 



263
264
265
 
# File 'lib/baltix/dsl.rb', line 263

def required_ruby_version
   @required_ruby_version ||= Gem::Requirement.new(dsl.instance_variable_get(:@ruby_version)&.engine_versions || ">= 0")
end

#required_rubygems_version ⇒ Object 



259
260
261
 
# File 'lib/baltix/dsl.rb', line 259

def required_rubygems_version
   ">= 0"
end

#ruby ⇒ Object 



219
220
221
 
# File 'lib/baltix/dsl.rb', line 219

def ruby
   { type: required_ruby, version: required_ruby_version }
end

#rubygems ⇒ Object 



223
224
225
 
# File 'lib/baltix/dsl.rb', line 223

def rubygems
   { version: required_rubygems_version }
end

#runtime_deps(kind = :gemspec) ⇒ Object 



150
151
152
153
154
155
156
 
# File 'lib/baltix/dsl.rb', line 150

def runtime_deps kind = :gemspec
   if kind == :gemspec
      deps_but(extracted_gemspec_runtime_deps)
   else
      deps_but(original_deps_for(:runtime))
   end
end

#to_gemfile ⇒ Object 



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/baltix/dsl.rb', line 239

def to_gemfile
   deps_but(original_deps).group_by { |d| d.name }.map do |name, deps|
      reqs = deps.map do |dep|
         reqs = dep.requirement.requirements.map {|r| "'#{r[0]} #{r[1]}'" }.join(", ")
      end.join(", ")

      dep = deps.first
      autoreq = dep.respond_to?(:autorequire) &&
                dep.autorequire &&
                "require: #{dep.autorequire.any? &&
                          "[" + dep.autorequire.map { |r| r.inspect }.join(', ') + "]" ||
                          "false"}" || nil
      groups = dep.respond_to?(:groups) && dep.groups || []
      g = groups - [ :default ]
      group_list = g.any? && "group: %i(#{groups.join("\n")})" || nil

      [ "gem '#{name}'", reqs, autoreq, group_list ].compact.join(', ')
   end.join("\n")
end

#to_ruby ⇒ Object 



231
232
233
234
235
236
237
 
# File 'lib/baltix/dsl.rb', line 231

def to_ruby
   spec = self.spec.dup
   deps_in = deps_but(extracted_gemspec_deps)
   deps = spec.dependencies.map {|x| deps_in.find {|a| a.name == x.name }}.compact
   spec.dependencies.replace(deps)
   spec.to_ruby
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


227
228
229
 
# File 'lib/baltix/dsl.rb', line 227

def valid?
   gemfiles.any? {|g| g.eql?(original_gemfile) }
end