bblib 0.4.1 → 1.0.2

data/lib/mixins/hooks.rb

@@ -83,17 +83,21 @@ module BBLib
     # 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.
+    # try_first   - Sends the args to the desired hook first and if the result
+    #               is non-nil, the result is sent instead of calling the hooked
+    #               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]
+        if opts[:send_args] || opts[:send_arg] || opts[:modify_args] || opts[:send_method] || opts[:try_first]
           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)
+          return result if result && opts[:try_first]
           args = result if opts[:modify_args]
         else
           method(hook).call
@@ -112,6 +116,7 @@ module BBLib
     # 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.
+    # send_all     - Sends a hash containing the args, method and value (return).
     def _hook_after_method(method, hook, opts = {})
       return false if method == hook
       _add_hooked_method(:after, hook, method)
@@ -127,6 +132,8 @@ module BBLib
         elsif opts[:send_return_ary] || opts[:send_value_ary]
           result = method(hook).call(*rtr)
           rtr = result if opts[:modify_value] || opts[:modify_return]
+        elsif opts[:send_all]
+          result = method(hook).call(args: args, value: rtr, method: method)
         else
           method(hook).call
         end

data/lib/mixins/logger.rb

@@ -5,11 +5,11 @@ module BBLib
       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
+    # [: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
@@ -20,11 +20,11 @@ module BBLib
         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
+      # [: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

data/lib/mixins/prototype.rb

@@ -0,0 +1,26 @@
+
+module BBLib
+  module Prototype
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def prototype(opts = prototype_defaults)
+        @prototype ||= self.new(*prototype_defaults)
+      end
+
+      def prototype_defaults
+        []
+      end
+
+      def method_missing(method, *args, &block)
+        prototype.respond_to?(method) ? prototype.send(method, *args, &block) : super
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        prototype.respond_to?(method) || super
+      end
+    end
+  end
+end

data/lib/mixins/simple_init.rb

@@ -14,32 +14,56 @@ module BBLib
         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)
+          _initialize(*args, &block)
           send(:simple_init, *args, &block) if respond_to?(:simple_init, true)
-          instance_eval(&block) if block
+          if block && !_attrs.any? { |k, v| v[:options][:arg_at] == :block }
+            result = instance_eval(&block)
+            simple_init_block_result(result) if respond_to?(:simple_init_block_result, true)
+          end
+        end
+      end
+
+      if BBLib.in_opal?
+        base.singleton_class.class_eval do
+          alias __new new
+
+          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 = [self, descendants].flatten.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 #{init_foundation_method} \"#{named[init_foundation_method]}\" for #{self}" unless klass
+              klass == self ? __new(*args, &block) : klass.new(*args, &block)
+            else
+              __new(*args, &block)
+            end
+          end
         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.
+        # instantiations of descendants by using the named init_foundation_method argument.
         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|
+            klass = [self, descendants].flatten.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)
+            raise ArgumentError, "Unknown #{init_foundation_method} \"#{named[init_foundation_method]}\"" unless klass
+            klass == self ? super : klass.new(*args, &block)
           else
             super
           end
@@ -65,14 +89,14 @@ module BBLib
       end
 
       def init_foundation_compare(&block)
-        @init_foundation_compare = block if block_given?
+        @init_foundation_compare = block if block
         @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?
+        self.init_foundation_compare(&block) if block
       end
 
       def ancestor_init_foundation_method
@@ -127,17 +151,23 @@ module BBLib
 
     protected
 
-    def _initialize(*args)
+    def _initialize(*args, &block)
       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)
+          next unless details[:options][:arg_at] && (details[:options][:arg_at].is_a?(Integer) || details[:options][:arg_at] == :block)
+          if details[:options][:arg_at] == :block
+            send("#{method}=", block) if block
+            method
+          else
           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
+            if args.size > index
+              accept = details[:options][:arg_at_accept]
+              next if args[index].is_a?(Hash) && (accept.nil? || ![accept].flatten.include?(Hash))
+              if accept.nil? || [accept].flatten.any? { |a| a >= args[index].class }
+                send("#{method}=", args[index])
+                method
+              end
             end
           end
         end.compact

data/lib/mixins/type_init.rb

@@ -0,0 +1,21 @@
+module BBLib
+  # Requires Simple init to be loaded first. This sets up a very basic
+  # init foundation by adding a method called type and setting the init
+  # foundation method to it.
+  module TypeInit
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:bridge_method, :type)
+      base.send(:serialize_method, :type, always: true)
+      base.send(:setup_init_foundation, :type) { |a, b| a && b && a.to_s.to_sym == b.to_s.to_sym }
+    end
+
+    module ClassMethods
+      def type
+        to_s.split('::').last.method_case.to_sym
+      end
+    end
+
+  end
+end

data/lib/number/bbnumber.rb

@@ -17,4 +17,94 @@ module BBLib
     num = min if max && num > max
     num
   end
+
+  NUMBER_WORDS = {
+    special: {
+      0 => nil,
+      1 => 'one',
+      2 => 'two',
+      3 => 'three',
+      4 => 'four',
+      5 => 'five',
+      6 => 'six',
+      7 => 'seven',
+      8 => 'eight',
+      9 => 'nine',
+      10 => 'ten',
+      11 => 'eleven',
+      12 => 'twleve',
+      13 => 'thirteen',
+      14 => 'fourteen',
+      15 => 'fifteen',
+      16 => 'sixteen',
+      17 => 'seventeen',
+      18 => 'eighteen',
+      19 => 'nineteen'
+    },
+    double_range: {
+      2 => 'twenty',
+      3 => 'thirty',
+      4 => 'forty',
+      5 => 'fifty',
+      6 => 'sixty',
+      7 => 'seventy',
+      8 => 'eighty',
+      9 => 'ninety'
+    },
+    ranges: [
+      nil, 'thousand', 'million', 'billion', 'trillion', 'quadrillion',
+      'quintillion', 'sextillion', 'septillion'
+    ]
+  }
+
+  def self.number_spelled_out(number, range = 0, include_and: true)
+    number = number.to_i
+    negative = number.negative?
+    number = number * -1 if negative
+    return 'zero' if number.zero?
+    str = []
+    three_digit = number > 999 ? number.to_s[-3..-1].to_i : number
+    case three_digit
+    when 1..19
+      str << NUMBER_WORDS[:special][three_digit]
+    when 20..99
+      str << NUMBER_WORDS[:double_range][three_digit.to_s[-2].to_i]
+      str << NUMBER_WORDS[:special][three_digit.to_s[-1].to_i]
+    when 100..999
+      str << NUMBER_WORDS[:special][three_digit.to_s[0].to_i]
+      str << 'hundred'
+      str << 'and' if include_and
+      if three_digit.to_s[-2].to_i == 1
+        str << NUMBER_WORDS[:special][three_digit.to_s[-2..-1].to_i]
+      else
+        str << NUMBER_WORDS[:double_range][three_digit.to_s[-2].to_i]
+        str << NUMBER_WORDS[:special][three_digit.to_s[-1].to_i]
+      end
+    end
+    str << NUMBER_WORDS[:ranges][range] unless str.compact.empty?
+    (negative ? 'negative ' : '') +
+    ((number.to_s.size > 3 ? "#{number_spelled_out(number.to_s[0..-4].to_i, range + 1)} " : '') +
+    str.compact.join(' ')).gsub(/\s+/, ' ')
+  end
+end
+
+class Integer
+  # Convert this integer into a string with every three digits separated by a delimiter
+  def to_delimited_s(delim = ',')
+    self.to_s.reverse.gsub(/(\d{3})/, "\\1#{delim}").reverse.uncapsulate(',')
+  end
+
+  def spell_out
+    BBLib.number_spelled_out(self)
+  end
+end
+
+class Float
+  # Convert this integer into a string with every three digits separated by a delimiter
+  # on the left side of the decimal
+  def to_delimited_s(delim = ',')
+    split = self.to_s.split('.')
+    split[0] = split.first.reverse.gsub(/(\d{3})/, "\\1#{delim}").reverse
+    split.join('.').uncapsulate(',')
+  end
 end

data/lib/object/bbobject.rb

@@ -1,13 +1,9 @@
-# frozen_string_literal: true
-# require_relative 'attr'
-# require_relative 'hooks'
-
 module BBLib
   def self.are_all?(klass, *vars)
     vars.all? { |var| var.is_a?(klass) }
   end
 
-  def self.is_a?(obj, *klasses)
+  def self.is_any?(obj, *klasses)
     klasses.any? { |klass| obj.is_a?(klass) }
   end
 

data/lib/opal/bbopal.rb

@@ -2,11 +2,16 @@ module BBLib
   def self.in_opal?
     RUBY_ENGINE == 'opal'
   end
+
+  # Used when a method is called while in the wrong engine (such as Opal)
+  class WrongEngineError < StandardError; end
 end
 
 if BBLib.in_opal?
   class Element
     alias_native :replace_with, :replaceWith
     alias_native :prepend
+    alias_native :insert_after, :insertAfter
+    alias_native :insert_before, :insertBefore
   end
 end

data/lib/os/bbos.rb

@@ -1,5 +1,3 @@
-require_relative 'bbsys'
-
 module BBLib
   module OS
     def self.os
@@ -26,67 +24,6 @@ module BBLib
       !(/#{builds.join('|')}/i =~ RUBY_PLATFORM).nil?
     end
 
-    def self.os_info
-      if windows?
-        data = `wmic os get manufacturer,name,organization,osarchitecture,version /format:list`
-        data = data.split("\n").reject { |r| r.strip == '' }.map do |m|
-          spl = m.split('=')
-          [spl.first.to_clean_sym.downcase, spl[1..-1].join('=')]
-        end.to_h
-        data[:name] = data[:name].split('|').first
-        data[:osarchitecture] = data[:osarchitecture].extract_integers.first
-        data.hpath_move('osarchitecture' => 'bits')
-        data[:host] = `hostname`.strip
-        data[:os] = os
-        data
-      else
-        release = {}
-        begin
-          # First attempt to get release info uses lsb_release
-          release = `lsb_release -a`.split("\n").map do |l|
-            spl = l.split(':')
-            [
-              spl.first.downcase.to_clean_sym,
-              spl[1..-1].join(':').strip
-            ]
-          end.to_h
-          release.hpath_move('description' => 'name', 'release' => 'name', 'distributor_id' => 'manufacturer')
-        rescue
-          # Try finding the release file and parsing it instead of lsb_release
-          begin
-            release = `cat /etc/*release`
-                      .split("\n")
-                      .reject { |l| !(l.include?(':') || l.include?('=')) }
-                      .map { |l| l.msplit('=', ':') }
-                      .map { |a| [a.first.downcase.to_clean_sym, a[1..-1].join(':').uncapsulate] }
-                      .to_h
-          rescue StandardError => e
-            # Both attempts failed
-          end
-        end
-        {
-          release: `uname -r`.strip,
-          bits:    `uname -r` =~ /x86_64/i ? 64 : 32,
-          host:    `uname -n`.strip,
-          os:      os
-        }.merge(release)
-      end
-    end
-
-    # The following is Windows specific code
-    if windows?
-
-      def self.parse_wmic(cmd)
-        `#{cmd} /format:list`
-          .split("\n\n\n").reject(&:empty?)
-          .map do |l|
-            l.split("\n\n")
-             .map { |l| spl = l.split('='); [spl.first.strip.downcase.to_clean_sym, spl[1..-1].join('=').strip] }.to_h
-          end.reject(&:empty?)
-      end
-
-    end
-
     # Mostly platform agnost way to find the full path of an executable in the current env path.
     def self.which(cmd)
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|

data/lib/string/bbstring.rb

@@ -94,6 +94,27 @@ module BBLib
       str_b
     end
   end
+
+  # Pattern render takes (by default) a mustache style template and then uses
+  # a context (either a Hash or Object) to then interpolate in placeholders.
+  # The default pattern looks for {{method_name}} within the string but can be
+  # customized to a different pattern by setting the pattern named argument.
+  def self.pattern_render(text, context = {}, pattern: /\{{2}.*?\}{2}/, field_pattern: /(?<=^\{{2}).*(?=\}{2})/)
+    raise ArgumentError, "Expected text argument to be a String, got a #{text.class}" unless text.is_a?(String)
+    txt = text.dup
+    txt.scan(pattern).each do |match|
+      field = match.scan(field_pattern).first
+      next unless field
+      value = case context
+      when Hash
+        context[field.to_sym] || context[field]
+      else
+        context.send(field) if context.respond_to?(field)
+      end.to_s
+      txt.sub!(match, value)
+    end
+    txt
+  end
 end
 
 class String
@@ -130,7 +151,7 @@ class String
               else
                 encapsulator
               end
-    patterns = delimiters.map { |d| /#{d}(?=(?:[^#{pattern}]|[#{pattern}][^#{pattern}]*[#{pattern}])*$)/}
+    patterns = delimiters.map { |d| /#{Regexp.escape(d)}(?=(?:[^#{pattern}]|[#{pattern}][^#{pattern}]*[#{pattern}])*$)/}
     msplit(*patterns)
   end