interfacets 0.1.0 → 0.9.9

data/lib/interfacets/client/utils/active_support_concern.rb

@@ -0,0 +1,220 @@
+# rubocop:disable all
+
+module ActiveSupport
+  # = Active Support \Concern
+  #
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using +ActiveSupport::Concern+ the above module could instead be
+  # written as:
+  #
+  #   # require "active_support/concern"
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With +ActiveSupport::Concern+,
+  # module dependencies are properly resolved:
+  #
+  #   # require "active_support/concern"
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  #
+  # === Prepending concerns
+  #
+  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
+  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
+  # prepended as well.
+  #
+  # <tt>prepend</tt> is also used for any dependencies.
+  module Concern
+    class MultipleIncludedBlocks < StandardError # :nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    class MultiplePrependBlocks < StandardError # :nodoc:
+      def initialize
+        super "Cannot define multiple 'prepended' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) # :nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base) # :nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.include(dep) }
+        Interfacets::Client::Assets.loader.load(self)
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def prepend_features(base) # :nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies).unshift self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.prepend(dep) }
+        super
+        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
+      end
+    end
+
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +included+ block, it raises an exception.
+    def included(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_included_block)
+          if @_included_block.source_location != block.source_location
+            raise MultipleIncludedBlocks
+          end
+        else
+          @_included_block = block
+        end
+      else
+        super
+      end
+    end
+
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +prepended+ block, it raises an exception.
+    def prepended(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_prepended_block)
+          if @_prepended_block.source_location != block.source_location
+            raise MultiplePrependBlocks
+          end
+        else
+          @_prepended_block = block
+        end
+      else
+        super
+      end
+    end
+
+    # Define class methods from given block.
+    # You can define private class methods as well.
+    #
+    #   module Example
+    #     extend ActiveSupport::Concern
+    #
+    #     class_methods do
+    #       def foo; puts 'foo'; end
+    #
+    #       private
+    #         def bar; puts 'bar'; end
+    #     end
+    #   end
+    #
+    #   class Buzz
+    #     include Example
+    #   end
+    #
+    #   Buzz.foo # => "foo"
+    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end
+
+# rubocop:enable all

data/lib/interfacets/client/utils/mruby_patches.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Utils
+      module MrubyPatches
+        module HashExt
+          NO_DEFAULT = Object.new
+
+          def fetch(k, default = NO_DEFAULT)
+            if key?(k)
+              self[k]
+            elsif block_given?
+              yield
+            elsif default == NO_DEFAULT
+              raise("#{k} not found in #{inspect}")
+            else
+              default
+            end
+          end
+        end
+
+        module InspectPatch
+          def inspect(...)
+            "<#{self.class}:#{self.object_id}>"
+          end
+        end
+
+        module ArrayPatch
+          def index_by
+            raise(ArgumentError) unless block_given?
+
+            result = {}
+            each { |elem| result[yield(elem)] = elem }
+            result
+          end
+        end
+
+        module ObjectPresence
+          def blank?
+            false
+          end
+
+          def present?
+            !blank?
+          end
+        end
+
+        module EnumerablePresence
+          def blank?
+            empty?
+          end
+        end
+
+        module FalsyPresence
+          def blank?
+            true
+          end
+        end
+
+        module StringPresence
+          def blank?
+            match?(/^\s*$/)
+          end
+        end
+
+        if RUBY_ENGINE == "mruby"
+          Object.prepend(InspectPatch)
+          Hash.prepend(HashExt)
+          Array.prepend(ArrayPatch)
+
+          Object.include(ObjectPresence)
+          Enumerable.include(EnumerablePresence)
+          NilClass.include(FalsyPresence)
+          FalseClass.include(FalsyPresence)
+          String.include(StringPresence)
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/utils/open_struct.rb

@@ -0,0 +1,102 @@
+# rubocop:disable all
+
+# copied from github
+
+class OpenStruct
+  def initialize hash=nil
+    @table = {}
+    if hash
+      hash.each do |k,v|
+        k = k.to_sym
+        @table[k] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  def initialize_copy orig
+    super
+    @table = @table.dup
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def each_pair
+    return to_enum __method__ unless block_given?
+    @table.each{|p| yield p}
+  end
+
+  def new_ostruct_member name
+    name = name.to_sym
+    unless respond_to?(name)
+      define_singleton_method(name){ @table[name] }
+      define_singleton_method("#{name}=".to_sym){ |x| @table[name] = x }
+    end
+    name
+  end
+  protected :new_ostruct_member
+
+  def inspect
+    str = "#<#{self.class}"
+    ary = []
+    @table.each do |k,v|
+      ary << "#{k}=#{v}"
+    end
+    if 0 < ary.length
+      str << ' '
+      str << ary.join(', ')
+    end
+    str << '>'
+  end
+  alias :to_s :inspect
+
+  def delete_field name
+    sym = name.to_sym
+    singleton_class.__send__ :remove_method, sym, "#{sym}=".to_sym
+    @table.delete sym
+  end
+
+  def == other
+    return false unless other.kind_of?(OpenStruct)
+    @table == other.table
+  end
+
+  def [] key
+    @table[key.to_sym]
+  end
+
+  def []= key, value
+    @table[new_ostruct_member(key)] = value
+  end
+
+  def eql? other
+    return false unless other.kind_of?(OpenStruct)
+    @table.eql?(other.table)
+  end
+
+  def hash
+    @table.hash
+  end
+
+  attr_reader :table
+  protected :table
+
+  def method_missing mid, *args
+    mname = mid.to_s
+    len = args.length
+    if mname.chomp! '='
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)"
+      end
+      @table[new_ostruct_member(mname)] = args[0]
+    elsif len == 0
+      @table[mid]
+    else
+      raise NoMethodError, "undefined method `#{mid}' for #{self}"
+    end
+  end
+end
+# rubocop:enable all

data/lib/interfacets/client/utils/securerandom.rb

@@ -0,0 +1,69 @@
+# rubocop:disable all
+
+if RUBY_ENGINE == "mruby"
+
+class SecureRandom
+  class << self
+    def random_bytes(n=nil)
+      n = n ? n.to_int : 16
+
+      # Need to read more than the number of bytes because sometimes it comes
+      # back as less. Not sure why, but whatever.
+      begin
+        File.open("/dev/urandom", 'r') {|f|
+          ret = f.read(n*2)
+          unless ret.length > n
+            raise NotImplementedError, "Unexpected partial read from random device: only #{ret.length} for #{n} bytes"
+          end
+          return ret[0..n]
+        }
+      rescue
+        raise File::NoFileError, "No random device"
+      end
+
+      raise NotImplementedError, "No random device"
+    end
+
+    def hex(n=nil)
+      random_bytes(n).unpack("H*")[0]
+    end
+
+    def base64(n=nil)
+      [random_bytes(n)].pack("m*").gsub("\n", "")
+    end
+
+    def urlsafe_base64(n=nil, padding=false)
+      s = base64.gsub("+", "-").gsub("/", "_")
+      s.gsub!("=", "") unless padding
+      s
+    end
+
+    def random_number(n=0)
+      if 0 < n
+        hex = n.to_s(16)
+        hex = '0' + hex if (hex.length & 1) == 1
+        bin = [hex].pack("H*")
+        mask = bin[0].ord
+        mask |= mask >> 1
+        mask |= mask >> 2
+        mask |= mask >> 4
+
+        loop do
+          rnd = random_bytes(bin.length)
+          rnd[0] = (rnd[0].ord & mask).chr
+          return rnd.unpack("H*")[0].hex if rnd < bin
+        end
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def uuid
+      ary = random_bytes(16).unpack("nnnnnnnn")
+      ary[3] = (ary[3] & 0x0fff) | 0x4000
+      ary[4] = (ary[4] & 0x3fff) | 0x8000
+      "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % ary
+    end
+  end
+end
+end

data/lib/interfacets/client/view.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class View
+      class Evaluator
+        def self.call(...)
+          new(...).call
+        end
+
+        attr_reader :entity, :channels, :block
+        def initialize(entity:, channels:, block:)
+          @entity = entity
+          @channels = channels
+          @block = block
+          @data = Hash.new { |h, k| h[k] = { streams: {} } }
+        end
+
+        def call
+          instance_exec(entity, &@block)
+        end
+
+        def render(channel_id, stream: "default", &block)
+          channels
+            .fetch(channel_id.to_s)
+            .builder(stream.to_s)
+            .then { instance_exec(_1, &block) }
+        end
+
+        def channel(name)
+          @channels.fetch(name)
+        end
+      end
+
+      class << self
+        def view(&block)
+          @view = block if block_given?
+          @view
+        end
+      end
+
+      def render(entity:, channels:)
+        Evaluator.call(entity: entity, channels:, block: self.class.view)
+      end
+    end
+  end
+end

data/lib/interfacets/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    def self.start(...)
+      @system = System.start(...)
+    end
+
+    def self.system
+      @system
+    end
+  end
+end

data/lib/interfacets/mruby/build.dockerfile

@@ -0,0 +1,66 @@
+FROM emscripten/emsdk:3.1.62
+
+RUN apt update
+RUN apt install -y vim git
+RUN apt install -y ruby
+RUN git clone https://github.com/mruby/mruby.git /home/root/interfacets/mruby
+WORKDIR /home/root/interfacets/mruby
+# RUN git fetch origin master && git reset --hard origin/master
+RUN git fetch origin --tags && git reset --hard 3.4.0
+RUN rake all test
+ENV PATH="/home/root/interfacets/mruby/bin:${PATH}"
+COPY ./lib/interfacets/mruby/build_config.rb \
+  /home/root/interfacets/
+WORKDIR /home/root/interfacets
+RUN cd mruby && \
+  sed -i '/MRB_STR_LENGTH_MAX 1048576/c#define MRB_STR_LENGTH_MAX 0' src/string.c && \
+  MRUBY_CONFIG=../build_config.rb rake
+RUN mkdir -p assets/mruby build
+RUN cp -r mruby/include assets/mruby \
+  && cp mruby/build/emscripten/lib/libmruby.a assets/mruby
+COPY ./lib/interfacets/mruby/init.c \
+  ./lib/interfacets/mruby/entrypoint.rb \
+  /home/root/interfacets/
+# RUN mrbc --help
+RUN mrbc -B ruby_app -o build/app.c entrypoint.rb
+RUN echo "\n" >> build/app.c && cat init.c >> build/app.c
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=web \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -s SINGLE_FILE=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/ruby.js
+
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  # -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=node \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s SIDE_MODULE=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/test.wasm
+
+RUN emcc \
+  -s EXPORT_NAME=MRuby \
+  -s EXPORTED_FUNCTIONS='_ruby_eval,_main,_ruby_call,stringToNewUTF8' \
+  -s ENVIRONMENT=node \
+  -s MODULARIZE=1 \
+  -s EXPORT_ES6=1 \
+  -s MAIN_MODULE=1 \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -I ./assets/mruby/include \
+  build/app.c \
+  ./assets/mruby/libmruby.a \
+  -o build/test.js
+
+RUN mv build /build

data/lib/interfacets/mruby/build_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+MRuby::Build.new do |conf|
+  toolchain :gcc
+  conf.gembox("full-core")
+end
+
+MRuby::CrossBuild.new("emscripten") do |conf|
+  toolchain :clang
+  conf.gembox("full-core")
+  conf.cc.command = "emcc"
+  conf.cc.flags = ["-Os", "-fPIC"]
+  conf.linker.command = "emcc"
+  conf.archiver.command = "emar"
+
+  conf.gem(github: "mattn/mruby-json")
+  conf.gem(github: "mattn/mruby-base64")
+  conf.gem(github: "monochromegane/mruby-secure-random")
+  conf.gem(github: "iij/mruby-regexp-pcre")
+end

data/lib/interfacets/mruby/entrypoint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kernel
+  def wrapped_eval(str, path)
+    eval(str, binding, path)
+  rescue StandardError, SyntaxError => e
+    $stderr.puts(e.class)
+    $stderr.puts(e.message)
+    $stderr.puts(e.backtrace.join("\n"))
+  end
+
+  def wrapped_call(json_string)
+    spec = JSON.parse(json_string)
+    eval(spec.fetch("receiver")).send(
+      spec.fetch("method"),
+      *spec.fetch("args", []),
+    )
+  rescue StandardError, SyntaxError => e
+    $stderr.puts(e.class)
+    $stderr.puts(e.message)
+    $stderr.puts(e.backtrace.join("\n"))
+  end
+end

data/lib/interfacets/mruby/init.c

@@ -0,0 +1,66 @@
+#include <mruby.h>
+#include <mruby/irep.h>
+#include <emscripten.h>
+
+mrb_value js_eval(mrb_state* mrb, mrb_value self)
+{
+  char *js_code;
+  mrb_get_args(mrb, "z", &js_code);
+  emscripten_run_script(js_code);
+  return self;
+}
+
+mrb_state *mrb;
+void EMSCRIPTEN_KEEPALIVE ruby_eval(char* str, char* path) {
+  int ai = mrb_gc_arena_save(mrb);
+  mrb_funcall(
+    mrb,
+    mrb_top_self(mrb),
+    "wrapped_eval",
+    2,
+    mrb_str_new_cstr(mrb, str),
+    mrb_str_new_cstr(mrb, path)
+  );
+
+  if (mrb->exc) mrb_print_error(mrb);
+  mrb_gc_arena_restore(mrb, ai);
+}
+
+// json of the form:
+// {receiver: , method:, args: [ ...] ]
+void EMSCRIPTEN_KEEPALIVE ruby_call(char* json) {
+  int ai = mrb_gc_arena_save(mrb);
+
+  mrb_funcall(
+    mrb,
+    mrb_top_self(mrb),
+    "wrapped_call",
+    1,
+    mrb_str_new_cstr(mrb, json)
+  );
+
+  if (mrb->exc) mrb_print_error(mrb);
+  mrb_gc_arena_restore(mrb, ai);
+}
+
+int main() {
+  // Leave this open for all eternity
+  mrb = mrb_open();
+
+  if (!mrb) { /* handle error */ }
+
+  mrb_define_method(
+    mrb,
+    mrb->kernel_module,
+    "js_eval",
+    js_eval,
+    MRB_ARGS_REQ(1)
+  );
+
+  mrb_load_irep(mrb, ruby_app);
+
+  // If an exception, print error
+  if (mrb->exc) mrb_print_error(mrb);
+
+  return 0;
+}