fluid_cli 0.1.2

data/lib/fluid_cli/theme/presenters/theme_presenter.rb

@@ -0,0 +1,49 @@
+
+require "forwardable"
+
+module FluidCLI
+  module Theme
+    module Presenters
+      class ThemePresenter
+        extend Forwardable
+
+        COLOR_BY_STATUS = {
+          "active" => "green",
+          "draft" => "yellow",
+          "development" => "blue",
+        }
+
+        attr_reader :theme
+
+        def_delegators :theme, :id, :name, :status
+
+        def initialize(theme)
+          @theme = theme
+        end
+
+        def to_s(mode = :long)
+          case mode
+          when :short
+            "{{bold:#{name}}}"
+          when :long
+            "{{green:##{id}}} {{bold:#{name}}}"
+          else
+            inspect
+          end
+        end
+
+        private
+
+        def theme_tags
+          tags = ["{{#{tag_color}:[#{status}]}}"]
+          tags << "{{cyan:[yours]}}}}" if theme.current_development?
+          tags.join(" ")
+        end
+
+        def tag_color
+          COLOR_BY_STATUS[status] || "italic"
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/presenters/themes_presenter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "theme_presenter"
+
+module FluidCLI
+  module Theme
+    module Presenters
+      class ThemesPresenter
+        SUPPORTED_STATUSES = %w(active draft development)
+
+        def initialize(ctx, root)
+          @ctx = ctx
+          @root = root
+        end
+
+        def all
+          all_themes
+            .select { |theme| SUPPORTED_STATUSES.include?(theme.status) }
+            .sort_by { |theme| SUPPORTED_STATUSES.index(theme.status) }
+            .map { |theme| ThemePresenter.new(theme) }
+        end
+
+        private
+
+        def all_themes
+          FluidCLI::Theme::Theme.all(@ctx, root: @root)
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/root.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require_relative "file"
+require "pathname"
+
+module FluidCLI
+  module Theme
+    class Root
+      attr_reader :root, :ctx
+
+      def initialize(ctx, root:)
+        @ctx = ctx
+        @root = Pathname.new(root) if root
+      end
+
+      def static_asset_files
+        glob("assets/*", raise_on_dir: true)
+      end
+
+      def liquid_files
+        glob("**/*.liquid")
+      end
+
+      def json_files
+        glob("**/*.json")
+      end
+
+      def glob(pattern, raise_on_dir: false)
+        root
+          .glob(pattern)
+          .select { |path| file?(path, raise_on_dir) }
+          .map { |path| File.new(path, root) }
+      end
+
+      def static_asset_file?(file)
+        static_asset_files.include?(self[file])
+      end
+
+      def static_asset_paths
+        static_asset_files.map(&:relative_path)
+      end
+
+      def [](file)
+        case file
+        when File
+          file
+        when Pathname
+          File.new(file, root)
+        when String
+          File.new(root.join(file), root)
+        end
+      end
+
+      def file?(path, raise_on_dir = false)
+        if raise_on_dir && ::File.directory?(path)
+          @ctx.abort(@ctx.message("theme.serve.error.invalid_subdirectory", path.to_s))
+        end
+
+        ::File.file?(path)
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/checksums.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Checksums
+        def initialize(theme)
+          @theme = theme
+          @checksum_by_key = {}
+
+          # Mutex used to coordinate changes in the checksums (shared accross `Syncer` threads)
+          @checksums_mutex = Mutex.new
+        end
+
+        def has?(file)
+          checksum_by_key.key?(to_key(file))
+        end
+
+        def file_has_changed?(file)
+          file.checksum != checksum_by_key[file.relative_path]
+        end
+
+        def delete(file)
+          checksums_mutex.synchronize do
+            checksum_by_key.delete(to_key(file))
+          end
+        end
+
+        def keys
+          checksum_by_key.keys
+        end
+
+        def [](key)
+          checksum_by_key[key]
+        end
+
+        def []=(key, value)
+          checksums_mutex.synchronize do
+            checksum_by_key[key] = value
+          end
+        end
+
+        # Generate .liquid asset files are reported twice in checksum:
+        # once of generated, once for .liquid. We only keep the .liquid, that's the one we have
+        # on disk.
+        def reject_duplicated_checksums!
+          checksums_mutex.synchronize do
+            checksum_by_key.reject! { |key, _| checksum_by_key.key?("#{key}.liquid") }
+          end
+        end
+
+        private
+
+        def to_key(file)
+          theme[file].relative_path
+        end
+
+        # Private getters only used in unit tests
+
+        attr_reader :checksum_by_key
+        attr_reader :theme
+        attr_reader :checksums_mutex
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/downloader.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Downloader
+        extend Forwardable
+
+        attr_reader :syncer, :ctx
+
+        def_delegators :syncer,
+          :ctx,
+          :checksums,
+          :get_theme_resources!,
+          :wait!
+
+        def initialize(syncer, delete, &update_progress_bar_block)
+          @syncer = syncer
+          @delete = delete
+          @update_progress_bar_block = update_progress_bar_block
+        end
+
+        def download!
+          get_theme_resources!
+
+          if delete_local_files?
+            to_be_deleted.each { |file| delete(file) }
+          end
+          wait!(&@update_progress_bar_block)
+        end
+
+        private
+
+        def delete(file)
+          ctx.debug("[#{self.class}] rm #{file.relative_path}")
+          file.delete
+        end
+
+        def delete_local_files?
+          @delete
+        end
+
+        def to_be_deleted
+          @to_be_deleted ||= syncer
+            .theme
+            .theme_files
+            .reject { |file| checksums.has?(file) }.uniq
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/error_reporter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      ##
+      # FluidCLI::Theme::Syncer::ErrorReporter allows delaying log of errors,
+      # mainly to not break the progress bar.
+      #
+      class ErrorReporter
+        attr_reader :ctx, :delayed_errors
+
+        def initialize(ctx)
+          @ctx = ctx
+          @has_any_error = false
+          @delay_errors = false
+          @delayed_errors = []
+        end
+
+        def disable!
+          @delay_errors = true
+        end
+
+        def enable!
+          @delay_errors = false
+          @delayed_errors.each { |error| report(error) }
+          @delayed_errors.clear
+        end
+
+        def report(error_message)
+          if @delay_errors
+            @delayed_errors << error_message
+          else
+            @has_any_error = true
+            @ctx.error(error_message)
+          end
+        end
+
+        def has_any_error?
+          @has_any_error
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/merger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Merger
+        class << self
+          ##
+          # Merge `theme_file` with the `new_content` by relying on the union merge
+          #
+          def union_merge(theme_file, new_content)
+            git_merge(theme_file, new_content, ["--union", "-p"])
+          end
+
+          private
+
+          ##
+          # Merge theme file (`FluidCLI::Theme::File`) with a new content (String),
+          # by creating a temporary file based on the `new_content`.
+          #
+          def git_merge(theme_file, new_content, opts)
+            remote_file = create_tmp_file(tmp_file_name(theme_file), new_content)
+            empty_file = create_tmp_file("empty")
+
+            FluidCLI::Git.merge_file(
+              theme_file.absolute_path,
+              empty_file.path,
+              remote_file.path,
+              opts
+            )
+          ensure
+            # Remove temporary files on Windows as well
+            remote_file.close!
+            empty_file.close!
+          end
+
+          def create_tmp_file(basename, content = "")
+            tmp_file = Tempfile.new(basename)
+            tmp_file.write(content)
+            tmp_file.close # Make it ready to merge
+            tmp_file
+          end
+
+          def tmp_file_name(ref_file)
+            "fluid-cli-merge-#{ref_file.name(".*")}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/operation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Operation
+        attr_accessor :method, :file, :options
+
+        COLOR_BY_STATUS = {
+          error: :red,
+          synced: :green,
+          warning: :yellow,
+          fixed: :cyan,
+        }
+
+        def initialize(ctx, method, file, options = {})
+          @ctx = ctx
+          @method = method
+          @file = file
+          @options = options
+        end
+
+        def to_s
+          "#{method} #{file_path}"
+        end
+
+        def as_error_message
+          as_message_with(status: :error)
+        end
+
+        def as_synced_message(color: :green)
+          as_message_with(status: :synced, color: color)
+        end
+
+        def as_fix_message
+          as_message_with(status: :fixed)
+        end
+
+        def file_path
+          file&.relative_path
+        end
+
+        private
+
+        def as_message_with(status:, color: nil)
+          color ||= COLOR_BY_STATUS[status]
+          text = "#{status.to_s.capitalize}"
+
+          "#{timestamp} {{#{color}:#{text}}} {{>}} {{blue:#{self}}}"
+        end
+
+        def timestamp
+          Time.now.strftime("%T")
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/standard_reporter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      ##
+      # FluidCLI::Theme::Syncer::StdReporter allows disabling/enabling
+      # messages reported in the standard error output (FluidCLI::Context#puts).
+      #
+      class StandardReporter
+        attr_reader :ctx
+
+        def initialize(ctx)
+          @enabled = true
+          @ctx = ctx
+        end
+
+        def disable!
+          @enabled = false
+        end
+
+        def enable!
+          @enabled = true
+        end
+
+        def report(message)
+          ctx.error(message) if @enabled
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/unsupported_script_warning.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class UnsupportedScriptWarning
+        attr_reader :ctx
+
+        def initialize(ctx, file)
+          @ctx = ctx
+          @file = file
+        end
+
+        def to_s
+          "\n\n#{occurrences} #{long_text}"
+        end
+
+        private
+
+        def occurrences
+          warnings.map { |w| occurrence(w) }.join("\n")
+        end
+
+        def occurrence(warning)
+          line_number = "{{blue: #{warning.line} |}}"
+          pointer = pointer_message(warning)
+
+          <<~OCCURRENCE
+            #{line_number} #{warning.line_content}
+            #{pointer}
+          OCCURRENCE
+        end
+
+        def long_text
+          lines_and_columns = warnings.map do |warning|
+            message("line_and_column", warning.line, warning.column)
+          end
+
+          message("unsupported_script_text", lines_and_columns.join)
+            .split("\n")
+            .reduce("") do |text, line|
+              # Add indentation in the long text to improve readability
+              line = " #{line}"
+
+              # Inline yellow (otherwise `CLI::UI::Frame` breaks multiline formatting)
+              line = "{{yellow:#{line}}}"
+
+              "#{text}#{line}\n"
+            end
+        end
+
+        def pointer_message(warning)
+          padding = warning.column + warning.line.to_s.size + 2
+          text = message("unsupported_script")
+
+          "{{yellow:#{" " * padding} ^ {{bold:#{text}}}}}"
+        end
+
+        def message(*args)
+          key = args.shift
+          @ctx.message("theme.serve.syncer.warnings.#{key}", *args)
+        end
+
+        def warnings
+          @warnings ||= @file.warnings.map { |w| Warning.new(@file, w) }
+        end
+
+        class Warning
+          attr_reader :line, :column
+
+          def initialize(file, warning_hash)
+            @file = file
+            @line = warning_hash["line"].to_i
+            @column = warning_hash["column"].to_i
+          end
+
+          def line_content
+            file_lines[line - 1]
+          end
+
+          private
+
+          def file_lines
+            @file_lines ||= @file.read.split("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/forms/apply_to_all.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "apply_to_all_form"
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class ApplyToAll
+            attr_reader :value
+
+            def initialize(ctx, number_of_files)
+              @ctx = ctx
+              @number_of_files = number_of_files
+              @value = nil
+              @apply = nil
+            end
+
+            def apply?(value)
+              return unless @number_of_files > 1
+
+              if @apply.nil?
+                @apply = ask.apply?
+                @value = value if @apply
+              end
+
+              @apply
+            end
+
+            private
+
+            def ask
+              ApplyToAllForm.ask(@ctx, [], number_of_files: @number_of_files)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/forms/apply_to_all_form.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class ApplyToAllForm < FluidCLI::Form
+            attr_accessor :apply
+            flag_arguments :number_of_files
+
+            def ask
+              title = message("title", number_of_files - 1)
+
+              self.apply = CLI::UI::Prompt.ask(title, allow_empty: false) do |handler|
+                handler.option(message("yes")) { true }
+                handler.option(message("no")) { false }
+              end
+
+              self
+            end
+
+            def apply?
+              apply
+            end
+
+            private
+
+            def message(key, *params)
+              ctx.message("theme.serve.syncer.forms.apply_to_all.#{key}", *params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/syncer/uploader/forms/base_strategy_form.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class BaseStrategyForm < FluidCLI::Form
+            attr_accessor :strategy
+
+            def ask
+              ctx.puts(title_context(file))
+
+              self.strategy = CLI::UI::Prompt.ask(title_question, allow_empty: false) do |handler|
+                strategies.each do |strategy|
+                  handler.option(as_text(strategy)) { strategy }
+                end
+              end
+
+              exit_cli if self.strategy == :exit
+
+              self
+            end
+
+            protected
+
+            ##
+            # List of strategies that populate the form options
+            #
+            def strategies
+              raise "`#{self.class.name}#strategies' must be defined"
+            end
+
+            ##
+            # Message prefix for the form title and options (strategies).
+            # See the methods `title` and `as_text`
+            #
+            def prefix
+              raise "`#{self.class.name}#prefix' must be defined"
+            end
+
+            private
+
+            def exit_cli
+              exit(0)
+            end
+
+            def title_context(file)
+              ctx.message("#{prefix}.title_context", file.relative_path)
+            end
+
+            def title_question
+              ctx.message("#{prefix}.title_question")
+            end
+
+            def as_text(strategy)
+              ctx.message("#{prefix}.#{strategy}")
+            end
+          end
+        end
+      end
+    end
+  end
+end