bblib 0.4.1 → 1.0.2

data/lib/hash_path/part.rb

@@ -75,8 +75,8 @@ class HashPath
       elsif str =~ /\[\-?\d+\.{2,3}\-?\d+\]/
         Range.new(*str.scan(/\-?\d+/).map(&:to_i))
       else
-        str
-      end.gsub('\\.', '.')
+        str.gsub('\\.', '.')
+      end
     end
 
   end

data/lib/html/bbhtml.rb

@@ -1,2 +1,3 @@
 require_relative 'builder'
 require_relative 'tag'
+require_relative 'tag_set'

data/lib/html/builder.rb

@@ -8,14 +8,19 @@ module BBLib
       SELF_CLOSING_TAGS.include?(tag.to_s.downcase)
     end
 
+    def self.build(*args, &block)
+      Builder.build(*args, &block)
+    end
+
     module Builder
 
       BBLib::HTML::TAGS.each do |tag|
         define_method(tag) do |content = nil, **attributes, &block|
           context = attributes.delete(:context) || self.context
-          t = Tag.new(type: tag, attributes: attributes, content: content, context: context)
-          children << t
-          t.instance_eval(&block) if block
+          Tag.new(type: tag, attributes: attributes, content: content, context: context).tap do |t|
+            children << t
+            t.instance_eval(&block) if block
+          end
         end
       end
 
@@ -24,10 +29,14 @@ module BBLib
         self
       end
 
-      def self.build(type, content = nil, **attributes, &block)
-        raise ArgumentError, "Unknown element type '#{type}'." unless TAGS.include?(type.to_s.downcase)
+      def self.build(type = nil, content = nil, **attributes, &block)
+        raise ArgumentError, "Unknown element type '#{type}'." unless TAGS.include?(type.to_s.downcase) || type == nil
         context = attributes.delete(:context)
-        Tag.new(type: type, content: content, attributes: attributes, context: context, &block)
+        if type
+          Tag.new(type: type, attributes: attributes, content: content, context: context, &block)
+        else
+          TagSet.new(attributes: attributes, context: context, &block)
+        end
       end
     end
   end

data/lib/html/tag.rb

@@ -4,12 +4,16 @@ module BBLib
       include BBLib::Effortless
       include Builder
 
+      APPEND_ATTRIBUTES = [:class, :style].freeze
+
       attr_str :type, required: true, arg_at: 0, arg_at_accept: [String, Symbol]
-      attr_str :content, arg_at: 1, arg_at_accept: [String, Symbol]
+      attr_str :content, default: nil, allow_nil: true, arg_at: 1, arg_at_accept: [String, Symbol]
       attr_hash :attributes, default: {}
       attr_ary_of Tag, :children, default: []
       attr_of Object, :context, default: nil, allow_nil: true
 
+      init_type :loose
+
       def render(pretty: false, tabs: 0)
         cont = render_content(pretty: pretty, tabs: tabs)
         tabbing = pretty ? ("\n" + ("\t" * tabs)) : ''
@@ -21,29 +25,94 @@ module BBLib
         end
       end
 
-      def to_s
-        render
+      alias to_html render
+
+      def add(*childs)
+        [childs].flatten.each { |child| children.push(child) }
+        nil
+      end
+
+      def to_s(*args)
+        render(*args)
       end
 
       def to_str
         to_s
       end
 
+      def set_attribute(attribute, value)
+        attributes[attribute] = value
+      end
+
+      def append_attribute(attribute, value)
+        attributes[attribute] = [attributes[attribute], value.to_s].compact.join(' ')
+      end
+
       def render_attributes
         return nil if attributes.empty?
         attributes[:style] = attributes[:style].map { |k, v| "#{k}: #{v}" }.join('; ') if attributes[:style] && attributes[:style].is_a?(Hash)
-        ' ' + attributes.map { | k, v| "#{k}=\"#{v.to_s.gsub('"', '"')}\"" }.join(' ')
+        ' ' + attributes.map do | k, v|
+          v = v.join(' ') if v.is_a?(Array)
+          "#{k}=\"#{v.to_s.gsub('"', '"')}\""
+        end.join(' ')
       end
 
       def render_content(pretty: false, tabs: 0)
         return nil if (content.nil? || content.empty?) && children.empty?
         tabbing = pretty ? ("\n" + ("\t" * (tabs + 1))) : ''
         text = if content && !content.empty?
-          "#{tabbing}#{content.gsub("\n", tabbing)}"
+          "#{tabbing}#{content.gsub("\n", pretty ? tabbing : "\n")}"
         end
         html = children.map { |tag| tag.render(pretty: pretty, tabs: tabs + 1) }.join
         [text, html].compact.join
       end
+
+      def merge(attributes)
+        raise ArgumentError, "Expected a Hash, got a #{attributes.class}" unless attributes.is_a?(Hash)
+        attributes.each do |k, v|
+          if APPEND_ATTRIBUTES.include?(k.to_sym)
+            append_attribute(k, v)
+          else
+            set_attribute(k, v)
+          end
+        end
+        self
+      end
+
+      protected
+
+      def simple_init(*args)
+        BBLib.named_args(*args).each do |k, v|
+          next if _attrs.include?(k)
+          self.attributes[k] = v
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if context && context.respond_to?(method)
+          context.send(method, *args, &block)
+        elsif method != :to_ary
+          if method.to_s.encap_by?('_')
+            self.set_attribute(:id, method.to_s.uncapsulate('_'))
+          else
+            klass = method.to_s.gsub(/(?<=[^\_])\_(?=[^\_])/, '-').gsub('__', '_')
+            self.append_attribute(:class, klass)
+          end
+          self._initialize(type, *args, &block)
+          self
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        super || context && context.respond_to?(method)
+      end
+
+      def simple_init_block_result(value)
+        return false unless value && content.nil? && !value.is_a?(Tag)
+        self.content = value.to_s
+      end
     end
   end
 end

data/lib/html/tag_set.rb

@@ -0,0 +1,20 @@
+module BBLib
+  module HTML
+    # Similar to the default tag but isn't representative of a an HTML element.
+    # Instead, this is a collection of nested HTML Elements, so only children of
+    # TagSets are rendered to html.
+    class TagSet < Tag
+      attr_str :type, required: false, default: nil, allow_nil: true
+
+      def render(pretty: false, tabs: 0)
+        render_content(pretty: pretty, tabs: tabs)
+      end
+
+      def render_content(pretty: false, tabs: 0)
+        return '' if children.empty?
+        children.map { |tag| tag.render(pretty: pretty, tabs: tabs + 1) }.join
+      end
+
+    end
+  end
+end

data/lib/logging/bblogging.rb

@@ -1,3 +1,4 @@
+require :logger.to_s unless BBLib::in_opal?
 
 module BBLib
 
@@ -12,7 +13,7 @@ module BBLib
       if msg.is_a?(Exception)
         msg = msg.inspect + "\n\t" + msg.backtrace.join("\n\t")
       end
-      "[#{datetime}] #{severity} - #{msg}\n"
+      "[#{datetime}] #{severity} - #{msg.to_s.chomp}\n"
     end
     log.datetime_format = '%Y-%m-%d %H:%M:%S'
     log

data/lib/mixins/attrs.rb

@@ -68,9 +68,15 @@ module BBLib
       ivar      = "@#{method}".to_sym
       mthd_type = opts[:singleton] ? :define_singleton_method : :define_method
 
-      self.send(mthd_type, "#{method}=") do |*args|
-        args = opts[:pre_proc].call(*args) if opts[:pre_proc]
-        instance_variable_set(ivar, (args.is_a?(Array) ? yield(*args) : yield(args)))
+      self.send(mthd_type, "#{method}=") do |args|
+        if opts[:pre_proc]
+          if opts[:pre_proc].is_a?(Proc)
+            args = opts[:pre_proc].call(args)
+          else
+            args = send(opts[:pre_proc], args)
+          end
+        end
+        instance_variable_set(ivar, yield(args))
       end
 
       self.send(mthd_type, method) do
@@ -80,7 +86,7 @@ module BBLib
           var
         elsif opts.include?(:default) || opts.include?(:default_proc)
           default_value =
-            if opts[:default].respond_to?(:dup) && BBLib.is_a?(opts[:default], Array, Hash)
+            if opts[:default].respond_to?(:dup) && BBLib.is_any?(opts[:default], Array, Hash)
               opts[:default].dup rescue opts[:default]
             elsif opts[:default_proc].is_a?(Proc)
               prc = opts[:default_proc]
@@ -115,12 +121,12 @@ module BBLib
       allowed = [klasses].flatten
       methods.each do |method|
         attr_custom(method, opts.merge(_attr_type: :of, classes: klasses)) do |arg|
-          if BBLib.is_a?(arg, *allowed) || (arg.nil? && opts[:allow_nil])
+          if BBLib.is_any?(arg, *allowed) || (arg.nil? && opts[:allow_nil])
             arg
           elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
             arg
           else
-            raise ArgumentError, "#{method} must be set to a class of #{allowed.join_terms(:or)}, NOT #{arg.class}" unless opts[:suppress]
+            raise TypeError, "#{method} must be set to a class of #{allowed.join_terms(:or)}, not #{arg.class}" unless opts[:suppress]
           end
         end
       end
@@ -178,12 +184,17 @@ module BBLib
 
     def attr_integer_between(min, max, *methods, **opts)
       methods.each do |method|
-        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : BBLib.keep_between(arg, min, max) }
+        attr_custom(method, opts.merge(min: min, max: max)) { |arg| arg.nil? && opts[:allow_nil] ? arg : BBLib.keep_between(arg, min, max).to_i }
       end
     end
 
     alias attr_int_between attr_integer_between
-    alias attr_float_between attr_integer_between
+
+    def attr_float_between(min, max, *methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts.merge(min: min, max: max)) { |arg| arg.nil? && opts[:allow_nil] ? arg : BBLib.keep_between(arg, min, max).to_f }
+      end
+    end
 
     def attr_integer_loop(min, max, *methods, **opts)
       methods.each do |method|
@@ -208,6 +219,7 @@ module BBLib
     end
 
     def attr_elements_of(list, *methods, **opts)
+      opts[:default] = [] unless opts.include?(:default) || opts.include?(:default_proc)
       methods.each do |method|
         attr_custom(method, opts.merge(list: list)) do |args|
           ls = list.is_a?(Proc) ? list.call : list
@@ -225,6 +237,7 @@ module BBLib
     end
 
     def attr_array(*methods, **opts)
+      opts[:default] = [] unless opts.include?(:default) || opts.include?(:default_proc)
       methods.each do |method|
         attr_custom(method, opts) do |arg|
           args = arg.is_a?(Array) ? arg : [arg]
@@ -239,6 +252,7 @@ module BBLib
     alias attr_ary attr_array
 
     def attr_array_of(klasses, *methods, **opts)
+      opts[:default] = [] unless opts.include?(:default) || opts.include?(:default_proc)
       klasses = [klasses].flatten
       methods.each do |method|
         attr_custom(method, opts.merge(classes: klasses)) do |args|
@@ -252,17 +266,17 @@ module BBLib
           else
             args = [args] unless args.is_a?(Array)
             args.each do |arg|
-              match = BBLib.is_a?(arg, *klasses)
+              match = BBLib.is_any?(arg, *klasses)
               if match
-                array.push(arg) if match
+                array.push(arg)
               elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
                 array.push(arg)
               else
-                raise ArgumentError, "Invalid class passed to #{method}: #{arg.class}. Must be a #{klasses.join_terms(:or)}." unless opts[:raise] == false
+                raise TypeError, "Invalid class passed to #{method} on #{self}: #{arg.class}. Must be a #{klasses.join_terms(:or)}." unless opts[:raise] == false
               end
             end
           end
-          array
+          opts[:uniq] ? array.uniq : array
         end
         attr_array_adder(method, opts[:adder_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:adder]
         attr_array_remover(method, opts[:remover_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:remover]
@@ -276,7 +290,7 @@ module BBLib
       mthd_type = singleton ? :define_singleton_method : :define_method
       send(mthd_type, name) do |*args|
         array = send(method)
-        args.each do |arg|
+        [args].flatten(1).each do |arg|
           arg = yield(arg) if block_given?
           array.push(arg)
         end
@@ -288,7 +302,7 @@ module BBLib
       name = "remove_#{method}" unless name
       define_method(name) do |*args|
         array = instance_variable_get("@#{method}")
-        args.map do |arg|
+        [args].flatten(1).map do |arg|
           next unless array && !array.empty?
           array.delete(arg)
         end
@@ -328,8 +342,8 @@ module BBLib
         attr_custom(method, **opts) do |arg|
           if opts[:formats]
             arg = arg.to_s
-            opts[:format].each do |format|
-              arg = Time.strftime(arg, format) rescue arg
+            [opts[:formats]].flatten.each do |format|
+              arg = Time.strptime(arg, format) rescue arg
             end
           end
           if arg.is_a?(Time) || arg.nil? && opts[:allow_nil]
@@ -339,7 +353,7 @@ module BBLib
           else
             begin
               Time.parse(arg.to_s)
-            rescue => e
+            rescue => _e
               nil
             end
           end
@@ -352,8 +366,8 @@ module BBLib
         attr_custom(method, **opts) do |arg|
           if opts[:formats]
             arg = arg.to_s
-            opts[:format].each do |format|
-              arg = Date.strftime(arg, format) rescue arg
+            [opts[:formats]].flatten.each do |format|
+              arg = Date.strptime(arg, format) rescue arg
             end
           end
           if arg.is_a?(Date) || arg.nil? && opts[:allow_nil]
@@ -363,7 +377,7 @@ module BBLib
           else
             begin
               Date.parse(arg.to_s)
-            rescue => e
+            rescue => _e
               nil
             end
           end
@@ -372,12 +386,13 @@ module BBLib
     end
 
     def attr_hash(*methods, **opts)
+      opts[:default] = {} unless opts.include?(:default) || opts.include?(:default_proc)
       methods.each do |method|
         attr_custom(method, **opts) do |arg|
           raise ArgumentError, "#{method} must be set to a hash, not a #{arg.class} (for #{self})." unless arg.is_a?(Hash) || arg.nil? && opts[:allow_nil]
           if opts[:keys] && arg
             arg.keys.each do |key|
-              if BBLib.is_a?(key, *opts[:keys])
+              if BBLib.is_any?(key, *opts[:keys])
                 next
               elsif (opts.include?(:pack_key) && opts[:pack_key]) && new_key = _attr_pack(key, klasses, opts)
                 arg[new_key] = arg.delete(key)
@@ -388,12 +403,12 @@ module BBLib
           end
           if opts[:values] && arg
             arg.each do |key, value|
-              if BBLib.is_a?(value, *opts[:values])
+              if BBLib.is_any?(value, *opts[:values])
                 next
               elsif (!opts.include?(:pack_value) || opts[:pack_value]) && value = _attr_pack(value, klasses, opts)
                 arg[key] = arg.delete(value)
               else
-                raise ArgumentError, "Invalid value type for #{method}: #{value.class}. Must be #{opts[:values].join_terms(:or)}."
+                raise TypeError, "Invalid value type for #{method}: #{value.class}. Must be #{opts[:values].join_terms(:or)}."
               end
             end
           end
@@ -405,8 +420,8 @@ module BBLib
 
     def _attr_pack(arg, klasses, opts = {})
       klasses = [klasses].flatten
-      unless BBLib.is_a?(arg, *klasses)
-        return klasses.first.new(*[arg].flatten(1))
+      unless BBLib.is_any?(arg, *klasses)
+        return klasses.first.new(*[arg].flatten(1)) if klasses.first.respond_to?(:new)
       end
       nil
     end

data/lib/mixins/bbmixins.rb

@@ -5,3 +5,5 @@ require_relative 'hooks'
 require_relative 'serializer'
 require_relative 'logger'
 require_relative 'bridge'
+require_relative 'prototype'
+require_relative 'type_init'

data/lib/mixins/family_tree.rb

@@ -6,6 +6,7 @@ module BBLib
   module FamilyTree
     # Return all classes that inherit from this class
     def descendants(include_singletons = false)
+      return _inherited_by.map { |c| [c, c.descendants] }.flatten.uniq if BBLib.in_opal?
       ObjectSpace.each_object(Class).select do |c|
         (include_singletons || !c.singleton_class?) && c < self
       end
@@ -15,6 +16,7 @@ module BBLib
 
     # Return all classes that directly inherit from this class
     def direct_descendants(include_singletons = false)
+      return _inherited_by if BBLib.in_opal?
       ObjectSpace.each_object(Class).select do |c|
         (include_singletons || !c.singleton_class?) && c.ancestors[1] == self
       end
@@ -37,5 +39,15 @@ module BBLib
 
     alias direct_subclasses direct_descendants
 
+    # If we are in Opal we need to track descendants a bit differently
+    if BBLib.in_opal?
+      def _inherited_by
+        @_inherited_by ||= []
+      end
+
+      def inherited(klass)
+        _inherited_by.push(klass)
+      end
+    end
   end
 end