action_spec 0.1.0

data/lib/action_spec/schema.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "action_spec/schema/base"
+require "action_spec/schema/field"
+require "action_spec/schema/scalar"
+require "action_spec/schema/object_of"
+require "action_spec/schema/array_of"
+require "action_spec/schema/resolver"
+require "action_spec/schema/type_caster"
+
+module ActionSpec
+  module Schema
+    Missing = Object.new.freeze
+    OPTION_KEYS = %i[default desc enum range pattern allow_nil allow_blank example examples].freeze
+
+    class << self
+      def build(type = nil, **options)
+        definition = options.symbolize_keys
+        definition[:type] = type if type
+        from_definition(definition)
+      end
+
+      def from_definition(definition)
+        return Scalar.new(String) if definition.blank?
+        return ArrayOf.new(from_definition(type: definition.first)) if definition.is_a?(Array) && definition.one?
+        return ArrayOf.new(from_definition(type: nil)) if definition == []
+        return Scalar.new(definition) unless definition.is_a?(Hash)
+
+        definition = definition.deep_symbolize_keys
+        if definition.key?(:type)
+          type = definition[:type]
+          options = definition.except(:type)
+          return ArrayOf.new(from_definition(type: type.first), options) if type.is_a?(Array) && type.one?
+          return ObjectOf.new(build_fields(definition.except(:type, *OPTION_KEYS))) if type == Object && definition.except(:type, *OPTION_KEYS).present?
+
+          return Scalar.new(type, options)
+        end
+
+        ObjectOf.new(build_fields(definition))
+      end
+
+      def build_fields(definition_hash)
+        definition_hash.each_with_object(ActiveSupport::OrderedHash.new) do |(name, definition), fields|
+          schema = build_field_schema(definition)
+          fields[field_name(name)] = Field.new(
+            name: field_name(name),
+            required: required_key?(name),
+            schema:
+          )
+        end
+      end
+
+      def field_name(name)
+        name.to_s.delete_suffix("!").to_sym
+      end
+
+      def required_key?(name)
+        name.to_s.end_with?("!")
+      end
+
+      def build_field_schema(definition)
+        return from_definition(type: definition) unless definition.is_a?(Hash)
+
+        definition = definition.symbolize_keys
+        return from_definition(definition) if definition.key?(:type)
+        return from_definition(definition) if (definition.keys - OPTION_KEYS).present?
+
+        from_definition(definition.merge(type: String))
+      end
+    end
+  end
+end

data/lib/action_spec/validation_result.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActionSpec
+  class ValidationResult
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+
+    attr_reader :errors, :px
+
+    def initialize
+      @errors = ActiveModel::Errors.new(self)
+      @px = ActiveSupport::HashWithIndifferentAccess.new(
+        path: ActiveSupport::HashWithIndifferentAccess.new,
+        query: ActiveSupport::HashWithIndifferentAccess.new,
+        body: ActiveSupport::HashWithIndifferentAccess.new,
+        headers: HeaderHash.new,
+        cookies: ActiveSupport::HashWithIndifferentAccess.new
+      )
+    end
+
+    def invalid?
+      errors.any?
+    end
+
+    def assign(location, key, value)
+      bucket(location)[key] = value
+      px[key] = value if root_bucket?(location)
+    end
+
+    def add_error(attribute, type, **options)
+      if (message = ActionSpec.config.message_for(attribute, type, options))
+        errors.add(attribute, message)
+      else
+        errors.add(attribute, type, **options)
+      end
+    end
+
+    def read_attribute_for_validation(_attribute)
+      nil
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(self, nil, "ActionSpec::Parameters")
+    end
+
+    def self.human_attribute_name(attribute, options = {})
+      key = attribute.to_s
+      defaults = [
+        :"activemodel.attributes.#{model_name.i18n_key}.#{key}",
+        :"activemodel.attributes.#{model_name.i18n_key}.#{key.tr('.', '_')}",
+        key.tr(".", " ").humanize
+      ]
+
+      I18n.translate(defaults.shift, **options, default: defaults)
+    end
+
+    private
+
+      def bucket(location)
+        px.fetch(location)
+      end
+
+      def root_bucket?(location)
+        %i[path query body].include?(location)
+      end
+  end
+end

data/lib/action_spec/validator/runner.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActionSpec
+  module Validator
+    class Runner
+      def initialize(endpoint:, controller:, coerce:)
+        @endpoint = endpoint
+        @controller = controller
+        @coerce = coerce
+      end
+
+      def call
+        result = ValidationResult.new
+        merge_group!(result, endpoint.request.path, source: path_source, location: :path)
+        merge_group!(result, endpoint.request.query, source: params_source, location: :query)
+        merge_group!(result, endpoint.request.body, source: params_source, location: :body)
+        merge_group!(result, endpoint.request.header, source: header_source, location: :headers)
+        merge_group!(result, endpoint.request.cookie, source: cookie_source, location: :cookies)
+        result
+      end
+
+      private
+
+        attr_reader :endpoint, :controller, :coerce
+
+        def merge_group!(result, group, source:, location:)
+          group.fields.each do |field|
+            value = resolve_field(field, result:, source:, location:)
+            next if value.equal?(ActionSpec::Schema::Missing)
+
+            result.assign(location, storage_key(field, location), value)
+          end
+        end
+
+        def resolve_field(field, result:, source:, location:)
+          raw_source = location == :headers ? normalize_headers(source) : source
+          field_source = raw_source.is_a?(Hash) ? raw_source.with_indifferent_access : raw_source
+          ActionSpec::Schema::Resolver.new(
+            field:,
+            source: field_source,
+            context: controller,
+            coerce:,
+            result:,
+            path: []
+          ).resolve
+        end
+
+        def params_source
+          controller.params.to_unsafe_h
+        end
+
+        def path_source
+          controller.request.path_parameters.except(:controller, :action)
+        end
+
+        def header_source
+          controller.request.headers.to_h
+        end
+
+        def cookie_source
+          return {} unless controller.respond_to?(:cookies, true)
+
+          controller.send(:cookies).to_hash
+        end
+
+        def normalize_headers(headers)
+          headers.each_with_object(HeaderHash.new) do |(key, value), normalized|
+            normalized[key] = value
+          end
+        end
+
+        def storage_key(field, location)
+          return field.name.to_s.tr("_", "-").downcase if location == :headers
+
+          field.name
+        end
+    end
+  end
+end

data/lib/action_spec/validator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "action_spec/validator/runner"
+
+module ActionSpec
+  module Validator
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from ActionSpec::InvalidParameters, with: :render_invalid_parameters if ActionSpec.config.rescue_invalid_parameters
+    end
+
+    def px
+      @px ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def validate_params!
+      @px = validate_with(coerce: false)
+    end
+
+    def validate_and_coerce_params!
+      @px = validate_with(coerce: true)
+    end
+
+    private
+
+      def validate_with(coerce:)
+        endpoint = self.class.respond_to?(:action_spec_for) ? self.class.action_spec_for(action_name) : nil
+        return ActiveSupport::HashWithIndifferentAccess.new unless endpoint
+
+        result = Runner.new(endpoint:, controller: self, coerce:).call
+        raise ActionSpec.config.invalid_parameters_exception_class.new(result) if result.invalid?
+
+        result.px
+      end
+
+      def render_invalid_parameters(error)
+        if (renderer = ActionSpec.config.invalid_parameters_renderer)
+          return renderer.arity == 2 ? renderer.call(self, error) : instance_exec(error, &renderer)
+        end
+
+        render json: { errors: error.errors.to_hash(full_messages: true) },
+               status: ActionSpec.config.invalid_parameters_status
+      end
+  end
+end

data/lib/action_spec/version.rb

@@ -0,0 +1,3 @@
+module ActionSpec
+  VERSION = "0.1.0"
+end

data/lib/action_spec.rb

@@ -0,0 +1,24 @@
+require "action_spec/version"
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "action_spec/configuration"
+require "action_spec/header_hash"
+require "action_spec/validation_result"
+require "action_spec/invalid_parameters"
+require "action_spec/doc"
+require "action_spec/schema"
+require "action_spec/validator"
+require "action_spec/railtie"
+
+module ActionSpec
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end

data/lib/tasks/action_spec_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :action_spec do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: action_spec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- zhandao
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: Concise and Powerful API Documentation Solution for Rails.
+email:
+- a@skipping.cat
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/locales/en.yml
+- config/locales/zh.yml
+- lib/action_spec.rb
+- lib/action_spec/configuration.rb
+- lib/action_spec/doc.rb
+- lib/action_spec/doc/dsl.rb
+- lib/action_spec/doc/endpoint.rb
+- lib/action_spec/header_hash.rb
+- lib/action_spec/invalid_parameters.rb
+- lib/action_spec/railtie.rb
+- lib/action_spec/schema.rb
+- lib/action_spec/schema/array_of.rb
+- lib/action_spec/schema/base.rb
+- lib/action_spec/schema/field.rb
+- lib/action_spec/schema/object_of.rb
+- lib/action_spec/schema/resolver.rb
+- lib/action_spec/schema/scalar.rb
+- lib/action_spec/schema/type_caster.rb
+- lib/action_spec/validation_result.rb
+- lib/action_spec/validator.rb
+- lib/action_spec/validator/runner.rb
+- lib/action_spec/version.rb
+- lib/tasks/action_spec_tasks.rake
+homepage: https://github.com/action-spec/action_spec
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/action-spec/action_spec
+  source_code_uri: https://github.com/action-spec/action_spec
+  changelog_uri: https://github.com/action-spec/action_spec/CHANils.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Concise and Powerful API Documentation Solution for Rails.
+test_files: []