diff options
Diffstat (limited to 'web/server/h2o/libh2o/deps/mruby/lib')
6 files changed, 0 insertions, 1369 deletions
diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb deleted file mode 100644 index 4c6d3ca76..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb +++ /dev/null @@ -1,79 +0,0 @@ -class Object - class << self - def attr_block(*syms) - syms.flatten.each do |sym| - class_eval "def #{sym}(&block);block.call(@#{sym}) if block_given?;@#{sym};end" - end - end - end -end - -class String - def relative_path_from(dir) - Pathname.new(File.expand_path(self)).relative_path_from(Pathname.new(File.expand_path(dir))).to_s - end - - def relative_path - relative_path_from(Dir.pwd) - end - - # Compatible with 1.9 on 1.8 - def %(params) - if params.is_a?(Hash) - str = self.clone - params.each do |k, v| - str.gsub!("%{#{k}}") { v } - end - str - else - if params.is_a?(Array) - sprintf(self, *params) - else - sprintf(self, params) - end - end - end -end - -class Symbol - # Compatible with 1.9 on 1.8 - def to_proc - proc { |obj, *args| obj.send(self, *args) } - end -end - -module Enumerable - # Compatible with 1.9 on 1.8 - def each_with_object(memo) - return to_enum :each_with_object, memo unless block_given? - each { |obj| yield obj, memo } - memo - end -end - -$pp_show = true - -if $verbose.nil? - if Rake.respond_to?(:verbose) && !Rake.verbose.nil? - if Rake.verbose.class == TrueClass - # verbose message logging - $pp_show = false - else - $pp_show = true - Rake.verbose(false) - end - else - # could not identify rake version - $pp_show = false - end -else - $pp_show = false if $verbose -end - -def _pp(cmd, src, tgt=nil, options={}) - return unless $pp_show - - width = 5 - template = options[:indent] ? "%#{width*options[:indent]}s %s %s" : "%-#{width}s %s %s" - puts template % [cmd, src, tgt ? "-> #{tgt}" : nil] -end diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb deleted file mode 100644 index 7d6aa49e1..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb +++ /dev/null @@ -1,355 +0,0 @@ -require "mruby/build/load_gems" -require "mruby/build/command" - -module MRuby - class << self - def targets - @targets ||= {} - end - - def each_target(&block) - return to_enum(:each_target) if block.nil? - @targets.each do |key, target| - target.instance_eval(&block) - end - end - end - - class Toolchain - class << self - attr_accessor :toolchains - end - - def initialize(name, &block) - @name, @initializer = name.to_s, block - MRuby::Toolchain.toolchains ||= {} - MRuby::Toolchain.toolchains[@name] = self - end - - def setup(conf,params={}) - conf.instance_exec(conf, params, &@initializer) - end - - def self.load - Dir.glob("#{MRUBY_ROOT}/tasks/toolchains/*.rake").each do |file| - Kernel.load file - end - end - end - Toolchain.load - - class Build - class << self - attr_accessor :current - end - include Rake::DSL - include LoadGems - attr_accessor :name, :bins, :exts, :file_separator, :build_dir, :gem_clone_dir - attr_reader :libmruby, :gems, :toolchains - attr_writer :enable_bintest, :enable_test - - COMPILERS = %w(cc cxx objc asm) - COMMANDS = COMPILERS + %w(linker archiver yacc gperf git exts mrbc) - attr_block MRuby::Build::COMMANDS - - Exts = Struct.new(:object, :executable, :library) - - def initialize(name='host', build_dir=nil, &block) - @name = name.to_s - - unless MRuby.targets[@name] - if ENV['OS'] == 'Windows_NT' - @exts = Exts.new('.o', '.exe', '.a') - else - @exts = Exts.new('.o', '', '.a') - end - - build_dir = build_dir || ENV['MRUBY_BUILD_DIR'] || "#{MRUBY_ROOT}/build" - - @file_separator = '/' - @build_dir = "#{build_dir}/#{@name}" - @gem_clone_dir = "#{build_dir}/mrbgems" - @cc = Command::Compiler.new(self, %w(.c)) - @cxx = Command::Compiler.new(self, %w(.cc .cxx .cpp)) - @objc = Command::Compiler.new(self, %w(.m)) - @asm = Command::Compiler.new(self, %w(.S .asm)) - @linker = Command::Linker.new(self) - @archiver = Command::Archiver.new(self) - @yacc = Command::Yacc.new(self) - @gperf = Command::Gperf.new(self) - @git = Command::Git.new(self) - @mrbc = Command::Mrbc.new(self) - - @bins = [] - @gems, @libmruby = MRuby::Gem::List.new, [] - @build_mrbtest_lib_only = false - @cxx_exception_enabled = false - @cxx_exception_disabled = false - @cxx_abi_enabled = false - @enable_bintest = false - @enable_test = false - @toolchains = [] - - MRuby.targets[@name] = self - end - - MRuby::Build.current = MRuby.targets[@name] - MRuby.targets[@name].instance_eval(&block) - - build_mrbc_exec if name == 'host' - build_mrbtest if test_enabled? - end - - def enable_debug - compilers.each do |c| - c.defines += %w(MRB_DEBUG) - if toolchains.any? { |toolchain| toolchain == "gcc" } - c.flags += %w(-g3 -O0) - end - end - @mrbc.compile_options += ' -g' - end - - def disable_cxx_exception - if @cxx_exception_enabled or @cxx_abi_enabled - raise "cxx_exception already enabled" - end - @cxx_exception_disabled = true - end - - def enable_cxx_exception - return if @cxx_exception_enabled - return if @cxx_abi_enabled - if @cxx_exception_disabled - raise "cxx_exception disabled" - end - @cxx_exception_enabled = true - compilers.each { |c| - c.defines += %w(MRB_ENABLE_CXX_EXCEPTION) - c.flags << c.cxx_exception_flag - } - linker.command = cxx.command if toolchains.find { |v| v == 'gcc' } - end - - def cxx_exception_enabled? - @cxx_exception_enabled - end - - def cxx_abi_enabled? - @cxx_abi_enabled - end - - def enable_cxx_abi - return if @cxx_abi_enabled - if @cxx_exception_enabled - raise "cxx_exception already enabled" - end - compilers.each { |c| - c.defines += %w(MRB_ENABLE_CXX_EXCEPTION MRB_ENABLE_CXX_ABI) - c.flags << c.cxx_compile_flag - } - compilers.each { |c| c.flags << c.cxx_compile_flag } - linker.command = cxx.command if toolchains.find { |v| v == 'gcc' } - @cxx_abi_enabled = true - end - - def compile_as_cxx src, cxx_src, obj = nil, includes = [] - src = File.absolute_path src - cxx_src = File.absolute_path cxx_src - obj = objfile(cxx_src) if obj.nil? - - file cxx_src => [src, __FILE__] do |t| - FileUtils.mkdir_p File.dirname t.name - IO.write t.name, <<EOS -#define __STDC_CONSTANT_MACROS -#define __STDC_LIMIT_MACROS - -#ifndef MRB_ENABLE_CXX_ABI -extern "C" { -#endif -#include "#{src}" -#ifndef MRB_ENABLE_CXX_ABI -} -#endif -EOS - end - - file obj => cxx_src do |t| - cxx.run t.name, t.prerequisites.first, [], ["#{MRUBY_ROOT}/src"] + includes - end - - obj - end - - def enable_bintest - @enable_bintest = true - end - - def bintest_enabled? - @enable_bintest - end - - def toolchain(name, params={}) - tc = Toolchain.toolchains[name.to_s] - fail "Unknown #{name} toolchain" unless tc - tc.setup(self, params) - @toolchains.unshift name.to_s - end - - def primary_toolchain - @toolchains.first - end - - def root - MRUBY_ROOT - end - - def enable_test - @enable_test = true - end - - def test_enabled? - @enable_test - end - - def build_mrbtest - gem :core => 'mruby-test' - end - - def build_mrbc_exec - gem :core => 'mruby-bin-mrbc' - end - - def mrbcfile - return @mrbcfile if @mrbcfile - - mrbc_build = MRuby.targets['host'] - gems.each { |v| mrbc_build = self if v.name == 'mruby-bin-mrbc' } - @mrbcfile = mrbc_build.exefile("#{mrbc_build.build_dir}/bin/mrbc") - end - - def compilers - COMPILERS.map do |c| - instance_variable_get("@#{c}") - end - end - - def define_rules - compilers.each do |compiler| - if respond_to?(:enable_gems?) && enable_gems? - compiler.defines -= %w(DISABLE_GEMS) - else - compiler.defines += %w(DISABLE_GEMS) - end - compiler.define_rules build_dir, File.expand_path(File.join(File.dirname(__FILE__), '..', '..')) - end - end - - def filename(name) - if name.is_a?(Array) - name.flatten.map { |n| filename(n) } - else - '"%s"' % name.gsub('/', file_separator) - end - end - - def cygwin_filename(name) - if name.is_a?(Array) - name.flatten.map { |n| cygwin_filename(n) } - else - '"%s"' % `cygpath -w "#{filename(name)}"`.strip - end - end - - def exefile(name) - if name.is_a?(Array) - name.flatten.map { |n| exefile(n) } - else - "#{name}#{exts.executable}" - end - end - - def objfile(name) - if name.is_a?(Array) - name.flatten.map { |n| objfile(n) } - else - "#{name}#{exts.object}" - end - end - - def libfile(name) - if name.is_a?(Array) - name.flatten.map { |n| libfile(n) } - else - "#{name}#{exts.library}" - end - end - - def build_mrbtest_lib_only - @build_mrbtest_lib_only = true - end - - def build_mrbtest_lib_only? - @build_mrbtest_lib_only - end - - def run_test - puts ">>> Test #{name} <<<" - mrbtest = exefile("#{build_dir}/bin/mrbtest") - sh "#{filename mrbtest.relative_path}#{$verbose ? ' -v' : ''}" - puts - run_bintest if bintest_enabled? - end - - def run_bintest - targets = @gems.select { |v| File.directory? "#{v.dir}/bintest" }.map { |v| filename v.dir } - targets << filename(".") if File.directory? "./bintest" - sh "ruby test/bintest.rb #{targets.join ' '}" - end - - def print_build_summary - puts "================================================" - puts " Config Name: #{@name}" - puts " Output Directory: #{self.build_dir.relative_path}" - puts " Binaries: #{@bins.join(', ')}" unless @bins.empty? - unless @gems.empty? - puts " Included Gems:" - @gems.map do |gem| - gem_version = " - #{gem.version}" if gem.version != '0.0.0' - gem_summary = " - #{gem.summary}" if gem.summary - puts " #{gem.name}#{gem_version}#{gem_summary}" - puts " - Binaries: #{gem.bins.join(', ')}" unless gem.bins.empty? - end - end - puts "================================================" - puts - end - end # Build - - class CrossBuild < Build - attr_block %w(test_runner) - # cross compiling targets for building native extensions. - # host - arch of where the built binary will run - # build - arch of the machine building the binary - attr_accessor :host_target, :build_target - - def initialize(name, build_dir=nil, &block) - @test_runner = Command::CrossTestRunner.new(self) - super - end - - def mrbcfile - MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc") - end - - def run_test - mrbtest = exefile("#{build_dir}/bin/mrbtest") - if (@test_runner.command == nil) - puts "You should run #{mrbtest} on target device." - puts - else - @test_runner.run(mrbtest) - end - end - end # CrossBuild -end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb deleted file mode 100644 index 694b4a24c..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb +++ /dev/null @@ -1,324 +0,0 @@ -require 'forwardable' - -module MRuby - class Command - include Rake::DSL - extend Forwardable - def_delegators :@build, :filename, :objfile, :libfile, :exefile, :cygwin_filename - attr_accessor :build, :command - - def initialize(build) - @build = build - end - - # clone is deep clone without @build - def clone - target = super - excepts = %w(@build) - instance_variables.each do |attr| - unless excepts.include?(attr.to_s) - val = Marshal::load(Marshal.dump(instance_variable_get(attr))) # deep clone - target.instance_variable_set(attr, val) - end - end - target - end - - NotFoundCommands = {} - - private - def _run(options, params={}) - return sh command + ' ' + ( options % params ) if NotFoundCommands.key? @command - begin - sh build.filename(command) + ' ' + ( options % params ) - rescue RuntimeError - NotFoundCommands[@command] = true - _run options, params - end - end - end - - class Command::Compiler < Command - attr_accessor :flags, :include_paths, :defines, :source_exts - attr_accessor :compile_options, :option_define, :option_include_path, :out_ext - attr_accessor :cxx_compile_flag, :cxx_exception_flag - - def initialize(build, source_exts=[]) - super(build) - @command = ENV['CC'] || 'cc' - @flags = [ENV['CFLAGS'] || []] - @source_exts = source_exts - @include_paths = ["#{MRUBY_ROOT}/include"] - @defines = %w() - @option_include_path = '-I%s' - @option_define = '-D%s' - @compile_options = '%{flags} -o %{outfile} -c %{infile}' - end - - alias header_search_paths include_paths - def search_header_path(name) - header_search_paths.find do |v| - File.exist? build.filename("#{v}/#{name}").sub(/^"(.*)"$/, '\1') - end - end - - def search_header(name) - path = search_header_path name - path && build.filename("#{path}/#{name}").sub(/^"(.*)"$/, '\1') - end - - def all_flags(_defineds=[], _include_paths=[], _flags=[]) - define_flags = [defines, _defineds].flatten.map{ |d| option_define % d } - include_path_flags = [include_paths, _include_paths].flatten.map do |f| - if MRUBY_BUILD_HOST_IS_CYGWIN - option_include_path % cygwin_filename(f) - else - option_include_path % filename(f) - end - end - [flags, define_flags, include_path_flags, _flags].flatten.join(' ') - end - - def run(outfile, infile, _defineds=[], _include_paths=[], _flags=[]) - FileUtils.mkdir_p File.dirname(outfile) - _pp "CC", infile.relative_path, outfile.relative_path - if MRUBY_BUILD_HOST_IS_CYGWIN - _run compile_options, { :flags => all_flags(_defineds, _include_paths, _flags), - :infile => cygwin_filename(infile), :outfile => cygwin_filename(outfile) } - else - _run compile_options, { :flags => all_flags(_defineds, _include_paths, _flags), - :infile => filename(infile), :outfile => filename(outfile) } - end - end - - def define_rules(build_dir, source_dir='') - @out_ext = build.exts.object - gemrake = File.join(source_dir, "mrbgem.rake") - rakedep = File.exist?(gemrake) ? [ gemrake ] : [] - - if build_dir.include? "mrbgems/" - generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(.*)#{Regexp.escape out_ext}$") - else - generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(?!mrbgems/.+/)(.*)#{Regexp.escape out_ext}$") - end - source_exts.each do |ext, compile| - rule generated_file_matcher => [ - proc { |file| - file.sub(generated_file_matcher, "#{source_dir}/\\1#{ext}") - }, - proc { |file| - get_dependencies(file) + rakedep - } - ] do |t| - run t.name, t.prerequisites.first - end - - rule generated_file_matcher => [ - proc { |file| - file.sub(generated_file_matcher, "#{build_dir}/\\1#{ext}") - }, - proc { |file| - get_dependencies(file) + rakedep - } - ] do |t| - run t.name, t.prerequisites.first - end - end - end - - private - def get_dependencies(file) - file = file.ext('d') unless File.extname(file) == '.d' - if File.exist?(file) - File.read(file).gsub("\\\n ", "").scan(/^\S+:\s+(.+)$/).flatten.map {|s| s.split(' ') }.flatten - else - [] - end + [ MRUBY_CONFIG ] - end - end - - class Command::Linker < Command - attr_accessor :flags, :library_paths, :flags_before_libraries, :libraries, :flags_after_libraries - attr_accessor :link_options, :option_library, :option_library_path - - def initialize(build) - super - @command = ENV['LD'] || 'ld' - @flags = (ENV['LDFLAGS'] || []) - @flags_before_libraries, @flags_after_libraries = [], [] - @libraries = [] - @library_paths = [] - @option_library = '-l%s' - @option_library_path = '-L%s' - @link_options = "%{flags} -o %{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}" - end - - def all_flags(_library_paths=[], _flags=[]) - library_path_flags = [library_paths, _library_paths].flatten.map do |f| - if MRUBY_BUILD_HOST_IS_CYGWIN - option_library_path % cygwin_filename(f) - else - option_library_path % filename(f) - end - end - [flags, library_path_flags, _flags].flatten.join(' ') - end - - def library_flags(_libraries) - [libraries, _libraries].flatten.map{ |d| option_library % d }.join(' ') - end - - def run(outfile, objfiles, _libraries=[], _library_paths=[], _flags=[], _flags_before_libraries=[], _flags_after_libraries=[]) - FileUtils.mkdir_p File.dirname(outfile) - library_flags = [libraries, _libraries].flatten.map { |d| option_library % d } - - _pp "LD", outfile.relative_path - if MRUBY_BUILD_HOST_IS_CYGWIN - _run link_options, { :flags => all_flags(_library_paths, _flags), - :outfile => cygwin_filename(outfile) , :objs => cygwin_filename(objfiles).join(' '), - :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '), - :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '), - :libs => library_flags.join(' ') } - else - _run link_options, { :flags => all_flags(_library_paths, _flags), - :outfile => filename(outfile) , :objs => filename(objfiles).join(' '), - :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '), - :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '), - :libs => library_flags.join(' ') } - end - end - end - - class Command::Archiver < Command - attr_accessor :archive_options - - def initialize(build) - super - @command = ENV['AR'] || 'ar' - @archive_options = 'rs %{outfile} %{objs}' - end - - def run(outfile, objfiles) - FileUtils.mkdir_p File.dirname(outfile) - _pp "AR", outfile.relative_path - if MRUBY_BUILD_HOST_IS_CYGWIN - _run archive_options, { :outfile => cygwin_filename(outfile), :objs => cygwin_filename(objfiles).join(' ') } - else - _run archive_options, { :outfile => filename(outfile), :objs => filename(objfiles).join(' ') } - end - end - end - - class Command::Yacc < Command - attr_accessor :compile_options - - def initialize(build) - super - @command = 'bison' - @compile_options = '-o %{outfile} %{infile}' - end - - def run(outfile, infile) - FileUtils.mkdir_p File.dirname(outfile) - _pp "YACC", infile.relative_path, outfile.relative_path - _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) } - end - end - - class Command::Gperf < Command - attr_accessor :compile_options - - def initialize(build) - super - @command = 'gperf' - @compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}' - end - - def run(outfile, infile) - FileUtils.mkdir_p File.dirname(outfile) - _pp "GPERF", infile.relative_path, outfile.relative_path - _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) } - end - end - - class Command::Git < Command - attr_accessor :flags - attr_accessor :clone_options, :pull_options, :checkout_options - - def initialize(build) - super - @command = 'git' - @flags = %w[] - @clone_options = "clone %{flags} %{url} %{dir}" - @pull_options = "pull" - @checkout_options = "checkout %{checksum_hash}" - end - - def run_clone(dir, url, _flags = []) - _pp "GIT", url, dir.relative_path - _run clone_options, { :flags => [flags, _flags].flatten.join(' '), :url => url, :dir => filename(dir) } - end - - def run_pull(dir, url) - root = Dir.pwd - Dir.chdir dir - _pp "GIT PULL", url, dir.relative_path - _run pull_options - Dir.chdir root - end - - def run_checkout(dir, checksum_hash) - root = Dir.pwd - Dir.chdir dir - _pp "GIT CHECKOUT", checksum_hash - _run checkout_options, { :checksum_hash => checksum_hash } - Dir.chdir root - end - end - - class Command::Mrbc < Command - attr_accessor :compile_options - - def initialize(build) - super - @command = nil - @compile_options = "-B%{funcname} -o-" - end - - def run(out, infiles, funcname) - @command ||= @build.mrbcfile - infiles = [infiles].flatten - infiles.each do |f| - _pp "MRBC", f.relative_path, nil, :indent => 2 - end - IO.popen("#{filename @command} #{@compile_options % {:funcname => funcname}} #{filename(infiles).join(' ')}", 'r+') do |io| - out.puts io.read - end - # if mrbc execution fail, drop the file - if $?.exitstatus != 0 - File.delete(out.path) - exit(-1) - end - end - end - - class Command::CrossTestRunner < Command - attr_accessor :runner_options - attr_accessor :verbose_flag - attr_accessor :flags - - def initialize(build) - super - @command = nil - @runner_options = '%{flags} %{infile}' - @verbose_flag = '' - @flags = [] - end - - def run(testbinfile) - puts "TEST for " + @build.name - _run runner_options, { :flags => [flags, verbose_flag].flatten.join(' '), :infile => testbinfile } - end - end - -end diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb deleted file mode 100644 index b48df6510..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb +++ /dev/null @@ -1,122 +0,0 @@ -module MRuby - module LoadGems - def gembox(gemboxfile) - gembox = File.expand_path("#{gemboxfile}.gembox", "#{MRUBY_ROOT}/mrbgems") - fail "Can't find gembox '#{gembox}'" unless File.exist?(gembox) - - GemBox.config = self - GemBox.path = gembox - - instance_eval File.read(gembox) - - GemBox.path = nil - end - - def gem(gemdir, &block) - caller_dir = File.expand_path(File.dirname(/^(.*?):\d/.match(caller.first).to_a[1])) - - if gemdir.is_a?(Hash) - gemdir = load_special_path_gem(gemdir) - elsif GemBox.path && gemdir.is_a?(String) - gemdir = File.expand_path(gemdir, File.dirname(GemBox.path)) - else - gemdir = File.expand_path(gemdir, caller_dir) - end - - gemrake = File.join(gemdir, "mrbgem.rake") - - fail "Can't find #{gemrake}" unless File.exist?(gemrake) - Gem.current = nil - load gemrake - return nil unless Gem.current - - Gem.current.dir = gemdir - Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current - Gem.current.build_config_initializer = block - gems << Gem.current - - cxx_srcs = ['src', 'test', 'tools'].map do |subdir| - Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}") - end.flatten - enable_cxx_exception unless cxx_srcs.empty? - - Gem.current - end - - def load_special_path_gem(params) - if params[:github] - params[:git] = "https://github.com/#{params[:github]}.git" - elsif params[:bitbucket] - if params[:method] == "ssh" - params[:git] = "git@bitbucket.org:#{params[:bitbucket]}.git" - else - params[:git] = "https://bitbucket.org/#{params[:bitbucket]}.git" - end - elsif params[:mgem] - mgem_list_dir = "#{gem_clone_dir}/mgem-list" - mgem_list_url = 'https://github.com/mruby/mgem-list.git' - if File.exist? mgem_list_dir - git.run_pull mgem_list_dir, mgem_list_url if $pull_gems - else - FileUtils.mkdir_p mgem_list_dir - git.run_clone mgem_list_dir, mgem_list_url, "--depth 1" - end - - require 'yaml' - - conf_path = "#{mgem_list_dir}/#{params[:mgem]}.gem" - conf_path = "#{mgem_list_dir}/mruby-#{params[:mgem]}.gem" unless File.exist? conf_path - fail "mgem not found: #{params[:mgem]}" unless File.exist? conf_path - conf = YAML.load File.read conf_path - - fail "unknown mgem protocol: #{conf['protocol']}" if conf['protocol'] != 'git' - params[:git] = conf['repository'] - params[:branch] = conf['branch'] if conf['branch'] - end - - if params[:core] - gemdir = "#{root}/mrbgems/#{params[:core]}" - elsif params[:path] - require 'pathname' - gemdir = Pathname.new(params[:path]).absolute? ? params[:path] : "#{root}/#{params[:path]}" - elsif params[:git] - url = params[:git] - gemdir = "#{gem_clone_dir}/#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}" - - # by default the 'master' branch is used - branch = params[:branch] ? params[:branch] : 'master' - - if File.exist?(gemdir) - if $pull_gems - git.run_pull gemdir, url - else - gemdir - end - else - options = [params[:options]] || [] - options << "--recursive" - options << "--branch \"#{branch}\"" - options << "--depth 1" unless params[:checksum_hash] - FileUtils.mkdir_p "#{gem_clone_dir}" - git.run_clone gemdir, url, options - end - - if params[:checksum_hash] - # Jump to the specified commit - git.run_checkout gemdir, params[:checksum_hash] - else - # Jump to the top of the branch - git.run_checkout gemdir, branch if $pull_gems - end - else - fail "unknown gem option #{params}" - end - - gemdir - end - - def enable_gems? - !@gems.empty? - end - end # LoadGems -end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb deleted file mode 100644 index 27a1d358c..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb +++ /dev/null @@ -1,459 +0,0 @@ -require 'pathname' -require 'forwardable' -require 'tsort' -require 'shellwords' - -module MRuby - module Gem - class << self - attr_accessor :current - end - LinkerConfig = Struct.new(:libraries, :library_paths, :flags, :flags_before_libraries, :flags_after_libraries) - - class Specification - include Rake::DSL - extend Forwardable - def_delegators :@build, :filename, :objfile, :libfile, :exefile - - attr_accessor :name, :dir, :build - alias mruby build - attr_accessor :build_config_initializer - attr_accessor :mrblib_dir, :objs_dir - - attr_accessor :version - attr_accessor :description, :summary - attr_accessor :homepage - attr_accessor :licenses, :authors - alias :license= :licenses= - alias :author= :authors= - - attr_accessor :rbfiles, :objs - attr_accessor :test_objs, :test_rbfiles, :test_args - attr_accessor :test_preload - - attr_accessor :bins - - attr_accessor :requirements - attr_reader :dependencies, :conflicts - - attr_accessor :export_include_paths - - attr_reader :generate_functions - - attr_block MRuby::Build::COMMANDS - - def initialize(name, &block) - @name = name - @initializer = block - @version = "0.0.0" - @mrblib_dir = "mrblib" - @objs_dir = "src" - MRuby::Gem.current = self - end - - def setup - MRuby::Gem.current = self - MRuby::Build::COMMANDS.each do |command| - instance_variable_set("@#{command}", @build.send(command).clone) - end - @linker = LinkerConfig.new([], [], [], [], []) - - @rbfiles = Dir.glob("#{@dir}/#{@mrblib_dir}/**/*.rb").sort - @objs = Dir.glob("#{@dir}/#{@objs_dir}/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f| - objfile(f.relative_path_from(@dir).to_s.pathmap("#{build_dir}/%X")) - end - - @test_rbfiles = Dir.glob("#{dir}/test/**/*.rb") - @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f| - objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X")) - end - @custom_test_init = !@test_objs.empty? - @test_preload = nil # 'test/assert.rb' - @test_args = {} - - @bins = [] - - @requirements = [] - @dependencies, @conflicts = [], [] - @export_include_paths = [] - @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include" - - instance_eval(&@initializer) - - @generate_functions = !(@rbfiles.empty? && @objs.empty?) - @objs << objfile("#{build_dir}/gem_init") if @generate_functions - - if !name || !licenses || !authors - fail "#{name || dir} required to set name, license(s) and author(s)" - end - - build.libmruby << @objs - - instance_eval(&@build_config_initializer) if @build_config_initializer - end - - def setup_compilers - compilers.each do |compiler| - compiler.define_rules build_dir, "#{dir}" - compiler.defines << %Q[MRBGEM_#{funcname.upcase}_VERSION=#{version}] - compiler.include_paths << "#{dir}/include" if File.directory? "#{dir}/include" - end - - define_gem_init_builder if @generate_functions - end - - def add_dependency(name, *requirements) - default_gem = requirements.last.kind_of?(Hash) ? requirements.pop : nil - requirements = ['>= 0.0.0'] if requirements.empty? - requirements.flatten! - @dependencies << {:gem => name, :requirements => requirements, :default => default_gem} - end - - def add_test_dependency(*args) - add_dependency(*args) if build.test_enabled? - end - - def add_conflict(name, *req) - @conflicts << {:gem => name, :requirements => req.empty? ? nil : req} - end - - def self.bin=(bin) - @bins = [bin].flatten - end - - def build_dir - "#{build.build_dir}/mrbgems/#{name}" - end - - def test_rbireps - "#{build_dir}/gem_test.c" - end - - def search_package(name, version_query=nil) - package_query = name - package_query += " #{version_query}" if version_query - _pp "PKG-CONFIG", package_query - escaped_package_query = Shellwords.escape(package_query) - if system("pkg-config --exists #{escaped_package_query}") - cc.flags += [`pkg-config --cflags #{escaped_package_query}`.strip] - cxx.flags += [`pkg-config --cflags #{escaped_package_query}`.strip] - linker.flags_before_libraries += [`pkg-config --libs #{escaped_package_query}`.strip] - true - else - false - end - end - - def funcname - @funcname ||= @name.gsub('-', '_') - end - - def compilers - MRuby::Build::COMPILERS.map do |c| - instance_variable_get("@#{c}") - end - end - - def define_gem_init_builder - file objfile("#{build_dir}/gem_init") => [ "#{build_dir}/gem_init.c", File.join(dir, "mrbgem.rake") ] - file "#{build_dir}/gem_init.c" => [build.mrbcfile, __FILE__] + [rbfiles].flatten do |t| - FileUtils.mkdir_p build_dir - generate_gem_init("#{build_dir}/gem_init.c") - end - end - - def generate_gem_init(fname) - open(fname, 'w') do |f| - print_gem_init_header f - build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty? - f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);] - f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);] - f.puts %Q[] - f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_init(mrb_state *mrb) {] - f.puts %Q[ int ai = mrb_gc_arena_save(mrb);] - f.puts %Q[ mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")] - unless rbfiles.empty? - f.puts %Q[ mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});] - f.puts %Q[ if (mrb->exc) {] - f.puts %Q[ mrb_print_error(mrb);] - f.puts %Q[ exit(EXIT_FAILURE);] - f.puts %Q[ }] - end - f.puts %Q[ mrb_gc_arena_restore(mrb, ai);] - f.puts %Q[}] - f.puts %Q[] - f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_final(mrb_state *mrb) {] - f.puts %Q[ mrb_#{funcname}_gem_final(mrb);] if objs != [objfile("#{build_dir}/gem_init")] - f.puts %Q[}] - end - end # generate_gem_init - - def print_gem_comment(f) - f.puts %Q[/*] - f.puts %Q[ * This file is loading the irep] - f.puts %Q[ * Ruby GEM code.] - f.puts %Q[ *] - f.puts %Q[ * IMPORTANT:] - f.puts %Q[ * This file was generated!] - f.puts %Q[ * All manual changes will get lost.] - f.puts %Q[ */] - end - - def print_gem_init_header(f) - print_gem_comment(f) - f.puts %Q[#include <stdlib.h>] unless rbfiles.empty? - f.puts %Q[#include <mruby.h>] - f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty? - end - - def print_gem_test_header(f) - print_gem_comment(f) - f.puts %Q[#include <stdio.h>] - f.puts %Q[#include <stdlib.h>] - f.puts %Q[#include <mruby.h>] - f.puts %Q[#include <mruby/irep.h>] - f.puts %Q[#include <mruby/variable.h>] - f.puts %Q[#include <mruby/hash.h>] unless test_args.empty? - end - - def test_dependencies - [@name] - end - - def custom_test_init? - @custom_test_init - end - - def version_ok?(req_versions) - req_versions.map do |req| - cmp, ver = req.split - cmp_result = Version.new(version) <=> Version.new(ver) - case cmp - when '=' then cmp_result == 0 - when '!=' then cmp_result != 0 - when '>' then cmp_result == 1 - when '<' then cmp_result == -1 - when '>=' then cmp_result >= 0 - when '<=' then cmp_result <= 0 - when '~>' - Version.new(version).twiddle_wakka_ok?(Version.new(ver)) - else - fail "Comparison not possible with '#{cmp}'" - end - end.all? - end - end # Specification - - class Version - include Comparable - include Enumerable - - def <=>(other) - ret = 0 - own = to_enum - - other.each do |oth| - begin - ret = own.next <=> oth - rescue StopIteration - ret = 0 <=> oth - end - - break unless ret == 0 - end - - ret - end - - # ~> compare algorithm - # - # Example: - # ~> 2.2 means >= 2.2.0 and < 3.0.0 - # ~> 2.2.0 means >= 2.2.0 and < 2.3.0 - def twiddle_wakka_ok?(other) - gr_or_eql = (self <=> other) >= 0 - still_minor = (self <=> other.skip_minor) < 0 - gr_or_eql and still_minor - end - - def skip_minor - a = @ary.dup - a.slice!(-1) - a[-1] = a[-1].succ - a - end - - def initialize(str) - @str = str - @ary = @str.split('.').map(&:to_i) - end - - def each(&block); @ary.each(&block); end - def [](index); @ary[index]; end - def []=(index, value) - @ary[index] = value - @str = @ary.join('.') - end - def slice!(index) - @ary.slice!(index) - @str = @ary.join('.') - end - end # Version - - class List - include Enumerable - - def initialize - @ary = [] - end - - def each(&b) - @ary.each(&b) - end - - def <<(gem) - unless @ary.detect {|g| g.dir == gem.dir } - @ary << gem - else - # GEM was already added to this list - end - end - - def empty? - @ary.empty? - end - - def generate_gem_table build - gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res } - - default_gems = [] - each do |g| - g.dependencies.each do |dep| - unless gem_table.key? dep[:gem] - if dep[:default]; default_gems << dep - elsif File.exist? "#{MRUBY_ROOT}/mrbgems/#{dep[:gem]}" # check core - default_gems << { :gem => dep[:gem], :default => { :core => dep[:gem] } } - else # fallback to mgem-list - default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } } - end - end - end - end - - until default_gems.empty? - def_gem = default_gems.pop - - spec = build.gem def_gem[:default] - fail "Invalid gem name: #{spec.name} (Expected: #{def_gem[:gem]})" if spec.name != def_gem[:gem] - spec.setup - - spec.dependencies.each do |dep| - unless gem_table.key? dep[:gem] - if dep[:default]; default_gems << dep - else default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } } - end - end - end - gem_table[spec.name] = spec - end - - each do |g| - g.dependencies.each do |dep| - name = dep[:gem] - req_versions = dep[:requirements] - dep_g = gem_table[name] - - # check each GEM dependency against all available GEMs - if dep_g.nil? - fail "The GEM '#{g.name}' depends on the GEM '#{name}' but it could not be found" - end - unless dep_g.version_ok? req_versions - fail "#{name} version should be #{req_versions.join(' and ')} but was '#{dep_g.version}'" - end - end - - cfls = g.conflicts.select { |c| - cfl_g = gem_table[c[:gem]] - cfl_g and cfl_g.version_ok?(c[:requirements] || ['>= 0.0.0']) - }.map { |c| "#{c[:gem]}(#{gem_table[c[:gem]].version})" } - fail "Conflicts of gem `#{g.name}` found: #{cfls.join ', '}" unless cfls.empty? - end - - gem_table - end - - def tsort_dependencies ary, table, all_dependency_listed = false - unless all_dependency_listed - left = ary.dup - until left.empty? - v = left.pop - table[v].dependencies.each do |dep| - left.push dep[:gem] - ary.push dep[:gem] - end - end - end - - ary.uniq! - table.instance_variable_set :@root_gems, ary - class << table - include TSort - def tsort_each_node &b - @root_gems.each &b - end - - def tsort_each_child(n, &b) - fetch(n).dependencies.each do |v| - b.call v[:gem] - end - end - end - - begin - table.tsort.map { |v| table[v] } - rescue TSort::Cyclic => e - fail "Circular mrbgem dependency found: #{e.message}" - end - end - - def check(build) - gem_table = generate_gem_table build - - @ary = tsort_dependencies gem_table.keys, gem_table, true - - each(&:setup_compilers) - - each do |g| - import_include_paths(g) - end - end - - def import_include_paths(g) - gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res } - g.dependencies.each do |dep| - dep_g = gem_table[dep[:gem]] - # We can do recursive call safely - # as circular dependency has already detected in the caller. - import_include_paths(dep_g) - - dep_g.export_include_paths.uniq! - g.compilers.each do |compiler| - compiler.include_paths += dep_g.export_include_paths - g.export_include_paths += dep_g.export_include_paths - compiler.include_paths.uniq! - g.export_include_paths.uniq! - end - end - end - end # List - end # Gem - - GemBox = Object.new - class << GemBox - attr_accessor :path - - def new(&block); block.call(self); end - def config=(obj); @config = obj; end - def gem(gemdir, &block); @config.gem(gemdir, &block); end - end # GemBox -end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb deleted file mode 100644 index 5819a322b..000000000 --- a/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb +++ /dev/null @@ -1,30 +0,0 @@ -require "pathname" - -module MRuby - module Source - # MRuby's source root directory - ROOT = Pathname.new(File.expand_path('../../../',__FILE__)) - - # Reads a constant defined at version.h - MRUBY_READ_VERSION_CONSTANT = Proc.new { |name| ROOT.join('include','mruby','version.h').read.match(/^#define #{name} +"?([\w\. ]+)"?$/)[1] } - - MRUBY_RUBY_VERSION = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_VERSION'] - MRUBY_RUBY_ENGINE = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_ENGINE'] - - MRUBY_RELEASE_MAJOR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MAJOR']) - MRUBY_RELEASE_MINOR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MINOR']) - MRUBY_RELEASE_TEENY = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_TEENY']) - - MRUBY_VERSION = [MRUBY_RELEASE_MAJOR,MRUBY_RELEASE_MINOR,MRUBY_RELEASE_TEENY].join('.') - MRUBY_RELEASE_NO = (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY) - - MRUBY_RELEASE_YEAR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_YEAR']) - MRUBY_RELEASE_MONTH = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MONTH']) - MRUBY_RELEASE_DAY = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_DAY']) - MRUBY_RELEASE_DATE = [MRUBY_RELEASE_YEAR,MRUBY_RELEASE_MONTH,MRUBY_RELEASE_DAY].join('.') - - MRUBY_BIRTH_YEAR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_BIRTH_YEAR']) - - MRUBY_AUTHOR = MRUBY_READ_VERSION_CONSTANT['MRUBY_AUTHOR'] - end -end |