interfacets 0.1.0 → 0.9.99

data/lib/interfacets/client/channels/url.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class Url
+        include Channels::Base
+
+        type("interfacets:url")
+
+        class Builder
+          attr_reader :state
+          def initialize
+            @state = {}
+          end
+
+          def path(path, query: {})
+            state[:urlSpec] = {
+              url: (
+                System
+                  .current_bus
+                  .url_for(path)
+              ),
+              queryParams: query,
+            }
+          end
+
+          def redirect(url, query: {})
+            @redirected = true
+            state[:redirectUrlSpec] = { url:, query: }
+          end
+
+          def redirected?
+            @redirected
+          end
+        end
+
+        def prepare(entity)
+          @builder ||= Builder.new
+        end
+
+        def builder(stream = "default")
+          @builder
+        end
+
+        def result
+          { streams: { default: @builder.state } }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Config
+      attr_accessor(
+        :mount_point,
+        :root_url
+      )
+
+      def url_for(path:)
+        [
+          root_url,
+          mount_point,
+          path,
+        ]
+          .map { _1.sub(%r{/$}, "").sub(%r{^/}, "") }
+          .join("/")
+      end
+    end
+  end
+end

data/lib/interfacets/client/delegator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    # alias: CrappyDelegator
+    class Delegator
+      def initialize(obj)
+        @__obj__ = obj
+      end
+
+      def __getobj__
+        @__obj__
+      end
+
+      def respond_to_missing?(...)
+        @__obj__.send(:respond_to_missing?, ...)
+      end
+
+      def method_missing(method, *a, **p, &)
+        @__obj__.send(method, *a, **p, &)
+      end
+
+      # delegation helpers
+      def inspect
+        [self.class.name, __getobj__.inspect].join(" -> ")
+      end
+
+      def to_s
+        inspect
+      end
+
+      def presence
+        self
+      end
+    end
+  end
+end

data/lib/interfacets/client/registry.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Registry
+      def initialize
+        @stores = {}
+      end
+
+      def build(name, id)
+        entity = Object.const_get(name).client_entity_class
+
+        @stores[id] ||= entity.store.new
+
+        entity.new(
+          store: @stores[id],
+          parent: nil,
+          nesting: ["root"]
+        )
+      end
+    end
+  end
+end

data/lib/interfacets/client/system.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class System
+      module Transmit
+        def self.call(data)
+          Kernel.js_eval("self.rubyEvent(#{data.to_json})")
+        end
+      end
+
+      class << self
+        attr_accessor(
+          :current_bus,
+          :logger,
+        )
+
+        def logger
+          @logger ||= InterfacetsLogger.main
+        end
+
+        def start(transmit: Transmit)
+          @instance = new(transmit)
+        end
+      end
+
+      attr_accessor :transmit
+      def initialize(transmit)
+        @transmit = transmit
+      end
+
+      def handle(event)
+        if event.fetch("type") == "interfacets:system:create_bus"
+          create_bus(event.fetch("payload"))
+        else
+          bus_id = event.dig("destination", "bus")
+          raise("unknown event: #{event.inspect}") unless bus_id
+
+          System.current_bus = bus_registry.fetch(bus_id)
+          payload = System.current_bus.handle(event)
+
+          transmit.(
+            {
+              type: "interfacets:system:render",
+              payload:,
+            },
+          )
+        end
+      ensure
+        GC.start
+      end
+
+      # private
+
+      def config
+        @config ||= Config.new
+      end
+
+      def create_bus(payload)
+        id = payload.fetch("id")
+        hydration_event = payload.fetch("hydration")
+
+        channel_ids = payload.fetch("channel_ids")
+
+        Bus.new(
+          id:,
+          channels: [
+            Channels::Api.new(id: "interfacets:api"),
+            Channels::React::Channel.new(id: "dom"),
+            Channels::Url.new(id: "url"),
+            (Channels::SpeechToText.new(id: "speechToText") if channel_ids.include?("speechToText")),
+            (Channels::Timer.new(id: "timer") if channel_ids.include?("timer")),
+            (Channels::Audio.new(id: "audio") if channel_ids.include?("audio")),
+          ].compact,
+          root_url: payload.fetch("config").fetch("root_url"),
+        ).tap do
+          bus_registry[id] = _1
+        end
+
+        handle(hydration_event)
+      end
+
+      def bus_registry
+        @bus_registry ||= {}
+      end
+    end
+  end
+end

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(/\A\s*\z/)
+          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,115 @@
+# rubocop:disable all
+
+# copied from github
+
+required = (
+  begin
+    require "ostruct"
+    true
+  rescue
+    false
+  end
+)
+
+unless required
+
+
+  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
+end

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