ruflet_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e4e545e3193b769addf80f3ec9f7a902fefed5ecaab529bc34b718d66d683679
+  data.tar.gz: f9011791ffdff4236321fd0ea0df09acd688a999a3d8612c06aa5acdddcbf0af
+SHA512:
+  metadata.gz: 8dcaf1e929c4707fd9ca238332f558408d7016900de561fb8cbcbeaefcddae07fa0808b64861bc3ef5efdecbaed208f9153390ab59db0910788f7f231556a0ff
+  data.tar.gz: 8a2218ad72419c96bc5b03dca4e41938aac900c7dd70afb7f639159682e38ded805e81aa0f8dd3d3488d3cd8d76fafb58ebcd4ea07ff85fed2827762d1bdd89c

data/README.md

@@ -0,0 +1,36 @@
+# Ruflet Rails
+
+`ruflet_rails` is the Rails-first integration package for Ruflet.
+
+Internal Rails transport/protocol code is bundled inside this gem as `Ruflet::Rails::Protocol`.
+No separate protocol gem is required.
+
+## Usage
+
+```ruby
+# Gemfile
+path "/path/to/ruflet/packages" do
+  gem "ruflet_rails"
+end
+```
+
+```ruby
+# app/mobile/main.rb
+require "ruflet"
+
+class MyApp < Ruflet::App
+  def view(page)
+    page.title = "Hello"
+    page.add(page.text(value: "Hello Ruflet"))
+  end
+end
+
+MyApp.new.run
+```
+
+```ruby
+# config/routes.rb
+mount Ruflet::Rails.mobile(Rails.root.join("app/mobile/main.rb")), at: "/ws"
+```
+
+Connect mobile to Rails base URL, e.g. `http://10.0.2.2:3000`.

data/lib/ruflet/rails/protocol/context.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      module Context
+        THREAD_KEY = :ruflet_rails_env
+
+        module_function
+
+        def current_env
+          Thread.current[THREAD_KEY]
+        end
+
+        def with_env(env)
+          previous = Thread.current[THREAD_KEY]
+          Thread.current[THREAD_KEY] = env
+          yield
+        ensure
+          Thread.current[THREAD_KEY] = previous
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol/endpoint.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module Ruflet
+  module Rails
+    module Protocol
+      class Endpoint
+        WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+        def initialize(server:, path: "/ws")
+          @server = server
+          @path = path
+        end
+
+        def call(env)
+          return not_found unless env["PATH_INFO"] == @path
+          return bad_request("Expected WebSocket upgrade") unless websocket_upgrade_request?(env)
+
+          hijack = env["rack.hijack"]
+          return bad_request("Rack hijack is required by Ruflet::Rails::Protocol::Endpoint") unless hijack.respond_to?(:call)
+
+          hijack.call
+          io = env["rack.hijack_io"]
+          return bad_request("Rack did not provide hijacked IO") unless io
+
+          io.sync = true if io.respond_to?(:sync=)
+          write_handshake(io, env["HTTP_SEC_WEBSOCKET_KEY"])
+
+          captured_env = env.dup
+          Thread.new(io, captured_env) do |socket, ws_env|
+            Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+            Context.with_env(ws_env) do
+              @server.handle_upgraded_socket(socket)
+            end
+          end
+
+          [-1, {}, []]
+        rescue StandardError => e
+          [500, { "content-type" => "text/plain" }, ["Ruflet Rails protocol error: #{e.message}"]]
+        end
+
+        private
+
+        def websocket_upgrade_request?(env)
+          return false unless env["REQUEST_METHOD"] == "GET"
+
+          upgrade = env["HTTP_UPGRADE"].to_s.downcase
+          connection = env["HTTP_CONNECTION"].to_s.downcase
+          key = env["HTTP_SEC_WEBSOCKET_KEY"].to_s
+
+          upgrade == "websocket" && connection.include?("upgrade") && !key.empty?
+        end
+
+        def write_handshake(io, key)
+          accept = [Digest::SHA1.digest("#{key}#{WEBSOCKET_GUID}")].pack("m0")
+
+          io.write("HTTP/1.1 101 Switching Protocols\r\n")
+          io.write("Upgrade: websocket\r\n")
+          io.write("Connection: Upgrade\r\n")
+          io.write("Sec-WebSocket-Accept: #{accept}\r\n")
+          io.write("\r\n")
+        end
+
+        def not_found
+          [404, { "content-type" => "text/plain" }, ["Not Found"]]
+        end
+
+        def bad_request(message)
+          [400, { "content-type" => "text/plain" }, [message]]
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol/middleware.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          Context.with_env(env) { @app.call(env) }
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol/mobile_loader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class MobileLoader
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def load!
+          absolute = File.expand_path(@file_path)
+          raise ArgumentError, "Mobile file not found: #{absolute}" unless File.file?(absolute)
+
+          captured_entrypoint = nil
+          interceptor = lambda do |entrypoint:, **_kwargs|
+            captured_entrypoint = entrypoint
+            :captured
+          end
+
+          Ruflet.with_run_interceptor(interceptor) do
+            Kernel.load(absolute)
+          end
+
+          raise ArgumentError, "No Ruflet app boot found in #{absolute}. Expected MyApp.new.run" unless captured_entrypoint
+
+          { entrypoint: captured_entrypoint }
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol/mount.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class Mount
+        def initialize(app, file_path:, path: "/ws")
+          @app = app
+          @path = path
+          @endpoint = Runner.new.build_mobile_endpoint(file_path: file_path, path: "/")
+        end
+
+        def call(env)
+          return @app.call(env) unless env["PATH_INFO"] == @path
+
+          mounted_env = env.dup
+          mounted_env["PATH_INFO"] = "/"
+          @endpoint.call(mounted_env)
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol/runner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class Runner
+        def initialize(&entrypoint)
+          @entrypoint = entrypoint
+        end
+
+        def build_endpoint(path: "/")
+          raise ArgumentError, "Ruflet::Rails::Protocol endpoint requires a block" unless @entrypoint.respond_to?(:call)
+
+          Endpoint.new(server: build_server(@entrypoint), path: path)
+        end
+
+        def build_mobile_endpoint(file_path:, path: "/")
+          loaded = MobileLoader.new(file_path).load!
+          Endpoint.new(server: build_server(loaded[:entrypoint]), path: path)
+        end
+
+        private
+
+        def build_server(entrypoint)
+          Ruflet::Server.new do |page|
+            env = Context.current_env
+            if entrypoint.arity == 1
+              entrypoint.call(page)
+            else
+              entrypoint.call(page, env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "protocol/context"
+require_relative "protocol/middleware"
+require_relative "protocol/endpoint"
+require_relative "protocol/mobile_loader"
+require_relative "protocol/runner"
+require_relative "protocol/mount"

data/lib/ruflet/rails/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "ruflet_rails.middleware" do |app|
+        app.middleware.use Ruflet::Rails::Protocol::Middleware
+      end
+    end
+  end
+end

data/lib/ruflet/rails.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module_function
+
+    # Mount inside Rails routes; route "at:" controls URL path.
+    def endpoint(&block)
+      Protocol::Runner.new(&block).build_endpoint
+    end
+
+    # Load app/mobile/main.rb (MyApp.new.run) and mount it in Rails routes.
+    def mobile(file_path)
+      Protocol::Runner.new.build_mobile_endpoint(file_path: file_path)
+    end
+  end
+end

data/lib/ruflet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ruflet
+  VERSION = "0.0.1" unless const_defined?(:VERSION)
+end

data/lib/ruflet_rails.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "ruflet"
+require_relative "ruflet/rails/protocol"
+require_relative "ruflet/rails"
+
+if defined?(::Rails::Railtie)
+  require_relative "ruflet/rails/railtie"
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ruflet_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- AdamMusa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: ruflet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: Rails-first integration package for mounting Ruflet mobile apps in Rails
+  routes.
+email:
+- adammusa2222@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ruflet/rails.rb
+- lib/ruflet/rails/protocol.rb
+- lib/ruflet/rails/protocol/context.rb
+- lib/ruflet/rails/protocol/endpoint.rb
+- lib/ruflet/rails/protocol/middleware.rb
+- lib/ruflet/rails/protocol/mobile_loader.rb
+- lib/ruflet/rails/protocol/mount.rb
+- lib/ruflet/rails/protocol/runner.rb
+- lib/ruflet/rails/railtie.rb
+- lib/ruflet/version.rb
+- lib/ruflet_rails.rb
+homepage: https://github.com/AdamMusa/Ruflet
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Rails integration for Ruflet.
+test_files: []