Class: Jars::Installer

Inherits:
Object
  • Object
show all
Defined in:
lib/jars/installer.rb

Defined Under Namespace

Classes: Dependency

Constant Summary collapse

COMMENT = 
'# this is a generated file, to avoid over-writing it just delete this comment'.freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(spec = nil) ⇒ Installer

Returns a new instance of Installer.



155
156
157
 
# File 'lib/jars/installer.rb', line 155

def initialize(spec = nil)
  @mvn = MavenExec.new(spec)
end

Class Method Details

.install_deps(deps, dir, require_filename, vendor) ⇒ Object 



119
120
121
122
123
 
# File 'lib/jars/installer.rb', line 119

def self.install_deps(deps, dir, require_filename, vendor)
  warn 'deprecated'
  write_require_jars(deps, require_filename)
  vendor_jars(deps, dir) if dir && vendor
end

.install_jars(write_require_file = false) ⇒ Object 



63
64
65
 
# File 'lib/jars/installer.rb', line 63

def self.install_jars(write_require_file = false)
  new.install_jars(write_require_file)
end

.load_from_maven(file) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/jars/installer.rb', line 67

def self.load_from_maven(file)
  result = []
  File.read(file).each_line do |line|
    dep = Dependency.new(line)
    result << dep if dep && dep.scope == :runtime
  end
  result
end

.needs_to_write?(require_filename) ⇒ Boolean

Returns:

  • (Boolean) 


115
116
117
 
# File 'lib/jars/installer.rb', line 115

def self.needs_to_write?(require_filename)
  require_filename && (!File.exist?(require_filename) || File.read(require_filename).match(COMMENT))
end

.print_require_jar(file, dep, fallback = false) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/jars/installer.rb', line 101

def self.print_require_jar(file, dep, fallback = false)
  return if dep.type != :jar || dep.scope != :runtime
  if dep.system?
    file.puts("require '#{dep.file}'") if file
  elsif dep.scope == :runtime
    if fallback
      file.puts("  require '#{dep.path}'") if file
    else
      file.puts("  require_jar '#{dep.gav.gsub(':', "', '")}'") if file
    end
  end
end

.vendor_file(dir, dep) ⇒ Object 



88
89
90
91
92
93
94
 
# File 'lib/jars/installer.rb', line 88

def self.vendor_file(dir, dep)
  if !dep.system? && dep.type == :jar && dep.scope == :runtime
    vendored = File.join(dir, dep.path)
    FileUtils.mkdir_p(File.dirname(vendored))
    FileUtils.cp(dep.file, vendored)
  end
end

.vendor_jars(deps, dir) ⇒ Object 



149
150
151
152
153
 
# File 'lib/jars/installer.rb', line 149

def self.vendor_jars(deps, dir)
  deps.each do |dep|
    vendor_file(dir, dep)
  end
end

.vendor_jars!(vendor_dir = nil) ⇒ Object 



173
174
175
 
# File 'lib/jars/installer.rb', line 173

def self.vendor_jars!(vendor_dir = nil)
  new.vendor_jars!(true, vendor_dir)
end

.write_dep(file, _dir, dep, _vendor) ⇒ Object 



96
97
98
99
 
# File 'lib/jars/installer.rb', line 96

def self.write_dep(file, _dir, dep, _vendor)
  warn 'deprecated'
  print_require_jar(file, dep)
end

.write_require_file(require_filename) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/jars/installer.rb', line 76

def self.write_require_file(require_filename)
  warn 'deprecated'
  if needs_to_write?(require_filename)
    FileUtils.mkdir_p(File.dirname(require_filename))
    f = File.open(require_filename, 'w')
    f.puts COMMENT
    f.puts "require 'jar_dependencies'"
    f.puts
    f
  end
end

.write_require_jars(deps, require_filename) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/jars/installer.rb', line 125

def self.write_require_jars(deps, require_filename)
  if needs_to_write?(require_filename)
    FileUtils.mkdir_p(File.dirname(require_filename))
    File.open(require_filename, 'w') do |f|
      f.puts COMMENT
      f.puts 'begin'
      f.puts "  require 'jar_dependencies'"
      f.puts 'rescue LoadError'
      deps.each do |dep|
        # do not use require_jar method
        print_require_jar(f, dep, true)
      end
      f.puts 'end'
      f.puts
      f.puts 'if defined? Jars'
      deps.each do |dep|
        print_require_jar(f, dep)
      end
      f.puts 'end'
      yield f if block_given?
    end
  end
end

Instance Method Details

#has_jars? ⇒ Boolean Also known as: jars?

Returns:

  • (Boolean) 


191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/jars/installer.rb', line 191

def has_jars?
  # first look if there are any requirements in the spec
  # and then if gem depends on jar-dependencies for runtime.
  # only then install the jars declared in the requirements
  result = (spec = self.spec) && !spec.requirements.empty? &&
           spec.dependencies.detect { |d| d.name == 'jar-dependencies' && d.type == :runtime } != nil
  if result && spec.platform.to_s != 'java'
    Jars.warn "\njar dependencies found on non-java platform gem - do not install jars\n"
    false
  else
    result
  end
end

#install_jars(write_require_file = true) ⇒ Object 



182
183
184
185
 
# File 'lib/jars/installer.rb', line 182

def install_jars(write_require_file = true)
  return unless has_jars?
  do_install(nil, write_require_file)
end

#ruby_maven_install_options=(options) ⇒ Object 



187
188
189
 
# File 'lib/jars/installer.rb', line 187

def ruby_maven_install_options=(options)
  @mvn.ruby_maven_install_options = options
end

#spec ⇒ Object 



159
160
161
 
# File 'lib/jars/installer.rb', line 159

def spec
  @mvn.spec
end

#vendor_jars(write_require_file = true, vendor_dir = nil) ⇒ Object 



163
164
165
166
167
168
169
170
171
 
# File 'lib/jars/installer.rb', line 163

def vendor_jars(write_require_file = true, vendor_dir = nil)
  return unless has_jars?
  if Jars.to_prop(Jars::VENDOR) == 'false'
    vendor_dir = nil
  else
    vendor_dir ||= spec.require_path
  end
  do_install(vendor_dir, write_require_file)
end

#vendor_jars!(write_require_file = true, vendor_dir = nil) ⇒ Object 



177
178
179
180
 
# File 'lib/jars/installer.rb', line 177

def vendor_jars!(write_require_file = true, vendor_dir = nil)
  vendor_dir ||= spec.require_path
  do_install(vendor_dir, write_require_file)
end