ukiryu 0.1.0

data/lib/ukiryu/type.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "uri"
+require "time"
+
+module Ukiryu
+  # Type validation and conversion
+  #
+  # Validates and converts parameters according to their type definitions.
+  module Type
+    class << self
+      # Validate a value against a type definition
+      #
+      # @param value [Object] the value to validate
+      # @param type [Symbol, Hash] the type definition
+      # @param options [Hash] additional validation options
+      # @return [Object] the validated and converted value
+      # @raise [ValidationError] if validation fails
+      def validate(value, type, options = {})
+        type_definition = normalize_type(type)
+
+        case type_definition[:name]
+        when :file
+          validate_file(value, options)
+        when :string
+          validate_string(value, options)
+        when :integer
+          validate_integer(value, options)
+        when :float
+          validate_float(value, options)
+        when :symbol
+          validate_symbol(value, options)
+        when :boolean
+          validate_boolean(value)
+        when :uri
+          validate_uri(value, options)
+        when :datetime
+          validate_datetime(value, options)
+        when :hash
+          validate_hash(value, options)
+        when :array
+          validate_array(value, options)
+        else
+          raise ValidationError, "Unknown type: #{type_definition[:name]}"
+        end
+      end
+
+      # Normalize type definition to hash format
+      #
+      # @param type [Symbol, String, Hash] the type definition
+      # @return [Hash] normalized type definition
+      def normalize_type(type)
+        if type.is_a?(Hash)
+          type
+        else
+          # Convert string types to symbols for consistency
+          type_sym = type.is_a?(String) ? type.to_sym : type
+          { name: type_sym }
+        end
+      end
+
+      # Check if a type is valid
+      #
+      # @param type [Symbol, Hash] the type to check
+      # @return [Boolean]
+      def valid_type?(type)
+        type_definition = normalize_type(type)
+        VALID_TYPES.include?(type_definition[:name])
+      end
+
+      private
+
+      VALID_TYPES = %i[file string integer float symbol boolean uri datetime hash array].freeze
+
+      # Validate file type
+      def validate_file(value, options)
+        value = value.to_s
+        raise ValidationError, "File path cannot be empty" if value.empty?
+
+        # Check if file exists (only if require_existing is true)
+        if options[:require_existing] && !File.exist?(value)
+          raise ValidationError, "File not found: #{value}"
+        end
+
+        value
+      end
+
+      # Validate string type
+      def validate_string(value, options)
+        value = value.to_s
+        raise ValidationError, "String cannot be empty" if value.empty? && !options[:allow_empty]
+
+        if options[:pattern] && !(value =~ options[:pattern])
+          raise ValidationError, "String does not match required pattern: #{options[:pattern]}"
+        end
+
+        value
+      end
+
+      # Validate integer type
+      def validate_integer(value, options)
+        value = value.is_a?(String) ? value.strip : value
+
+        begin
+          integer = Integer(value)
+        rescue ArgumentError, TypeError
+          raise ValidationError, "Invalid integer: #{value.inspect}"
+        end
+
+        if options[:range]
+          min, max = options[:range]
+          if integer < min || integer > max
+            raise ValidationError, "Integer #{integer} out of range [#{min}, #{max}]"
+          end
+        end
+
+        if options[:min] && integer < options[:min]
+          raise ValidationError, "Integer #{integer} below minimum #{options[:min]}"
+        end
+
+        if options[:max] && integer > options[:max]
+          raise ValidationError, "Integer #{integer} above maximum #{options[:max]}"
+        end
+
+        integer
+      end
+
+      # Validate float type
+      def validate_float(value, options)
+        value = value.is_a?(String) ? value.strip : value
+
+        begin
+          float = Float(value)
+        rescue ArgumentError, TypeError
+          raise ValidationError, "Invalid float: #{value.inspect}"
+        end
+
+        if options[:range]
+          min, max = options[:range]
+          if float < min || float > max
+            raise ValidationError, "Float #{float} out of range [#{min}, #{max}]"
+          end
+        end
+
+        float
+      end
+
+      # Validate symbol type
+      def validate_symbol(value, options)
+        value = value.is_a?(Symbol) ? value : value.to_s.downcase.to_sym
+
+        if options[:values]
+          # Convert values to symbols for comparison (handle both string and symbol values)
+          valid_values = options[:values].map { |v| v.is_a?(String) ? v.to_sym : v }
+          unless valid_values.include?(value)
+            raise ValidationError, "Invalid symbol: #{value.inspect}. Valid values: #{options[:values].inspect}"
+          end
+        end
+
+        value
+      end
+
+      # Validate boolean type
+      def validate_boolean(value)
+        # Accept various boolean representations
+        case value
+        when TrueClass, FalseClass
+          value
+        when "true", "1", "yes", "on"
+          true
+        when "false", "0", "no", "off", ""
+          false
+        else
+          raise ValidationError, "Invalid boolean: #{value.inspect}"
+        end
+      end
+
+      # Validate URI type
+      def validate_uri(value, options)
+        value = value.to_s
+        raise ValidationError, "URI cannot be empty" if value.empty?
+
+        begin
+          uri = URI.parse(value)
+          raise ValidationError, "Invalid URI: #{value}" unless uri.is_a?(URI::Generic)
+          uri.to_s
+        rescue URI::InvalidURIError => e
+          raise ValidationError, "Invalid URI: #{value} - #{e.message}"
+        end
+      end
+
+      # Validate datetime type
+      def validate_datetime(value, options)
+        if value.is_a?(Time) || value.is_a?(DateTime)
+          value
+        else
+          begin
+            Time.parse(value.to_s)
+          rescue ArgumentError => e
+            raise ValidationError, "Invalid datetime: #{value.inspect} - #{e.message}"
+          end
+        end
+      end
+
+      # Validate hash type
+      def validate_hash(value, options)
+        unless value.is_a?(Hash)
+          raise ValidationError, "Hash expected, got #{value.class}: #{value.inspect}"
+        end
+
+        if options[:keys]
+          unknown_keys = value.keys - options[:keys]
+          if unknown_keys.any?
+            raise ValidationError, "Unknown hash keys: #{unknown_keys.inspect}. Valid keys: #{options[:keys].inspect}"
+          end
+        end
+
+        value
+      end
+
+      # Validate array type
+      def validate_array(value, options)
+        array = value.is_a?(Array) ? value : [value]
+
+        if options[:min] && array.size < options[:min]
+          raise ValidationError, "Array has #{array.size} elements, minimum is #{options[:min]}"
+        end
+
+        if options[:max] && array.size > options[:max]
+          raise ValidationError, "Array has #{array.size} elements, maximum is #{options[:max]}"
+        end
+
+        if options[:size]
+          if options[:size].is_a?(Integer)
+            if array.size != options[:size]
+              raise ValidationError, "Array has #{array.size} elements, expected #{options[:size]}"
+            end
+          elsif options[:size].is_a?(Array)
+            unless options[:size].include?(array.size)
+              raise ValidationError, "Array has #{array.size} elements, expected one of: #{options[:size].inspect}"
+            end
+          end
+        end
+
+        # Validate element type if specified
+        if options[:of]
+          array = array.map { |v| validate(v, options[:of], options) }
+        end
+
+        array
+      end
+    end
+  end
+end

data/lib/ukiryu/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  VERSION = "0.1.0"
+end

data/lib/ukiryu.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "ukiryu/version"
+require_relative "ukiryu/errors"
+
+# Core modules
+require_relative "ukiryu/platform"
+require_relative "ukiryu/shell"
+require_relative "ukiryu/type"
+require_relative "ukiryu/executor"
+require_relative "ukiryu/registry"
+require_relative "ukiryu/tool"
+require_relative "ukiryu/schema_validator"
+
+# CLI (optional, only load if thor is available)
+begin
+  require "thor"
+  require_relative "ukiryu/cli"
+rescue LoadError
+  # Thor not available, CLI will not be available
+end
+
+module Ukiryu
+  class Error < StandardError; end
+
+  class << self
+    # Configure global Ukiryu settings
+    def configure
+      yield configuration
+    end
+
+    # Get global configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Reset configuration (mainly for testing)
+    def reset_configuration
+      @configuration = nil
+      Shell.reset
+    end
+  end
+
+  # Configuration class for global settings
+  class Configuration
+    attr_accessor :default_shell
+    attr_accessor :registry_path
+
+    def initialize
+      @default_shell = nil # Auto-detect by default
+      @registry_path = nil
+    end
+  end
+end

data/ukiryu.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/ukiryu/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ukiryu"
+  spec.version       = Ukiryu::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "Platform-adaptive command execution framework"
+  spec.description   = <<~DESCRIPTION
+    Ukiryu is a Ruby framework for creating robust, cross-platform wrappers
+    around external command-line tools through declarative YAML profiles.
+    Ukiryu turns external CLIs into Ruby APIs with explicit type safety,
+    shell detection, and platform profiles.
+  DESCRIPTION
+
+  spec.homepage      = "https://github.com/riboseinc/ukiryu"
+  spec.license       = "BSD-2-Clause"
+
+  spec.bindir        = "exe"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(bin|spec)/})
+  end
+  spec.test_files = `git ls-files -- {spec}/*`.split("\n")
+  spec.required_ruby_version = ">= 2.7.0"
+
+  # Ukiryu has zero dependencies for core functionality (Ruby stdlib only)
+  # json-schema is only needed for registry validation (optional)
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ukiryu
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-21 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Ukiryu is a Ruby framework for creating robust, cross-platform wrappers
+  around external command-line tools through declarative YAML profiles.
+  Ukiryu turns external CLIs into Ruby APIs with explicit type safety,
+  shell detection, and platform profiles.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- ".gitmodules"
+- Gemfile
+- README.adoc
+- Rakefile
+- lib/ukiryu.rb
+- lib/ukiryu/cli.rb
+- lib/ukiryu/errors.rb
+- lib/ukiryu/executor.rb
+- lib/ukiryu/platform.rb
+- lib/ukiryu/registry.rb
+- lib/ukiryu/schema_validator.rb
+- lib/ukiryu/shell.rb
+- lib/ukiryu/shell/base.rb
+- lib/ukiryu/shell/bash.rb
+- lib/ukiryu/shell/cmd.rb
+- lib/ukiryu/shell/fish.rb
+- lib/ukiryu/shell/powershell.rb
+- lib/ukiryu/shell/sh.rb
+- lib/ukiryu/shell/zsh.rb
+- lib/ukiryu/tool.rb
+- lib/ukiryu/type.rb
+- lib/ukiryu/version.rb
+- ukiryu.gemspec
+homepage: https://github.com/riboseinc/ukiryu
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Platform-adaptive command execution framework
+test_files: []