ruflet_rails 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58ab2a08d2694662952c449f89a6c539e01ad118ea38db22eb90b9eb13b4c16a
-  data.tar.gz: bd95c4b9e1c9794a263ca29d429e035492de1a99148e6f5b5574d085493a3aa7
+  metadata.gz: 91f92e0fef72cbb500ba43ac12d81590bac485bb9cf4642c93563aab2736811f
+  data.tar.gz: 609e6b2720465ca414898482223d561d264ddca837d717e07a2b54c1f874df6f
 SHA512:
-  metadata.gz: d0275388d9faf332d9e6bb84ab629f9fab542133c94c6231e9518bf4b1ffdeb6fdc73519ca9ef861fe1224d5e4e34dafa0ac750d333942ee7b75e9a502d92f70
-  data.tar.gz: 2653405372a6c783e7996390d8254ae17e7dce914a2066839a1fb924f81c282fca75074a72cdf7094bca2269627b5933d1151149ee9a4218931b4ca0ce2e9b1a
+  metadata.gz: 1f9e56edf7b86fccf776d7bfc8ee630ce501f42fde7854a9bb4f660a31ef85dfbe0e1a50ebe7a5c09dfe307e80eb88ca561a77d69777006a00810c34770dbba5
+  data.tar.gz: 23792bdae076841ddc0ed099475a25ab4bfd0240a244e90a0d71eb3d011c11c8e67e5610102bf8475a86e35dae2ea2aac6c8f58d1b75c1a8bf23ddf9682da60e

data/README.md

@@ -9,26 +9,62 @@ No separate protocol gem is required.
 
 ```ruby
 # Gemfile
-gem "ruflet_rails", ">= 0.0.4"
+gem "ruflet_rails", ">= 0.0.5"
 ```
 
-```ruby
-# app/mobile/main.rb
-require "ruflet"
+## Install into Rails
 
-class MyApp < Ruflet::App
-  def view(page)
-    page.title = "Hello"
-    page.add(text(value: "Hello Ruflet"))
-  end
-end
+```bash
+bin/rails generate ruflet:install
+```
 
-MyApp.new.run
+This generator will:
+- create `app/mobile/main.rb`
+- create `ruflet.yaml`
+- add the Ruflet mount route to `config/routes.rb`
+- copy/configure `ruflet_client` when the template is available locally
+
+Generated `ruflet.yaml`:
+
+```yaml
+app:
+  name: My App
+  ruflet_client_url: ""
+
+services: []
+
+assets:
+  splash_screen: assets/splash.png
+  icon_launcher: assets/icon.png
 ```
 
+For Rails apps, those asset paths are resolved from `app/assets/` during build.
+
+## Build client from Rails
+
+Uses the same build pipeline as `ruflet build`:
+
+```bash
+bundle exec rake ruflet:build[web]
+bundle exec rake ruflet:build[macos]
+bundle exec rake ruflet:build[windows]
+bundle exec rake ruflet:build[linux]
+bundle exec rake ruflet:build[apk]
+bundle exec rake ruflet:build[android]
+bundle exec rake ruflet:build[ios]
+bundle exec rake ruflet:build[aab]
+```
+
+## Manual usage
+
 ```ruby
-# config/routes.rb
-mount Ruflet::Rails.mobile(Rails.root.join("app/mobile/main.rb")), at: "/ws"
+# app/mobile/main.rb
+require "ruflet"
+
+Ruflet.run do |page|
+  page.title = "Hello"
+  page.add(text("Hello Ruflet"))
+end
 ```
 
 Connect mobile to Rails base URL, e.g. `http://10.0.2.2:3000`.

data/lib/generators/ruflet/install/install_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "ruflet/rails/install_support"
+
+module Ruflet
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc "Install Ruflet into a Rails app."
+
+      def create_mobile_entrypoint
+        target = File.join(destination_root, "app/mobile/main.rb")
+        return if File.exist?(target)
+
+        FileUtils.mkdir_p(File.dirname(target))
+        File.write(
+          target,
+          Ruflet::Rails::InstallSupport.default_mobile_app_template(app_title: app_name)
+        )
+      end
+
+      def create_ruflet_yaml
+        target = File.join(destination_root, "ruflet.yaml")
+        return if File.exist?(target)
+
+        File.write(
+          target,
+          Ruflet::Rails::InstallSupport.default_ruflet_yaml(app_name: app_name)
+        )
+      end
+
+      def copy_client_template
+        copied = Ruflet::Rails::InstallSupport.copy_ruflet_client_template(destination_root)
+        say_status(:warn, "ruflet_client template not found; add it manually before building", :yellow) unless copied
+      end
+
+      def configure_client_template
+        Ruflet::Rails::InstallSupport.configure_ruflet_client(destination_root)
+      end
+
+      def add_routes
+        target = File.join(destination_root, "config/routes.rb")
+        return unless File.file?(target)
+
+        route = Ruflet::Rails::InstallSupport.route_snippet
+        return if File.read(target).include?(route)
+
+        insert_into_file target, "  #{route}\n", after: /Rails\.application\.routes\.draw do\s*\n/
+      end
+
+      def print_install_status
+        say "ruflet.yaml generated"
+      end
+
+      private
+
+      def app_name
+        File.basename(destination_root).gsub(/[_-]+/, " ").split.map(&:capitalize).join(" ")
+      end
+    end
+  end
+end

data/lib/ruflet/rails/install_support.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+module Ruflet
+  module Rails
+    module InstallSupport
+      CLIENT_EXTENSION_MAP = {
+        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "flet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "flet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "flet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "flet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "flet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "flet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "flet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "flet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "flet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
+        "video" => { package: "flet_video", alias: "ruflet_video" },
+        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+      }.freeze
+
+      module_function
+
+      def default_mobile_app_template(app_title:)
+        <<~RUBY
+          require "ruflet"
+
+          Ruflet.run do |page|
+            page.title = #{app_title.inspect}
+            count = 0
+            count_text = text(count.to_s, size: 40)
+
+            page.add(
+              container(
+                expand: true,
+                alignment: Ruflet::MainAxisAlignment::CENTER,
+                content: column(
+                  alignment: Ruflet::MainAxisAlignment::CENTER,
+                  horizontal_alignment: Ruflet::CrossAxisAlignment::CENTER,
+                  children: [
+                    text("You have pushed the button this many times:"),
+                    count_text
+                  ]
+                )
+              ),
+              floating_action_button: fab(
+                icon: Ruflet::MaterialIcons::ADD,
+                on_click: ->(_e) do
+                  count += 1
+                  page.update(count_text, value: count.to_s)
+                end
+              )
+            )
+          end
+        RUBY
+      end
+
+      def default_ruflet_yaml(app_name:)
+        <<~YAML
+          app:
+            name: #{app_name}
+            ruflet_client_url: ""
+
+          services: []
+
+          assets:
+            splash_screen: assets/splash.png
+            icon_launcher: assets/icon.png
+        YAML
+      end
+
+      def route_snippet(entrypoint: "app/mobile/main.rb", mount_path: "/ws")
+        %(mount Ruflet::Rails.mobile(Rails.root.join("#{entrypoint}")), at: "#{mount_path}")
+      end
+
+      def client_template_root
+        env = ENV["RUFLET_CLIENT_TEMPLATE_DIR"].to_s.strip
+        return env if !env.empty? && Dir.exist?(env)
+
+        candidates = [
+          File.expand_path("../../../../../ruflet_client", __dir__),
+          File.expand_path("../../../../../templates/ruflet_flutter_template", __dir__)
+        ]
+        candidates.find { |path| Dir.exist?(path) }
+      end
+
+      def copy_ruflet_client_template(root)
+        template_root = client_template_root
+        return false unless template_root
+
+        target = File.join(root, "ruflet_client")
+        return true if Dir.exist?(target)
+
+        FileUtils.cp_r(template_root, target)
+        prune_client_template(target)
+        true
+      end
+
+      def prune_client_template(target)
+        %w[
+          .dart_tool
+          .idea
+          build
+          ios/Pods
+          ios/.symlinks
+          ios/Podfile.lock
+          macos/Pods
+          macos/Podfile.lock
+          android/.gradle
+          android/.kotlin
+          android/local.properties
+        ].each do |path|
+          full = File.join(target, path)
+          FileUtils.rm_rf(full) if File.exist?(full)
+        end
+      end
+
+      def configure_ruflet_client(root)
+        config_path = File.join(root, "ruflet.yaml")
+        return unless File.file?(config_path)
+
+        config = YAML.safe_load(File.read(config_path), aliases: true) || {}
+        extension_keys = Array(config["services"]).map { |v| normalize_extension_key(v) }.compact.uniq
+        extension_packages = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:package) }.uniq
+        extension_aliases = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:alias) }.uniq
+
+        client_dir = File.join(root, "ruflet_client")
+        return unless Dir.exist?(client_dir)
+
+        prune_client_pubspec(File.join(client_dir, "pubspec.yaml"), extension_packages)
+        prune_client_main(File.join(client_dir, "lib", "main.dart"), extension_aliases)
+      end
+
+      def normalize_extension_key(value)
+        key = value.to_s.strip.downcase
+        return nil if key.empty?
+
+        key.tr!("-", "_")
+        key.gsub!(/\A(flet_)+/, "")
+        key.gsub!(/\Aservice_/, "")
+        key.gsub!(/\Acontrol_/, "")
+        key = "file_picker" if key == "filepicker"
+        key
+      end
+
+      def prune_client_pubspec(path, selected_packages)
+        return unless File.file?(path)
+
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        deps = (data["dependencies"] || {}).dup
+        deps.keys.each do |name|
+          next unless name.start_with?("flet_")
+          next if name == "flet"
+          next if selected_packages.include?(name)
+
+          deps.delete(name)
+        end
+        data["dependencies"] = deps
+        File.write(path, YAML.dump(data))
+      end
+
+      def prune_client_main(path, selected_aliases)
+        return unless File.file?(path)
+
+        lines = File.readlines(path)
+        alias_to_package = {}
+
+        lines.each do |line|
+          match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          alias_to_package[match[2]] = match[1] if match
+        end
+
+        kept = lines.select do |line|
+          import_match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          if import_match
+            package_name = import_match[1]
+            next true if package_name == "flet"
+            next true if selected_aliases.include?(import_match[2])
+            next false
+          end
+
+          extension_match = line.match(/\A\s*([a-zA-Z0-9_]+)\.Extension\(\),\s*\z/)
+          if extension_match
+            extension_alias = extension_match[1]
+            package_name = alias_to_package[extension_alias]
+            next true if package_name.nil?
+            next true if selected_aliases.include?(extension_alias)
+            next false
+          end
+
+          true
+        end
+
+        File.write(path, kept.join)
+      end
+    end
+  end
+end

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

@@ -50,7 +50,7 @@ module Ruflet
           when Ruflet::Protocol::ACTIONS[:update_control], Ruflet::Protocol::ACTIONS[:update_control_props]
             on_update_control(ws, payload)
           when Ruflet::Protocol::ACTIONS[:invoke_control_method]
-            nil
+            on_invoke_control_method(ws, payload)
           else
             raise "Unknown action: #{action.inspect}"
           end
@@ -144,6 +144,11 @@ module Ruflet
           page.apply_client_update(update["id"], update["props"] || {})
         end
 
+        def on_invoke_control_method(ws, payload)
+          page = fetch_page(ws)
+          page.handle_invoke_method_result(Ruflet::Protocol.normalize_invoke_method_result_payload(payload))
+        end
+
         def fetch_page(ws)
           page = @sessions_mutex.synchronize { @sessions[ws.session_key] }
           raise "Session not found" unless page

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

@@ -18,7 +18,7 @@ module Ruflet
             when Float
               "\xcb".b + [value].pack("G")
             when String
-              pack_string(value)
+              binary_string?(value) ? pack_binary(value) : pack_string(value)
             when Symbol
               pack_string(value.to_s)
             when Array
@@ -71,6 +71,23 @@ module Ruflet
             end
           end
 
+          def pack_binary(value)
+            bytes = value.to_s.b
+            len = bytes.bytesize
+
+            if len <= 0xff
+              "\xc4".b + [len].pack("C") + bytes
+            elsif len <= 0xffff
+              "\xc5".b + [len].pack("n") + bytes
+            else
+              "\xc6".b + [len].pack("N") + bytes
+            end
+          end
+
+          def binary_string?(value)
+            value.encoding == Encoding::BINARY || !value.valid_encoding?
+          end
+
           def pack_array(value)
             len = value.length
             head =
@@ -130,10 +147,23 @@ module Ruflet
             when 0xd9 then reader.read_string(reader.read_u8)
             when 0xda then reader.read_string(reader.read_u16)
             when 0xdb then reader.read_string(reader.read_u32)
+            when 0xc4 then reader.read_binary(reader.read_u8)
+            when 0xc5 then reader.read_binary(reader.read_u16)
+            when 0xc6 then reader.read_binary(reader.read_u32)
             when 0xdc then read_array(reader, reader.read_u16)
             when 0xdd then read_array(reader, reader.read_u32)
             when 0xde then read_map(reader, reader.read_u16)
             when 0xdf then read_map(reader, reader.read_u32)
+            when 0xd4
+              read_ext(reader, 1)
+            when 0xd5
+              read_ext(reader, 2)
+            when 0xd6
+              read_ext(reader, 4)
+            when 0xd7
+              read_ext(reader, 8)
+            when 0xd8
+              read_ext(reader, 16)
             when 0xc7
               read_ext(reader, reader.read_u8)
             when 0xc8
@@ -167,8 +197,17 @@ module Ruflet
           end
 
           def read_ext(reader, size)
-            reader.read_i8
-            reader.read_exact(size)
+            type = reader.read_i8
+            data = reader.read_exact(size)
+
+            case type
+            when 1, 2, 4
+              data.dup.force_encoding("UTF-8")
+            when 3
+              data.to_i
+            else
+              data
+            end
           end
         end
 
@@ -204,6 +243,7 @@ module Ruflet
           def read_f32 = read_exact(4).unpack1("g")
           def read_f64 = read_exact(8).unpack1("G")
           def read_string(size) = read_exact(size).force_encoding("UTF-8")
+          def read_binary(size) = read_exact(size)
         end
       end
     end

data/lib/ruflet/rails/railtie.rb

@@ -6,6 +6,25 @@ module Ruflet
       initializer "ruflet_rails.middleware" do |app|
         app.middleware.use Ruflet::Rails::Protocol::Middleware
       end
+
+      rake_tasks do
+        namespace :ruflet do
+          desc "Build Ruflet client for this Rails app. Usage: rake ruflet:build[web]"
+          task :build, [:platform] do |_task, args|
+            platform = args[:platform].to_s.strip
+            if platform.empty?
+              warn "Usage: rake ruflet:build[apk|android|ios|aab|web|macos|windows|linux]"
+              next
+            end
+
+            require "ruflet/cli"
+            exit_code = Dir.chdir(::Rails.root) do
+              Ruflet::CLI.command_build([platform])
+            end
+            raise SystemExit, exit_code unless exit_code.to_i.zero?
+          end
+        end
+      end
     end
   end
 end

data/lib/ruflet/version.rb

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

data/lib/ruflet_rails.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-local_ruflet_lib = File.expand_path("../../ruflet/lib", __dir__)
-if File.directory?(local_ruflet_lib) && !$LOAD_PATH.include?(local_ruflet_lib)
-  $LOAD_PATH.unshift(local_ruflet_lib)
+%w[ruflet_core ruflet].reverse_each do |package|
+  local_package_lib = File.expand_path("../../#{package}/lib", __dir__)
+  if File.directory?(local_package_lib) && !$LOAD_PATH.include?(local_package_lib)
+    $LOAD_PATH.unshift(local_package_lib)
+  end
 end
 
-require "ruflet"
+require "ruflet_core"
 require_relative "ruflet/rails/protocol"
+require_relative "ruflet/rails/install_support"
 require_relative "ruflet/rails"
 
 if defined?(::Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - AdamMusa
@@ -27,16 +27,30 @@ dependencies:
   name: ruflet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.13
+- !ruby/object:Gem::Dependency
+  name: ruflet_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.13
 description: Rails-first integration package for mounting Ruflet mobile apps in Rails
   routes.
 email:
@@ -46,7 +60,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/generators/ruflet/install/install_generator.rb
 - lib/ruflet/rails.rb
+- lib/ruflet/rails/install_support.rb
 - lib/ruflet/rails/protocol.rb
 - lib/ruflet/rails/protocol/context.rb
 - lib/ruflet/rails/protocol/endpoint.rb