textus 0.4.0 → 0.8.0

data/lib/textus/cli/verb/migrate_keys.rb

@@ -0,0 +1,16 @@
+module Textus
+  class CLI
+    class Verb
+      class MigrateKeys < Verb
+        option :write, "--write"
+        option :dry_run, "--dry-run"
+
+        def call(store)
+          effective_write = write && !dry_run
+          res = Textus::MigrateKeys.run(store, write: effective_write || false)
+          emit(res, exit_code: res["ok"] ? 0 : 1)
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/mv.rb

@@ -0,0 +1,17 @@
+module Textus
+  class CLI
+    class Verb
+      class Mv < Verb
+        option :as_flag, "--as=ROLE"
+        option :dry_run, "--dry-run"
+
+        def call(store)
+          old_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
+          new_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
+          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          emit(store.mv(old_key, new_key, as: role, dry_run: dry_run || false))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/published.rb

@@ -0,0 +1,11 @@
+module Textus
+  class CLI
+    class Verb
+      class Published < Verb
+        def call(store)
+          emit({ "published" => store.published })
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/put.rb

@@ -0,0 +1,50 @@
+module Textus
+  class CLI
+    class Verb
+      class Put < Verb
+        option :as_flag, "--as=ROLE"
+        option :use_stdin, "--stdin"
+        option :fetch_name, "--fetch=NAME"
+
+        def call(store) # rubocop:disable Metrics/AbcSize
+          key = positional.shift or raise UsageError.new("put requires a key")
+          raise UsageError.new("put requires --stdin in v1") unless use_stdin
+
+          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
+
+          raw = @stdin.read
+          payload =
+            if fetch_name
+              callable = store.registry.rpc_callable(:fetch, fetch_name)
+              result =
+                begin
+                  Timeout.timeout(Textus::Refresh::FETCH_TIMEOUT_SECONDS) do
+                    callable.call(config: { "bytes" => raw }, store: Textus::Store::View.new(store), args: {})
+                  end
+                rescue Timeout::Error
+                  raise UsageError.new(
+                    "fetch '#{fetch_name}' exceeded #{Textus::Refresh::FETCH_TIMEOUT_SECONDS}s timeout",
+                  )
+                end
+              basename = key.split(".").last
+              {
+                "_meta" => {
+                  "name" => basename,
+                  "last_refreshed_at" => Time.now.utc.iso8601,
+                  "fetched_with" => fetch_name,
+                }.merge(result[:_meta] || result["_meta"] || result[:frontmatter] || result["frontmatter"] || {}),
+                "body" => result[:body] || result["body"] || "",
+              }
+            else
+              JSON.parse(raw)
+            end
+
+          meta = payload["_meta"] || payload["frontmatter"] || {}
+          body = payload["body"] || ""
+          if_etag = payload["if_etag"]
+          emit(store.put(key, meta: meta, body: body, if_etag: if_etag, as: role))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/rdeps.rb

@@ -0,0 +1,12 @@
+module Textus
+  class CLI
+    class Verb
+      class Rdeps < Verb
+        def call(store)
+          key = positional.shift or raise UsageError.new("rdeps requires a key")
+          emit({ "key" => key, "rdeps" => store.rdeps(key) })
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/refresh.rb

@@ -0,0 +1,15 @@
+module Textus
+  class CLI
+    class Verb
+      class Refresh < Verb
+        option :as_flag, "--as=ROLE"
+
+        def call(store)
+          key = positional.shift or raise UsageError.new("refresh requires a key")
+          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          emit(Textus::Refresh.call(store, key, as: role))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/schema.rb

@@ -0,0 +1,12 @@
+module Textus
+  class CLI
+    class Verb
+      class Schema < Verb
+        def call(store)
+          key = positional.shift or raise UsageError.new("schema requires a key")
+          emit(store.schema_envelope(key))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/schema_diff.rb

@@ -0,0 +1,12 @@
+module Textus
+  class CLI
+    class Verb
+      class SchemaDiff < Verb
+        def call(store)
+          name = positional.shift or raise UsageError.new("schema diff NAME")
+          emit(Textus::Schema::Tools.diff(store, name: name))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/schema_init.rb

@@ -0,0 +1,16 @@
+module Textus
+  class CLI
+    class Verb
+      class SchemaInit < Verb
+        option :from_key, "--from=KEY"
+
+        def call(store)
+          name = positional.shift or raise UsageError.new("schema init NAME")
+          raise UsageError.new("schema init requires --from=KEY") unless from_key
+
+          emit(Textus::Schema::Tools.init(store, name: name, from: from_key))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/schema_migrate.rb

@@ -0,0 +1,16 @@
+module Textus
+  class CLI
+    class Verb
+      class SchemaMigrate < Verb
+        option :rename, "--rename=O:N"
+
+        def call(store)
+          name = positional.shift or raise UsageError.new("schema migrate NAME")
+          raise UsageError.new("schema migrate requires --rename=OLD:NEW") unless rename
+
+          emit(Textus::Schema::Tools.migrate(store, name: name, rename: rename))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/stale.rb

@@ -0,0 +1,14 @@
+module Textus
+  class CLI
+    class Verb
+      class Stale < Verb
+        option :prefix, "--prefix=KEY"
+        option :zone, "--zone=Z"
+
+        def call(store)
+          emit(store.stale(prefix: prefix, zone: zone))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/uid.rb

@@ -0,0 +1,12 @@
+module Textus
+  class CLI
+    class Verb
+      class Uid < Verb
+        def call(store)
+          key = positional.shift or raise UsageError.new("uid requires a key")
+          emit({ "key" => key, "uid" => store.uid(key) })
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/where.rb

@@ -0,0 +1,12 @@
+module Textus
+  class CLI
+    class Verb
+      class Where < Verb
+        def call(store)
+          key = positional.shift or raise UsageError.new("where requires a key")
+          emit(store.where(key))
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/verb.rb

@@ -0,0 +1,62 @@
+require "json"
+require "optparse"
+
+module Textus
+  class CLI
+    # Subclasses must implement #call(store) and return an integer exit code.
+    # Use #emit(obj) for normal JSON output (returns 0).
+    # Subclasses that don't need a Textus store (e.g. Init) override
+    # `.needs_store?` to return false; dispatch will pass nil instead.
+    class Verb
+      class << self
+        def option(name, optspec)
+          options << [name, optspec]
+          attr_accessor(name)
+        end
+
+        def options
+          @options ||= []
+        end
+
+        def needs_store?
+          true
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@options, [])
+        end
+      end
+
+      def initialize(stdin:, stdout:, stderr:, cwd: nil)
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+        @cwd = cwd
+      end
+
+      def parse(argv)
+        fmt = "json"
+        OptionParser.new do |o|
+          self.class.options.each do |name, optspec|
+            o.on(optspec) { |v| public_send(:"#{name}=", v) }
+          end
+          o.on("--format=FMT") { |v| fmt = v }
+        end.permute!(argv)
+        raise UsageError.new("only --format=json is supported in v1") unless fmt == "json"
+
+        @positional = argv.dup
+      end
+
+      attr_reader :positional
+
+      # Hashes get "protocol" => PROTOCOL prepended unless they already
+      # carry one (Store envelopes do). Caller's value wins on collision.
+      def emit(obj, exit_code: 0)
+        payload = obj.is_a?(Hash) ? { "protocol" => PROTOCOL }.merge(obj) : obj
+        @stdout.puts(JSON.generate(payload))
+        exit_code
+      end
+    end
+  end
+end