nested_inherited_jruby_include_package 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f84fa63cba7b90887125a367a19fc17af87c88a0d5f783ea40052fc38378a35
+  data.tar.gz: 07c16bf6709eff7d1aad7ae47f5ced1c22c83ec07abb1fff73b22059592c40e1
+SHA512:
+  metadata.gz: 35d06a985045b47f4edb3308c6257ec55b6b98d53f0d30f5794fd86298735bbcc61cb89659033e50cc6ef01dc0669006d2c75230baab62ab19b28c1db2d16922
+  data.tar.gz: 5c57fa8298931eaa9935e935e03a19a94b996ef6959dba90e1c59443677dddc59f4e87a7a9b33a63c3b77bffd323a5ad8cf933fb4cd12d4622b970e9293be246

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Andy Maleh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# nested_inherited_jruby_include_package
+
+JRuby's `include_package` (mentioned in https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby) includes Java packages in JRuby on `const_missing`. However, it does not trickle down to subclasses/submodules nor nested-classes/nested-modules.
+
+`nested_inherited_jruby_include_package` patches up JRuby to add that capability.
+
+Example (nesting):
+
+```ruby
+require 'nested_inherited_jruby_include_package'
+
+class OuterClass
+  include_package java.util
+  class InnerClass
+    def initialize
+      p Arrays.asList(1, 2, 3)
+    end
+  end
+end
+
+OuterClass::InnerClass.new
+# prints #<Java::JavaUtil::Arrays::ArrayList:0x233fe9b6>
+```
+
+Example (inheritance):
+
+```ruby
+require 'nested_inherited_jruby_include_package'
+
+class SuperClass
+  include_package java.util
+end
+
+class SubClass < SuperClass
+  def initialize
+    p Arrays.asList(1, 2, 3)
+  end
+end
+
+SubClass.new
+# prints #<Java::JavaUtil::Arrays::ArrayList:0x7ce3cb8e>
+```
+
+More examples can be found in:
+
+[spec/lib/core/src/main/ruby/jruby/java/core_ext/module_spec.rb](spec/lib/core/src/main/ruby/jruby/java/core_ext/module_spec.rb)
+
+# Setup
+
+Add the following to `Gemfile`:
+```
+gem 'nested_inherited_jruby_include_package', '~> 0.1.0'
+```
+
+And, then run:
+```
+jruby -S bundle install
+```
+
+If you are not using Bundler, run:
+```
+jruby -S gem install nested_inherited_jruby_include_package -v 0.1.0
+```
+
+# Caveats
+
+This gem relies on `Module#const_missing` after it aliases it to `Module#const_missing_without_nested_inherited_jruby_include_package`
+
+As such, it works optimally if your project and loaded gems do not override `Module#const_missing`
+
+# Implementation Note
+
+To avoid method and constant pollution in `Module`, the implementation intentionally trades off code clarity for lack of pollution by not relying on methods, yet local lambdas, in modularizing logic.
+
+# Issue Reporting
+
+This is an early alpha. It has only been used in a couple of projects. As such, there are no guarantees for its functionality. Please report any issues you might discover when using on your own projects.
+
+# License
+
+The MIT License
+
+[LICENSE.txt](LICENSE.txt)
+
+# Copyright
+
+Copyright (c) 2020 Andy Maleh

data/lib/core/src/main/ruby/jruby/java/core_ext/module.rb

@@ -0,0 +1,117 @@
+# Extensions to the standard Module package.
+class Module
+
+  alias const_missing_without_nested_inherited_jruby_include_package const_missing
+
+  def const_missing(constant)
+    hidden_methods = {
+      included_packages_from_ancestors_namespaces: lambda do |m|
+        m.ancestors.map do |klass|
+          hidden_methods[:included_packages_from_namespaces].call(klass)
+        end.map(&:to_a).reduce([], :+).uniq
+      end,
+
+      included_packages_from_namespaces: lambda do |m|
+        hidden_methods[:namespaces].call(m).map do |klass|
+          hidden_methods[:included_packages].call(klass)
+        end.map(&:to_a).reduce([], :+).uniq
+      end,
+
+      included_packages: lambda do |m|
+        return [] unless m.respond_to?(:instance_variable_get)
+        m.instance_variable_set(:@included_packages, []) unless m.instance_variable_get(:@included_packages)
+        m.instance_variable_get(:@included_packages)
+      end,
+
+      java_aliases_from_ancestors_namespaces: lambda do |m|
+        m.ancestors.map do |klass|
+          hidden_methods[:java_aliases_from_namespaces].call(klass)
+        end.reverse.reduce({}, :merge)
+      end,
+
+      java_aliases_from_namespaces: lambda do |m|
+        hidden_methods[:namespaces].call(m).map do |klass|
+          hidden_methods[:java_aliases].call(klass)
+        end.reverse.reduce({}, :merge)
+      end,
+
+      java_aliases: lambda do |m|
+        return {} unless m.respond_to?(:instance_variable_get)
+        m.instance_variable_set(:@java_aliases, {}) unless m.instance_variable_get(:@java_aliases)
+        m.instance_variable_get(:@java_aliases)
+      end,
+
+      # Returns namespaces containing this module/class starting with self.
+      # Example: `Outer::Inner::Shape.namespaces` returns:
+      # => [Outer::Inner::Shape, Outer::Inner, Outer]
+      namespaces: lambda do |m|
+        return [m] if m.name.nil?
+        namespace_constants = m.name.split(/::/).map(&:to_sym)
+        namespace_constants.reduce([Object]) do |output, namespace_constant|
+          output += [output.last.const_get(namespace_constant)]
+        end[1..-1].uniq.reverse
+      end
+    }
+    all_included_packages = hidden_methods[:included_packages_from_ancestors_namespaces].call(self)
+    return const_missing_without_nested_inherited_jruby_include_package(constant) if all_included_packages.empty?
+    real_name = hidden_methods[:java_aliases_from_ancestors_namespaces].call(self)[constant] || constant
+
+    java_class = nil
+    last_error = nil
+
+    all_included_packages.each do |package|
+      begin
+        java_class = JavaUtilities.get_java_class("#{package}.#{real_name}")
+      rescue NameError => e
+        # we only rescue NameError, since other errors should bubble out
+        last_error = e
+      end
+      break if java_class
+    end
+
+    if java_class
+      return JavaUtilities.create_proxy_class(constant, java_class, self)
+    else
+      # try to chain to super's const_missing
+      begin
+        return const_missing_without_nested_inherited_jruby_include_package(constant)
+      rescue NameError => e
+        # super didn't find anything either, raise our Java error
+        raise NameError.new("#{constant} not found in packages #{all_included_packages.join(', ')}; last error: #{(last_error || e).message}")
+      end
+    end
+  end
+
+  private
+
+  ##
+  # Includes a Java package into this class/module. The Java classes in the
+  # package will become available in this class/module, unless a constant
+  # with the same name as a Java class is already defined.
+  #
+  def include_package(package)
+    hidden_methods = {
+      included_packages: lambda do |m|
+        return [] unless m.respond_to?(:instance_variable_get)
+        m.instance_variable_set(:@included_packages, []) unless m.instance_variable_get(:@included_packages)
+        m.instance_variable_get(:@included_packages)
+      end,
+    }
+    package = package.package_name if package.respond_to?(:package_name)
+    the_included_packages = hidden_methods[:included_packages].call(self)
+    the_included_packages << package unless the_included_packages.include?(package)
+    nil
+  end
+
+  def java_alias(new_id, old_id)
+    hidden_methods = {
+      java_aliases: lambda do |m|
+        return {} unless m.respond_to?(:instance_variable_get)
+        m.instance_variable_set(:@java_aliases, {}) unless m.instance_variable_get(:@java_aliases)
+        m.instance_variable_get(:@java_aliases)
+      end,
+    }
+    hidden_methods[:java_aliases].call(self)[new_id] = old_id
+  end
+
+end

data/lib/nested_inherited_jruby_include_package.rb

@@ -0,0 +1 @@
+require_relative 'core/src/main/ruby/jruby/java/core_ext/module.rb'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: nested_inherited_jruby_include_package
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Maleh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  name: rspec
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  name: rdoc
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+  name: jeweler
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: simplecov
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: JRuby include_package implementation that works across nested/inherited
+  classes/modules
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- lib/core/src/main/ruby/jruby/java/core_ext/module.rb
+- lib/nested_inherited_jruby_include_package.rb
+homepage: http://github.com/AndyObtiva/nested_inherited_jruby_include_package
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: JRuby include_package implementation that works across nested/inherited classes/modules
+test_files: []