democracy 0.0.56

data/crystal-gobject/src/generator/build_namespace.cr

@@ -0,0 +1,22 @@
+require "../crout"
+require "../g_i_repository"
+require "./namespace"
+
+name = ARGV[0]
+version = ARGV[1]?
+namespace = Namespace.new(name, version)
+
+Crout.build(STDOUT) do |builder|
+  section do
+    namespace.dependencies.each do |dependency, version|
+      if version
+        line call("require_gobject", literal(dependency), literal(version))
+      else
+        line call("require_gobject", literal(dependency))
+      end
+    end
+  end
+
+  namespace.lib_definition(builder)
+  namespace.wrapper_definitions(builder)
+end

data/crystal-gobject/src/generator/doc.cr

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:33 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 5 of 16 source files
+module Crystal::Config
+require_relative "string__"
+ require_relative "./crystal"
+require_relative "./repository"
+  def self.path
+    Crystal::PATH
+  end
+
+  def self.library_path
+    {{env("CRYSTAL_CONFIG_LIBRARY_PATH") || env("CRYSTAL_LIBRARY_PATH") || `crystal env CRYSTAL_LIBRARY_PATH`.stringify}} || previous_def
+  end
+end
+
+struct Crystal::CrystalPath
+  def self.default_path
+    default = previous_def
+    "#{default}#{Process::PATH_DELIMITER}#{gobject_path}"
+  end
+
+  def self.gobject_path
+    File.expand_path(File.join(__DIR__, "..", "..", "samples", "lib")) # darn hack, is there a better way?
+  end
+end
+
+class Crystal::Doc::Type
+  setter doc : String?
+
+  def doc
+    previous_def || @doc
+  end
+end
+
+class Crystal::Doc::Method
+  setter doc : String?
+
+  def doc
+    previous_def || @doc
+  end
+end
+
+class Crystal::Doc::Constant
+  setter doc : String?
+
+  def doc
+    previous_def || @doc
+  end
+end
+
+class Generator < Crystal::Doc::Generator
+  @girs = {} of String => XML::Node?
+  @gir_namespace_cache = {} of String => Bool
+
+  setter gir_namespaces : Array(String) = [] of String
+  setter gir_search_paths : Array(String) = ["/usr/share/gir-1.0"]
+
+  def is_gir_namespace?(name : String)
+    return @gir_namespace_cache[name] if @gir_namespace_cache.has_key?(name)
+
+    could_load = !GIRepository::Repository.instance.require(name).nil? rescue false
+    @gir_namespace_cache[name] = could_load
+    could_load
+  end
+
+  def must_include?(location : Crystal::Location)
+    return true if is_gir_namespace?(location.filename.to_s)
+
+    super
+  end
+
+  def gir(namespace : String)
+    @girs[namespace] ||= begin
+      file = Namespace.new(namespace).girname
+      path = @gir_search_paths.map { |path| File.join(path, file) }.find { |path| File.exists?(path) }
+      if path
+        File.open(path, &->XML.parse(IO)).first_element_child
+      else
+        STDERR.puts "Couldn't find #{file} in #{@gir_search_paths.join(":")}"
+        exit 1
+      end
+    end
+  end
+
+  def gir(type : Crystal::Doc::Type)
+    return gir(type.name) if is_gir_namespace?(type.name)
+    namespace = type.namespace
+    gir(namespace) if namespace
+  end
+
+  def gir(method : Crystal::Doc::Method)
+    gir(method.type)
+  end
+
+  def gir(constant : Crystal::Doc::Constant)
+    gir(constant.type)
+  end
+
+  def parse_docstring(doc)
+    doc.gsub(/^#/m, "  #")
+  end
+
+  def doc(type : Crystal::Doc::Type)
+    set_doc(type, {"class", "record", "union", "enumeration", "bitfield"})
+
+    super
+  end
+
+  def doc(method : Crystal::Doc::Method)
+    if method.type.kind == :enum
+      set_doc(method, {"member"}, Tuple.new, method.type, {"enumeration", "bitfield"})
+    elsif method.type.kind == :module
+      set_doc(method, {"function"}, {"get_"}, method.type, {"namespace"})
+    else
+      set_doc(method, {"method", "function", "field"}, {"get_"},
+        method.type, {"class", "record", "union"})
+    end
+
+    super
+  end
+
+  def doc(constant : Crystal::Doc::Constant)
+    if constant.type.enum?
+      set_doc(constant, {"member"}, Tuple.new, constant.type, {"enumeration", "bitfield"}, item_case: :lower)
+    else
+      set_doc(constant, {"constant"})
+    end
+
+    super
+  end
+
+  def set_doc(item, gir_kinds, prefixes = Tuple.new, item_namespace = nil, item_gir_kinds = {"*"}, *, item_case = :given)
+    if item.doc.nil?
+      gir = gir(item)
+      if gir
+        namespace = gir.namespace
+        namespaces = {"gir" => namespace.href} if namespace
+        prefixes = Tuple.new("", *prefixes)
+        name = item.name.rchop('?')
+        name = name.downcase if item_case == :lower
+        kinds = gir_kinds.map { |kind| "self::gir:#{kind}" }.join(" or ")
+        names = prefixes.map { |prefix| "@name='#{prefix}#{name}'" }.join(" or ")
+        xpath = "//gir:*[#{kinds}][#{names}]/gir:doc/text()"
+
+        if item_namespace
+          kinds = item_gir_kinds.map { |kind| "self::gir:#{kind}" }.join(" or ")
+          xpath = "//gir:*[#{kinds}][@name='#{item_namespace.name}']#{xpath}"
+        end
+
+        doc = gir.xpath_node(xpath, namespaces).try &.content
+        item.doc = parse_docstring(doc) if doc
+      end
+    end
+  end
+
+  def compute_repository
+  end
+
+  def read_readme
+    "# Documentation for #{@gir_namespaces.join(", ")} and dependencies"
+  end
+
+  def relative_location(location : Crystal::Location?)
+    location
+  end
+
+  def relative_filename(location)
+    filename = location.filename
+    return unless filename.is_a?(String)
+    filename
+  end
+
+  def relative_locations(type)
+
+    locations = [] of Crystal::Doc::RelativeLocation
+    type.locations.try &.each do |location|
+      location = relative_location location
+      next unless location
+
+      filename = relative_filename location
+      next unless filename
+
+      locations << Crystal::Doc::RelativeLocation.new(filename, location.line_number)
+    end
+
+    locations
+  end
+end
+
+opt_namespaces = nil
+output_directory = "docs/gobject"
+gir_search_paths = nil
+
+OptionParser.parse do |p|
+  p.banner = "Usage: gi-doc [opts] NAMESPACE ..."
+  p.on("-o DIR", "--output=DIR", "Output directory (defaults to docs/gobject") { |dir| output_directory = dir }
+  p.on("-g DIR:DIR:...", "--girs=DIR:DIR:...", "Colon separated list of directories to search .gir files in (defaults to /usr/share/gir-1.0/)") do |paths|
+    gir_search_paths = paths.split(":")
+  end
+  p.on("-h", "--help", "Show this help") do
+    puts p
+    exit
+  end
+  p.unknown_args do |args|
+    opt_namespaces = args
+  end
+end
+
+namespaces = opt_namespaces
+namespaces = nil if namespaces && namespaces.empty?
+
+unless namespaces
+  STDERR.puts "Please give one or more GIR namespaces!"
+  exit 1
+end
+
+namespaces = namespaces.map { |namespace| Namespace.new(namespace) }
+compiler = Crystal::Compiler.new
+sources = [Crystal::Compiler::Source.new("require", %(require "gobject"))]
+sources.concat namespaces.map { |namespace|
+  Crystal::Compiler::Source.new(namespace.name, %(require_gobject "#{namespace.name}"))
+}
+included_dirs = namespaces.map { |namespace| File.dirname(namespace.typelib_path) }
+included_dirs << Crystal::CrystalPath.gobject_path
+compiler.flags << "docs"
+compiler.wants_doc = true
+result = compiler.top_level_semantic sources
+
+generator = Generator.new(result.program, included_dirs, output_directory, "html", nil, "", "",
+  Crystal::Doc::ProjectInfo.new(namespaces.map(&.name).join(", "), namespaces.map(&.girname).join("/")))
+generator.gir_namespaces = namespaces.map(&.name)
+if paths = gir_search_paths
+  generator.gir_search_paths = paths
+end
+generator.run
+puts "Docs written to #{output_directory}"
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/generator/dump.cr

@@ -0,0 +1,55 @@
+require "option_parser"
+require "../crout"
+require "../g_i_repository"
+
+opt_root = nil
+max_nesting = 3
+all = false
+opt_namespace = nil
+
+OptionParser.parse do |p|
+  p.banner = "Usage: gi-dump [opts] NAMESPACE[-VERSION]"
+  p.on("-r NAME", "--root=NAME", "Only print given toplevel info instead of all") { |name| opt_root = name }
+  p.on("-n LIMIT", "--nesting=LIMIT", "Stop after LIMIT recursions (default 3)") { |limit| max_nesting = limit.to_i? }
+  p.on("-a", "--all", "Don't limit nesting, print all") { all = true }
+  p.on("-h", "--help", "Show this help") do
+    puts p
+    exit
+  end
+  p.unknown_args do |args|
+    opt_namespace = args.first?
+    if args.size > 1
+      STDERR.puts "Too many arguments"
+      exit 1
+    end
+  end
+end
+
+unless namespace = opt_namespace
+  STDERR.puts "Missing namespace"
+  exit 1
+end
+
+unless max_nesting
+  STDERR.puts "Invalid recursion limit"
+  exit 1
+end
+
+namespace, version = namespace.split("-", 2) if namespace.includes?('-')
+
+repo = GIRepository::Repository.instance
+repo.require namespace, version
+dumper = GIRepository::Dumper.new(STDOUT, all ? nil : max_nesting)
+if root = opt_root
+  info = repo.find_by_name(namespace, root)
+  if info
+    info.dump(dumper)
+  else
+    puts "Couldn't find any info named #{root} in #{namespace}"
+    exit 1
+  end
+else
+  repo.all_infos(namespace).each do |info|
+    info.dump(dumper)
+  end
+end

data/crystal-gobject/src/generator/generator.cr

@@ -0,0 +1,22 @@
+require "file_utils"
+require "../crout"
+require "./namespace"
+
+generation_dir = "src/generated-next"
+target_dir = "src/generated"
+
+name = "GIRepository"
+namespace = Namespace.new(name)
+print "Generate #{name}... "
+namespace.dependencies.each do |dependency, version|
+  dependency_namespace = Namespace.new(dependency)
+  dependency_namespace.write_lib generation_dir
+  if dependency == "GObject"
+    dependency_namespace.write_wrapper generation_dir, "ParamFlags"
+    dependency_namespace.write_wrapper generation_dir, "SignalFlags"
+  end
+end
+namespace.write generation_dir
+puts "done."
+FileUtils.rm_r target_dir
+File.rename generation_dir, target_dir

data/crystal-gobject/src/generator/namespace.cr

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:33 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 4 of 16 source files
+      module_functions_definition(builder)
+require_relative "string__"
+ require_relative "./repository"
+
+      each_info do |info|
+        info.wrapper_definition(builder, libname)
+      end
+    end
+  end
+
+  def write_wrapper(directory, name)
+    prefix = File.join(directory, GIRepository.filename(@namespace))
+    Dir.mkdir_p prefix
+
+    info = GIRepository::Repository.instance.find_by_name(@namespace, name)
+    if info
+      wrapper_path = File.join(directory, GIRepository.filename(@namespace), "#{GIRepository.filename(info.name)}.cr")
+      write_wrapper(wrapper_path, info) { |builder| info.wrapper_definition(builder, libname) }
+    else
+      STDERR.puts "Warning: Couldn't find #{@namespace}/#{name}"
+    end
+  end
+
+  def write_wrappers(directory)
+    prefix = File.join(directory, GIRepository.filename(@namespace))
+    Dir.mkdir_p prefix
+
+    wrapper_path = File.join(prefix, "#{GIRepository.filename(@namespace)}.cr")
+    File.open(wrapper_path, "w") do |io|
+      io.puts %(require "../../g_object/wrapped_type")
+      io.puts %(require "../#{lib_filename}")
+      io.puts
+      GIRepository::Repository.instance.dependencies(@namespace).each do |dependency|
+        namespace, version = dependency
+        name = Namespace.new(namespace).wrapper_filename
+        path = "../../#{name}" if File.exists? File.join(directory, "..", name) # Overrides
+        path ||= "../#{name}" if File.exists? File.join(directory, name)        # Wrapper
+        io.puts %(require "#{path}") if path
+      end
+      io.puts
+      io.puts %(require "./*")
+    end
+
+    each_info do |info|
+      wrapper_path = File.join(directory, GIRepository.filename(@namespace), "#{GIRepository.filename(info.name)}.cr")
+      write_wrapper(wrapper_path, info) { |builder| info.wrapper_definition(builder, libname) }
+    end
+
+    write_module_functions_wrapper(directory)
+  end
+
+  def write_module_functions_wrapper(directory)
+    prefix = File.join(directory, GIRepository.filename(@namespace))
+    Dir.mkdir_p prefix
+    write_wrapper(File.join(prefix, "module_functions.cr")) { |builder| module_functions_definition(builder) }
+  end
+
+  private def each_info
+    infos = GIRepository::Repository.instance.all_infos(@namespace).select { |info|
+      next false if skip_info? info
+      next false if info.is_a? GIRepository::FunctionInfo
+      next false if info.is_a? GIRepository::ConstantInfo
+      true
+    }
+
+    sort_childs_after_parents(infos)
+
+    infos.each do |info|
+      yield info
+    end
+  end
+
+  private def sort_childs_after_parents(infos)
+    names = infos.map { |info|
+      info.full_constant if info.is_a?(GIRepository::ObjectInfo) || info.is_a?(GIRepository::InterfaceInfo)
+    }
+
+    parents = infos.map { |info|
+      parent_names = [] of String
+      if info.is_a?(GIRepository::ObjectInfo)
+        parent = info.parent
+        parent_names << parent.full_constant if parent
+        parent_names.concat info.interfaces.map(&.full_constant)
+      end
+
+      parent_names
+    }
+
+    child_index = 0
+    while child_index < names.size
+      next child_index += 1 if names[child_index].nil?
+
+      swapped = false
+      child_index.upto(names.size - 1) do |index|
+        if parents[child_index].includes? names[index]
+          swap(infos, child_index, index)
+          swap(names, child_index, index)
+          swap(parents, child_index, index)
+          swapped = true
+          break
+        end
+      end
+
+      child_index += 1 unless swapped
+    end
+  end
+
+  private def swap(items, a, b)
+    tmp = items[a]
+    items[a] = items[b]
+    items[b] = tmp
+  end
+
+  private def module_functions_definition(builder)
+    builder.section do
+      GIRepository::Repository.instance.all_infos(@namespace).select { |info|
+        info.is_a?(GIRepository::ConstantInfo)
+      }.each(&.wrapper_definition(builder, libname))
+    end
+
+    GIRepository::Repository.instance.all_infos(@namespace).select { |info|
+      next false if skip_info?(info)
+      info.is_a?(GIRepository::FunctionInfo) ? !info.method? : false
+    }.each(&.wrapper_definition(builder, libname))
+  end
+
+  private def write_wrapper(path, info = nil)
+    File.open(path, "w") do |io|
+      Crout.build(io) do |builder|
+        if info && info.is_a?(GIRepository::ObjectInfo)
+          parent = info.parent
+          if parent && parent.namespace == @namespace
+            io.puts %(require "./#{GIRepository.filename(parent.name)}")
+            io.puts
+          end
+        end
+
+        wrapper_definition(builder) { |builder| yield builder }
+      end
+    end
+  end
+
+  private def wrapper_definition(builder, source_path = nil)
+    if source_path
+      builder.source_location(source_path) do
+        builder.def_module(Namespace.constant(@namespace)) { yield builder }
+      end
+    else
+      builder.def_module(Namespace.constant(@namespace)) { yield builder }
+    end
+  end
+
+  def self.constant(string)
+    "#{string[0].upcase}#{string[1..-1]}"
+  end
+
+  private def skip_info?(info)
+    case info
+    when GIRepository::EnumInfo
+      name = info.name
+      return true unless name
+      return true unless 'A' <= name[0] <= 'Z' # Bug in typelib?
+    else
+      false
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/generator/stage2.cr

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:33 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 3 of 16 source files
+module GLib
+require_relative "string__"
+ require_relative ".//"
+require_relative "./repository"
+  class Error < Exception
+    def self.assert(error)
+      raise new(error) if error
+    end
+
+    def initialize(gerror : LibGLib::GError*)
+      super String.new(gerror.value.message)
+    end
+  end
+end
+
+macro each_converted(prefix, basename, type, plural = nil)
+  def each_{{basename.id}}
+    n = LibGIRepository.{{prefix.id}}_get_n_{{plural ? plural.id : "#{basename}s".id}}(self)
+    0.upto(n-1) do |index|
+      yield {{type.id}}.new LibGIRepository.{{prefix.id}}_get_{{basename.id}}(self, index)
+    end
+  end
+end
+
+
+module GIRepository
+  class BaseInfo
+    def initialize(@ptr)
+    end
+
+    def to_unsafe
+      @ptr
+    end
+  end
+
+  class Repository
+    include GObject::WrappedType
+
+    def initialize(@ptr)
+    end
+
+    def to_unsafe
+      @ptr
+    end
+
+    def require(namespace, version, flags)
+      __error = Pointer(LibGLib::Error).null
+      __return_value = LibGIRepository.repository_require((to_unsafe as LibGIRepository::Repository*), namespace, version, flags, pointerof(__error))
+      GLib::Error.assert __error
+    end
+
+    def dependencies(namespace)
+      __return_value = LibGIRepository.repository_get_dependencies((to_unsafe as LibGIRepository::Repository*), namespace)
+      GObject::PointerIterator.new(__return_value) { |__item_76| raise "Expected string but got null" unless __item_76; String.new(__item_76) }
+    end
+
+    def shared_library(namespace)
+      __return_value = LibGIRepository.repository_get_shared_library((to_unsafe as LibGIRepository::Repository*), namespace)
+      raise "Expected string but got null" unless __return_value; String.new(__return_value)
+    end
+
+    def n_infos(namespace)
+      __return_value = LibGIRepository.repository_get_n_infos((to_unsafe as LibGIRepository::Repository*), namespace)
+      __return_value
+    end
+
+    def info(namespace, index)
+      __return_value = LibGIRepository.repository_get_info((to_unsafe as LibGIRepository::Repository*), namespace, Int32.new(index))
+      GIRepository::BaseInfo.new(__return_value)
+    end
+
+    def c_prefix(namespace)
+      __return_value = LibGIRepository.repository_get_c_prefix((to_unsafe as LibGIRepository::Repository*), namespace)
+      raise "Expected string but got null" unless __return_value; String.new(__return_value)
+    end
+
+    def self.default
+      new LibGIRepository.repository_get_default
+    end
+  end
+
+  def self.filename(filename)
+    filename.gsub(/[A-Z][a-z]*(?=[A-Z])/) { |m| "#{m.downcase}_" }
+      .gsub(/::/, "_")
+      .downcase
+  end
+end
+
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/generator/stage3.cr

@@ -0,0 +1,3 @@
+require "../g_i_repository"
+require "./generator"
+

data/crystal-gobject/src/gio/gio.cr

@@ -0,0 +1,4 @@
+require "../g_object"
+
+require "../gobject"
+require_gobject "Gio"