fluid_cli 0.1.2

data/lib/fluid_cli/theme/dev_server/web_server.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "stringio"
+
+module FluidCLI
+  module Theme
+    class DevServer
+      # WEBrick will sometimes cause a fatal deadlock error on shutdown.
+      # The error happens because `Thread#join` is called without a timeout argument.
+      # We monkey-patch WEBrick to call `Thread#join(timeout)` before the existing
+      # `Thread#join`.
+      module WEBrickGenericServerThreadJoinWithTimeout
+        # Hook into a method called right before the threads are shutdown.
+        def cleanup_listener
+          # Force a Thread#join with a timeout to prevent any deadlock error on stop
+          Thread.list.each do |thread|
+            next unless thread[:WEBrickThread]
+            thread.join(2)
+            # Prevent the `join` call without a timeout inside WEBrick.
+            thread[:WEBrickThread] = false
+          end
+          super
+        end
+      end
+
+      # Base on Rack::Handler::WEBrick
+      class WebServer < ::WEBrick::HTTPServlet::AbstractServlet
+        def self.run(app, **options)
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : nil
+
+          if !options[:BindAddress] || options[:Host]
+            options[:BindAddress] = options.delete(:Host) || default_host
+          end
+          options[:Port] ||= 8080
+          if options[:SSLEnable]
+            require "webrick/https"
+          end
+
+          @server = ::WEBrick::HTTPServer.new(options)
+          @server.extend(WEBrickGenericServerThreadJoinWithTimeout)
+          @server.mount("/", WebServer, app)
+          yield @server if block_given?
+          @server.start
+        end
+
+        def self.valid_options
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+          {
+            "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+            "Port=PORT" => "Port to listen on (default: 8080)",
+          }
+        end
+
+        def self.shutdown
+          if @server
+            @server.shutdown
+            @server = nil
+          end
+        end
+
+        def initialize(server, app)
+          super(server)
+          @app = app
+        end
+
+        def service(req, res)
+          # res.rack = true
+          env = req.meta_vars
+          env.delete_if { |_k, v| v.nil? }
+
+          rack_input = StringIO.new(req.body.to_s)
+          rack_input.set_encoding(Encoding::BINARY)
+
+          env.update(
+            "rack.version"      => [1, 3],
+            "rack.input"        => rack_input,
+            "rack.errors"       => $stderr,
+            "rack.multithread"  => true,
+            "rack.multiprocess" => false,
+            "rack.run_once"     => false,
+            "rack.url_scheme"   => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http",
+            "rack.hijack?"      => true,
+            "rack.hijack"       => lambda { raise NotImplementedError, "only partial hijack is supported." },
+            "rack.hijack_io"    => nil
+          )
+
+          env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+          env["QUERY_STRING"] ||= ""
+          unless env["PATH_INFO"] == ""
+            path = req.request_uri.path
+            n = env["SCRIPT_NAME"].length
+            env["PATH_INFO"] = path[n, path.length - n]
+          end
+          env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env["PATH_INFO"]].join
+
+          status, headers, body = @app.call(env)
+
+          res.status = status.to_i
+          io_lambda = nil
+          headers.each do |k, vs|
+            if k == "rack.hijack"
+              io_lambda = vs
+            elsif k == "webrick.chunked"
+              res.chunked = true
+            elsif k.downcase == "set-cookie"
+              res.cookies.concat(vs.split("\n"))
+            else
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
+            end
+          end
+
+          if io_lambda
+            rd, wr = IO.pipe
+            res.body = rd
+            res.chunked = true
+            io_lambda.call(wr)
+            body.close if body.respond_to?(:close)
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, "rb")
+            body.close if body.respond_to?(:close)
+          else
+            res.body = lambda do |out|
+              out.set_encoding(Encoding::BINARY) if out.respond_to?(:set_encoding)
+              body.each do |part|
+                out.write(part)
+              end
+              body.close if body.respond_to?(:close)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "singleton"
+
+# require_relative "dev_server/cdn_fonts"
+require_relative "dev_server/certificate_manager"
+require_relative "dev_server/errors"
+require_relative "dev_server/header_hash"
+
+require_relative "dev_server/hot_reload"
+require_relative "dev_server/hot_reload/script_injector"
+require_relative "dev_server/local_assets"
+require_relative "dev_server/proxy_param_builder"
+require_relative "dev_server/proxy"
+require_relative "dev_server/reload_mode"
+require_relative "dev_server/sse"
+require_relative "dev_server/watcher"
+
+require_relative "dev_server/web_server"
+require "fluid_cli/theme/dev_server/hooks/file_change_hook"
+
+require_relative "development_theme"
+require_relative "syncer"
+
+module FluidCLI
+  module Theme
+    class DevServer
+      include Singleton
+
+      attr_reader :app, :stopped, :ctx, :root, :host, :theme_identifier, :port, :poll, :editor_sync, :mode,
+        :block, :includes, :ignores
+
+      class << self
+        def start(
+          ctx,
+          root,
+          host: "127.0.0.1",
+          theme: nil,
+          port: 9292,
+          poll: false,
+          editor_sync: false,
+          overwrite_json: false,
+          mode: ReloadMode.default,
+          includes: nil,
+          ignores: nil,
+          &block
+        )
+          instance.setup(
+            ctx,
+            root,
+            host,
+            theme,
+            port,
+            poll,
+            editor_sync,
+            overwrite_json,
+            mode,
+            includes,
+            ignores,
+            &block
+          )
+          instance.start
+        end
+
+        def stop
+          instance.stop
+        end
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def setup(
+        ctx,
+        root,
+        host,
+        theme_identifier,
+        port,
+        poll,
+        editor_sync,
+        overwrite_json,
+        mode,
+        includes,
+        ignores,
+        &block
+      )
+        @ctx = ctx
+        @root = root
+        @host = host
+        @theme_identifier = theme_identifier
+        @port = port
+        @poll = poll
+        @editor_sync = editor_sync
+        @overwrite_json = overwrite_json
+        @mode = mode
+        @includes = includes
+        @ignores = ignores
+        @block = block
+      end
+
+      def start
+        sync_theme
+
+        # Handle process stop
+        trap("INT") { stop("SIGINT") }
+        trap("TERM") { stop("SIGTERM") }
+
+        # Setup the middleware stack. Mimics Rack::Builder / config.ru, but in reverse order
+        @app = middleware_stack
+
+        # Start development server
+        setup_server
+        start_server
+        teardown_server
+
+      rescue FluidCLI::API::APIRequestForbiddenError,
+             FluidCLI::API::APIRequestUnauthorizedError
+        ctx.abort(ensure_user_message)
+      rescue Errno::EADDRINUSE
+        ctx.abort(port_error_message, port_error_help_message)
+      rescue Errno::EADDRNOTAVAIL
+        ctx.abort(binding_error_message)
+      end
+
+      def stop(signal = nil)
+        ctx.debug(stop_signal(signal)) unless signal.nil?
+
+        @stopped = true
+
+        ctx.puts(stopping_message)
+        app.close
+        WebServer.shutdown
+      end
+
+      private
+
+      def setup_server
+        watcher.start
+      end
+
+      def teardown_server
+        # Use instance variables, so we don't build components
+        # at the teardown phase.
+        @watcher&.stop
+        @syncer&.shutdown
+      end
+
+      def start_server
+        WebServer.run(
+          app,
+          BindAddress: host,
+          Port: port,
+          Logger: logger,
+          AccessLog: [],
+        )
+      end
+
+      def middleware_stack
+        @app = Proxy.new(ctx, theme, param_builder)
+        # @app = LocalAssets.new(ctx, @app, theme)
+        @app = HotReload.new(ctx, @app, broadcast_hooks: broadcast_hooks, watcher: watcher, mode: mode,
+          script_injector: script_injector)
+      end
+
+      def sync_theme
+        CLI::UI::Frame.open(viewing_theme_message) do
+          ctx.print_task(syncing_theme_message)
+          syncer.start_threads
+
+          if block
+            block.call(syncer)
+          else
+            syncer.upload_theme!(delay_low_priority_files: true)
+          end
+
+          return if stopped
+
+          ctx.puts(serving_theme_message)
+          
+          ctx.open_url!(address)
+        end
+      end
+
+      def theme
+        @theme ||= if theme_identifier
+          theme = FluidCLI::Theme::Theme.find_by_identifier(ctx, root: root, identifier: theme_identifier)
+          theme || ctx.abort(not_found_error_message)
+        else
+          DevelopmentTheme.find_or_create!(ctx, root: root)
+        end
+      end
+
+      def syncer
+        @syncer ||= Syncer.new(
+          ctx,
+          theme: theme,
+          overwrite_json: !editor_sync || @overwrite_json
+        )
+      end
+
+      def watcher
+        @watcher ||= Watcher.new(
+          ctx,
+          theme: theme,
+          syncer: syncer,
+          poll: poll
+        )
+      end
+
+      def param_builder
+        @param_builder ||= ProxyParamBuilder
+          .new
+          .with_theme(theme)
+          .with_syncer(syncer)
+      end
+
+      def logger
+        @logger ||= if ctx.debug?
+          WEBrick::Log.new(nil, WEBrick::BasicLog::INFO)
+        else
+          WEBrick::Log.new(nil, WEBrick::BasicLog::FATAL)
+        end
+      end
+
+      # Hooks
+
+      def broadcast_hooks
+        file_handler = Hooks::FileChangeHook.new(ctx, theme: theme)
+        [file_handler]
+      end
+
+      def script_injector
+        HotReload::ScriptInjector.new(ctx, theme: theme)
+      end
+
+      def address
+        @address ||= "http://#{host}:#{port}"
+      end
+
+      # Messages
+
+      def ensure_user_message
+        shop = FluidCLI::AdminAPI.get_shop_or_abort(ctx)
+        "Please ensure you are logged in to #{shop}"
+      end
+
+      def port_error_message
+        "The address #{address} is already in use."
+      end
+
+      def port_error_help_message
+        "Please try a different port."
+      end
+
+      def binding_error_message
+        "There was a binding error in #{FluidCLI::TOOL_NAME}."
+      end
+
+      def viewing_theme_message
+        "Viewing theme #{theme.id} (#{theme.company})"
+      end
+
+      def syncing_theme_message
+        "Syncing theme #{theme.id} (#{theme.company})"
+      end
+
+      def serving_theme_message
+        "Serving theme #{theme.id} (#{theme.company})"
+      end
+
+      def stopping_message
+        "Stopping theme #{theme.id} (#{theme.company})"
+      end
+
+      def stop_signal(signal)
+        "Received stop signal: #{signal}"
+      end
+
+      def not_found_error_message
+        "Theme not found: #{theme_identifier}"
+      end
+
+      def preview_message
+        preview_suffix = editor_sync ? "" : "Please download changes"
+
+        "To customize or preview your theme, visit #{theme.editor_url} or #{theme.preview_url}. #{preview_suffix}"
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/development_theme.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require_relative "theme"
+
+require "socket"
+require "securerandom"
+
+module FluidCLI
+  module Theme
+    API_NAME_LIMIT = 50
+
+    class DevelopmentTheme < Theme
+      def id
+        FluidCLI::DB.get(:development_theme_id)
+      end
+
+      def name
+        existing_name = FluidCLI::DB.get(:development_theme_name)
+        # Up to version 2.3.0 (included) generated names stored locally
+        # could have more than 50 characters and the API rejected them.
+        # This code ensures we update the name for those users to ensure
+        # the name stays under the limit.
+        if existing_name.nil? || existing_name.length > API_NAME_LIMIT
+          generate_theme_name
+        else
+          existing_name
+        end
+      end
+
+      def role
+        "development"
+      end
+
+      def ensure_exists!
+        if exists?
+          @ctx.debug("Using temporary development theme: ##{id} #{name}")
+        else
+          create
+          @ctx.debug("Created temporary development theme: #{@id}")
+          FluidCLI::DB.set(development_theme_id: @id)
+        end
+
+        self
+      end
+
+      def exists?
+        return false unless id
+
+        _status, resp = api_client.get(
+          path: "application_themes/#{id}"
+        )
+      rescue FluidCLI::API::APIRequestNotFoundError
+        false
+      end
+
+      def delete
+        super if exists?
+        FluidCLI::DB.del(:development_theme_id) if FluidCLI::DB.exists?(:development_theme_id)
+        FluidCLI::DB.del(:development_theme_name) if FluidCLI::DB.exists?(:development_theme_name)
+      end
+
+      def self.delete(ctx)
+        new(ctx).delete
+      end
+
+      def self.find(ctx, root: nil)
+        dev_theme = new(ctx, root: root)
+        dev_theme.exists? ? dev_theme : nil
+      end
+
+      def self.find_or_create!(ctx, root: nil)
+        new(ctx, root: root).ensure_exists!
+      end
+
+      private
+
+      def generate_theme_name
+        hostname = Socket.gethostname.split(".").shift
+        hash = SecureRandom.hex(3)
+
+        theme_name = "Development ()"
+        hostname_character_limit = API_NAME_LIMIT - theme_name.length - hash.length - 1
+        identifier = encode_identifier("#{hash}-#{hostname[0, hostname_character_limit]}")
+        theme_name = "Development (#{identifier})"
+
+        FluidCLI::DB.set(development_theme_name: theme_name)
+
+        theme_name
+      end
+
+      ##
+      # In some cases, the identifier string encoding may be obfuscated by the hostname,
+      # which may be an ASCII string.
+      #
+      # This method ensures the result identifier is a UTF-8 valid string.
+      #
+      def encode_identifier(identifier)
+        identifier.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "-")
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/file.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+require_relative "mime_type"
+
+module FluidCLI
+  module Theme
+    class File < Struct.new(:path)
+      attr_accessor :remote_checksum
+      attr_writer :warnings
+
+      def initialize(path, root)
+        super(Pathname.new(path))
+
+        # Path may be relative or absolute depending on the source.
+        # By converting both the path and the root to absolute paths, we
+        # can safely fetch a relative path.
+        @relative_path = self.path.expand_path.relative_path_from(root.expand_path)
+      end
+
+      def read
+        if text?
+          path.read(universal_newline: true)
+        else
+          path.read(mode: "rb")
+        end
+      end
+
+      def write(content)
+        path.parent.mkpath unless path.parent.directory?
+        if text?
+          path.write(content, universal_newline: true)
+        else
+          path.write(content, 0, mode: "wb")
+        end
+      rescue Encoding::UndefinedConversionError
+        ##
+        # The CLI tries to write the file and normalize EOL characters to avoid
+        # errors on Windows when files are shared across different operational systems.
+        #
+        # The CLI fallbacks any error during the conversion by writing the file
+        # in binary mode when the normalization fails (e.g., ASCII files), so no data is lost.
+        #
+        path.write(content, 0, mode: "wb")
+      end
+
+      def delete
+        path.delete
+      end
+
+      def exist?
+        path.exist?
+      end
+
+      def mime_type
+        @mime_type ||= FluidCLI::Theme::MimeType.by_filename(@relative_path)
+      end
+
+      def text?
+        mime_type.text?
+      end
+
+      def liquid?
+        path.extname == ".liquid"
+      end
+
+      def liquid_css?
+        relative_path.end_with?(".css.liquid")
+      end
+
+      def json?
+        path.extname == ".json"
+      end
+
+      def template?
+        relative_path.start_with?("templates/")
+      end
+
+      def checksum
+        content = read
+        Digest::SHA256.hexdigest(content)
+      end
+
+      # Make it possible to check whether a given File is within a list of Files with `include?`,
+      # some of which may be relative paths while others are absolute paths.
+      def ==(other)
+        relative_path == other.relative_path
+      end
+
+      def name(*args)
+        ::File.basename(path, *args)
+      end
+
+      def absolute_path
+        path.realpath.to_s
+      end
+
+      def relative_path
+        @relative_path.to_s
+      end
+
+      def warnings
+        @warnings || []
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/forms/select.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "fluid_cli/theme/presenters/themes_presenter"
+
+module FluidCLI
+  module Theme
+    module Forms
+      class Select < FluidCLI::Form
+        attr_accessor :theme
+        flag_arguments :root, :title, :exclude_roles, :include_foreign_developments, :cmd
+
+        def ask
+          self.theme = CLI::UI::Prompt.ask(title, allow_empty: false) do |handler|
+            theme_presenters.each do |presenter|
+              theme = presenter.theme
+
+              handler.option(presenter.to_s(:short)) { theme }
+            end
+            if handler.options.empty? && cmd
+              @ctx.abort(@ctx.message("theme.#{cmd}.no_themes_error"), @ctx.message("theme.#{cmd}.no_themes_resolution"))
+            end
+          end
+        end
+
+        private
+
+        def theme_presenters
+          FluidCLI::Theme::Presenters::ThemesPresenter.new(ctx, root).all
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/mime_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "webrick"
+
+module FluidCLI
+  module Theme
+    class MimeType < Struct.new(:name)
+      MIME_TYPES = WEBrick::HTTPUtils::DefaultMimeTypes.merge(
+        "liquid" => "text/x-liquid",
+      )
+
+      class << self
+        def by_filename(filename)
+          new(WEBrick::HTTPUtils.mime_type(filename.to_s, MIME_TYPES))
+        end
+      end
+
+      def text?
+        /text/.match?(name) || json? || javascript?
+      end
+
+      def json?
+        name == "application/json"
+      end
+
+      def javascript?
+        name == "application/javascript"
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end