comet-cpp 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76cf704d8d362f1b97c3f6fb318d9176899355ed9e59d868d777cc05f81ee72a
+  data.tar.gz: d5fb5a73fe2a213689448bb1579cf9eec90339fc52df6273435ebb359baabbcc
+SHA512:
+  metadata.gz: c4c4858560da8cc6d439028fdc4c8fa19906018681c425e1eee1e537243d26d3caf0769050aa434923479c061f89a10b437276a0127735a3718b5d544d457aa9
+  data.tar.gz: cd4b469ae6f9e3162f8520311fbcf1c67df47346a55bb9752b610d7f7dd6cbb0faa32d9e450ce5580bd5caa746c4f86d3471b593e43f1f5f00deb7290cd79458

data/bin/comet-html

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'fileutils'
+require 'json'
+require 'comet-html/generator'
+
+@source_path = "app"
+@output_path = "comet-elements/html"
+@config_path = "config/comet.json"
+
+OptionParser.new do |opts|
+  opts.on "-i PATH", "--source-path=PATH" do |v| @source_path = v end
+  opts.on "-o PATH", "--output=PATH"      do |v| @output_path = v end
+  opts.on "-c PATH", "--config=PATH"      do |v| @config_path = v end
+end.parse!
+
+@source_path = File.expand_path(@source_path)
+@output_path = File.expand_path(@output_path)
+@config_path = File.expand_path(@config_path)
+
+def purge_old_files whitelist
+  Dir["#{@output_path}/**/*"].each do |file|
+    next if File.directory? file
+    File.delete file unless whitelist.include? file
+  end
+end
+
+def write_if_content_changed file, content
+  if !File.exists?(file) || File.read(file) != content
+    File.open file, 'w' do |f| f.write content end
+    puts "[comet] Generated #{file}"
+  end
+end
+
+files   = Dir["#{@source_path}/**/*.html"]
+config  = if File.exists?(@config_path) then JSON.parse(File.read @config_path) else nil end
+success = true
+current_filename = nil
+
+begin
+  generated_files = []
+  files.each do |file|
+    current_filename = file
+    generator = ::Comet::Generator.new @output_path, @source_path, file
+    generator.set_config config unless config.nil?
+    header_file = generator.compiled_header_path
+    source_file = generator.compiled_source_path
+
+    FileUtils.mkdir_p File.dirname(header_file)
+    code = generator.generate
+    write_if_content_changed header_file, code[:header]
+    write_if_content_changed source_file, code[:source]
+    generated_files << header_file << source_file
+  rescue ::Comet::ParseError => e
+    STDERR.puts "[comet] parse error at #{current_filename}:#{e.line}: #{e.message}"
+    success = false
+  rescue ::Comet::HtmlParseError => e
+    STDERR.puts "[comet] parse error at #{current_filename}:#{e.message}"
+    success = false
+  rescue ::Comet::LoadError => e
+    STDERR.puts "[comet] #{e.message}"
+    success = false
+  rescue StandardError => e
+    STDERR.puts e.message
+    e.backtrace.each do |line| STDERR.puts line end
+    success = false
+  end
+  purge_old_files generated_files
+end

data/bin/comet-make

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'pathname'
+require 'fileutils'
+require 'pty'
+
+@cheerp_path     = "/opt/cheerp"
+@build_type      = "RELEASE"
+@build_path      = ".comet-build"
+@cmakelists_path = "./"
+@output_path     = "public"
+
+OptionParser.new do |opts|
+  opts.on "-c PATH", "--cheerp-path=PATH" do |v| @cheerp_path = v end
+  opts.on "-g", "--debug"                 do |v| @build_type = "DEBUG" end
+  opts.on "-i PATH", "--cmakelists=PATH"  do |v| @cmakelists_path = v end
+  opts.on "-o PATH", "--output=PATH"      do |v| @output_path = v end
+end.parse!
+
+@cmakelists_path = File.expand_path @cmakelists_path
+@output_path     = File.expand_path @output_path
+@build_path      = File.expand_path @build_path
+@cheerp_path     = File.expand_path @cheerp_path
+
+cmake_options = []
+cmake_options << "-DCMAKE_TOOLCHAIN_FILE=#{@cheerp_path}/share/cmake/Modules/CheerpToolchain.cmake"
+cmake_options << "-DCMAKE_BUILD_TYPE=#{@build_type}"
+
+def run_command cmd
+  puts "+ #{cmd}"
+  PTY.spawn(cmd) do |stdout,stdin,pid|
+    begin
+      stdout.each {|line| print line}
+    rescue Errno::EIO
+    end
+    Process.wait(pid)
+  end
+  exit -1 unless $?.success?
+end
+
+FileUtils.mkdir_p @build_path
+
+Dir.chdir @build_path do
+  run_command "cmake #{cmake_options.join ' '} #{@cmakelists_path}"
+  run_command "make"
+end
+
+FileUtils.mkdir_p @output_path
+Dir["#{@build_path}/*.{js,js.map}"].each do |target|
+  path = Pathname.new target
+  basename = path.basename
+  FileUtils.mv target, "#{@output_path}/#{@basename}"
+end

data/bin/comet-new

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'fileutils'
+
+@build_path     = ".comet-build"
+@vendor_path    = "#{@build_path}/vendor"
+@project_dir    = "./"
+@project_name   = "project-name"
+@skip_project   = false
+
+OptionParser.new do |opts|
+  opts.on "-p PATH", "--project-path=PATH" do |v| @project_dir = v end
+  opts.on "-n NAME", "--name=NAME"         do |v| @project_name = v end
+  opts.on "-v PATH", "--vendor-path=PATH"  do |v| @vendor_path = v end
+  opts.on "-z", "--skip-project-files"     do |v| @skip_project = v end
+end.parse!
+
+@build_path     = File.expand_path @build_path
+@project_dir    = File.expand_path @project_dir
+@vendor_path    = File.expand_path @vendor_path
+@comet_src_path = "#{@vendor_path}/comet"
+
+FileUtils.mkdir_p @comet_src_path
+
+gemspec    = Gem::Specification.find_all_by_name("comet-cpp").first
+vendor_dir = File.expand_path "#{gemspec.bin_dir}/../vendor"
+src_dir    = vendor_dir + "/src"
+app_dir    = vendor_dir + "/project"
+
+def initialize_directory src_dir, output_dir, override
+  Dir["#{src_dir}/**/*"].each do |filepath|
+    next if File.directory? filepath
+    relative_path = filepath[src_dir.length + 1..-1]
+    dest_path     = output_dir + '/' + relative_path
+    FileUtils.mkdir_p(File.dirname dest_path)
+    if !File.exists?(dest_path) || override
+      FileUtils.cp filepath, dest_path
+    end
+  end
+end
+
+initialize_directory src_dir, @comet_src_path, true
+initialize_directory app_dir, @project_dir, false unless @skip_project
+
+File.open "#{@project_dir}/CMakeLists.txt", "w" do |file|
+  relative_vendor_path = Pathname.new(@vendor_path).relative_path_from(Pathname.new(@project_dir)).to_s
+  file.write <<EOF
+cmake_minimum_required(VERSION 3.0)
+
+project(#{@project_name})
+include_directories(#{relative_vendor_path} comet-elements)
+
+if (CMAKE_BUILD_TYPE EQUAL "DEBUG")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -cheerp-sourcemap=application.js.map -cheerp-sourcemap-standalone")
+endif()
+
+file(GLOB_RECURSE vendor_src #{relative_vendor_path}/*.cpp)
+file(GLOB_RECURSE app_src app/*.cpp comet-elements/*.cpp)
+
+add_executable(application ${vendor_src} ${app_src})
+EOF
+end unless @skip_project || (File.exists? "#{@project_dir}/CMakeLists.txt")

data/bin/comet-web

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+@output_path = "public"
+
+OptionParser.new do |opts|
+  opts.on "-o PATH", "--output=PATH" do |v| @output_path = v end
+end.parse!
+
+@output_path = File.expand_path @output_path
+
+server = WEBrick::HTTPServer.new Port: 8000, DocumentRoot: @output_path
+trap 'INT' do server.shutdown end
+server.start

data/lib/comet-html/generator.rb

@@ -0,0 +1,220 @@
+require 'comet-html/parser-class'
+require 'comet-html/parser-repeater'
+require 'comet-html/parser-slot'
+require 'comet-html/utils'
+require 'comet-html/header-generator'
+require 'comet-html/source-generator'
+require 'nokogiri'
+require 'pathname'
+
+module Comet
+  class LoadError < StandardError
+    attr_reader :message
+    def initialize
+      @message = "Load error: #{message}"
+    end
+  end
+
+  class ParseError < StandardError
+    attr_reader :el, :message
+
+    def initialize el, message
+      @el = el
+      @message = message
+    end
+    
+    def line
+      el.line
+    end
+  end
+  
+  class HtmlParseError < StandardError
+    attr_reader :message, :line
+    
+    def initialize error
+      @message = error.message
+      @line    = error.line
+    end
+  end
+
+  class Generator
+    def initialize output, input, file
+      @output   = output
+      @input    = input
+      @filepath = file
+    end
+
+    def set_config config
+      @config = config
+    end
+    
+    def relative_filepath
+      @filepath[@input.length..-1]
+    end
+
+    def compiled_header_path
+      @output + relative_filepath.delete_suffix(File.extname relative_filepath) + ".hpp"
+    end
+
+    def compiled_source_path
+      @output + relative_filepath.delete_suffix(File.extname relative_filepath) + ".cpp"
+    end
+  
+    def append_classes_predeclaration
+      result = ""
+      Context.classes.each do |object|
+        next if object.should_skip?
+        result += "  class #{object.typename};\n"
+      end
+      result
+    end
+    
+    def load_includes head
+      head.css("include").each do |include_attribute|
+        unless include_attribute["require"].nil?
+          type = include_attribute["require"].to_s
+          tag  = if include_attribute["tag-name"].nil?
+            parts = type.split("<")
+            parts[0].gsub! "::", "_"
+            parts.join("<").dasherize
+          else
+            include_attribute["tag-name"].to_s
+          end
+          Context.element_types[tag] = type
+        end
+      end
+    end
+
+    def prepare_includes head
+      result = ""
+      included_paths = []
+      head.css("include").each do |include_attribute|
+        included_paths << include_attribute["src"].to_s
+      end
+      included_paths.uniq.each do |include_path|
+        result += "# include \"#{include_path}\"\n"
+      end
+      @config["elements"].each do |element_data|
+        if Context.referenced_types.include? element_data["require"]
+          result += "# include \"#{element_data["include"]}\"\n"
+        end
+      end if !@config.nil? && !@config["elements"].nil?
+      result
+    end
+
+    def html5_tags
+      ["article", "aside", "details", "figcaption", "figure", "footer", "header", "main", "mark", "nav", "section", "summary", "time"]
+    end
+    
+    def whitelisted_tags
+      ["svg"] + (if @config.nil? then [] else @config["whitelisted-tags"] || [] end)
+    end
+    
+    def internal_tags
+      ["include", "attribute", "slot"]
+    end
+
+    def is_error_fatal? error
+      matches = error.message.match(/^[0-9]+:[0-9]+: ERROR: Tag (.+) invalid$/)
+      unless matches.nil?
+        tagName = matches[1]
+        return false if (internal_tags + html5_tags + whitelisted_tags).include? tagName
+        return (if Context.element_types[tagName].nil? then true else false end)
+      end
+      return false if error.message.end_with?("ERROR: htmlParseEntityRef: no name") ||
+                      error.message.end_with?("ERROR: Expected a doctype token$")
+      true
+    end
+
+    def generate
+      src = File.read @filepath
+      src.gsub! /<template/i,  "<html"
+      src.gsub! /<\/template/i, "</html>"
+
+      document = Nokogiri::HTML.parse(src) do |config| config.strict end
+      
+      html = document.xpath("html").first
+      head = document.xpath("//head")
+      body = document.xpath("//body")
+      raise LoadError.new "could not load html template `#{@filepath}`" if html.nil?
+      raise LoadError.new "missing body element in `#{@filepath}`" if body.first.nil?
+
+      Context.reset
+      Context.filename = @filepath
+      if !@config.nil? && !@config["elements"].nil?
+        Context.load_global_element_types @config["elements"]
+      end
+      
+      load_includes head
+      
+      fatal_error = nil
+      document.errors.each do |error|
+        if is_error_fatal? error
+          puts "[comet-html] #{@filepath}:#{error.line}:#{error.column}: #{error.message}"
+          fatal_error ||= error
+          error_count += 1
+        end
+      end
+      raise HtmlParseError.new fatal_error unless fatal_error.nil?
+
+      main_element = Comet::Class.new body
+      main_element.typename = if html["classname"].nil?
+        File.basename(@filepath, ".html").to_s.camelize
+      else
+        html["classname"]
+      end
+      main_element.superclass = html["extends"] unless html["extends"].nil?
+      main_element.probe
+
+      main_element.inline_code = ""
+      head.css("script").each do |script|
+        main_element.inline_code += script.text.strip + "\n"
+      end
+
+      head.css("attribute").each do |attribute|
+        main_element.refs << (CppReference.new attribute, attribute["type"], attribute["name"], attribute["value"])
+      end
+
+      define_name = "__COMET_CUSTOM_ELEMENT_#{main_element.typename.upcase}__"
+      header_code = ""
+      source_code = ""
+      Context.classes.reverse.each do |object|
+        next if object.should_skip?
+        header_code += HeaderGenerator.new(object).generate + "\n"
+        source_code += SourceGenerator.new(object).generate + "\n"
+      end
+
+      includes_str = prepare_includes head
+      
+      header = <<HEADER
+#ifndef  #{define_name}
+# define #{define_name}
+
+# include <comet/bindable.hpp>
+# include <comet/repeater.hpp>
+# include <comet/slot_element.hpp>
+# include <comet/comment_element.hpp>
+# include <comet/custom_element.hpp>
+# include <comet/signal.hpp>
+#{includes_str}
+
+namespace HtmlTemplate
+{
+#{append_classes_predeclaration}
+#{header_code}
+}
+
+#endif
+HEADER
+
+      source = <<SOURCE
+#include <comet/lexical_cast.hpp>
+#include "#{compiled_header_path}"
+
+#{source_code}
+SOURCE
+
+      { header: header, source: source }
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+module Comet
+  class HeaderGenerator
+    attr_reader :object, :source
+
+    def initialize object
+      @object = object
+    end
+    
+    def indent
+      "      "
+    end
+
+    def signaler_definition
+      return "" if object.implements_ibindable_view?
+      # Signaler def. Must be a reference if the object isn't the root object
+      signaler_type  = "Comet::Signal<std::string>"
+      signaler_type += "&" unless object.parent.nil?
+      "#{signaler_type} signaler;"
+    end
+    
+    def bound_attributes_definition
+      return "" if object.implements_ibindable_view?
+      "Comet::BoundAttributes bound_attributes;"
+    end
+    
+    def generate_getters_setters
+      result = ""
+      object.refs.each do |ref|
+        is_ptr = ref.type.end_with? '*'
+        if ref.has_getter?
+          if is_ptr
+            result += indent + "#{ref.type} get_#{ref.name}() const { return #{ref.name}; }\n"
+          else
+            result += indent + "const #{ref.type}& get_#{ref.name}() const { return #{ref.name}; }\n"
+          end
+        end
+        if ref.has_setter?
+          if is_ptr
+            result += indent + "virtual void set_#{ref.name}(#{ref.type} __v) { #{ref.name} = __v; }\n"
+          else
+            result += indent + "virtual void set_#{ref.name}(const #{ref.type}& __v) { #{ref.name} = __v; }\n"
+          end
+        end
+      end
+      result
+    end
+    
+    def generate_anchors
+      result = ""
+      anchor_count = 0
+      object.collect_children.each do |child|
+        if child.is_anchorable?
+          anchor_count += 1
+          child.anchor_name = "anchor_#{anchor_count}"
+          result += indent + "Comet::CommentElement #{child.anchor_name};\n"
+        end
+      end
+      result
+    end
+    
+    def friends_def
+      result = ""
+      object.context.classes.each do |klass|
+        result += indent + "friend class #{klass.typename};\n" unless klass == object
+      end
+      result
+    end
+
+    def generate_properties
+      protected_properties_def = ""
+      public_properties_def    = ""
+      private_properties_def   = ""
+      if object.is_root?
+        protected_properties_def += indent + "#{object.typename}* root;\n"
+      else
+        public_properties_def  += indent + "#{object.parent.typename}* parent;\n"
+        protected_properties_def += indent + "#{object.root.typename}* root;\n"
+      end
+      object.refs.each do |ref|
+        suffix = " = #{ref.default_value}" if ref.has_default_value?
+        if ref.is_explicit?
+          protected_properties_def += indent + "#{ref.type} #{ref.name}#{suffix};\n"
+        elsif ref.is_implicit?
+          private_properties_def   += indent + "#{ref.type} #{ref.name}#{suffix};\n"
+        end
+      end
+      ## BEGIN Repeaters
+      object.repeaters.each do |repeater|
+        protected_properties_def += indent + "Comet::Repeater<#{repeater.list_type}, #{repeater.typename}> #{repeater.repeater_name};\n" 
+      end
+      if object.class == Repeater
+        public_properties_def += indent + "#{object.value_type} #{object.value_name};\n"
+      end
+      ## END Repeaters
+      ## BEGIN SLOTS
+      # Slots emanate from the root object.
+      if object.is_root?
+        all_slots = object.slots
+        object.recursively_collect_children.each do |child|
+          all_slots += child.slots
+        end
+        all_slots.each do |slot|
+          public_properties_def += indent + "Comet::SlotElement #{slot.slot_ref};\n"
+        end
+      else
+        object.slots.each do |slot|
+          public_properties_def += indent + "Comet::SlotElement& #{slot.slot_ref};\n"
+        end
+      end
+      ## END SLOTS
+      [public_properties_def, protected_properties_def, private_properties_def]
+    end
+
+    def generate
+      anchors_def = generate_anchors
+      public_properties_def, protected_properties_def, private_properties_def = generate_properties
+
+<<HEADER
+    class #{object.typename} : public #{object.superclass}
+    {
+#{friends_def}
+    protected:
+      #{bound_attributes_definition}
+#{protected_properties_def}
+    private:
+#{anchors_def}
+#{private_properties_def}
+    public:
+      #{signaler_definition}
+#{public_properties_def}
+
+      #{object.constructor_decl}
+      virtual ~#{object.typename}() {}
+
+      void bind_attributes();
+      void trigger_binding_updates();
+      
+#{generate_getters_setters}
+
+      #{object.inline_code}
+    };
+HEADER
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'comet-html/utils'
+
+module Comet  
+  class EventListener
+    attr_reader :el, :attribute_name, :code, :is_cpp
+
+    def initialize el, parent, key, value
+      @el             = el
+      @parent         = parent
+      @is_cpp         = key.start_with?("cpp::")
+      @attribute_name = key.delete_suffix(".trigger")
+      @attribute_name = @attribute_name[5..-1] if is_cpp
+      @code           = value
+
+      if @parent.find_reference_for(el).nil?
+        @parent.refs << (Reference.new(el, @parent))
+      end
+    end
+  end
+
+  class Binding
+    attr_reader :el, :attribute_name, :is_cpp, :bind_mode, :code
+    
+    def initialize el, parent, key, value
+      @el     = el
+      @parent = parent
+
+      @attribute_name   = key.delete_suffix(".bind")
+      @is_cpp           = attribute_name.start_with?("cpp::")
+      @attribute_name   = attribute_name[5..-1] if is_cpp
+      @code, @bind_mode = extract_bind_mode_from value
+
+      if @parent.find_reference_for(el).nil?
+        @parent.refs << (Reference.new(el, @parent))
+      end
+    end
+    
+    def binds_to_cpp_property?
+      @is_cpp
+    end
+  end
+end