comet-cpp 0.9.0

data/lib/comet-html/parser-class.rb

@@ -0,0 +1,168 @@
+require 'comet-html/parser-context'
+require 'comet-html/parser-reference'
+require 'comet-html/parser-binding'
+
+module Comet
+  class Class < Context
+    attr_accessor :typename, :inline_code, :anchor_name, :superclass
+    attr_reader :el, :parent, :children, :refs, :slots, :slot_plugins, :repeaters, :bindings, :event_listeners
+
+    def initialize el, parent = nil
+      context.classes << self
+      parent.children << self unless parent.nil?
+      el["_cheerp_class"] = self if el.class != Nokogiri::XML::NodeSet
+      @el              = el
+      @superclass      = if is_root? then context.template_base_type else context.template_base_subtype end
+      @parent          = parent
+      @refs            = []
+      @bindings        = []
+      @slots           = []
+      @slot_plugins    = []
+      @repeaters       = []
+      @event_listeners = []
+      @children        = []
+    end
+    
+    def implements_ibindable_view?
+      false
+    end
+
+    def constructor_decl
+      "#{@typename}(#{if parent.nil? then "" else "#{parent.typename}*" end});"
+    end
+
+    def find_reference_for el
+      @refs.each do |ref|
+        return ref if ref.el == el
+      end
+      return ThisReference.new if el == @el
+      nil
+    end
+    
+    def find_class_for el
+      collect_children.each do |child|
+        return child if child.el == el
+      end
+      nil
+    end
+
+    def is_root?
+      @parent.nil?
+    end
+    
+    def is_anchorable?
+      false
+    end
+    
+    def should_skip?
+      false
+    end
+    
+    def collect_children
+      children = []
+      context.classes.each do |object|
+        children << object if object.parent == self
+      end
+      children
+    end
+    
+    def recursively_collect_children
+      children = collect_children
+      descendants = []
+      children.each do |child|
+        descendants += child.recursively_collect_children
+      end
+      children + descendants
+    end
+
+    def root
+      current_class = @parent
+      current_class = current_class.parent until current_class.parent.nil?
+      current_class
+    end
+
+    def probe
+      probe_subtypes
+      probe_slots_plugins
+      probe_references
+      probe_bindings
+    end
+
+    def probe_subtypes root = nil
+      root = @el if root.nil?
+      root.children.each do |el|
+        context.use_cpp_type el.name if context.has_cpp_type?(el)
+        if Slot::Probe.matches? el
+          @slots << Slot.new(el, self)
+          @slots.last.probe
+        elsif Repeater::Probe.matches? el
+          @repeaters << Repeater.new(el, self)
+          @repeaters.last.probe
+        else
+          probe_subtypes el unless context.has_cpp_type?(el)
+        end
+      end
+    end
+
+    def probe_references root = nil
+      root = @el if root.nil?
+      root.children.each do |el|
+        next unless el["_cheerp_class"].nil?
+        next unless find_reference_for(el).nil?
+        if !(el["ref"].nil?)
+          create_reference(el, :explicit)
+        elsif context.has_cpp_type?(el)
+          create_reference(el, :implicit)
+        end
+        probe_references el unless context.has_cpp_type?(el)
+      end
+    end
+    
+    def create_reference el, mode
+      @refs << Reference.new(el, self, mode)
+    end
+    
+    def blocks_remote_references?
+      false
+    end
+    
+    def probe_bindings root = nil
+      root = @el if root.nil?
+      root.children.each do |el|
+        next unless el["_cheerp_class"].nil?
+        probe_bindings_for el
+        probe_bindings el unless context.has_cpp_type?(el)
+      end
+    end
+    
+    def probe_bindings_for el
+      el.attributes.each do |key, value|
+        if key.end_with? ".trigger"
+          @event_listeners << EventListener.new(el, self, key, value)
+        elsif key.end_with? ".bind"
+          @bindings << Binding.new(el, self, key, value)
+        end
+      end
+    end
+    
+    def probe_slots_plugins root = nil
+      root = @el if root.nil?
+      root.children.each do |el|
+        next unless el["_cheerp_class"].nil?
+        if context.has_cpp_type?(el)
+          el.children.each do |candidate|
+            unless candidate["slot"].nil?
+              @slot_plugins << (SlotPlugin.new candidate, self, el)
+              @slot_plugins.last.probe
+            else
+              candidate.remove # Non-slot children for cpp custom elements must be ignored
+            end
+          end
+        else
+          probe_slots_plugins el
+        end
+      end
+    end
+
+  end
+end

data/lib/comet-html/parser-context.rb

@@ -0,0 +1,61 @@
+module Comet
+  class Context
+    class << self
+      attr_accessor :slot_count, :repeater_count, :element_types, :filename
+      attr_reader :classes, :referenced_types
+
+      def reset
+        @slot_count = @repeater_count = 0
+        @implicit_ref_count = 0
+        @classes = []
+        @element_types = {}
+        @referenced_types = []
+        @filename = nil
+      end
+
+      def template_base_type
+        "Comet::IBindableView"
+      end
+
+      def template_base_subtype
+        template_base_type
+      end
+      
+      def element_base_type
+        "Comet::Element"
+      end
+
+      def has_cpp_type? el
+        @element_types.keys.include? el.name
+      end
+
+      def find_cpp_type name, options = {}
+        if @element_types.keys.include? name
+          @element_types[name]
+        else
+          options[:fallback] || element_base_type
+        end
+      end
+
+      def use_cpp_type name
+        @referenced_types << @element_types[name]
+      end
+
+      def generate_new_ref_name
+        @implicit_ref_count += 1
+        "implicit_reference_#{@implicit_ref_count}"
+      end
+
+      def load_global_element_types data
+        data.each do |element_data|
+          tag_name = element_data["tagName"] || element_data["require"].dasherize
+          @element_types[tag_name] = element_data["require"]
+        end
+      end
+    end
+
+    def context
+      Context
+    end
+  end
+end

data/lib/comet-html/parser-reference.rb

@@ -0,0 +1,98 @@
+module Comet
+  class ReferenceBase
+    def has_default_value?
+      false
+    end
+    
+    def has_initializer?
+      false
+    end
+    
+    def has_getter?
+      false
+    end
+    
+    def has_setter?
+      false
+    end
+  end
+
+  class CppReference < ReferenceBase
+    attr_reader :el, :type, :name, :default_value
+    attr_accessor :initializer, :setter_enabled
+    
+    def initialize el, type, name, default_value = nil
+      @el             = el
+      @type           = type
+      @name           = name
+      @default_value  = default_value
+      @setter_enabled = true
+      if type.nil? || name.nil?
+        raise ParseError.new(el, "incomplete attribute definition")
+      end
+      unless is_valid_cpp_variable_name?(@name)
+        raise ParseError.new(el, "attribute name `#{@name}` is not a valid C++ variable name")
+      end
+    end
+    
+    def is_explicit? ; true ; end
+    def is_implicit ; false ; end
+    def has_default_value? ; !default_value.nil? ; end
+    def has_initializer? ; !@initializer.nil? end      
+    def has_getter? ; true ; end
+    def has_setter? ; @setter_enabled ; end
+      
+    def initializer root_getter
+      @initializer
+    end
+  end
+
+  class Reference < ReferenceBase
+    attr_reader :el, :type, :name
+
+    def initialize el, parent, mode = nil
+      el["_cheerp_ref"] = self
+      @el     = el
+      @parent = parent
+      @type   = @parent.context.find_cpp_type el.name
+      set_mode mode
+    end
+
+    def set_mode mode
+      if (mode.nil? && !@el["ref"].nil?) || (mode == :explicit)
+        @mode = :explicit
+        @name = @el["ref"].to_s
+        unless is_valid_cpp_variable_name?(@name)
+          raise ParseError.new(el, "ref `#{@name}` is not a valid c++ variable name")
+        end
+      else
+        @mode = :implicit
+        @name = "element_#{@parent.context.generate_new_ref_name}"
+      end
+    end
+
+    def is_explicit? ; @mode == :explicit ; end
+    def is_implicit? ; @mode == :implicit ; end
+  end
+  
+  class RemoteReference < Reference    
+    def type
+      "#{@type}&"
+    end
+
+    def has_initializer?
+      true
+    end
+
+    def initializer root_getter
+      "#{root_getter}->#{name}"
+    end
+  end
+
+  class ThisReference
+    def name
+      "(*this)"
+    end
+  end
+end
+

data/lib/comet-html/parser-repeater.rb

@@ -0,0 +1,58 @@
+require 'comet-html/parser-class'
+
+module Comet
+  class Repeater < Comet::Class
+    class Probe
+      class << self
+        def matches? el
+          !(el["repeat.for"].nil?)
+        end
+
+        def evaluate el, parent
+          Repeater.new el, parent
+        end
+      end
+    end
+
+    attr_reader :repeater_name, :value_type, :value_name, :list_type, :list_name, :bind_mode, :anchor
+
+    def initialize el, parent
+      super el, parent
+      value, bind_mode = extract_bind_mode_from el["repeat.for"].to_s
+      parts = value.to_s.match /^\s*(\[([^\]]+)\])?\s*([^\s]+)\s+of\s+\[([^\]]+)\]\s*(.*)$/
+      raise ParseError.new(el, "invalid repeater definition: `#{value}`") if parts.nil?
+      @typename   = "#{context.classes.first.typename}Repeatable_#{context.repeater_count}"
+      @superclass = context.find_cpp_type(el.name, fallback: context.template_base_subtype)
+
+      @repeater_name = "repeater_#{context.repeater_count}"
+      @value_type    = parts[2] || "#{parts[4]}::value_type"
+      @value_name    = parts[3]
+      @list_type     = parts[4]
+      @list_name     = parts[5]
+      @bind_mode     = bind_mode
+      
+      unless is_valid_cpp_variable_name?(@value_name)
+        raise ParseError.new(el, "invalid variable name `#{@value_name}`") 
+      end
+
+      context.repeater_count += 1
+    end
+
+    def constructor_decl
+      "#{@typename}(#{parent.typename}*, #{@value_type});"
+    end
+    
+    def is_anchorable?
+      true
+    end
+    
+    def blocks_remote_references?
+      true
+    end
+    
+    def probe
+      super
+      probe_bindings_for el
+    end
+  end
+end

data/lib/comet-html/parser-slot.rb

@@ -0,0 +1,108 @@
+require 'comet-html/parser-class'
+
+module Comet
+  class SlotBase < Comet::Class
+    def find_remote_reference_holder
+      p = @parent
+      until p.is_root?
+        return nil if p.blocks_remote_references?
+        p = p.parent
+      end
+      p
+    end
+
+    def create_reference el, mode
+      ref_root = nil 
+      if (mode == :implicit) || (ref_root = find_remote_reference_holder).nil?
+        super el, mode
+      else
+        ref_root.refs << Reference.new(el, ref_root, mode)
+        @refs << RemoteReference.new(el, self, mode)
+      end
+    end
+  end
+
+  class SlotPlugin < SlotBase
+    attr_reader :slot_name, :on_element
+
+    def implements_ibindable_view?
+      is_custom_element?
+    end
+    
+    def is_custom_element?
+      context.has_cpp_type? el
+    end
+
+    def initialize el, parent, on_element
+      super el, parent
+      @slot_name  = el["slot"].to_s
+      @on_element = on_element
+      @typename   = "#{context.classes.first.typename}SlotPlugin_#{context.slot_count}"
+      @superclass = context.find_cpp_type el.name, fallback: context.template_base_subtype
+      context.use_cpp_type el.name if is_custom_element?
+      context.slot_count += 1
+
+      if has_ref?
+        ref_root = find_remote_reference_holder
+        if ref_root.nil?
+          puts "[comet-html] ignoring ref at #{context.filename}:#{el.line}"
+          el["ref"] = nil
+        else
+          @parent = ref_root
+          ref = CppReference.new el, @typename, el["ref"]
+          ref.initializer = constructor_params
+          ref.setter_enabled = false
+          ref_root.refs << ref
+        end
+      end
+    end
+    
+    def constructor_params
+      "this"
+    end
+    
+    def has_ref?
+      not el["ref"].nil?
+    end
+    
+    def probe
+      super
+      probe_bindings_for el
+    end
+  end
+
+  class Slot < SlotBase
+    class Probe
+      class << self
+        def matches? el
+          el.name == "slot"
+        end
+
+        def evaluate el, parent
+          Slot.new el, parent
+        end
+      end
+    end
+
+    attr_reader :slot_name, :slot_ref, :anchor
+
+    def initialize el, parent
+      super el, parent
+      @typename   = "#{context.classes.first.typename}Slot_#{context.slot_count}"
+
+      @slot_name = el["name"].to_s
+      @slot_ref  = "slot_#{@slot_name}"
+      @anchor    = find_anchorable_anchor(el)
+
+      unless is_valid_cpp_variable_name?(@slot_name)
+        raise ParseError.new(el, "slot name `#{@slot_name}` is not a valid C++ variable name")
+      end
+
+      context.slot_count += 1
+    end
+    
+    def is_anchorable?
+      true
+    end
+  end
+end