ruflet_rails 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58ab2a08d2694662952c449f89a6c539e01ad118ea38db22eb90b9eb13b4c16a
-  data.tar.gz: bd95c4b9e1c9794a263ca29d429e035492de1a99148e6f5b5574d085493a3aa7
+  metadata.gz: 8ac570f3b6d92f8fc6d21723cc2814c658861c20e8b38d884e389185916d559f
+  data.tar.gz: 02cbfbdc2da5e487af2cd07b2d176066c6a5cd0487a141245ffc84ca0a23ff3f
 SHA512:
-  metadata.gz: d0275388d9faf332d9e6bb84ab629f9fab542133c94c6231e9518bf4b1ffdeb6fdc73519ca9ef861fe1224d5e4e34dafa0ac750d333942ee7b75e9a502d92f70
-  data.tar.gz: 2653405372a6c783e7996390d8254ae17e7dce914a2066839a1fb924f81c282fca75074a72cdf7094bca2269627b5933d1151149ee9a4218931b4ca0ce2e9b1a
+  metadata.gz: de4d8d0a43bda6f2ebbab447c8c25209d44cfabccae8fb584024a355cf1ba464577200737d3cfae692d2e2c52aca294ae13d556de95875dd07d8a407b5a1c8d3
+  data.tar.gz: 1b3a8dd5f338a32c9e91f30a1b0d85cd9618019b2903f931cd27de45cee4717830daeabc44dc6dff01daf9dcf1e503a7bfacff7f8f7f813e4efb06ca6dbb9b02

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/wire_codec.rb

@@ -130,10 +130,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
@@ -204,6 +217,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.6" unless const_defined?(:VERSION)
 end

data/lib/ruflet_rails.rb

@@ -5,8 +5,9 @@ if File.directory?(local_ruflet_lib) && !$LOAD_PATH.include?(local_ruflet_lib)
   $LOAD_PATH.unshift(local_ruflet_lib)
 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.6
 platform: ruby
 authors:
 - AdamMusa
@@ -24,19 +24,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: ruflet
+  name: ruflet_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.11
 description: Rails-first integration package for mounting Ruflet mobile apps in Rails
   routes.
 email:
@@ -46,7 +46,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