ffidb 0.12.0

data/lib/ffidb/library.rb

@@ -0,0 +1,120 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'library_parser'
+require_relative 'release'
+require_relative 'symbol_table'
+
+require 'pathname'
+require 'yaml'
+
+module FFIDB
+  class Library
+    include SymbolTable
+    include Comparable
+
+    attr_reader :name
+    attr_reader :version
+    attr_reader :path
+
+    attr_reader :summary
+    attr_reader :website
+    attr_reader :source
+    attr_reader :packages
+    attr_reader :dlopen
+    attr_reader :objects
+    attr_reader :headers
+
+    ##
+    # @param  [Library] other
+    # @return [Integer]
+    def <=>(other) self.name <=> other&.name end # FIXME
+
+    ##
+    # @param [String, #to_s] name
+    # @param [String, #to_s] version
+    # @param [Pathname, #to_s] path
+    def initialize(name, version, path)
+      @name, @version = name.to_s.freeze, (version || :stable).to_s.freeze
+      @path = Pathname(path).freeze
+      if (metadata_path = @path.join('library.yaml')).exist?
+        metadata  = YAML.load(metadata_path.read).transform_keys(&:to_sym)
+        metadata.delete(:name)
+        @summary  = metadata.delete(:summary).freeze
+        @website  = metadata.delete(:website).freeze
+        @source   = metadata.delete(:source).freeze
+        @packages = metadata.delete(:packages).transform_keys(&:to_sym).freeze
+        dlopen    = metadata.delete(:dlopen).freeze
+        @dlopen   = dlopen.is_a?(Array) ? dlopen : [dlopen]
+        @objects  = (metadata.delete(:objects) || []).freeze
+        @headers  = (metadata.delete(:headers) || []).freeze
+      end
+    end
+
+    ##
+    # @return [String]
+    def soname() self.objects&.first end
+
+    ##
+    # @yield  [release]
+    # @yieldparam [release] Release
+    # @return [Enumerator]
+    def each_release(&block)
+      return self.to_enum(:each_release) unless block_given?
+      # TODO
+    end
+
+    ##
+    # @yield  [typedef]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_typedef(&block)
+      return self.to_enum(:each_typedef) unless block_given?
+      self.each_symbol.filter { |symbol| symbol.typedef? }.each(&block)
+    end
+
+    ##
+    # @yield  [enum]
+    # @yieldparam [enum] Enum
+    # @return [Enumerator]
+    def each_enum(&block)
+      return self.to_enum(:each_enum) unless block_given?
+      self.each_symbol.filter { |symbol| symbol.enum? }.each(&block)
+    end
+
+    ##
+    # @yield  [struct]
+    # @yieldparam [struct] Struct
+    # @return [Enumerator]
+    def each_struct(&block)
+      return self.to_enum(:each_struct) unless block_given?
+      self.each_symbol.filter { |symbol| symbol.struct? }.each(&block)
+    end
+
+    ##
+    # @yield  [union]
+    # @yieldparam [union] Union
+    # @return [Enumerator]
+    def each_union(&block)
+      return self.to_enum(:each_union) unless block_given?
+      self.each_symbol.filter { |symbol| symbol.union? }.each(&block)
+    end
+
+    ##
+    # @yield  [function]
+    # @yieldparam [function] Function
+    # @return [Enumerator]
+    def each_function(&block)
+      return self.to_enum(:each_function) unless block_given?
+      self.each_symbol.filter { |symbol| symbol.function? }.each(&block)
+    end
+
+    ##
+    # @yield  [symbol]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_symbol(&block)
+      return self.to_enum(:each_symbol) unless block_given?
+      LibraryParser.new(self.path.join(self.version)).each_symbol(&block)
+    end
+  end # Library
+end # FFIDB

data/lib/ffidb/library_parser.rb

@@ -0,0 +1,132 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'symbol_table'
+
+require 'pathname'
+require 'psych'
+
+module FFIDB
+  class LibraryParser
+    include SymbolTable
+
+    attr_reader :path
+
+    ##
+    # @param [Pathname, #to_s] path
+    def initialize(path)
+      @path = Pathname(path).freeze
+    end
+
+    ##
+    # @yield  [typedef]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_typedef(&block)
+      return self.to_enum(:each_typedef) unless block_given?
+      self.parse_yaml_dir(self.path, [:typedef], &block)
+    end
+
+    ##
+    # @yield  [enum]
+    # @yieldparam [enum] Enum
+    # @return [Enumerator]
+    def each_enum(&block)
+      return self.to_enum(:each_enum) unless block_given?
+      self.parse_yaml_dir(self.path, [:enum], &block)
+    end
+
+    ##
+    # @yield  [struct]
+    # @yieldparam [struct] Struct
+    # @return [Enumerator]
+    def each_struct(&block)
+      return self.to_enum(:each_struct) unless block_given?
+      self.parse_yaml_dir(self.path, [:struct], &block)
+    end
+
+    ##
+    # @yield  [union]
+    # @yieldparam [union] Union
+    # @return [Enumerator]
+    def each_union(&block)
+      return self.to_enum(:each_union) unless block_given?
+      self.parse_yaml_dir(self.path, [:union], &block)
+    end
+
+    ##
+    # @yield  [function]
+    # @yieldparam [function] Function
+    # @return [Enumerator]
+    def each_function(&block)
+      return self.to_enum(:each_function) unless block_given?
+      self.parse_yaml_dir(self.path, [:function], &block)
+    end
+
+    ##
+    # @yield  [symbol]
+    # @yieldparam [symbol] Symbolic
+    # @return [Enumerator]
+    def each_symbol(&block)
+      return self.to_enum(:each_symbol) unless block_given?
+      self.parse_yaml_dir(self.path, nil, &block)
+    end
+
+    ##
+    # @param  [Pathname] path
+    # @param  [Array<Symbol>] kind_filter
+    # @yield  [symbol]
+    # @yieldparam [symbol] Symbolic
+    # @return [void]
+    def parse_yaml_dir(path, kind_filter = nil, &block)
+      self.path.glob('*.yaml') do |path|
+        path.open do |file|
+          self.parse_yaml_file(file, kind_filter, &block)
+        end
+      end
+    end
+
+    ##
+    # @param  [IO] file
+    # @param  [Array<Symbol>] kind_filter
+    # @yield  [symbol]
+    # @yieldparam [symbol] Symbolic
+    # @return [void]
+    def parse_yaml_file(file, kind_filter = nil, &block)
+      Psych.parse_stream(file) do |yaml_doc|
+        kind = yaml_doc.children.first.tag[1..-1].to_sym
+        next if kind_filter && !kind_filter.include?(kind)
+        yaml = yaml_doc.to_ruby.transform_keys!(&:to_sym)
+        case kind
+          when :typedef
+            yield Typedef.new(yaml[:name], Type.for(yaml[:type]), yaml[:comment])
+          when :enum
+            yield Enum.new(yaml[:name], yaml[:values] || {}, yaml[:comment])
+          when :struct
+            fields = (yaml[:fields] || {}).inject({}) do |fs, (k, v)|
+              fs[k.to_sym] = Type.for(v)
+              fs
+            end
+            yield Struct.new(yaml[:name], fields, yaml[:comment])
+          when :union
+            yield Union.new(yaml[:name], yaml[:fields] || {}, yaml[:comment])
+          when :function
+            parameters = (yaml[:parameters] || {}).inject({}) do |ps, (k, v)|
+              k = k.to_sym
+              ps[k] = Parameter.new(k, Type.for(v))
+              ps
+            end
+            yield Function.new(
+              name: yaml[:name],
+              type: Type.for(yaml[:type]),
+              parameters: parameters,
+              definition: !yaml.has_key?(:definition) ? nil : Location.new(
+                file: yaml.dig(:definition, 'file'),
+                line: yaml.dig(:definition, 'line'),
+              ),
+              comment: yaml[:comment],
+            )
+        end
+      end
+    end
+  end # LibraryParser
+end # FFIDB

data/lib/ffidb/location.rb

@@ -0,0 +1,17 @@
+# This is free and unencumbered software released into the public domain.
+
+module FFIDB
+  class Location < ::Struct.new(:file, :line, keyword_init: true)
+    ##
+    # @return [String]
+    def to_s
+      "#{self.file}:#{self.line}"
+    end
+
+    ##
+    # @return [Hash<Symbol, Object>]
+    def to_h
+      {file: self.file, line: self.line}
+    end
+  end # Location
+end # FFIDB

data/lib/ffidb/parameter.rb

@@ -0,0 +1,35 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'type'
+
+module FFIDB
+  class Parameter < ::Struct.new(:name, :type)
+    include Comparable
+
+    ##
+    # @param  [Symbol, #to_sym] name
+    # @param  [Type] type
+    def initialize(name, type = nil)
+      super(name.to_sym, type ? Type.for(type) : nil)
+    end
+
+    ##
+    # @param  [Parameter] other
+    # @return [Integer]
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    ##
+    # @return [String]
+    def to_s
+      "#{self.name}: #{self.type}"
+    end
+
+    ##
+    # @return [Hash<Symbol, Type>]
+    def to_h
+      {self.name => self.type}
+    end
+  end # Parameter
+end # FFIDB

data/lib/ffidb/registry.rb

@@ -0,0 +1,87 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'errors'
+
+require 'pathname'
+
+module FFIDB
+  class Registry
+    GIT_HTTPS_URL = 'https://github.com/ffidb/ffidb.git'.freeze
+
+    attr_reader :path
+
+    ##
+    # @return [Pathname]
+    def self.default_path
+      Pathname(ENV['HOME']).join('.ffidb')
+    end
+
+    ##
+    # @param [Pathname, #to_s] path
+    def self.open(path = nil, &block)
+      registry = self.new(path)
+      block_given? ? block.call(registry) : registry
+    end
+
+    ##
+    # @param [Pathname, #to_s] path
+    # @raise [RegistryVersionMismatch] if this version of FFIDB.rb is unable to open the registry
+    def initialize(path = nil)
+      @path = Pathname(path || self.class.default_path)
+
+      if (version_file = @path.join('.cli-version')).exist?
+        min_version = version_file.read.chomp.split('.').map(&:to_i)
+        if (FFIDB::VERSION.to_a <=> min_version).negative?
+          raise RegistryVersionMismatch, "FFIDB.rb #{min_version.join('.')}+ is required for the registry directory #{@path}"
+        end
+      end
+    end
+
+    ##
+    # @yield  [library]
+    # @return [Enumerator]
+    def each_library(&block)
+      return self.to_enum(:each_library) unless block_given?
+      library_names = self.path.glob('*')
+        .select { |path| path.directory? && !(path.symlink?) }
+        .map { |path| path.basename.to_s }
+        .sort
+      library_names.each do |library_name|
+        yield self.open_library(library_name)
+      end
+    end
+
+    ##
+    # @param  [String, #to_s] library_name
+    # @param  [String, #to_s] library_version
+    # @yield  [library]
+    # @return [Library]
+    def open_library(library_name, library_version = nil, &block)
+      library_path = self.path.join(library_name.to_s)
+      return nil unless library_path.directory?
+      library = Library.new(library_name, library_version, library_path)
+      block_given? ? block.call(library) : library
+    end
+
+    ##
+    # @param  [Glob, #===] matcher
+    # @param  [Symbol] kind
+    # @yield  [function]
+    # @yield  [library]
+    # @return [Enumerator]
+    def find_symbols(matcher, kind: nil, &block)
+      return self.to_enum(:find_symbols) unless block_given?
+      count = 0
+      self.each_library do |library|
+        library.each_symbol do |symbol|
+          next if kind && kind != symbol.kind
+          if matcher === symbol.name.to_s
+            count += 1
+            yield symbol, library
+          end
+        end
+      end
+      count > 0 ? count : nil
+    end
+  end # Registry
+end # FFIDB

data/lib/ffidb/release.rb

@@ -0,0 +1,14 @@
+# This is free and unencumbered software released into the public domain.
+
+module FFIDB
+  class Release < ::Struct.new(:version, :headers)
+    ##
+    # @yield  [header]
+    # @yieldparam [header] Header
+    # @return [Enumerator]
+    def each_header(&block)
+      return self.to_enum(:each_header) unless block_given?
+      self.headers(&block) if self.headers
+    end
+  end # Release
+end # FFIDB

data/lib/ffidb/struct.rb

@@ -0,0 +1,41 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'symbolic'
+
+module FFIDB
+  class Struct < ::Struct.new(:name, :fields, :comment)
+    include Symbolic
+
+    ##
+    # @param  [Symbol, #to_sym] name
+    # @param  [Map<Symbol, Type>] fields
+    # @param  [String, #to_s] comment
+    def initialize(name, fields = {}, comment = nil)
+      super(name.to_sym, fields || {}, comment&.to_s)
+    end
+
+    ##
+    # @return [Boolean]
+    def struct?() return true end
+
+    ##
+    # @return [Boolean]
+    def opaque?() !self.fields || self.fields.empty? end
+
+    ##
+    # @return [String]
+    def to_s
+      "struct #{self.name}"
+    end
+
+    ##
+    # @return [Hash<Symbol, Type>]
+    def to_h
+      {
+        name: self.name.to_s,
+        comment: self.comment,
+        fields: self.opaque? ? nil : self.fields&.transform_values { |t| t.to_s },
+      }.delete_if { |k, v| v.nil? }
+    end
+  end # Struct
+end # FFIDB