bblib 0.3.0 → 0.4.1

data/lib/mixins/bbmixins.rb

@@ -0,0 +1,7 @@
+require_relative 'simple_init'
+require_relative 'attrs'
+require_relative 'family_tree'
+require_relative 'hooks'
+require_relative 'serializer'
+require_relative 'logger'
+require_relative 'bridge'

data/lib/mixins/bridge.rb

@@ -0,0 +1,17 @@
+
+module BBLib
+  # Adds basic convenience methods to a class to extend getters or setters from
+  # class methods to instances.
+  module Bridge
+
+    def bridge_method(*class_methods)
+      class_methods.each do |class_method|
+        define_method(class_method) do |*args|
+          self.class.send(class_method, *args)
+        end
+      end
+      true
+    end
+
+  end
+end

data/lib/mixins/family_tree.rb

@@ -0,0 +1,41 @@
+
+
+module BBLib
+  # Various methods for finding descendants and subclasses of a class. Intended as an
+  # extend mixin for any class.
+  module FamilyTree
+    # Return all classes that inherit from this class
+    def descendants(include_singletons = false)
+      ObjectSpace.each_object(Class).select do |c|
+        (include_singletons || !c.singleton_class?) && c < self
+      end
+    end
+
+    alias subclasses descendants
+
+    # Return all classes that directly inherit from this class
+    def direct_descendants(include_singletons = false)
+      ObjectSpace.each_object(Class).select do |c|
+        (include_singletons || !c.singleton_class?) && c.ancestors[1] == self
+      end
+    end
+
+    # Return all live instances of the class
+    # Passing false will not include instances of sub classes
+    def instances(descendants = true)
+      inst = ObjectSpace.each_object(self).to_a
+      descendants ? inst : inst.select { |i| i.class == self }
+    end
+
+    def namespace
+      BBLib.namespace_of(self)
+    end
+
+    def root_namespace
+      BBLib.root_namespace_of(self)
+    end
+
+    alias direct_subclasses direct_descendants
+
+  end
+end

data/lib/mixins/hooks.rb

@@ -0,0 +1,139 @@
+
+
+module BBLib
+  # Adds method hooking capability to a class. Intended to be used as a mixin.
+  module Hooks
+
+    [:before, :after].each do |hook_type|
+      define_method(hook_type) do |*methods, **opts|
+        raise ArgumentError, 'You must pass in at least one method followed by the name of the hook method.' if methods.size < 2
+        hooks = _hooks[hook_type][methods.pop] ||= { methods: [], opts: {} }
+        hooks[:methods] += methods
+        hooks[:opts] = hooks[:opts].deep_merge(opts)
+        methods.each { |method| _hook_method(method) if method_defined?(method) }
+        true
+      end
+    end
+
+    def method_added(method)
+      if _defining_hook?
+        @_defining_hook = false
+      else
+        _hook_method(method)
+      end
+    end
+
+    def singleton_method_added(method)
+      if _defining_hook?
+        @_defining_hook = false
+      else
+        self.singleton_class.send(:_hook_method, method, force: true) if self.singleton_class.respond_to?(:_hook_method)
+      end
+    end
+
+    def _hook_method(method, force: false)
+      return false if _defining_hook?
+      [:before, :after].each do |hook_type|
+        _hooks[hook_type].find_all { |hook, data| data[:methods].include?(method) }.to_h.each do |hook, data|
+          next if !force && _hooked_methods[hook_type] && _hooked_methods[hook_type][hook] && _hooked_methods[hook_type][hook].include?(method)
+          send("_hook_#{hook_type}_method", method, hook, data[:opts])
+        end
+      end
+    end
+
+    # def _hook_all
+    #   _hooks.each do |type, hooks|
+    #     hooks.each do |hook, data|
+    #       data[:methods].each do |method|
+    #         _hook_method(method)
+    #       end
+    #     end
+    #   end
+    # end
+
+    def _superclass_hooks
+      hooks = { before: {}, after: {} }
+      ancestors.reverse.each do |ancestor|
+        next if ancestor == self
+        hooks = hooks.deep_merge(ancestor.send(:_hooks)) if ancestor.respond_to?(:_hooks)
+      end
+      hooks
+    end
+
+    def _hooks
+      @_hooks ||= _superclass_hooks
+    end
+
+    def _hooked_methods
+      @_hooked_methods ||= { before: {}, after: {} }
+    end
+
+    def _add_hooked_method(type, hook, method)
+      history = _hooked_methods[type]
+      history[hook] = {} unless history[hook]
+      history[hook][method] = instance_method(method)
+    end
+
+    def _defining_hook?
+      @_defining_hook ||= false
+    end
+
+    # Current opts:
+    # send_args - Sends the arguments of the method to the before hook.
+    # modify_args - Replaces the original args with the returned value of the
+    # send_method - Sends the method name as an argument to the hooked method.
+    #               before hook method.
+    def _hook_before_method(method, hook, opts = {})
+      return false if method == hook
+      _add_hooked_method(:before, hook, method)
+      original = instance_method(method)
+      @_defining_hook = true
+      define_method(method) do |*args, &block|
+        if opts[:send_args] || opts[:send_arg] || opts[:modify_args] || opts[:send_method]
+          margs = args
+          margs = [method] + args if opts[:send_method]
+          margs = args + [opts[:add_args]].flatten(1) if opts[:add_args]
+          result = method(hook).call(*margs)
+          args = result if opts[:modify_args]
+        else
+          method(hook).call
+        end
+        original.bind(self).call(*args, &block)
+      end
+      @_defining_hook = false
+      true
+    end
+
+    # Current opts:
+    # send_args - Sends the arguments of the method to the after method.
+    # send_value - Sends the return value of the method to the hook method.
+    # send_value_ary - Sends the return value of the method to the hook method
+    # =>                with the splat operator.
+    # modify_value - Opts must also include one of the two above. Passes the returned
+    # =>              value of the method to the hook and returns the hooks value
+    # =>              rather than the original methods value.
+    def _hook_after_method(method, hook, opts = {})
+      return false if method == hook
+      _add_hooked_method(:after, hook, method)
+      original = instance_method(method)
+      @_defining_hook = true
+      define_method(method) do |*args, &block|
+        rtr = original.bind(self).call(*args, &block)
+        if opts[:send_args]
+          method(hook).call(*args)
+        elsif opts[:send_return] || opts[:send_value]
+          result = method(hook).call(rtr)
+          rtr = result if opts[:modify_value] || opts[:modify_return]
+        elsif opts[:send_return_ary] || opts[:send_value_ary]
+          result = method(hook).call(*rtr)
+          rtr = result if opts[:modify_value] || opts[:modify_return]
+        else
+          method(hook).call
+        end
+        rtr
+      end
+      @_defining_hook = false
+      true
+    end
+  end
+end

data/lib/mixins/logger.rb

@@ -0,0 +1,31 @@
+module BBLib
+  module Logger
+
+    def logger
+      self.class.logger
+    end
+
+    [:debug, :info, :warn, :error, :fatal, :unknown].each do |sev|
+      define_method(sev) do |msg = nil, &block|
+          logger.send(sev) { "[#{self.class}] #{msg ? msg : block.call}" }
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def logger
+        BBLib.logger
+      end
+
+      [:debug, :info, :warn, :error, :fatal, :unknown].each do |sev|
+        define_method(sev) do |msg = nil, &block|
+            logger.send(sev) { "[#{self}] #{msg ? msg : block.call}" }
+        end
+      end
+    end
+
+  end
+end

data/lib/mixins/serializer.rb

@@ -0,0 +1,71 @@
+
+
+module BBLib
+
+  module Serializer
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def _serialize_fields
+        @_serialize_fields ||= _ancestor_serialize_fields
+      end
+
+      def _ancestor_serialize_fields
+        hash = {}
+        ancestors.reverse.map do |ancestor|
+          next unless ancestor.respond_to?(:_serialize_fields) && ancestor != self
+          hash = hash.deep_merge(ancestor._serialize_fields)
+        end
+        hash
+      end
+
+      def _dont_serialize_fields
+        @_dont_serialize_fields ||= _ancestor_dont_serialize_fields
+      end
+
+      def _ancestor_dont_serialize_fields
+        ancestors.reverse.flat_map do |ancestor|
+          next unless ancestor.respond_to?(:_dont_serialize_fields) && ancestor != self
+          ancestor._dont_serialize_fields
+        end.compact.uniq
+      end
+
+      def dont_serialize_method(method)
+        _dont_serialize_fields.push(method) unless _dont_serialize_fields.include?(method)
+      end
+
+      def serialize_method(name, method = nil, **opts)
+        return false if method == :serialize || name == :serialize && method.nil?
+        _serialize_fields[name.to_sym] = {
+          method: (method || name).to_sym
+        }.merge(opts)
+      end
+    end
+
+    def serialize(ignore_defaults = false)
+      self.class._serialize_fields.map do |name, opts|
+        next if self.class._dont_serialize_fields.include?(name)
+        args = [opts[:method]] + (opts.include?(:args) ? [opts[:args]].flatten(1) : [])
+        value = send(*args)
+        next if value == self
+        unless opts[:flat]
+          if value.is_a?(Hash)
+            value = value.map { |k, v| [k, v != self && v.respond_to?(:serialize) ? v.serialize(ignore_defaults) : v] }.to_h
+          elsif value.is_a?(Array)
+            value = value.map { |v| v != self && v.respond_to?(:serialize) ? v.serialize(ignore_defaults) : v }
+          elsif value.respond_to?(:serialize)
+            value = value.serialize(ignore_defaults)
+          end
+        end
+        if !opts[:always] && (ignore_defaults && value == opts[:default] || opts.include?(:ignore) && value == opts[:ignore])
+          nil
+        else
+          [name, value]
+        end
+      end.compact.to_h
+    end
+  end
+
+end

data/lib/mixins/simple_init.rb

@@ -0,0 +1,160 @@
+
+
+module BBLib
+  # Allows any public setter method to be called during initialization using keyword arguments.
+  # Add include BBLib::SimpleInit or prepend BBLib::SimpleInit to classes to add this behavior.
+  module SimpleInit
+    attr_reader :_init_type
+
+    INIT_TYPES = [:strict, :loose].freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        define_method(:initialize) do |*args, &block|
+          send(:simple_setup) if respond_to?(:simple_setup, true)
+          send(:simple_preinit, *args, &block) if respond_to?(:simple_preinit, true)
+          _initialize(*args)
+          send(:simple_init, *args, &block) if respond_to?(:simple_init, true)
+          instance_eval(&block) if block
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # TODO: Currently init foundation breaks when running in opal.
+      unless BBLib.in_opal?
+        # Overriden new method that allows parent classes to dynamically generate
+        # instantiations of descendants by using the named :_class argument.
+        # :_class needs to be the fully qualified name of the descendant.
+        def new(*args, &block)
+          named = BBLib.named_args(*args)
+          if init_foundation && named[init_foundation_method] && ((named[init_foundation_method] != self.send(init_foundation_method)) rescue false)
+            klass = descendants.find do |k|
+              if init_foundation_compare
+                init_foundation_compare.call(k.send(init_foundation_method), named[init_foundation_method])
+              else
+                k.send(init_foundation_method).to_s == named[init_foundation_method].to_s
+              end
+            end
+            raise ArgumentError, "Unknown class type #{named[init_foundation_method]}" unless klass
+            klass.new(*args, &block)
+          else
+            super
+          end
+        end
+      end
+
+      # If true, this allows the overriden new method to generate descendants from
+      # its constructors.
+      def init_foundation
+        @init_foundation ||= false
+      end
+
+      # Sets the init_foundation variable to true of false. When false, the new
+      # method behaves like any other class. If true, the new method can instantiate
+      # child classes using the :_class named parameter.
+      def init_foundation=(toggle)
+        @init_foundation = toggle
+      end
+
+      def init_foundation_method(method = nil)
+        @init_foundation_method = method if method
+        @init_foundation_method ||= ancestor_init_foundation_method
+      end
+
+      def init_foundation_compare(&block)
+        @init_foundation_compare = block if block_given?
+        @init_foundation_compare
+      end
+
+      def setup_init_foundation(method, &block)
+        self.init_foundation = true
+        self.init_foundation_method(method)
+        self.init_foundation_compare(&block) if block_given?
+      end
+
+      def ancestor_init_foundation_method
+        anc = ancestors.find do |a|
+          next if a == self
+          a.respond_to?(:init_foundation_method)
+        end
+        anc ? anc.init_foundation_method : :_class
+      end
+
+      # Sets or returns the current init type for this class.
+      # Available types are:
+      #=> :strict = Unknown named arguments will raise an error.
+      #=> :loose  = Unknown named arguments are ignored.
+      def init_type(type = nil)
+        return @init_type ||= _super_init_type unless type
+        raise ArgumentError, "Unknown init type '#{type}'. Must be #{INIT_TYPES.join_terms('or', encapsulate: "'")}." unless INIT_TYPES.include?(type)
+        @init_type = type
+      end
+
+      # Used to load the init type of the nearest ancestor for inheritance.
+      def _super_init_type
+        ancestors.each do |ancestor|
+          next if ancestor == self
+          return ancestor.init_type if ancestor.respond_to?(:init_type)
+        end
+        :strict
+      end
+
+      # Dynamically create a new class based on this one. By default this class
+      # is generated in the same namespace as the parent class. A custom namespace
+      # can be passed in using the named argument :namespace.
+      def build_descendant(name, namespace: parent_namespace)
+        namespace.const_set(name, Class.new(self))
+      end
+
+      # Returns the nearest parent namespace to thi current class. Object is
+      # returned if this class is not in a namespace.
+      def parent_namespace
+        parent = self.to_s.split('::')[0..-2].join('::')
+        if parent.empty?
+          return Object
+        else
+          Object.const_get(parent)
+        end
+      end
+
+      def _class
+        self.to_s
+      end
+    end
+
+    protected
+
+    def _initialize(*args)
+      named = BBLib.named_args(*args)
+      if self.class.respond_to?(:_attrs)
+        set_v_arg = self.class._attrs.map do |method, details|
+          next unless details[:options][:arg_at] && details[:options][:arg_at].is_a?(Integer)
+          index = details[:options][:arg_at]
+          if args.size > index
+            accept = details[:options][:arg_at_accept]
+            if accept.nil? || [accept].flatten.any? { |a| a >= args[index].class }
+              send("#{method}=", args[index])
+              method
+            end
+          end
+        end.compact
+        missing = self.class._attrs.map do |method, details|
+          next unless !set_v_arg.include?(method) && details[:options][:required] && !named.include?(method) && !send(method)
+          method
+        end.compact
+        raise ArgumentError, "You are missing the following required #{BBLib.pluralize('argument', missing.size)}: #{missing.join_terms}" unless missing.empty?
+      end
+      named.each do |method, value|
+        next if method == self.class.init_foundation_method
+        setter = "#{method}="
+        exists = respond_to?(setter)
+        raise ArgumentError, "Undefined attribute #{setter} for class #{self.class}." if !exists && self.class.init_type == :strict
+        next unless exists
+        send(setter, value)
+      end
+    end
+  end
+end