comet-cpp 0.9.0

data/lib/comet-html/source-generator.rb

@@ -0,0 +1,285 @@
+module Comet
+  class SourceGenerator
+    attr_reader :object, :source
+    
+    def initialize object
+      @object = object
+    end
+
+    def generate
+      @source  = generate_constructor_header
+      @source += generate_constructor_body
+      @source += generate_constructor_footer + "\n"
+      @source += generate_method_bind_attributes + "\n"
+      @source += generate_method_trigger_binding_updates   
+      @source
+    end
+
+    def tag_name
+      if @object.parent.nil?
+        if @object.el.first["tag-name"].nil?
+          @object.typename.dasherize
+        else
+          @object.el.first["tag-name"]
+        end
+      else
+        @object.el.name
+      end
+    end
+
+    def root_ptr
+      if object.parent.nil? then "this" else "root" end
+    end
+    
+    def get_root_from_parent_code parent_symbol
+      if object.is_root?
+        "this"
+      else
+        result = parent_symbol
+        current_parent = object.parent
+        until current_parent.parent.nil?
+          result += "->parent"
+          current_parent = current_parent.parent
+        end
+        result
+      end
+    end
+
+    def make_parent_to_root_initializer parent_symbol
+      "root(#{get_root_from_parent_code(parent_symbol)})"
+    end
+
+    def generate_constructor_header
+      initializers = []      
+      parent_symbol = "__p"
+      root_getter   = get_root_from_parent_code parent_symbol
+      
+      case object.superclass
+      when object.context.template_base_type then
+        initializers << "#{object.context.template_base_type}(\"#{tag_name}\")"
+#      when object.context.template_base_subtype then
+#        initializers << "#{object.context.template_base_subtype}(\"#{tag_name}\", #{parent_symbol}->signaler)"
+      end
+
+      # Constructor
+      result  = "HtmlTemplate::#{object.typename}::#{object.typename}("
+      unless object.is_root?
+        initializers << make_parent_to_root_initializer(parent_symbol)
+        result += "#{object.parent.typename}* #{parent_symbol}"
+      else
+        initializers << "root(this)"
+      end
+      (object.refs.select{|r| r.has_initializer?}).each do |ref|
+        initializers << "#{ref.name}(#{ref.initializer root_getter})"
+      end
+      unless object.is_root?
+        initializers << "signaler(#{parent_symbol}->signaler)" unless object.implements_ibindable_view?
+        initializers << "parent(#{parent_symbol})"
+      end
+      if object.class == Repeater
+        initializers << "#{object.value_name}(__i)"
+        result += ", #{object.value_type} __i"
+      end
+      unless object.is_root?
+        object.slots.each do |slot|
+          initializers << "#{slot.slot_ref}(#{root_getter}->#{slot.slot_ref})"
+        end
+      end
+      result += ")"
+      result += " : " + initializers.join(", ") if initializers.count > 0
+      result += "\n"
+      result += "{\n"
+      result
+    end
+
+    def generate_constructor_body
+      result  = generate_element_initializers
+      result += generate_binding_initializers
+      result += generate_dom_constructor
+      result += generate_anchors_initializers
+      result
+    end
+
+    def generate_constructor_footer
+      result = ""
+      result += "}\n"
+      result
+    end
+
+    def generate_element_initializers
+      result = ""
+      object.refs.each do |ref|
+        if ref.type == "Comet::Element"
+          result += "  #{ref.name} = Comet::Element(\"#{ref.el.name}\");\n"
+        end
+      end
+      result
+    end
+    
+    def generate_binding_initializers
+      result = ""
+      object.bindings.each do |binding|
+        ref = object.find_reference_for binding.el
+        initializer = if binding.binds_to_cpp_property?
+          "Comet::Bindable([this]() { #{ref.name}.set_#{binding.attribute_name}(#{binding.code}); })"
+        elsif binding.attribute_name == "show"
+          "Comet::Bindable([this]() { #{ref.name}.visible(#{binding.code}); })"
+        elsif binding.attribute_name == "text"
+          "Comet::Bindable([this]() { #{ref.name}.text(#{binding.code}); })"
+        elsif binding.attribute_name == "innerhtml"
+          "Comet::Bindable([this]() { #{ref.name}.html(#{binding.code}); })"
+        else
+          "Comet::Bindable(#{ref.name}, \"#{binding.attribute_name}\", [this]() -> std::string { return Comet::lexical_cast<std::string>(#{binding.code}); })"
+        end
+        result += "  bound_attributes.push_back(#{initializer}#{binding.bind_mode});\n"
+      end
+
+      object.repeaters.each do |repeater|
+        refresh_code = "#{repeater.repeater_name}.refresh(this, #{repeater.list_name});"
+        initializer  = "Comet::Bindable([this]() { #{refresh_code} })"
+        result += "  bound_attributes.push_back(#{initializer}#{repeater.bind_mode});\n"
+      end
+
+      object.event_listeners.each do |event_listener|
+        ref = object.find_reference_for event_listener.el
+        unless event_listener.is_cpp
+          result += "  #{ref.name}.events->on(\"#{event_listener.attribute_name}\", [this](client::Event* _event) { #{event_listener.code}; });\n"
+        else
+          result += "  #{ref.name}.signaler.connect([this](std::string signal_name)\n"
+          result += "  {\n"
+          result += "    if (signal_name == \"#{event_listener.attribute_name}\")\n"
+          result += "    {\n"
+          result += "      #{event_listener.code};\n"
+          result += "    }\n"
+          result += "  });\n"
+        end
+      end
+      result
+    end
+    
+    def generate_dom_constructor
+      result = ""
+      source_el = if object.is_root? then object.el.first else object.el end
+      html_attributes = make_attr_from_el source_el
+      result += "  attr({#{html_attributes.join ','}});\n" if html_attributes.length > 0
+      dom_code = dom_generator object.el, 4
+      result += "  inner({#{dom_code}\n  });\n" unless dom_code.empty?
+      result
+    end
+
+    def dom_generator el, indent
+      result = ""
+      count = 0
+      el.children.each do |el|
+        sub_object = object.find_class_for el
+        if !sub_object.nil? && sub_object.is_anchorable?
+          result += "," if count > 0
+          result += "\n" + (" " * indent)
+          result += sub_object.anchor_name
+          count += 1
+        elsif !(el["_cheerp_class"].nil?)
+          next
+        elsif el.name != "text" && el.name != "comment"
+          reference = object.find_reference_for(el)
+          html_attributes = make_attr_from_el el
+
+          result += "," if count > 0
+          result += "\n" + (" " * indent)
+
+          result += if reference.nil? then "Comet::Element(\"#{el.name}\")" else reference.name end
+          result += ".attr({#{html_attributes.join ','}})" if html_attributes.count > 0
+          children_result = dom_generator el, indent + 2
+          result += ".inner({#{children_result}\n#{" " * indent}})" if children_result.length > 0
+
+          count += 1
+        elsif el.name == "text" && !(el.text.strip.empty?)
+          escaped_text = el.text.gsub /"/, "\\\""
+          escaped_text.gsub! "\n", '\n'
+          result += "," if count > 0
+          result += "\n" + (" " * indent)
+          result += "Comet::Element(\"span\").text(\"#{escaped_text}\")"
+          count += 1
+        end
+      end
+      result
+    end
+    
+    def generate_anchors_initializers
+      result = ""
+      object.repeaters.each do |repeater|
+        result += "  #{repeater.repeater_name}.set_anchor(#{repeater.anchor_name}, #{anchor_symbol_to_enum :append});\n"
+      end
+
+      object.slots.each do |slot|
+        result += "  #{slot.slot_ref}.set_anchor(#{slot.anchor_name}, #{anchor_symbol_to_enum :append});\n"
+        result += "  #{slot.slot_ref}.set_element(std::make_shared<#{slot.typename}>(this));\n"
+      end
+
+      object.slot_plugins.each do |slot_plugin|
+        ref = object.find_reference_for(slot_plugin.on_element)
+        initializer = if slot_plugin.has_ref?
+          "root->#{slot_plugin.el["ref"]}"
+        else
+          "std::make_shared<#{slot_plugin.typename}>(#{slot_plugin.constructor_params})"
+        end
+        result += "  #{ref.name}.slot_#{slot_plugin.slot_name}.set_element(#{initializer});\n"
+      end
+      result
+    end
+    
+    def inherits_binding_methods?
+      !([object.context.template_base_type, object.context.template_base_subtype].include? object.superclass)
+    end
+    
+    def generate_method_bind_attributes
+      result = ""
+      result += "void HtmlTemplate::#{object.typename}::bind_attributes()\n"
+      result += "{\n"
+      if inherits_binding_methods?
+        result += "  #{object.superclass}::bind_attributes();\n"
+      else
+        result += "  bound_attributes.enable(signaler);\n"
+      end
+      object.refs.each do |ref|
+        if ref.el && object.context.has_cpp_type?(ref.el)
+          result += "  #{ref.name}.bind_attributes();\n"
+          result += "  signaler.connect([this](std::string _event) { #{ref.name}.signaler.trigger(_event); });\n"
+        end
+      end
+      object.repeaters.each do |repeater|
+        result += "  #{repeater.repeater_name}.bind_attributes();\n"
+      end
+      object.slots.each do |slot|
+        result += "  if (#{slot.slot_ref}.has_element())\n"
+        result += "    #{slot.slot_ref}.get_element()->bind_attributes();\n"
+      end
+      result += "}\n"
+      result
+    end
+    
+    def generate_method_trigger_binding_updates
+      result = ""
+      result += "void HtmlTemplate::#{object.typename}::trigger_binding_updates()\n"
+      result += "{\n"
+      if inherits_binding_methods?
+        result += "  #{object.superclass}::trigger_binding_updates();\n"
+      else
+        result += "  bound_attributes.update();\n"
+      end
+      object.refs.each do |ref|
+        if ref.el && object.context.has_cpp_type?(ref.el)
+          result += "  #{ref.name}.trigger_binding_updates();\n"
+        end
+      end
+      object.repeaters.each do |repeater|
+        result += "  #{repeater.repeater_name}.trigger_binding_updates();\n"
+      end
+      object.slots.each do |slot|
+        result += "  if (#{slot.slot_ref}.has_element())\n"
+        result += "    #{slot.slot_ref}.get_element()->trigger_binding_updates();\n"
+      end
+      result += "}\n"
+      result
+    end
+  end
+end

data/lib/comet-html/utils.rb

@@ -0,0 +1,88 @@
+ class String
+  def camelize
+    parts = self.split(/_+|-+|\W+/)
+    (parts.map do |part| part.capitalize end).join
+  end
+
+  def dasherize
+    tmp = self.gsub(/([A-Z]+)/, '_\1')
+    parts = tmp.split(/_+|-+|\W+/)
+    parts.select! {|item| item != ""}
+    (parts.map do |part| part.downcase end).join '-'
+  end
+end
+
+#module Comet
+  def find_anchorable_anchor el
+    it = el
+    loop do
+      it = it.previous
+      break if it.nil? || it.name != "text" || it.name == "comment"
+    end
+    unless it.nil?
+      { el: it, mode: :append }
+    else
+      it = el
+      loop do
+        it = it.next
+        break if it.nil? || it.name != "text" || it.name == "comment"
+      end
+      unless it.nil?
+        { el: it, mode: :prepend }
+      else
+        { el: el.parent, mode: :children }
+      end
+    end
+  end
+
+  def anchor_symbol_to_enum anchor_name
+    "Comet::" + case anchor_name
+    when :append   then "AppendAnchor"
+    when :prepend  then "PrependAnchor"
+    when :children then "ChildrenAnchor"
+    end
+  end  
+  
+  def has_trigger_attributes? el
+    result = false
+    el.attributes.each do |key,value|
+      result = true if key.end_with?(".trigger")
+    end
+    result
+  end
+
+  def make_attr_from_el el
+    hard_attributes  = []
+    el.attributes.each do |key, value|
+      reserved_keywords = ["ref", "slot", "_cheerp_class", "_cheerp_ref"]
+      if !reserved_keywords.include?(key) && !(key.end_with? ".bind") && !(key.end_with? ".trigger") && !(key.end_with? ".for")
+        hard_attributes << "{\"#{key}\",\"#{value}\"}"
+      end
+    end
+    hard_attributes
+  end
+
+  def extract_bind_mode_from value
+    bind_mode_match = value.to_s.match(/\s*&\s*(throttle|signal):([a-zA-Z0-9_-]+)$/)
+    if bind_mode_match.nil?
+      bind_mode = ""
+    else
+      value = value.to_s.delete_suffix bind_mode_match[0]
+      bind_mode_enum = case bind_mode_match[1]
+                       when 'signal' then "SignalBind"
+                       when 'throttle' then "ThrottleBind"
+                       else "StaticBind"
+                       end
+      bind_mode = ".use_mode(Comet::Bindable::#{bind_mode_enum}, \"#{bind_mode_match[2]}\")"
+    end
+    [value, bind_mode]
+  end
+  
+  def is_valid_cpp_variable_name? value
+    if value.length <= 255
+      not (value.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/).nil?)
+    else
+      false
+    end
+  end
+#end

data/lib/guard/comet-html.rb

@@ -0,0 +1,32 @@
+module ::Guard
+  class CometHtml < Plugin
+    def initialize options = {}
+      @options = options
+      super
+    end
+
+    def run_on_modifications(paths)
+      run_all
+    end
+
+    def generate_command
+      gemspec  = Gem::Specification.find_all_by_name("comet-cpp").first
+      command  = "#{gemspec.bin_dir}/comet-html"
+      command += " -i '#{@options[:source]}'" unless @options[:source].nil?
+      command += " -o '#{@options[:output]}'" unless @options[:output].nil?
+      command += " -c '#{@options[:config]}'" unless @options[:config].nil?
+      command
+    end
+
+    def run_all
+      PTY.spawn(generate_command) do |stdout,stdin,pid|
+        begin
+          stdout.each {|line| print line}
+        rescue Errno::EIO
+        end
+        Process.wait(pid)
+      end
+      if $?.success? then :success else :failure end
+    end
+  end
+end

data/lib/guard/comet.rb

@@ -0,0 +1,36 @@
+require 'pty'
+
+module ::Guard
+  class Comet < Plugin
+    def initialize options = {}
+      @options = options
+      super
+    end
+
+    def run_on_modifications(paths)
+      run_all
+    end
+
+    def compile_command
+      gemspec  = Gem::Specification.find_all_by_name("comet-cpp").first
+      compiler = "#{gemspec.bin_dir}/comet-make"
+      command = "#{compiler}"
+      command += " -c '#{@options[:cheerp_path]}'" unless @options[:cheerp_path].nil?
+      command += " -i '#{@options[:cmakelists]}'"  unless @options[:cmakelists].nil?
+      command += " -o '#{@options[:output]}'"      unless @options[:output].nil?
+      command += " -g" if @options[:debug] == true
+      command
+    end
+
+    def run_all
+      PTY.spawn(compile_command) do |stdout,stdin,pid|
+        begin
+          stdout.each {|line| print line}
+        rescue Errno::EIO
+        end
+        Process.wait(pid)
+      end
+      if $?.success? then :success else :failure end
+    end
+  end
+end

data/vendor/project/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'guard'
+gem 'comet-cpp'

data/vendor/project/Guardfile

@@ -0,0 +1,5 @@
+guard 'comet-html' do
+  watch(%r{^app/.+\.html$})
+end
+
+guard 'comet'

data/vendor/project/app/application.hpp

@@ -0,0 +1,29 @@
+#ifndef  MY_APPLICATION_HPP
+# define MY_APPLICATION_HPP
+
+# include <comet/router.hpp>
+
+class Application
+{
+  Application() {}
+  Application(const Application&)    = delete;
+  void operator=(const Application&) = delete;
+
+public:
+  static Application& get()
+  {
+    static Application instance;
+    return instance;
+  }
+
+  static void start()
+  {
+    auto& app = get();
+
+    app.router.start();
+  }
+
+  Comet::Router router;
+};
+
+#endif

data/vendor/project/app/main.cpp

@@ -0,0 +1,6 @@
+#include "application.hpp"
+
+void webMain()
+{
+  Application::start();
+}

data/vendor/project/app/routes.cpp

@@ -0,0 +1,7 @@
+#include <comet/router.hpp>
+
+using namespace Comet;
+
+void Router::initialize()
+{
+}

data/vendor/project/public/index.html

@@ -0,0 +1,7 @@
+<html>
+  <head>
+    <title>Hello comet</title>
+    <script src="/application.js"></script>
+  </head>
+  <body comet-app="main"></body>
+</html>

data/vendor/src/anchorable_element.hpp

@@ -0,0 +1,79 @@
+#ifndef  COMET_ANCHORABLE_ELEMENT_HPP
+# define COMET_ANCHORABLE_ELEMENT_HPP
+
+# include "element.hpp"
+# include "exception.hpp"
+
+namespace Comet
+{
+  enum AnchorMode
+  {
+    ChildrenAnchor,
+    AppendAnchor,
+    PrependAnchor,
+    AnchorsEnd
+  };
+
+  struct AnchorableElement
+  {
+    Comet::Element anchor;
+    AnchorMode             anchor_mode = AnchorsEnd;
+
+    inline void set_anchor(Comet::Element el, AnchorMode mode)
+    {
+      anchor = el;
+      anchor_mode = mode;
+    }
+
+    inline bool is_anchorable() const
+    {
+      return anchor_mode != AnchorsEnd;
+    }
+
+    template<typename LIST>
+    void attach_elements(const LIST& elements)
+    {
+      switch (anchor_mode)
+      {
+      case ChildrenAnchor:
+        for (auto el : elements)
+          el->append_to(anchor);
+        break ;
+      case AppendAnchor:
+        append_to_anchor(elements);
+        break ;
+      case PrependAnchor:
+        prepend_to_anchor(elements);
+        break ;
+      case AnchorsEnd:
+        raise(std::logic_error("AnchorableElement::attach_element called with unset anchor"));
+        break ;
+      }
+    }
+
+  private:
+    template<typename LIST>
+    void append_to_anchor(const LIST& elements)
+    {
+      auto current_anchor = anchor;
+      for (auto it = elements.begin() ; it != elements.end() ; ++it)
+      {
+        (*it)->insert_after(current_anchor);
+        current_anchor = Comet::Element(*(*it));
+      }
+    }
+
+    template<typename LIST>
+    void prepend_to_anchor(const LIST& elements)
+    {
+      auto current_anchor = anchor;
+      for (auto it = elements.rbegin() ; it != elements.rend() ; ++it)
+      {
+        (*it)->insert_before(current_anchor);
+        current_anchor = Comet::Element(*(*it));
+      }
+    }
+  };
+}
+
+#endif

data/vendor/src/append_semantics.hpp

@@ -0,0 +1,73 @@
+#ifndef  CRAILS_FRONT_APPEND_SEMANTICS_HPP
+# define CRAILS_FRONT_APPEND_SEMANTICS_HPP
+
+# include <cheerp/clientlib.h>
+# include <vector>
+# include <list>
+# include <memory>
+# include <type_traits>
+
+/*
+ * Type solving tools for the `inner` and `operator>` methods of Comet::Element
+ * - support std::list and std::vector containers, or passing by value
+ * - support pointer and non-pointer value types (including shared_ptr)
+ */
+namespace Comet
+{
+  class Element;
+
+  template<typename Test, template<typename...> class Ref>
+  struct is_specialization : std::false_type {};
+
+  template<template<typename...> class Ref, typename... Args>
+  struct is_specialization<Ref<Args...>, Ref>: std::true_type {};    
+  
+  template<typename Test>
+  struct is_array_container
+  {
+    static const bool value = is_specialization<Test, std::vector>::value || is_specialization<Test, std::list>::value;
+  };
+
+  template<typename ELEMENT, bool is_pointer>
+  struct ElementAppender
+  {
+    static void append_a_to_b(const ELEMENT& a, client::HTMLElement* b)
+    {
+      b->appendChild(*a);
+    }
+  };
+
+  template<typename ELEMENT>
+  struct ElementAppender<ELEMENT, true>
+  {
+    static void append_a_to_b(const ELEMENT& a, client::HTMLElement* b)
+    {
+      b->appendChild(**a);
+    }
+  };
+
+  template<typename CONTAINER, bool is_array>
+  struct ElementListAppender
+  {
+    static void append_list(const CONTAINER& container, client::HTMLElement* ptr)
+    {
+      constexpr bool is_ptr = std::is_pointer<typename CONTAINER::value_type>::value || std::is_same<typename CONTAINER::value_type, std::shared_ptr<Comet::Element> >::value;
+
+      for (const auto& i : container)
+        ElementAppender<typename CONTAINER::value_type, is_ptr>::append_a_to_b(i, ptr);
+    }
+  };
+
+  template<typename CONTAINER>
+  struct ElementListAppender<CONTAINER, false>
+  {
+    static void append_list(const CONTAINER& container, client::HTMLElement* ptr)
+    {
+      constexpr bool is_ptr = std::is_pointer<CONTAINER>::value || std::is_same<CONTAINER, std::shared_ptr<Comet::Element> >::value;
+
+      ElementAppender<CONTAINER, is_ptr>::append_a_to_b(container, ptr);
+    }
+  };
+}
+
+#endif