web_function 0.5.0 → 0.8.0

data/lib/web_function/type/array_of.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module WebFunction
+  module Type
+    class ArrayOf
+      attr_reader :base_type, :of
+
+      def initialize(of)
+        @base_type = "array"
+        @of = of
+      end
+
+      def refinement
+        nil
+      end
+
+      def inspect
+        "#<ArrayOf #{@of.inspect}>"
+      end
+
+      def format(format = :default)
+        case format
+        when :base
+          "array"
+        when :compact, :default
+          "array<#{@of.format(format)}>"
+        else
+          raise ArgumentError, "unknown format: #{format.inspect}"
+        end
+      end
+
+      def to_s
+        format(:default)
+      end
+
+      def ==(other)
+        other.is_a?(ArrayOf) && other.of == @of
+      end
+      alias eql? ==
+
+      def hash
+        [ArrayOf, @of].hash
+      end
+
+      def objects
+        @of.objects
+      end
+
+      def without_refinements
+        ArrayOf.new(@of.without_refinements)
+      end
+
+      def valid?(value)
+        value.is_a?(Array) && value.all? { |element| @of.valid?(element) }
+      end
+    end
+  end
+end

data/lib/web_function/type/base.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module WebFunction
+  module Type
+    class Base
+      attr_reader :base_type, :refinement
+
+      def initialize(base_type:, refinement: nil)
+        @base_type = base_type
+        @refinement = refinement
+      end
+
+      def inspect
+        if @refinement
+          "#<#{@base_type} #{@refinement}>"
+        else
+          "#<#{@base_type}>"
+        end
+      end
+
+      def format(format = :default)
+        case format
+        when :compact
+          @refinement || @base_type
+        when :base
+          @base_type
+        when :default
+          if @refinement
+            "#{@base_type}.#{@refinement}"
+          else
+            @base_type
+          end
+        else
+          raise ArgumentError, "unknown format: #{format.inspect}"
+        end
+      end
+
+      def to_s
+        format(:default)
+      end
+
+      def ==(other)
+        other.is_a?(Base) && other.base_type == @base_type && other.refinement == @refinement
+      end
+      alias eql? ==
+
+      def hash
+        [Base, @base_type, @refinement].hash
+      end
+
+      def objects
+        if @base_type == "object" && @refinement
+          [@refinement]
+        else
+          []
+        end
+      end
+
+      def without_refinements
+        return self if @refinement.nil?
+
+        Base.new(base_type: @base_type)
+      end
+
+      def valid?(value)
+        case @base_type
+        when "string"
+          value.is_a?(String) && refinement_valid?(value)
+        when "number"
+          value.is_a?(Numeric) && !value.is_a?(Complex) && refinement_valid?(value)
+        when "object"
+          value.is_a?(Hash)
+        when "boolean"
+          value == true || value == false
+        when "null"
+          value.nil?
+        else
+          false
+        end
+      end
+
+      private
+
+      def refinement_valid?(value)
+        @refinement.nil? || REFINEMENT_VALIDATORS.fetch(@refinement).call(value)
+      end
+    end
+  end
+end

data/lib/web_function/type/union.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module WebFunction
+  module Type
+    class Union
+      attr_reader :members
+
+      def initialize(members)
+        @members = members
+      end
+
+      def base_type
+        nil
+      end
+
+      def refinement
+        nil
+      end
+
+      def inspect
+        "#<Union #{@members.map(&:inspect).join(" | ")}>"
+      end
+
+      def format(format = :default)
+        @members.map { |member| member.format(format) }.join(" | ")
+      end
+
+      def to_s
+        format(:default)
+      end
+
+      def ==(other)
+        other.is_a?(Union) && other.members == @members
+      end
+      alias eql? ==
+
+      def hash
+        [Union, @members].hash
+      end
+
+      def objects
+        @members.flat_map(&:objects).uniq
+      end
+
+      def without_refinements
+        Type.union(@members.map(&:without_refinements))
+      end
+
+      def valid?(value)
+        @members.any? { |member| member.valid?(value) }
+      end
+    end
+  end
+end

data/lib/web_function/type.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "uri"
+
+require_relative "type/base"
+require_relative "type/array_of"
+require_relative "type/union"
+require_relative "type/any"
+
+module WebFunction
+  module Type
+    ALLOWED_REFINEMENTS = {
+      "number" => %w[u32 u64 i32 i64 f32 f64 timestamp].freeze,
+      "string" => %w[date time datetime uuid base64 email phone url uri ipv4 ipv6 hostname].freeze,
+    }.freeze
+
+    # Value-level validators for each refinement, keyed by refinement name. Refinement names are unique across base
+    # types, so a flat table is enough. Must stay in sync with {ALLOWED_REFINEMENTS}.
+    REFINEMENT_VALIDATORS = {
+      "u32" => ->(v) { v.is_a?(Integer) && v.between?(0, 0xFFFFFFFF) },
+      "u64" => ->(v) { v.is_a?(Integer) && v.between?(0, 0xFFFFFFFFFFFFFFFF) },
+      "i32" => ->(v) { v.is_a?(Integer) && v.between?(-0x80000000, 0x7FFFFFFF) },
+      "i64" => ->(v) { v.is_a?(Integer) && v.between?(-0x8000000000000000, 0x7FFFFFFFFFFFFFFF) },
+      "f32" => ->(v) { v.is_a?(Numeric) && v.to_f.finite? && v.to_f.abs <= 3.4028235e38 },
+      "f64" => ->(v) { v.is_a?(Numeric) && v.to_f.finite? },
+      "timestamp" => ->(v) { v.is_a?(Integer) && v >= 0 },
+      "date" => ->(v) { v.match?(/\A\d{4}-\d{2}-\d{2}\z/) },
+      "time" => ->(v) { v.match?(/\A\d{2}:\d{2}:\d{2}(\.\d+)?\z/) },
+      "datetime" => ->(v) { v.match?(/\A\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?\z/) },
+      "uuid" => ->(v) { v.match?(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/) },
+      "base64" => ->(v) { (v.length % 4).zero? && v.match?(%r{\A[A-Za-z0-9+/]*={0,2}\z}) },
+      "email" => ->(v) { v.match?(/\A[^@\s]+@[^@\s]+\.[^@\s]+\z/) },
+      "phone" => ->(v) { v.match?(/\A\+[1-9]\d{1,14}\z/) },
+      "url" => ->(v) { (uri = URI.parse(v)).is_a?(URI::HTTP) && !uri.host.nil? rescue false },
+      "uri" => ->(v) { !URI.parse(v).scheme.nil? rescue false },
+      "ipv4" => ->(v) { IPAddr.new(v).ipv4? rescue false },
+      "ipv6" => ->(v) { IPAddr.new(v).ipv6? rescue false },
+      "hostname" => lambda do |v|
+        v.match?(%r{\A(?=.{1,253}\z)([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\z})
+      end,
+    }.freeze
+
+    def self.parse(raw)
+      types = [*raw].map { |type| Type.detect(type) }.compact
+
+      if types.empty?
+        return Type.any
+      end
+
+      Type.union(types)
+    end
+
+    def self.detect(raw)
+      case raw
+      when String
+        Type.base(raw)
+      when Array
+        types = raw.map { |type| Type.detect(type) }.compact
+
+        if types.empty?
+          return Type.array(Type.any)
+        end
+
+        Type.array(Type.union(types))
+      else
+        return nil
+      end
+    end
+
+    def self.base(type)
+      base_type, refinement = type.split(".", 2)
+
+      case base_type
+      when "string"
+        if refinement && !ALLOWED_REFINEMENTS["string"].include?(refinement)
+          return Type.string
+        end
+
+        Type.string(refinement)
+      when "number"
+        if refinement && !ALLOWED_REFINEMENTS["number"].include?(refinement)
+          return Type.number
+        end
+
+        Type.number(refinement)
+      when "object"
+        Type.object(refinement)
+      when "array"
+        Type.array
+      when "boolean"
+        Type.boolean
+      when "null"
+        Type.null
+      when "any"
+        Type.any
+      else
+        nil
+      end
+    end
+
+    def self.string(refinement = nil)
+      Base.new(base_type: "string", refinement: refinement)
+    end
+
+    def self.number(refinement = nil)
+      Base.new(base_type: "number", refinement: refinement)
+    end
+
+    def self.object(refinement = nil)
+      Base.new(base_type: "object", refinement: refinement)
+    end
+
+    def self.array(of = any)
+      ArrayOf.new(of)
+    end
+
+    def self.boolean
+      Base.new(base_type: "boolean")
+    end
+
+    def self.null
+      Base.new(base_type: "null")
+    end
+
+    def self.union(types)
+      types = types.uniq
+
+      if types.length > 1
+        Union.new(types)
+      else
+        types.first
+      end
+    end
+
+    def self.any
+      Any.new
+    end
+  end
+end

data/lib/web_function/utils.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module WebFunction
+  # Internal utility methods.
+  #
+  # @api private
+  #
+  module Utils
+    module_function
+
+    # Normalizes a collection. Yields each item to the block if a block is given, otherwise returns the item.
+    # Any `nil` items are removed.
+    #
+    # @param collection [Array] The collection to normalize
+    #
+    # @return [Array] The normalized array
+    #
+    def normalize_array(collection)
+      unless collection.is_a?(Array)
+        return []
+      end
+
+      items = collection.map do |item|
+        if block_given?
+          yield item
+        else
+          item
+        end
+      end
+
+      items.compact
+    end
+
+    # Normalizes an array of strings. Uses #normalize_array under the hood.
+    #
+    # @param collection [Array] The collection to normalize
+    #
+    # @return [Array] The normalized array
+    #
+    def normalize_array_of_strings(collection)
+      normalize_array(collection) { |item| item.to_s }
+    end
+
+    def get_body_from_url(url, extra_query_params: {})
+      url = add_query_params(url, extra_query_params)
+      response = ::Excon.get(url, headers: {
+        "User-Agent": "webfunction/#{::WebFunction::VERSION}",
+        "Accept-Encoding": "gzip",
+      })
+
+      response.body
+    end
+
+    def add_query_params(url, params = {})
+      uri = ::URI.parse(url)
+      existing_params = ::URI.decode_www_form(uri.query || "").to_h
+      new_params = params.reject { |_, value| value.nil? }.transform_keys(&:to_s)
+      merged_params = existing_params.merge(new_params)
+
+      unless merged_params.empty?
+        uri.query = ::URI.encode_www_form(merged_params)
+      end
+
+      uri.to_s
+    end
+  end
+end

data/lib/web_function/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebFunction
-  VERSION = "0.5.0"
+  VERSION = "0.8.0"
 end

data/lib/web_function.rb

@@ -5,35 +5,47 @@ require "json"
 require "uri"
 
 require_relative "web_function/version"
+require_relative "web_function/request"
 require_relative "web_function/client"
+require_relative "web_function/flaggable"
 require_relative "web_function/package"
 require_relative "web_function/endpoint"
 require_relative "web_function/argument"
 require_relative "web_function/attribute"
+require_relative "web_function/object_schema"
 require_relative "web_function/documented_error"
 require_relative "web_function/pipeline"
 require_relative "web_function/promise"
+require_relative "web_function/type"
+require_relative "web_function/utils"
 
 module WebFunction
+  # A base error class for WebFunction. All errors inherit from this class.
+  #
+  # @api private
+  #
   class Error < StandardError
     attr_reader :code, :details
 
-    def initialize(message = nil, code: self.class.name, details: nil)
+    def initialize(message = nil, code: self.class.error_code, details: nil)
       super(message)
       @code = code
       @details = details
     end
-  end
-
-  class UnresolvedPromiseError < Error
-  end
 
-  class UnexpectedStatusCodeError < Error
-  end
-
-  class JsonParseError < Error
+    # Returns the error code for the error. Used as default error code if no code is provided.
+    #
+    # @return [String] The error code
+    #
+    def self.error_code
+      name.sub(/^WebFunction::/, "WFN_")
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .upcase
+    end
   end
 
-  class BadRequestError < Error
-  end
+  UnresolvedPromiseError = Class.new(Error)
+  UnexpectedStatusCodeError = Class.new(Error)
+  JsonParseError = Class.new(Error)
+  BadRequestError = Class.new(Error)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: web_function
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Robin Clart
@@ -9,6 +9,34 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
@@ -60,9 +88,18 @@ files:
 - lib/web_function/client.rb
 - lib/web_function/documented_error.rb
 - lib/web_function/endpoint.rb
+- lib/web_function/flaggable.rb
+- lib/web_function/object_schema.rb
 - lib/web_function/package.rb
 - lib/web_function/pipeline.rb
 - lib/web_function/promise.rb
+- lib/web_function/request.rb
+- lib/web_function/type.rb
+- lib/web_function/type/any.rb
+- lib/web_function/type/array_of.rb
+- lib/web_function/type/base.rb
+- lib/web_function/type/union.rb
+- lib/web_function/utils.rb
 - lib/web_function/version.rb
 - sig/web_function.rbs
 homepage: https://github.com/robinclart/web_function