ruble 0.0.3.alpha

data/lib/ruble/build/data/extension.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RuBLE
+  module Build
+    module Data
+      module Extension
+        include Memery
+
+        memoize def gem_spec = Data.this_gem
+        memoize def gem_name = gem_spec.name.freeze
+        memoize def root_dir = Data.bundler.root.cleanpath(false)
+        # memoize def gem_full_path = Pathname.new(gem_spec.full_gem_path).freeze
+        def gem_full_path = root_dir
+
+        memoize def gem_version = gem_spec.version.freeze
+        def extension_version = gem_version
+
+        memoize def extension_names
+          gem_spec.extensions.map do |extconf_path|
+            Pathname.new(extconf_path).parent.basename.to_s.freeze
+          end.freeze
+        end
+        memoize def extension_name = extension_names.first
+
+        memoize def git_root = run_cmd('git rev-parse --show-toplevel', path: true)
+        memoize def git_root? = !!git_root
+        memoize def git_head = run_cmd('git rev-parse HEAD', chdir: git_root)
+        memoize def git_status = run_cmd('git status --porcelain', chdir: git_root)
+        memoize def git_dirty? = git_status.nil? || git_status&.empty?
+        memoize def git_last_tag = run_cmd('git describe --tags --abbrev=0', chdir: git_root)
+        memoize def git_tagged? = git_root? && !git_dirty? && git_last_tag == git_head
+        memoize def git_tag = (git_last_tag if git_tagged?)
+        memoize def git_commit_str = [git_head, git_dirty? && '-dirty'].select(&:itself).join
+
+        memoize def github_url = gem_spec.metadata['source_code_uri']
+        memoize def github_release_asset(asset:, tag: git_tag)
+          "#{github_url}/releases/download/#{tag}/#{asset}".freeze if tag
+        end
+
+        memoize def debug_asset_name = "#{extension_name}.#{target_os}-#{target_cpu}.so.debug"
+        memoize def debug_info_url   = github_release_asset(asset: debug_asset_name)
+
+        memoize def target_os = RbConfig::CONFIG['target_os']
+        memoize def target_cpu = RbConfig::CONFIG['target_cpu']
+
+        # library metadata (such as version/commit hash, etc) to be passed to
+        #   `ld --package-metadata` (https://systemd.io/ELF_PACKAGE_METADATA/)
+        memoize def linker_package_metadata
+          {
+            type:         'gem',
+            name:         gem_name,
+            version:      gem_version,
+            dirty:        git_dirty?,
+            commit:       git_commit_str,
+            release:      git_tag,
+            os:           target_os,
+            sysname:      Etc.uname.fetch(:sysname),
+            os_rel:       Etc.uname.fetch(:release),
+            os_ver:       Etc.uname.fetch(:version),
+            machine:      Etc.uname.fetch(:machine),
+            arch:         target_cpu,
+            build_os:     RbConfig::CONFIG['build_os'],
+            arch_os:      RbConfig::CONFIG['build_cpu'],
+            libc:         (Etc.confstr(Etc::CS_GNU_LIBC_VERSION) rescue nil),
+            pthread:      (Etc.confstr(Etc::CS_GNU_LIBPTHREAD_VERSION) rescue nil),
+            debugInfoUrl: debug_info_url,
+          }.compact.transform_keys(&:to_s).freeze
+        end
+
+        memoize def extension_data
+          {
+            gem_name:   gem_name,
+            name:       extension_name,
+            version:    gem_version.to_s,
+            path:       gem_full_path.to_s,
+            package:    {
+              linker_metadata: linker_package_metadata.to_json,
+            },
+            debug_build: true,
+          }.freeze
+        end
+
+      private
+
+        def run_cmd(*args, chdir: __dir__, path: false, **kwargs)
+          return nil if chdir.nil?
+
+          out, status = ::Open3.capture2(*args, chdir:, err: :close, stdin_data: '', **kwargs)
+          return nil unless status.success?
+
+          out.strip!
+          return out.empty? ? nil : Pathname.new(out).cleanpath(false) if path
+
+          out
+        end
+      end
+    end
+  end
+end

data/lib/ruble/build/data/os.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    module Data
+      # noinspection RubyClassModuleNamingConvention
+      module OS
+        include Memery
+
+        OS_FIELDS = %i[dev_null cpu_count host posix? linux? host_os iron_ruby? bits host_cpu
+                     java? windows? mac? jruby? osx? x? freebsd? cygwin?].freeze
+
+        memoize def os_data
+          result = OS_FIELDS.to_h { |name| [name.to_s.delete_suffix('?'), ::OS.send(name)] }
+          result['os_release'] = OS.parse_os_release rescue nil
+          result.compact.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ruble/build/data/rice.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    module Data
+      module Rice
+        include Memery
+
+        memoize def rice_spec = Data['rice']
+        memoize def rice_full_path = Pathname.new(rice_spec.full_gem_path).freeze
+        memoize def rice_include_dir = (rice_full_path / 'include').freeze
+        memoize def rice_version = rice_spec.version.freeze
+
+        memoize def rice_data
+          {
+            gem_path:    rice_full_path.to_s,
+            include_dir: rice_include_dir.to_s,
+            version:     rice_version.to_s,
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ruble/build/data.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    module Data
+      class << self
+        include Memery
+
+        memoize def bundler = ::Bundler.load
+        memoize def specs = bundler.specs
+
+        memoize def this_gem
+          specs.find { |gem| gem.full_gem_path == bundler.root.to_s }
+        end
+
+        memoize def [](name)
+          specs.find_by_name_and_platform(name, RbConfig::CONFIG['target'])
+        end
+      end
+    end
+  end
+end

data/lib/ruble/build/extconf.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    class Extconf
+      include Memery
+
+      class << self
+        private :new
+        def instance = @instance ||= new
+
+        def add_github_repo_data(name)
+          klass_name = RuBLE::Build.zeitwerk.inflector.camelize(name.to_s, __dir__).to_sym
+          klass = RuBLE::Build.const_get(klass_name)
+          define_method name.to_sym do
+            # TODO: accept custom path
+            # TODO: choose shared vs static
+            # TODO: choose build vs precompiled
+
+            static = enable_config("#{name}-static", true)
+            precompiled = enable_config("precompiled-#{name}", true)
+
+            tag = with_config("#{name}-release")&.freeze || 'default'
+            klass.new(tag:, static:, precompiled:)
+          end
+          memoize name.to_sym
+          klass
+        end
+      end
+
+      def initialize
+        ENV[debug_env_var] = 'on' if debug_mode?
+      end
+
+      include RuBLE::Build::Data::OS
+      include RuBLE::Build::Data::Bundler
+      include RuBLE::Build::Data::Rice
+      include RuBLE::Build::Data::Extension
+      include RuBLE::Build::CMake
+
+      memoize def debug_env_var = "#{gem_name.upcase}_DEBUG_ON"
+
+      memoize def debug_mode? = with_config('debug') || ENV[debug_env_var] # rubocop:disable Style/FetchEnvVar
+
+      memoize def default_library_version(name:)
+        gem_spec.metadata.fetch("#{name}_library_version")
+      end
+
+      memoize def rbconfig_data
+        RbConfig::CONFIG.select do |_k, v|
+          v && !v.strip.empty?
+        end
+      end
+
+      add_github_repo_data :simpleble
+      add_github_repo_data :boost
+
+      memoize def config_data
+        @config_data = {
+          bundler:      bundler_data,
+          extconf:      extension_data,
+          rb:           rbconfig_data,
+          rb_os:        os_data,
+          rb_simpleble: simpleble.config_data,
+          rb_boost:     boost.config_data,
+          rice:         rice_data,
+        }.each_value(&:freeze).freeze
+      end
+
+      def write_build_config(path:)
+        path.unlink if path.file?
+        cmake_generate(config_data, path:)
+      end
+    end
+  end
+end

data/lib/ruble/build/github_repo.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    class GithubRepo
+      include Memery
+      include Data::Extension
+
+      GITHUB_API_VERSION = '2022-11-28'
+
+      class << self
+        def github_repo = const_get(:GITHUB_REPO)
+        def github_repo_url = "https://github.com/#{github_repo}"
+        def github_api_base_url = "https://api.github.com/repos/#{github_repo}"
+      end
+
+      attr_reader *%i[requested_tag static precompiled]
+      def initialize(tag: 'default', static: true, precompiled: true)
+        # rubocop:disable Style/ClassEqualityComparison
+        raise "Cannot instantiate #{self.class} directly. Must subclass." if self.class == GithubRepo
+
+        @requested_tag = tag.to_s.freeze
+        @static = static
+        @precompiled = precompiled
+      end
+
+      memoize def gem_spec = Extconf.instance.gem_spec
+      memoize def github_repo = self.class.github_repo
+      memoize def github_repo_url = self.class.github_repo_url
+      memoize def github_api_base_url = self.class.github_api_base_url
+
+      memoize def static? = static
+      memoize def linkage = (static? ? 'static' : 'dynamic')
+      memoize def precompiled? = precompiled
+      memoize def build? = !precompiled?
+
+      memoize def latest_release(include_prereleases: false)
+        github_api.get('releases').body.detect do |release|
+          is_draft = release.fetch('draft')
+          is_prerelease = release.fetch('prerelease')
+          !is_draft && (include_prereleases || !is_prerelease)
+        end.fetch('id')
+      end
+
+      memoize def release
+        tag = requested_tag.to_s
+        tag = Extconf.instance.debug_mode? ? latest_release : tag_from_gemspec if tag == 'default'
+
+        github_api.get("releases/#{tag}").body.freeze
+      end
+
+      memoize def release_name = release.fetch('name').freeze
+
+      memoize def tag_from_gemspec
+        class_name = self.class.name
+        raise "Can't determine name of anonymous class" unless class_name
+
+        gem_spec.metadata.fetch("#{class_name.downcase}_library_release_tag")
+      end
+
+      memoize def real_tag_name = release.fetch('tag_name').freeze
+
+      memoize def commit_hash
+        github_api.get("commits/#{real_tag_name}").body.fetch('sha').freeze
+      end
+
+      memoize def assets = release.fetch('assets').to_h { [ _1.fetch('name'), _1 ] }.freeze
+      
+      def matching_asset
+        raise NotImplementedError, "This function must be defined in the subclass"
+      end
+
+      memoize def download_size
+        matching_asset.fetch('size')
+      end
+
+      memoize def gem_spec
+        Bundler.load.specs.find_by_name_and_platform('RuBLE', RUBY_PLATFORM)
+      end
+
+      alias_method :full_gem_path, :gem_full_path
+
+      memoize def config_data
+        release_data = release.dup.tap { _1.delete('assets') }
+        release_data['author']&.reject! { |k, _v| k.to_s.end_with?('_url') }
+
+        asset_data = matching_asset.dup.tap { _1.delete('uploader') }
+
+        {
+          **filter_github_metadata(release_data),
+          linkage:,
+          requested_tag:,
+          commit_hash:,
+          release_tag:   real_tag_name,
+          asset:         filter_github_metadata(asset_data),
+          repo_url:      github_repo_url,
+        }.freeze
+      end
+
+    protected
+
+      memoize def github_api
+        options = {
+          headers: {
+            'X-GitHub-Api-Version' => GITHUB_API_VERSION,
+            'Accept'               => 'application/vnd.github+json',
+          },
+          request: { timeout: 15 },
+        }
+        Faraday.new(github_api_base_url, options) do |f|
+          f.response :json
+          f.request  :retry
+          f.response :raise_error
+          f.response :follow_redirects
+          # f.response :logger
+        end
+      end
+
+      def filter_github_metadata(data)
+        data.reject! do |k, v|
+          next true if v == ''
+
+          k.to_s.match?(/(\A|_)(mentions|reactions|node_id|body|gravatar)(\z|_)/)
+        end
+        data.transform_values! { _1.is_a?(Hash) ? filter_github_metadata(_1) : _1 }
+      end
+    end
+  end
+end

data/lib/ruble/build/simpleble.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    class SimpleBLE < GithubRepo
+      GITHUB_REPO = 'OpenBluetoothToolbox/SimpleBLE'
+      EXTRACT_OS_PATH_PRUNE = {
+        macos:   'Users/runner/work/SimpleBLE/SimpleBLE/build/install',
+        windows: 'install',
+        linux:   'SimpleBLE/SimpleBLE/build_simpleble/install',
+      }.freeze
+
+      class << self
+        def os_arch
+          if OS.mac?
+            OS.host_cpu == 'x86_64' ? 'macos-x86_64' : 'macos-arm64'
+          elsif OS.linux?
+            return 'armv6' if OS.host_cpu.start_with?('arm')
+
+            OS.bits == 32 ? 'x86' : 'x64'
+          elsif OS.windows?
+            OS.bits == 32 ? 'Win32' : 'x64'
+          else
+            raise 'Unsupported OS'
+          end
+        end
+
+        def os
+          return 'macos' if OS.mac?
+          return 'windows' if OS.windows?
+          return 'linux' if OS.linux?
+
+          raise 'Unsupported OS'
+        end
+
+        def os_asset_name = "#{os}-#{os_arch}"
+      end
+
+      # Static makes sense for distribution if we can do it
+      memoize def asset_prefix = (static? ? 'simpleble_static' : 'simpleble_shared')
+      memoize def asset_name = self.class.os_asset_name
+      memoize def asset_filename = "#{asset_prefix}_#{asset_name}.zip".freeze
+      memoize def matching_asset = assets.fetch(asset_filename).freeze
+
+      memoize def extract_src_path
+        EXTRACT_OS_PATH_PRUNE.fetch(self.class.os.to_sym).freeze
+      end
+
+      memoize def config_data
+        super.dup.tap do |data|
+          data[:archive_path] = extract_src_path
+        end.freeze
+      end
+    end
+  end
+end

data/lib/ruble/build.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'build/core_ext'
+
+module RuBLE
+  module Build
+    class << self
+      include Memery
+      memoize def zeitwerk
+        require 'zeitwerk'
+        Zeitwerk::Loader.new.tap do |loader|
+          loader.inflector.inflect(
+            'cmake'     => 'CMake',
+            'ruble'     => 'RuBLE',
+            'simpleble' => 'SimpleBLE',
+            'os'        => 'OS',
+          )
+          loader.push_dir("#{__dir__}/build", namespace: RuBLE::Build)
+          loader.ignore("#{__dir__}/build/core_ext.rb")
+        end
+      end
+      private :zeitwerk
+    end
+  end
+end
+
+RuBLE::Build.send(:zeitwerk).setup

data/lib/ruble/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuBLE
+  VERSION = '0.0.3.alpha'
+  BOOST_LIBRARY_RELEASE_TAG = '1.83.0'
+  SIMPLEBLE_LIBRARY_RELEASE_TAG = 'v0.6.1'
+end

data/lib/ruble.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'ruble/version'
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'ruble'    => 'RuBLE',
+  'simpleble' => 'SimpleBLE',
+)
+loader.ignore("#{__dir__}/tasks")
+loader.ignore("#{__dir__}/ruble/build")
+loader.ignore("#{__dir__}/ruble/build.rb")
+loader.ignore("#{__dir__}/RuBLE.rb")
+# preloading RuBLE::VERSION manually, to avoid issues if RuBLE::Build
+#  and its zeitwerk loader are being used, but this loader can't be used
+#  due to lack of library file
+loader.ignore("#{__dir__}/ruble/version.rb")
+loader.setup
+
+module RuBLE
+  # TODO: is this used? (should it be?)
+  class Error < StandardError; end
+  class << self
+    def try_demangle(symbol)
+      require 'open3'
+      demangled, status = Open3.capture2('c++filt', stdin_data: symbol)
+      demangled if status.success?
+    rescue Exception # rubocop:disable Lint/RescueException
+      nil
+    end
+  end
+
+  # Your code goes here...
+end
+
+begin
+  require_relative 'ruble/ruble.so'
+rescue LoadError => ex
+  if (symbol = ex.message[/\A[^:]+: undefined symbol: (\S+) - /, 1])
+    demangled = RuBLE.try_demangle(symbol)
+    ex.message << "\n\nDemangled symbol: #{demangled}" if demangled
+  end
+  raise
+end
+

data/lib/tasks/dev/dev_tasks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative './pager'
+require_relative './state_hash'
+require_relative './paths'
+
+class DevTasks
+  include Paths
+  include StateHash
+
+  attr_reader :pager
+  def initialize(*flags)
+    @flags = flags.map(&:to_sym).to_set
+    @pager = Pager.instance
+    @pager.start
+  end
+
+  def flag?(name) = @flags.include?(name.to_sym)
+  def quiet? = flag?(:quiet)
+  def verbose? = !quiet?
+  def single? = flag?(:single)
+  def nproc = single? ? 1 : Etc.nprocessors
+
+  def write_hash_file! = HASH_FILE.write(state_hash)
+
+  def ninja_cmd(target: nil)
+    verbose_flag = verbose? ? '-v' : nil
+    [ 'ninja', "-j#{nproc}", verbose_flag, target].compact
+  end
+
+  def make_cmd(target: nil)
+    verbose_val = verbose? ? 1 : 0
+    ['make', "-j#{nproc}", "V=#{verbose_val}", 'CXX=g++-13', target].compact
+  end
+
+
+  def pristine!
+    HASH_FILE.unlink if HASH_FILE.exist?
+    pager.exec_paginated!(ninja_cmd(target: 'clean'), chdir: BUILD_DIR) if NINJA_FILE.exist?
+    pager.exec_paginated!(make_cmd(target: 'clean'), chdir: TEST_DIR) if (TEST_DIR / 'Makefile').exist?
+    LIB_FILE.unlink if LIB_FILE.exist?
+    BUILD_INFO_FILE.unlink if BUILD_INFO_FILE.exist?
+    BUILD_DIR.rmtree if BUILD_DIR.exist?
+  end
+
+  def reconfigure!
+    pristine!
+    pager.exec_paginated!(%W[bundle exec ruby extconf.rb -- --with-debug].shelljoin, chdir: EXT_DIR)
+
+
+    BUILD_DIR.mkpath
+    cmd = %W[
+      cmake -G Ninja
+      -DCMAKE_CXX_COMPILER=#{CMAKE_CXX_COMPILER}
+      -DCMAKE_BUILD_TYPE=Debug
+      -DCMAKE_INSTALL_CONFIG_NAME=Debug
+      #{EXT_DIR_FROM_BUILD_DIR}
+    ]
+    pager.exec_paginated!(cmd, chdir: BUILD_DIR)
+    write_hash_file!
+  end
+
+  def needs_reconfigure? = !HASH_FILE.exist? || HASH_FILE.read.strip != state_hash
+  def maybe_reconfigure! = needs_reconfigure? && reconfigure!
+
+  def build!
+    maybe_reconfigure!
+    pager.exec_paginated!(make_cmd, chdir: TEST_DIR)
+
+    pager.exec_paginated!(ninja_cmd, chdir: BUILD_DIR)
+    pager.exec_paginated!(ninja_cmd(target: 'install'), chdir: BUILD_DIR)
+  end
+
+  Symbol = Struct.new(:Symbol, *%i[address name file flag defined], keyword_init: true) do
+    include Comparable
+
+    def defined? = self.defined
+
+    def ignore?
+      return true if name =~ /\A(typeinfo|vtable|TLS init function) for /
+
+      false
+    end
+
+    def err_if_undefined?
+      name =~ /Simple(Rb)?BLE/
+    end
+
+    def <=>(other) = name <=> other.name
+  end
+
+  def audit_objfile_symbols!
+    defined_symbols = Set.new
+    undefined_symbols = Hash.new
+    objfiles = OBJFILES_DIR.glob('{**/,}*.o')
+    filenames = objfiles.map(&:to_s)
+    cmd = %W[nm -A -C --defined-only] + filenames
+    _result, out, _err = pager.exec_unpaginated!(cmd, chdir: BUILD_DIR)
+    out.strip.split(/[\n\r]+/).each do |line|
+      file, _, line = line.partition(/:\s*/)
+      addr_str, flag, name = line.strip.split(/\s+/, 3)
+      address = addr_str.to_i(16)
+      sym = Symbol.new(address:, name:, flag:, file:, defined: true)
+      defined_symbols << sym
+    end
+
+    cmd = %W[nm -A -C --undefined-only] + filenames
+    _result, out, _err = pager.exec_unpaginated!(cmd, chdir: BUILD_DIR)
+    out.strip.split(/[\n\r]+/).each do |line|
+      file, line = line.split(/:\s*/,2)
+      flag, name = line.strip.split(/\s+/, 2)
+      sym = Symbol.new(name:, flag:, file:, defined: false)
+      next if sym.ignore?
+
+      undefined_symbols[name] ||= []
+      undefined_symbols[name] << sym
+    end
+
+    defined_symbol_names = defined_symbols.map(&:name).to_set
+    undefined_symbol_names = undefined_symbols.keys.to_set
+    missing_symbol_names = undefined_symbol_names - defined_symbol_names
+    missing_symbols = undefined_symbols.values_at(*missing_symbol_names).flatten
+    puts 'The following symbols are not defined in the object files, but should be:'
+    missing_symbols.select!(&:err_if_undefined?)
+
+    missing_symbols.map(&:name).uniq.each { puts _1 }
+  end
+end
+