third-party/mruby/lib/mruby/gem.rb

   1 require 'pathname'
   2 require 'forwardable'
   3 require 'tsort'
   4 require 'shellwords'
   5
   6 module MRuby
   7   module Gem
   8     class << self
   9       attr_accessor :current
  10     end
  11     LinkerConfig = Struct.new(:libraries, :library_paths, :flags, :flags_before_libraries, :flags_after_libraries)
  12
  13     class Specification
  14       include Rake::DSL
  15       extend Forwardable
  16       def_delegators :@build, :filename, :objfile, :libfile, :exefile
  17
  18       attr_accessor :name, :dir, :build
  19       alias mruby build
  20       attr_accessor :build_config_initializer
  21       attr_accessor :mrblib_dir, :objs_dir
  22
  23       attr_accessor :version
  24       attr_accessor :description, :summary
  25       attr_accessor :homepage
  26       attr_accessor :licenses, :authors
  27       alias :license= :licenses=
  28       alias :author= :authors=
  29
  30       attr_accessor :rbfiles, :objs
  31       attr_accessor :test_objs, :test_rbfiles, :test_args
  32       attr_accessor :test_preload
  33
  34       attr_accessor :bins
  35
  36       attr_accessor :requirements
  37       attr_reader :dependencies, :conflicts
  38
  39       attr_accessor :export_include_paths
  40
  41       attr_reader :generate_functions
  42
  43       attr_block MRuby::Build::COMMANDS
  44
  45       def initialize(name, &block)
  46         @name = name
  47         @initializer = block
  48         @version = "0.0.0"
  49         @mrblib_dir = "mrblib"
  50         @objs_dir = "src"
  51         MRuby::Gem.current = self
  52       end
  53
  54       def setup
  55         return if defined?(@linker)  # return if already set up
  56
  57         MRuby::Gem.current = self
  58         MRuby::Build::COMMANDS.each do |command|
  59           instance_variable_set("@#{command}", @build.send(command).clone)
  60         end
  61         @linker = LinkerConfig.new([], [], [], [], [])
  62
  63         @rbfiles = Dir.glob("#{@dir}/#{@mrblib_dir}/**/*.rb").sort
  64         @objs = Dir.glob("#{@dir}/#{@objs_dir}/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
  65           objfile(f.relative_path_from(@dir).to_s.pathmap("#{build_dir}/%X"))
  66         end
  67
  68         @test_rbfiles = Dir.glob("#{dir}/test/**/*.rb").sort
  69         @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
  70           objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X"))
  71         end
  72         @custom_test_init = !@test_objs.empty?
  73         @test_preload = nil # 'test/assert.rb'
  74         @test_args = {}
  75
  76         @bins = []
  77
  78         @requirements = []
  79         @dependencies, @conflicts = [], []
  80         @export_include_paths = []
  81         @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
  82
  83         instance_eval(&@initializer)
  84
  85         @generate_functions = !(@rbfiles.empty? && @objs.empty?)
  86         @objs << objfile("#{build_dir}/gem_init") if @generate_functions
  87
  88         if !name || !licenses || !authors
  89           fail "#{name || dir} required to set name, license(s) and author(s)"
  90         end
  91
  92         build.libmruby_objs << @objs
  93
  94         instance_eval(&@build_config_initializer) if @build_config_initializer
  95       end
  96
  97       def setup_compilers
  98         compilers.each do |compiler|
  99           compiler.define_rules build_dir, "#{dir}"
 100           compiler.defines << %Q[MRBGEM_#{funcname.upcase}_VERSION=#{version}]
 101           compiler.include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
 102         end
 103
 104         define_gem_init_builder if @generate_functions
 105       end
 106
 107       def add_dependency(name, *requirements)
 108         default_gem = requirements.last.kind_of?(Hash) ? requirements.pop : nil
 109         requirements = ['>= 0.0.0'] if requirements.empty?
 110         requirements.flatten!
 111         @dependencies << {:gem => name, :requirements => requirements, :default => default_gem}
 112       end
 113
 114       def add_test_dependency(*args)
 115         add_dependency(*args) if build.test_enabled? || build.bintest_enabled?
 116       end
 117
 118       def add_conflict(name, *req)
 119         @conflicts << {:gem => name, :requirements => req.empty? ? nil : req}
 120       end
 121
 122       def build_dir
 123         "#{build.build_dir}/mrbgems/#{name}"
 124       end
 125
 126       def test_rbireps
 127         "#{build_dir}/gem_test.c"
 128       end
 129
 130       def search_package(name, version_query=nil)
 131         package_query = name
 132         package_query += " #{version_query}" if version_query
 133         _pp "PKG-CONFIG", package_query
 134         escaped_package_query = Shellwords.escape(package_query)
 135         if system("pkg-config --exists #{escaped_package_query}")
 136           cc.flags += [`pkg-config --cflags #{escaped_package_query}`.strip]
 137           cxx.flags += [`pkg-config --cflags #{escaped_package_query}`.strip]
 138           linker.flags_before_libraries += [`pkg-config --libs #{escaped_package_query}`.strip]
 139           true
 140         else
 141           false
 142         end
 143       end
 144
 145       def funcname
 146         @funcname ||= @name.gsub('-', '_')
 147       end
 148
 149       def compilers
 150         MRuby::Build::COMPILERS.map do |c|
 151           instance_variable_get("@#{c}")
 152         end
 153       end
 154
 155       def define_gem_init_builder
 156         file objfile("#{build_dir}/gem_init") => [ "#{build_dir}/gem_init.c", File.join(dir, "mrbgem.rake") ]
 157         file "#{build_dir}/gem_init.c" => [build.mrbcfile, __FILE__] + [rbfiles].flatten do |t|
 158           FileUtils.mkdir_p build_dir
 159           generate_gem_init("#{build_dir}/gem_init.c")
 160         end
 161       end
 162
 163       def generate_gem_init(fname)
 164         open(fname, 'w') do |f|
 165           print_gem_init_header f
 166           build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty?
 167           f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);]
 168           f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);]
 169           f.puts %Q[]
 170           f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_init(mrb_state *mrb) {]
 171           f.puts %Q[  int ai = mrb_gc_arena_save(mrb);]
 172           f.puts %Q[  mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")]
 173           unless rbfiles.empty?
 174             f.puts %Q[  mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});]
 175             f.puts %Q[  if (mrb->exc) {]
 176             f.puts %Q[    mrb_print_error(mrb);]
 177             f.puts %Q[    mrb_close(mrb);]
 178             f.puts %Q[    exit(EXIT_FAILURE);]
 179             f.puts %Q[  }]
 180           end
 181           f.puts %Q[  mrb_gc_arena_restore(mrb, ai);]
 182           f.puts %Q[}]
 183           f.puts %Q[]
 184           f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_final(mrb_state *mrb) {]
 185           f.puts %Q[  mrb_#{funcname}_gem_final(mrb);] if objs != [objfile("#{build_dir}/gem_init")]
 186           f.puts %Q[}]
 187         end
 188       end # generate_gem_init
 189
 190       def print_gem_comment(f)
 191         f.puts %Q[/*]
 192         f.puts %Q[ * This file is loading the irep]
 193         f.puts %Q[ * Ruby GEM code.]
 194         f.puts %Q[ *]
 195         f.puts %Q[ * IMPORTANT:]
 196         f.puts %Q[ *   This file was generated!]
 197         f.puts %Q[ *   All manual changes will get lost.]
 198         f.puts %Q[ */]
 199       end
 200
 201       def print_gem_init_header(f)
 202         print_gem_comment(f)
 203         f.puts %Q[#include <stdlib.h>] unless rbfiles.empty?
 204         f.puts %Q[#include <mruby.h>]
 205         f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty?
 206       end
 207
 208       def print_gem_test_header(f)
 209         print_gem_comment(f)
 210         f.puts %Q[#include <stdio.h>]
 211         f.puts %Q[#include <stdlib.h>]
 212         f.puts %Q[#include <mruby.h>]
 213         f.puts %Q[#include <mruby/irep.h>]
 214         f.puts %Q[#include <mruby/variable.h>]
 215         f.puts %Q[#include <mruby/hash.h>] unless test_args.empty?
 216       end
 217
 218       def test_dependencies
 219         [@name]
 220       end
 221
 222       def custom_test_init?
 223         @custom_test_init
 224       end
 225
 226       def version_ok?(req_versions)
 227         req_versions.map do |req|
 228           cmp, ver = req.split
 229           cmp_result = Version.new(version) <=> Version.new(ver)
 230           case cmp
 231           when '=' then cmp_result == 0
 232           when '!=' then cmp_result != 0
 233           when '>' then cmp_result == 1
 234           when '<' then cmp_result == -1
 235           when '>=' then cmp_result >= 0
 236           when '<=' then cmp_result <= 0
 237           when '~>'
 238             Version.new(version).twiddle_wakka_ok?(Version.new(ver))
 239           else
 240             fail "Comparison not possible with '#{cmp}'"
 241           end
 242         end.all?
 243       end
 244     end # Specification
 245
 246     class Version
 247       include Comparable
 248       include Enumerable
 249
 250       def <=>(other)
 251         ret = 0
 252         own = to_enum
 253
 254         other.each do |oth|
 255           begin
 256             ret = own.next <=> oth
 257           rescue StopIteration
 258             ret = 0 <=> oth
 259           end
 260
 261           break unless ret == 0
 262         end
 263
 264         ret
 265       end
 266
 267       # ~> compare algorithm
 268       #
 269       # Example:
 270       #    ~> 2.2   means >= 2.2.0 and < 3.0.0
 271       #    ~> 2.2.0 means >= 2.2.0 and < 2.3.0
 272       def twiddle_wakka_ok?(other)
 273         gr_or_eql = (self <=> other) >= 0
 274         still_minor = (self <=> other.skip_minor) < 0
 275         gr_or_eql and still_minor
 276       end
 277
 278       def skip_minor
 279         a = @ary.dup
 280         a.slice!(-1)
 281         a[-1] = a[-1].succ
 282         a
 283       end
 284
 285       def initialize(str)
 286         @str = str
 287         @ary = @str.split('.').map(&:to_i)
 288       end
 289
 290       def each(&block); @ary.each(&block); end
 291       def [](index); @ary[index]; end
 292       def []=(index, value)
 293         @ary[index] = value
 294         @str = @ary.join('.')
 295       end
 296       def slice!(index)
 297         @ary.slice!(index)
 298         @str = @ary.join('.')
 299       end
 300     end # Version
 301
 302     class List
 303       include Enumerable
 304
 305       def initialize
 306         @ary = []
 307       end
 308
 309       def each(&b)
 310         @ary.each(&b)
 311       end
 312
 313       def <<(gem)
 314         unless @ary.detect {|g| g.dir == gem.dir }
 315           @ary << gem
 316         else
 317           # GEM was already added to this list
 318         end
 319       end
 320
 321       def empty?
 322         @ary.empty?
 323       end
 324
 325       def default_gem_params dep
 326         if dep[:default]; dep
 327         elsif File.exist? "#{MRUBY_ROOT}/mrbgems/#{dep[:gem]}" # check core
 328           { :gem => dep[:gem], :default => { :core => dep[:gem] } }
 329         else # fallback to mgem-list
 330           { :gem => dep[:gem], :default => { :mgem => dep[:gem] } }
 331         end
 332       end
 333
 334       def generate_gem_table build
 335         gem_table = each_with_object({}) { |spec, h| h[spec.name] = spec }
 336
 337         default_gems = {}
 338         each do |g|
 339           g.dependencies.each do |dep|
 340             default_gems[dep[:gem]] ||= default_gem_params(dep)
 341           end
 342         end
 343
 344         until default_gems.empty?
 345           def_name, def_gem = default_gems.shift
 346           next if gem_table[def_name]
 347
 348           spec = gem_table[def_name] = build.gem(def_gem[:default])
 349           fail "Invalid gem name: #{spec.name} (Expected: #{def_name})" if spec.name != def_name
 350           spec.setup
 351
 352           spec.dependencies.each do |dep|
 353             default_gems[dep[:gem]] ||= default_gem_params(dep)
 354           end
 355         end
 356
 357         each do |g|
 358           g.dependencies.each do |dep|
 359             name = dep[:gem]
 360             req_versions = dep[:requirements]
 361             dep_g = gem_table[name]
 362
 363             # check each GEM dependency against all available GEMs
 364             if dep_g.nil?
 365               fail "The GEM '#{g.name}' depends on the GEM '#{name}' but it could not be found"
 366             end
 367             unless dep_g.version_ok? req_versions
 368               fail "#{name} version should be #{req_versions.join(' and ')} but was '#{dep_g.version}'"
 369             end
 370           end
 371
 372           cfls = g.conflicts.select { |c|
 373             cfl_g = gem_table[c[:gem]]
 374             cfl_g and cfl_g.version_ok?(c[:requirements] || ['>= 0.0.0'])
 375           }.map { |c| "#{c[:gem]}(#{gem_table[c[:gem]].version})" }
 376           fail "Conflicts of gem `#{g.name}` found: #{cfls.join ', '}" unless cfls.empty?
 377         end
 378
 379         gem_table
 380       end
 381
 382       def tsort_dependencies ary, table, all_dependency_listed = false
 383         unless all_dependency_listed
 384           left = ary.dup
 385           until left.empty?
 386             v = left.pop
 387             table[v].dependencies.each do |dep|
 388               left.push dep[:gem]
 389               ary.push dep[:gem]
 390             end
 391           end
 392         end
 393
 394         ary.uniq!
 395         table.instance_variable_set :@root_gems, ary
 396         class << table
 397           include TSort
 398           def tsort_each_node &b
 399             @root_gems.each &b
 400           end
 401
 402           def tsort_each_child(n, &b)
 403             fetch(n).dependencies.each do |v|
 404               b.call v[:gem]
 405             end
 406           end
 407         end
 408
 409         begin
 410           table.tsort.map { |v| table[v] }
 411         rescue TSort::Cyclic => e
 412           fail "Circular mrbgem dependency found: #{e.message}"
 413         end
 414       end
 415
 416       def check(build)
 417         gem_table = generate_gem_table build
 418
 419         @ary = tsort_dependencies gem_table.keys, gem_table, true
 420
 421         each(&:setup_compilers)
 422
 423         each do |g|
 424           import_include_paths(g)
 425         end
 426       end
 427
 428       def import_include_paths(g)
 429         gem_table = each_with_object({}) { |spec, h| h[spec.name] = spec }
 430
 431         g.dependencies.each do |dep|
 432           dep_g = gem_table[dep[:gem]]
 433           # We can do recursive call safely
 434           # as circular dependency has already detected in the caller.
 435           import_include_paths(dep_g)
 436
 437           dep_g.export_include_paths.uniq!
 438           g.compilers.each do |compiler|
 439             compiler.include_paths += dep_g.export_include_paths
 440             g.export_include_paths += dep_g.export_include_paths
 441             compiler.include_paths.uniq!
 442             g.export_include_paths.uniq!
 443           end
 444         end
 445       end
 446     end # List
 447   end # Gem
 448
 449   GemBox = Object.new
 450   class << GemBox
 451     attr_accessor :path
 452
 453     def new(&block); block.call(self); end
 454     def config=(obj); @config = obj; end
 455     def gem(gemdir, &block); @config.gem(gemdir, &block); end
 456     def gembox(gemfile); @config.gembox(gemfile); end
 457   end # GemBox
 458 end # MRuby