interfaced 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21dbf466abb75317aba888e47ffc1d62ead219d6154719b95f521581c9762b69
+  data.tar.gz: daf48b61f6b8d27c4795539657b9e2a6daab467ab86e7c79939e69395fdee3e4
+SHA512:
+  metadata.gz: 7bf520ca3db883672c8c3e25105b9d97f8c8f9d64b2139a796ac03a7ac52547d1424656207ec470795593bce726d0738d41a2917258449fe103417601896c811
+  data.tar.gz: 91acf860185fd0b20edfa05539ca8a3bb81f9d311d333e7045bbfe86b3e6a1c1b2c9305ef0c30e635a50fab62b33fcc4ff8cf992930fefe05dfc9528fadd2b7e

data/lib/interfaced.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "interfaced/version"
+
+# A module for implementing Java-like interfaces in Ruby.
+# More information about Java interfaces:
+# http://java.sun.com/docs/books/tutorial/java/concepts/interface.html
+
+module Interfaced
+  class MethodMissing < StandardError; end
+
+  private def extend_object(obj) # based on https://www.rubydoc.info/stdlib/core/1.8.7/Module#extend_object-instance_method callback
+    return append_features(obj) if obj.is_a?(Interfaced)
+
+    append_features(class << obj; self end) # source code: https://github.com/ruby/ruby/blob/9c236f114001fb557fde97632136c84e669e489c/eval.c#L1029
+    included(obj)
+  end
+
+  private def append_features(mod) # based on https://www.rubydoc.info/stdlib/core/1.8.7/Module:append_features
+    return super if mod.is_a?(Interfaced)
+
+    # Taking required methods from sub interfaces
+    sub_interfaces = (ancestors - [self]).select { |x| x.is_a?(Interfaced) }
+    inherited_req_methods = sub_interfaces.map { |x| x.instance_variable_get('@req_methods') }
+
+    # Store required methods (both from current interface and sub interfaces)
+    req_methods = @req_methods + inherited_req_methods.flatten
+    @unreq_methods ||= []
+
+    # Iterate over the list of required methods, and raise
+    # an error if the method has not been defined.
+    (req_methods - @unreq_methods).uniq.each do |req_method|
+      unless mod.instance_methods(true).include?(req_method)
+        raise Interfaced::MethodMissing, req_method
+      end
+    end
+
+    super mod
+  end
+
+  # Accepts an array of method names that define the interface. When this
+  # module is included/implemented, those method names must have already been
+  # defined or error Interfaced::MethodMissing will be raised.
+  def required_methods(*req_methods)
+    @req_methods = req_methods
+  end
+
+  # Accepts an array of method names that are to be removed from required list.
+  # Presumably you would use this in a sub-interfaces where
+  # you only wanted a partial implementation of an existing interface.
+  def unrequired_methods(*unreq_methods)
+    @unreq_methods ||= []
+    @unreq_methods += unreq_methods
+  end
+
+  alias :extends :extend
+end
+
+class Object
+  # The interfaced method (or its alias `interface`) created an interface module
+  # that sets a list of methods that must be included or implemented
+  # If the methods are not defined, an Interfaced::MethodMissing error is raised.
+  # An Interface can extend any other existing interfaces as well.
+  # The similar implementation to TypeScript
+  # (https://www.typescripttutorial.net/typescript-tutorial/typescript-extend-interface/)
+  #
+  # Examples:
+  #
+  #   # require :foo and :bar methods
+  #   FooBarInterface = interfaced_with { # interface, interfaced, create_interface are alies
+  #     required_methods :foo, :bar
+  #   }
+  #
+  #   # A sub-interface that extends FooBarInterface but make changes to it
+  #   FooBazInterface = interfaced_with {
+  #     extends FooBarInterface # extend is an alias
+  #     required_methods :baz
+  #     unrequired_methods :bar
+  #   }
+  #
+  #   # Raises an Interfaced::MethodMissing error because :bar is not defined.
+  #   class MyClass
+  #     def foo = ...
+  #     def baz = ...
+  #
+  #     implements FooBazInterface # use_interface is an alias
+  #   end
+  #
+  def interfaced_with(&block)
+    Module.new do |mod|
+      mod.extend(Interfaced)
+      mod.instance_eval(&block)
+    end
+  end
+
+  alias :interface :interfaced_with
+  alias :interfaced :interfaced_with
+  alias :create_interface :interfaced_with
+end
+
+class Module
+  alias :implements :include
+  alias :use_interface :include
+end

data/spec/interfaced_spec.rb

@@ -0,0 +1,126 @@
+require "rspec"
+require "interfaced"
+
+RSpec.describe Interfaced do
+  foo_bar_interface = interfaced_with do
+    required_methods :foo, :bar
+  end
+
+  foo_baz_interface = interfaced_with do
+    extends foo_bar_interface
+    required_methods :baz
+    unrequired_methods :bar
+  end
+
+  let(:empty_class) { Class.new }
+
+  let(:foo_bar_class) do
+    Class.new do
+      def foo; end
+
+      def bar; end
+    end
+  end
+
+  let(:foo_baz_class) do
+    Class.new do
+      def foo; end
+
+      def baz; end
+    end
+  end
+
+  describe "version" do
+    subject { Interfaced::VERSION }
+
+    it { is_expected.to eq("0.1.0") }
+    it { is_expected.to be_frozen }
+  end
+
+  describe "#interfaced_with" do
+    context "with single interface" do
+      context "foo_bar_interface interface with :foo and :bar required method" do
+        context "casting on empty class (without required method being implemented)" do
+          it "raises an error" do
+            expect { empty_class.new.extend(foo_bar_interface) }.to raise_error(Interfaced::MethodMissing)
+          end
+        end
+
+        context "casting on class with :foo and :bar methods being implemented" do
+          it "doesn't raise an error" do
+            expect { foo_bar_class.new.extend(foo_bar_interface) }.not_to raise_error
+          end
+        end
+
+        context "casting on class with :foo and :baz methods being implemented" do
+          it "raises an error" do
+            expect { foo_baz_class.new.extend(foo_bar_interface) }.to raise_error(Interfaced::MethodMissing)
+          end
+        end
+      end
+
+      context "foo_baz_interface with :foo and :baz required methods (:foo and :bar from sub interface, :bar unrequired)" do
+        context "casting on empty class (without required method being implemented)" do
+          it "raises an error" do
+            expect { empty_class.new.extend(foo_baz_interface) }.to raise_error(Interfaced::MethodMissing)
+          end
+        end
+
+        context "casting on class with :foo and :bar methods being implemented" do
+          it "raises an error" do
+            expect { foo_bar_class.new.extend(foo_baz_interface) }.to raise_error(Interfaced::MethodMissing)
+          end
+        end
+
+        context "casting on class with :foo and :baz methods being implemented" do
+          it "doesn't raise an error" do
+            expect { foo_baz_class.new.extend(foo_baz_interface) }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    context "with multiple interfaces" do
+      context "casting on empty class (without required method being implemented" do
+        it "raises an error" do
+          expect do
+            empty_class.new.extend(foo_bar_interface)
+            empty_class.new.extend(foo_baz_interface)
+          end.to raise_error(Interfaced::MethodMissing)
+        end
+      end
+
+      context "casting on class with :foo and :bar methods being implemented" do
+        it "raises and error" do
+          expect do
+            foo_bar_class.new.extend(foo_bar_interface)
+            foo_bar_class.new.extend(foo_baz_interface)
+          end.to raise_error(Interfaced::MethodMissing)
+        end
+      end
+
+      context "casting on class with :foo and :baz methods being implemented" do
+        context "when one of interface with required method that class doesn't implement" do
+          it "raises an error" do
+            expect do
+              foo_baz_class.new.extend(foo_bar_interface)
+              foo_baz_class.new.extend(foo_baz_interface)
+            end.to raise_error(Interfaced::MethodMissing)
+          end
+        end
+
+        context "when both interfaces with required methods that class implements" do
+          foo_interface = interface { required_methods :foo }
+          baz_interface = interface { required_methods :baz }
+
+          it "doesn't raise an error" do
+            expect do
+              foo_baz_class.new.extend(foo_interface)
+              foo_baz_class.new.extend(baz_interface)
+            end.not_to raise_error
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: interfaced
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Oleh Klym
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-01-24 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      Module that providers Java-like interfaces for Ruby.
+      It lets you define a set a methods that must be defined in the
+      including class or module without the need of inheriting it from interface class.
+      Otherwise an error is raised.
+email: k4138314@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/interfaced.rb
+- spec/interfaced_spec.rb
+homepage: https://github.com/PET-PROJECTING/interfaced
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/PET-PROJECTING/interfaced
+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.4.10
+signing_key:
+specification_version: 4
+summary: Module that providers Java-like interface to Ruby
+test_files:
+- spec/interfaced_spec.rb