comet-cpp 0.9.0

data/vendor/src/router_base.hpp

@@ -0,0 +1,107 @@
+#ifndef  ROUTER_BASE_HPP
+# define ROUTER_BASE_HPP
+
+# include <functional>
+# include <vector>
+# include <string>
+# define ROUTER_PARAM_PATTERN "[a-zA-Z0-9_-]*"
+# include "object.hpp"
+
+namespace Comet
+{
+  template<typename PARAMS, typename ACTION>
+  class RouterBase
+  {
+  public:
+    typedef ACTION Action;
+    typedef Comet::ObjectImpl<client::RegExp> JsRegExp;
+
+    struct Item
+    {
+      Item() : regexp(new client::RegExp("")) {}
+
+      Action                   run;
+      std::string              method;
+      std::string              regexp_src, regexp_original;
+      JsRegExp                 regexp;
+      std::vector<std::string> param_names;
+    };
+
+    typedef std::vector<Item> Items;
+
+    const Action* get_action(const std::string& method, const std::string& uri, PARAMS& query_params) const
+    {
+      using namespace std;
+      Comet::String js_uri(uri);
+
+      for (const Item& item : routes)
+      {
+        bool does_match = item.regexp->test(*js_uri);
+
+        if (does_match)
+        {
+          auto matches = Comet::Object(js_uri->match(*item.regexp)).to_vector<std::string>();
+
+          for (unsigned short i = 1 ; i < matches.size() ; ++i)
+          {
+            const string& param_name  = item.param_names[i - 1];
+            const string& param_value = matches[i];
+
+            query_params[param_name] = param_value;
+          }
+          return &(item.run);
+        }
+      }
+      return 0;
+    }
+
+    void      match(const std::string& route, Action callback)
+    {
+      match("", route, callback);
+    }
+
+    void      match(const std::string& method, const std::string& route, Action callback)
+    {
+      Item item;
+
+      item_initialize_regex(item, '^' + route + '$');
+      item.method = method;
+      item.run    = callback;
+      routes.push_back(item);
+    }
+
+  private:
+    void      item_initialize_regex(Item& item, const std::string& route)
+    {
+      using namespace std;
+      string   find_params_str(':' + std::string(ROUTER_PARAM_PATTERN));
+      JsRegExp find_params(new client::RegExp(find_params_str.c_str(), "g"));
+      string   regexified_route;
+      auto     matches = Comet::Object(
+        Comet::String(route)->match(*find_params)
+      ).to_vector<string>();
+      size_t   last_position = 0;
+
+      for (unsigned short i = 0 ; i < matches.size() ; ++i)
+      {
+        const string& match = matches[i];
+        size_t match_position = route.find(match);
+
+        regexified_route += route.substr(last_position, match_position - last_position);
+        regexified_route  = regexified_route + '(' + ROUTER_PARAM_PATTERN + ')';
+        item.param_names.push_back(route.substr(match_position + 1, match.length() - 1));
+        last_position = match_position + match.length();
+      }
+      regexified_route += route.substr(last_position);
+      item.regexp_src = regexified_route;
+      item.regexp_original = route;
+      item.regexp = new client::RegExp(regexified_route.c_str());
+    }
+
+  public:
+    Items routes;
+  };
+}
+
+#endif
+

data/vendor/src/signal.hpp

@@ -0,0 +1,150 @@
+#ifndef  COMET_SIGNAL_HPP
+# define COMET_SIGNAL_HPP
+
+# include <map>
+# include <vector>
+
+namespace Comet
+{
+  class ISignal
+  {
+  public:
+    virtual void disconnect(unsigned long) = 0;
+  private:
+  };
+
+  class Listener
+  {
+  public:
+    virtual ~Listener()
+    {
+      stop_listening();
+    }
+
+    template<typename SIGNAL>
+    void listen_to(SIGNAL& signal, typename SIGNAL::Callback callback)
+    {
+      unsigned long id = signal.connect(callback);
+
+      connections.push_back(std::pair<ISignal*,unsigned long>(&signal, id));
+    }
+
+    void stop_listening(ISignal* ptr = 0)
+    {
+      for (auto it = connections.begin() ; it != connections.end() ;)
+      {
+        if (ptr == 0 || it->first == ptr)
+        {
+          it->first->disconnect(it->second);
+          it = connections.erase(it);
+        }
+        else
+          it++;
+      }
+    }
+
+  private:
+    std::vector<std::pair<ISignal*,unsigned long> > connections;
+  };
+
+  template<typename ...Args>
+  class Signal : public ISignal
+  {
+    friend class Listener;
+    typedef std::function<void (Args...)> Callback;
+  public:
+    Signal() : listener_i(0)
+    {
+    }
+
+    Signal(const Signal& cpy) : listener_i(0)
+    {
+    }
+
+    Signal& operator=(const Signal& cpy)
+    {
+      return *this;
+    }
+
+    void trigger(Args... args)
+    {
+      for (auto slot : callbacks)
+        slot.second(args...);
+    }
+
+    unsigned long connect(Callback callback)
+    {
+      callbacks.insert(std::pair<unsigned long, Callback>(listener_i, callback));
+      listener_i++;
+      return listener_i - 1;
+    }
+
+    void disconnect(unsigned long i)
+    {
+      for (auto it = callbacks.begin() ; it != callbacks.end() ; ++it)
+      {
+        if (it->first == i)
+        {
+          callbacks.erase(it);
+          break ;
+        }
+      }
+    }
+
+  private:
+    int listener_i;
+    std::map<unsigned long, Callback> callbacks;
+  };
+
+  template<>
+  class Signal<void> : public ISignal
+  {
+    friend class Listener;
+    typedef std::function<void (void)> Callback;
+  public:
+    Signal() : listener_i(0)
+    {
+    }
+
+    Signal(const Signal& cpy) : listener_i(0)
+    {
+    }
+
+    Signal& operator=(const Signal& cpy)
+    {
+      return *this;
+    }
+
+    void trigger()
+    {
+      for (auto slot : callbacks)
+        slot.second();
+    }
+
+    unsigned long connect(Callback callback)
+    {
+      callbacks.insert(std::pair<unsigned long, Callback>(listener_i, callback));
+      listener_i++;
+      return listener_i - 1;
+    }
+
+    void disconnect(unsigned long i)
+    {
+      for (auto it = callbacks.begin() ; it != callbacks.end() ; ++it)
+      {
+        if (it->first == i)
+        {
+          callbacks.erase(it);
+          break ;
+        }
+      }
+    }
+
+  private:
+    int listener_i;
+    std::map<unsigned long, Callback> callbacks;
+  };
+
+}
+
+#endif

data/vendor/src/slot_element.hpp

@@ -0,0 +1,61 @@
+#ifndef  CRAILS_FRONT_SLOT_ELEMENT_HPP
+# define CRAILS_FRONT_SLOT_ELEMENT_HPP
+
+# include "anchorable_element.hpp"
+# include "bindable.hpp"
+
+namespace Comet
+{
+  class SlotElement : public AnchorableElement
+  {
+    std::shared_ptr<IBindableView> element;
+    IBindableView*                 element_ptr = nullptr;
+
+  public:
+    bool has_element() const
+    {
+      return element_ptr != nullptr;
+    }
+
+    IBindableView* get_element() const
+    {
+      return element_ptr;
+    }
+
+    void attach()
+    {
+      std::vector<Comet::Element*> element_list;
+
+      element_list.push_back(get_element());
+      attach_elements(element_list);
+    }
+
+    void set_element(IBindableView& el)
+    {
+      cleanup();
+      element_ptr = &el;
+      if (is_anchorable())
+        attach();
+    }
+
+    template<typename ELEMENT>
+    void set_element(std::shared_ptr<ELEMENT> pointer)
+    {
+      cleanup();
+      element = std::dynamic_pointer_cast<IBindableView>(pointer);
+      element_ptr = element.get();
+      if (is_anchorable() && has_element())
+        attach();
+    }
+  private:
+    void cleanup()
+    {
+      if (has_element())
+        get_element()->destroy();
+      element = nullptr;
+      element_ptr = nullptr;
+    }
+  };
+}
+
+#endif

data/vendor/src/url.cpp

@@ -0,0 +1,19 @@
+#include "url.hpp"
+#include "globals.hpp"
+
+using namespace std;
+using namespace Comet;
+
+string Url::encode(const string& src)
+{
+  Comet::String js_string(src.c_str());
+
+  return window.apply("encodeURIComponent", js_string);
+}
+
+string Url::decode(const string& src)
+{
+  Comet::String js_string(src.c_str());
+
+  return window.apply("decodeURIComponent", js_string);
+}

data/vendor/src/url.hpp

@@ -0,0 +1,15 @@
+#ifndef  COMET_HTTP_HPP
+# define COMET_HTTP_HPP
+
+# include <string>
+
+namespace Comet
+{
+  namespace Url
+  {
+    std::string encode(const std::string&);
+    std::string decode(const std::string&);
+  }
+}
+
+#endif

data/vendor/src/window.cpp

@@ -0,0 +1,22 @@
+#include "window.hpp"
+#include "globals.hpp"
+
+using namespace Comet;
+using namespace std;
+
+Comet::Window Comet::window;
+
+Window::Window() : ObjectImpl((client::Window*)&client::window), events(make_shared<JavascriptEvents>((client::EventTarget*)&client::window))
+{
+  events->on("resize", [this]() { resized.trigger(); });
+}
+
+void Window::set_timeout(function<void()> callback, double interval) const
+{
+  client::window.setTimeout(cheerp::Callback(callback), interval);
+}
+
+void Window::set_interval(function<void()> callback, double interval) const
+{
+  client::window.setInterval(cheerp::Callback(callback), interval);
+}

data/vendor/src/window.hpp

@@ -0,0 +1,24 @@
+#ifndef  CRAILS_FRONT_WINDOW_HPP
+# define CRAILS_FRONT_WINDOW_HPP
+
+# include "object.hpp"
+# include "signal.hpp"
+# include "events.hpp"
+
+namespace Comet
+{
+  class Window : public ObjectImpl<client::Window>
+  {
+  public:
+    std::shared_ptr<JavascriptEvents> events;
+
+    Signal<void> resized;
+
+    Window();
+
+    void set_timeout(std::function<void()>, double interval) const;
+    void set_interval(std::function<void()>, double interval) const;
+  };
+}
+
+#endif

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: comet-cpp
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Michael Martin Moro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.8
+description: ''
+email: michael@unetresgrossebite.com
+executables:
+- comet-make
+- comet-html
+- comet-new
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/comet-html
+- bin/comet-make
+- bin/comet-new
+- bin/comet-web
+- lib/comet-html/generator.rb
+- lib/comet-html/header-generator.rb
+- lib/comet-html/parser-binding.rb
+- lib/comet-html/parser-class.rb
+- lib/comet-html/parser-context.rb
+- lib/comet-html/parser-reference.rb
+- lib/comet-html/parser-repeater.rb
+- lib/comet-html/parser-slot.rb
+- lib/comet-html/source-generator.rb
+- lib/comet-html/utils.rb
+- lib/guard/comet-html.rb
+- lib/guard/comet.rb
+- vendor/project/Gemfile
+- vendor/project/Guardfile
+- vendor/project/app/application.hpp
+- vendor/project/app/collections/.gitkeep
+- vendor/project/app/controllers/.gitkeep
+- vendor/project/app/main.cpp
+- vendor/project/app/models/.gitkeep
+- vendor/project/app/routes.cpp
+- vendor/project/app/views/layouts/.gitkeep
+- vendor/project/public/index.html
+- vendor/src/anchorable_element.hpp
+- vendor/src/append_semantics.hpp
+- vendor/src/bindable.cpp
+- vendor/src/bindable.hpp
+- vendor/src/cheerp_parse_cookie_values.cpp
+- vendor/src/comment_element.cpp
+- vendor/src/comment_element.hpp
+- vendor/src/cookies.cpp
+- vendor/src/cookies.hpp
+- vendor/src/custom_element.hpp
+- vendor/src/datatree.cpp
+- vendor/src/datatree.hpp
+- vendor/src/document.cpp
+- vendor/src/document.hpp
+- vendor/src/element.cpp
+- vendor/src/element.hpp
+- vendor/src/events.hpp
+- vendor/src/exception.cpp
+- vendor/src/exception.hpp
+- vendor/src/from_string.cpp
+- vendor/src/from_string.hpp
+- vendor/src/globals.cpp
+- vendor/src/globals.hpp
+- vendor/src/http.cpp
+- vendor/src/http.hpp
+- vendor/src/lexical_cast.hpp
+- vendor/src/local_storage.cpp
+- vendor/src/local_storage.hpp
+- vendor/src/mvc/collection.hpp
+- vendor/src/mvc/controller.hpp
+- vendor/src/mvc/id_type.hpp
+- vendor/src/mvc/layout.hpp
+- vendor/src/mvc/model.cpp
+- vendor/src/mvc/model.hpp
+- vendor/src/object.cpp
+- vendor/src/object.hpp
+- vendor/src/parse_cookie_values.hpp
+- vendor/src/promise.cpp
+- vendor/src/promise.hpp
+- vendor/src/repeater.hpp
+- vendor/src/router.cpp
+- vendor/src/router.hpp
+- vendor/src/router_base.hpp
+- vendor/src/signal.hpp
+- vendor/src/slot_element.hpp
+- vendor/src/url.cpp
+- vendor/src/url.hpp
+- vendor/src/window.cpp
+- vendor/src/window.hpp
+homepage: https://github.com/crails-framework/comet-cpp
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Comet.cpp is a JavaScript client framework
+test_files: []