wisco 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 832da4703274d86e1bc2f5e1684e499b9c4f2de2628c3f0dfb362e23e34213b9
+  data.tar.gz: 369be3677fdc543c2a0d1a5344e195bf97e05a61d1a9816b6f1993bc521c63af
+SHA512:
+  metadata.gz: 3c5e906f59c4f5db77e30a8c583e09cea24e02074c89dfb1b9f985a7c3078bf789f17e5723d49d303789f8b0328d1c5a2c8bf80b735ea1706c4834700eef8dcb
+  data.tar.gz: e474a3f6f3b761f3165366fb335c276f7d73ed2725d50a7dc2bea9fde92decf13b10991a809bc86b2737dbbc558284e8617c4301f321c67dadfe00e127e68eee

data/bin/wisco

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+if Gem.win_platform?
+  $stdout.binmode
+  $stdout.set_encoding('UTF-8')
+end
+require 'wisco'
+Wisco::CLI.start(ARGV)

data/lib/wisco/commands/exec.rb

@@ -0,0 +1,126 @@
+require 'fileutils'
+require 'workato/connector/sdk'
+require 'workato/cli/exec_command'
+require_relative '../config'
+require_relative '../connector'
+require_relative '../path_utils'
+
+module Wisco
+  module Commands
+    module Exec
+      module_function
+
+      def run(path_arg, target_dir, input: nil, debug: false)
+        target_dir = File.expand_path(target_dir)
+        config_path = Wisco.config_path(target_dir)
+
+        unless File.exist?(config_path)
+          warn "Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}."
+          warn "       Run '#{Wisco::CLI_NAME} init' first."
+          exit 1
+        end
+
+        config = Wisco::Config.load_config(config_path)
+        connector_path = config.dig('connector', 'path')
+        connector_file = config.dig('connector', 'file')
+
+        if connector_path.nil? || connector_file.nil?
+          warn "Error: #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} is missing connector path/file. Run '#{Wisco::CLI_NAME} init' again."
+          exit 1
+        end
+
+        connector_full_path = File.join(connector_path, connector_file)
+        connection = config['connection']
+
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        pairs = Wisco::PathUtils.parse_path(path_arg, connector)
+
+        pairs.each do |section, key|
+          puts "Executing #{section}.#{key}"
+          fixtures_dir = File.join(target_dir, 'fixtures', section, key)
+          fixture_dir_output = fixtures_dir.sub(connector_path, '.')
+
+          unless File.directory?(fixtures_dir)
+            warn "Error: fixtures directory not found: #{fixture_dir_output}"
+            warn "       Run '#{Wisco::CLI_NAME} fixtures #{section}.#{key}' first."
+            next
+          end
+
+          input_files = resolve_input_files(input, fixtures_dir)
+
+          if input_files.empty?
+            warn "\tWarning: No ready input files found in #{fixture_dir_output}"
+            next
+          end
+
+          input_files.each do |input_file|
+            execute_one(section, key, input_file, fixtures_dir,
+                        connector_full_path, connection, debug: debug)
+          end
+        end
+      end
+
+      # Resolve the list of input files to execute.
+      # If an explicit input filename/path is given, use that (relative to fixtures_dir).
+      # Otherwise glob execute_* in fixtures_dir and exclude files still containing the sentinel.
+      def resolve_input_files(input, fixtures_dir)
+        if input
+          path = File.absolute_path?(input) ? input : File.join(fixtures_dir, input)
+          unless File.exist?(path)
+            warn "Error: Input file not found: #{path}"
+            exit 1
+          end
+          [path]
+        else
+          Dir.glob(File.join(fixtures_dir, 'execute_*')).select do |f|
+            File.file?(f) && !file_has_sentinel?(f)
+          end
+        end
+      end
+
+      def file_has_sentinel?(path)
+        first_line = begin
+          File.open(path, &:readline).chomp
+        rescue StandardError
+          ''
+        end
+        first_line == Wisco::Commands::Fixtures::SENTINEL
+      end
+
+      def execute_one(section, key, input_file, fixtures_dir, connector_full_path, connection, debug: false)
+        stem        = File.basename(input_file, '.*')
+        output_file = File.join(fixtures_dir, "output_#{stem}.json")
+        error_file  = File.join(fixtures_dir, "error_#{stem}.txt")
+
+        options = { connector: connector_full_path, input: input_file, output: output_file }
+        options[:connection] = connection if connection
+
+        if debug
+          warn "[exec] path:       #{section}.#{key}.execute"
+          warn "[exec] connector:  #{connector_full_path}"
+          warn "[exec] connection: #{connection.inspect}"
+          warn "[exec] input:      #{input_file}"
+          warn "[exec] output:     #{output_file}"
+        end
+
+        begin
+          cmd = Workato::CLI::ExecCommand.new(path: "#{section}.#{key}.execute", options: options)
+          cmd.call
+        rescue StandardError => e
+          File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
+          warn "Error executing #{section}.#{key} with #{File.basename(input_file)}: #{e.message}"
+          warn "  Details written to: #{error_file}"
+          return
+        end
+
+        FileUtils.rm_f(error_file)
+
+        return unless File.exist?(output_file)
+
+        pretty = JSON.pretty_generate(JSON.parse(File.read(output_file)))
+        File.write(output_file, pretty + "\n")
+        puts "  Written: #{output_file}"
+      end
+    end
+  end
+end

data/lib/wisco/commands/fixtures.rb

@@ -0,0 +1,149 @@
+require 'fileutils'
+require 'workato/connector/sdk'
+require 'workato/cli/exec_command'
+require_relative '../config'
+require_relative '../connector'
+require_relative '../path_utils'
+
+module Wisco
+  module Commands
+    module Fixtures
+      SENTINEL = '# Remove this comment before updating. Files that include this line will be overwritten.'
+
+      module_function
+
+      def run(path_arg, target_dir, overwrite: false, debug: false)
+        target_dir = File.expand_path(target_dir)
+        config_path = Wisco.config_path(target_dir)
+
+        unless File.exist?(config_path)
+          warn "Error: No #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} found in #{target_dir}."
+          warn "       Run '#{Wisco::CLI_NAME} init' first."
+          exit 1
+        end
+
+        config = Wisco::Config.load_config(config_path)
+        connector_path = config.dig('connector', 'path')
+        connector_file = config.dig('connector', 'file')
+
+        if connector_path.nil? || connector_file.nil?
+          warn "Error: #{Wisco::WISCO_DIR}/#{Wisco::CONFIG_FILENAME} is missing connector path/file. Run '#{Wisco::CLI_NAME} init' again."
+          exit 1
+        end
+
+        connector_full_path = File.join(connector_path, connector_file)
+        connection = config['connection']
+
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        pairs = Wisco::PathUtils.parse_path(path_arg, connector)
+
+        pairs.each do |section, key|
+          puts "Processing #{section}.#{key}"
+          fixtures_dir = File.join(target_dir, 'fixtures', section, key)
+          FileUtils.mkdir_p(fixtures_dir)
+
+          input_fields_file = File.join(fixtures_dir, 'input_fields.json')
+          call_exec(
+            path: "#{section}.#{key}.input_fields",
+            connector: connector_full_path,
+            connection: connection,
+            output: input_fields_file,
+            debug: debug
+          )
+
+          generate_execute_input(input_fields_file, fixtures_dir, overwrite: overwrite, debug: debug)
+
+          output_fields_file = File.join(fixtures_dir, 'output_fields.json')
+          call_exec(
+            path: "#{section}.#{key}.output_fields",
+            connector: connector_full_path,
+            connection: connection,
+            output: output_fields_file,
+            debug: debug
+          )
+        end
+      end
+
+      # Reads input_fields.json, builds a template hash, writes execute_input.json.
+      # The file is prefixed with SENTINEL so it is identifiable as an unedited template.
+      # Overwrite rules:
+      #   - File absent                  -> write
+      #   - File present, sentinel L1    -> overwrite (still a template)
+      #   - File present, no sentinel    -> skip (user-edited); force with --overwrite
+      def generate_execute_input(input_fields_file, fixtures_dir, overwrite: false, debug: false)
+        return unless File.exist?(input_fields_file)
+
+        fields = JSON.parse(File.read(input_fields_file))
+        return if fields.empty?
+
+        output_file = File.join(fixtures_dir, 'execute_input.json')
+
+        if File.exist?(output_file)
+          first_line = begin
+            File.open(output_file, &:readline).chomp
+          rescue StandardError
+            ''
+          end
+          has_sentinel = (first_line == SENTINEL)
+
+          unless has_sentinel || overwrite
+            puts "  Skipped (user-edited): #{output_file}" if debug
+            return
+          end
+        end
+
+        template = schema_to_template(fields)
+        content  = "#{SENTINEL}\n#{JSON.pretty_generate(template)}\n"
+        File.write(output_file, content)
+        puts "  Written: #{output_file}"
+      end
+
+      # Recursively converts a Workato schema array into a template hash.
+      # Scalars become "<type_value_required|optional>" placeholder strings.
+      # Objects expand into a nested hash via their properties.
+      # Arrays expand into a single-element array via their properties.
+      def schema_to_template(fields)
+        fields.each_with_object({}) do |field, hash|
+          name     = field['name']
+          type     = field['type'] || 'string'
+          optional = field.fetch('optional', true)
+          req_str  = optional ? 'optional' : 'required'
+
+          hash[name] = case type
+                       when 'object'
+                         schema_to_template(field['properties'] || [])
+                       when 'array'
+                         [schema_to_template(field['properties'] || [])]
+                       else
+                         "<#{type}_value_#{req_str}>"
+                       end
+        end
+      end
+
+      def call_exec(path:, connector:, connection:, output:, debug: false)
+        options = { connector: connector, output: output }
+        options[:connection] = connection if connection
+
+        if debug
+          warn "[fixtures] path:       #{path}"
+          warn "[fixtures] connector:  #{connector}"
+          warn "[fixtures] connection: #{connection.inspect}"
+          warn "[fixtures] output:     #{output}"
+        end
+
+        cmd = Workato::CLI::ExecCommand.new(path: path, options: options)
+        begin
+          cmd.call
+        rescue StandardError => e
+          warn "  Warning: #{path} failed — #{e.message}"
+          return
+        end
+
+        return unless File.exist?(output)
+
+        pretty = JSON.pretty_generate(JSON.parse(File.read(output)))
+        File.write(output, pretty + "\n")
+      end
+    end
+  end
+end

data/lib/wisco/commands/init.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require_relative '../config'
+require_relative '../connector'
+
+module Wisco
+  module Commands
+    module Init
+      module_function
+
+      def run(target_dir)
+        target_dir = File.expand_path(target_dir)
+
+        unless Dir.exist?(target_dir)
+          warn "Error: Directory not found: #{target_dir}"
+          exit 1
+        end
+
+        puts "Searching for connector in #{target_dir}..."
+
+        connector_file = Wisco::Connector.detect_connector(target_dir)
+
+        if connector_file.nil?
+          warn "Error: No valid Workato connector file found in #{target_dir}"
+          exit 1
+        end
+
+        puts "Found connector: #{connector_file}"
+
+        wisco_dir   = File.join(target_dir, Wisco::WISCO_DIR)
+        FileUtils.mkdir_p(wisco_dir)
+
+        config_path = Wisco.config_path(target_dir)
+        config      = Wisco::Config.load_config(config_path)
+
+        config['connector'] ||= {}
+        config['connector']['path'] = target_dir
+        config['connector']['file'] = connector_file
+
+        Wisco::Config.save_config(config_path, config)
+        puts "Config written to #{config_path}"
+
+        update_gitignore(target_dir)
+      end
+
+      def update_gitignore(target_dir)
+        gitignore_path = File.join(target_dir, '.gitignore')
+        entry          = "#{Wisco::WISCO_DIR}/"
+
+        if File.exist?(gitignore_path)
+          content = File.read(gitignore_path)
+          if content.include?(entry)
+            puts ".gitignore already contains '#{entry}' — no changes made."
+          else
+            File.open(gitignore_path, 'a') { |f| f.puts entry }
+            puts "Added '#{entry}' to .gitignore"
+          end
+        else
+          puts "Note: No .gitignore found — consider adding '#{entry}' manually."
+        end
+      end
+    end
+  end
+end

data/lib/wisco/commands/list.rb

@@ -0,0 +1,192 @@
+require_relative '../connector'
+
+module Wisco
+  module Commands
+    module List
+      TREE_FORK = '├── '
+      TREE_LAST = '└── '
+      TREE_PIPE = '│   '
+      TREE_BLANK = '    '
+      EXPANDABLE_KEYS = %i[actions triggers object_definitions methods pick_lists].freeze
+      SORT_FIELDS = %w[key title].freeze
+
+      module_function
+
+      def run(subcommand, target, sort: nil)
+        validate_sort!(sort)
+
+        case subcommand
+        when nil        then run_tree(target)
+        when 'actions'  then run_actions(target, sort: sort)
+        when 'triggers' then run_triggers(target, sort: sort)
+        when 'all'      then run_all(target, sort: sort)
+        else
+          warn "Error: Unknown list subcommand '#{subcommand}'"
+          warn "Run '#{Wisco::CLI_NAME} --help' for usage."
+          exit 1
+        end
+      end
+
+      def run_tree(target_dir)
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        puts connector[:title]
+
+        keys = connector.keys
+        keys.each_with_index do |key, idx|
+          last = idx == keys.size - 1
+          connector_str = last ? TREE_LAST : TREE_FORK
+          child_prefix = last ? TREE_BLANK : TREE_PIPE
+          value = connector[key]
+
+          if key == :connection && value.is_a?(Hash)
+            puts "#{connector_str}#{key}"
+            render_connection_tree(value, child_prefix)
+          elsif EXPANDABLE_KEYS.include?(key) && value.is_a?(Hash) && !value.empty?
+            puts "#{connector_str}#{key} [#{value.size}]"
+            render_children_tree(value, child_prefix)
+          elsif value.is_a?(Hash)
+            puts "#{connector_str}#{key} [#{value.size}]"
+          elsif value.is_a?(Array)
+            puts "#{connector_str}#{key} [#{value.size}]"
+          else
+            puts "#{connector_str}#{key}"
+          end
+        end
+      end
+
+      def run_actions(target_dir, sort: nil)
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        actions = connector[:actions]
+
+        if actions.nil? || actions.empty?
+          puts 'No actions defined.'
+          return
+        end
+
+        rows = actions.map { |key, item| [key, title_for(key, item), subtitle_for(item)] }
+        rows = sort_rows(rows, sort)
+        render_markdown_table(%w[Key Title Subtitle], rows)
+      end
+
+      def run_triggers(target_dir, sort: nil)
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        triggers = connector[:triggers]
+
+        if triggers.nil? || triggers.empty?
+          puts 'No triggers defined.'
+          return
+        end
+
+        rows = triggers.map { |key, item| [key, title_for(key, item), subtitle_for(item)] }
+        rows = sort_rows(rows, sort)
+        render_markdown_table(%w[Key Title Subtitle], rows)
+      end
+
+      def run_all(target_dir, sort: nil)
+        puts '## Overview'
+        run_tree(target_dir)
+        puts
+        puts '## Actions'
+        run_actions(target_dir, sort: sort)
+        puts
+        puts '## Triggers'
+        run_triggers(target_dir, sort: sort)
+      end
+
+      # ---------------------------------------------------------------------------
+      # List utilities
+      # ---------------------------------------------------------------------------
+
+      def strip_html(str)
+        str.to_s.gsub(/<[^>]+>/, '').squeeze(' ').strip
+      end
+
+      def humanise_key(key)
+        key.to_s.split('_').map(&:capitalize).join(' ')
+      end
+
+      def title_for(key, item)
+        item.is_a?(Hash) && item[:title] ? item[:title] : humanise_key(key)
+      end
+
+      def subtitle_for(item)
+        return '' unless item.is_a?(Hash)
+        return item[:subtitle] if item[:subtitle]
+
+        strip_html(item[:description]) if item[:description]
+        item[:subtitle] || strip_html(item[:description].to_s)
+      end
+
+      def render_markdown_table(headers, rows)
+        all_rows = [headers] + rows
+        widths = headers.length.times.map do |i|
+          all_rows.map { |r| r[i].to_s.length }.max
+        end
+
+        fmt = widths.map { |w| "%-#{w}s" }.join(' | ')
+        sep = widths.map { |w| '-' * w }.join('-|-')
+
+        puts "| #{format(fmt, *headers)} |"
+        puts "|-#{sep}-|"
+        rows.each { |r| puts "| #{format(fmt, *r)} |" }
+      end
+
+      def validate_sort!(sort)
+        return if sort.nil? || SORT_FIELDS.include?(sort)
+
+        warn "Error: Unsupported sort field '#{sort}'. Valid values: #{SORT_FIELDS.join(', ')}."
+        exit 1
+      end
+
+      def sort_rows(rows, sort)
+        return rows if sort.nil?
+
+        index = SORT_FIELDS.index(sort)
+        rows.sort_by { |row| [row[index].to_s.downcase, row[0].to_s.downcase] }
+      end
+
+      # ---------------------------------------------------------------------------
+      # Tree rendering
+      # ---------------------------------------------------------------------------
+
+      def value_label(value)
+        case value
+        when Hash  then "[#{value.size}]"
+        when Array then "[#{value.size}]"
+        when Proc  then '(lambda)'
+        else            value.to_s
+        end
+      end
+
+      def render_connection_tree(conn, prefix)
+        keys = conn.keys
+        keys.each_with_index do |key, idx|
+          last = idx == keys.size - 1
+          connector = last ? TREE_LAST : TREE_FORK
+          child_prefix = prefix + (last ? TREE_BLANK : TREE_PIPE)
+          value = conn[key]
+
+          if value.is_a?(Hash)
+            puts "#{prefix}#{connector}#{key}"
+            sub_keys = value.keys
+            sub_keys.each_with_index do |sk, si|
+              sl = si == sub_keys.size - 1
+              sc = sl ? TREE_LAST : TREE_FORK
+              puts "#{child_prefix}#{sc}#{sk}"
+            end
+          else
+            puts "#{prefix}#{connector}#{key} #{value_label(value)}"
+          end
+        end
+      end
+
+      def render_children_tree(value, prefix)
+        child_keys = value.keys.sort
+        child_keys.each_with_index do |ck, ci|
+          cl = ci == child_keys.size - 1
+          puts "#{prefix}#{cl ? TREE_LAST : TREE_FORK}#{ck}"
+        end
+      end
+    end
+  end
+end