camille 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc11ed315c4734ac80beb3ae93d6bf723f999f20a9a0aa4a48852887b71c6e62
-  data.tar.gz: ef779ddcd4a19ab7da7d2993532d8bf1f26b575cd5b4c7fbb286ab33c436b1f6
+  metadata.gz: f5911a8f4d1519a2a373ebee118bce4f110d64f5eaeafece5c8c8e46580b5c20
+  data.tar.gz: b59a4600bd145350d1217219b0074ffb6e80d8cdc97318995b6ba2b0bffe7450
 SHA512:
-  metadata.gz: 3199c11e71dfbdbc668ce4951fdad1f63621978f7c0ba5973ac5583bcd7e1864d2cd02c4a14a28e9ab97d8bdee3f882a62bdc96998eb742193769591e0e238ba
-  data.tar.gz: dffe0a0f65c35cda70b1771849e1bb871d27a19b5af27790c5e29f43b47981e61d6e2c2fa9e8f7cefcb6cd8bb83f16e7e775a35ad8b6c5b42234bcf4403cfb9c
+  metadata.gz: 3088068a948ca92e1a6bc90690c5f27d5e2c788c3f76e2ba40b5ebf62b7c3fdffac809411941a3f05a77ace636ce16bf7742c12c1ae5700c4b45d7bfb9fdddfb
+  data.tar.gz: c6f0a0b72216805bf591bc4289172e69382f702ccc14d161a3b63267dc83816a47045e9d61884029349543aac5ecf5aeb43bbc82f0c95ef23ff7df569037b8b6

data/Gemfile

@@ -8,3 +8,6 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+
+gem "rails"
+gem "rspec-rails"

data/Gemfile.lock

@@ -2,11 +2,140 @@ PATH
   remote: .
   specs:
     camille (0.1.0)
+      rails (>= 6.1, < 8)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actioncable (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activejob (= 7.0.4.2)
+      activerecord (= 7.0.4.2)
+      activestorage (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      actionview (= 7.0.4.2)
+      activejob (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.4.2)
+      actionview (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activerecord (= 7.0.4.2)
+      activestorage (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.4.2)
+      activesupport (= 7.0.4.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.4.2)
+      activesupport (= 7.0.4.2)
+      globalid (>= 0.3.6)
+    activemodel (7.0.4.2)
+      activesupport (= 7.0.4.2)
+    activerecord (7.0.4.2)
+      activemodel (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+    activestorage (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activejob (= 7.0.4.2)
+      activerecord (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.4.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    builder (3.2.4)
+    concurrent-ruby (1.2.2)
+    crass (1.0.6)
+    date (3.3.3)
     diff-lcs (1.5.0)
+    erubi (1.12.0)
+    globalid (1.1.0)
+      activesupport (>= 5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.19.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.17.0)
+    net-imap (0.3.4)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.1)
+      timeout
+    net-smtp (0.3.3)
+      net-protocol
+    nio4r (2.5.8)
+    nokogiri (1.14.2-x86_64-linux)
+      racc (~> 1.4)
+    racc (1.6.2)
+    rack (2.2.6.3)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rails (7.0.4.2)
+      actioncable (= 7.0.4.2)
+      actionmailbox (= 7.0.4.2)
+      actionmailer (= 7.0.4.2)
+      actionpack (= 7.0.4.2)
+      actiontext (= 7.0.4.2)
+      actionview (= 7.0.4.2)
+      activejob (= 7.0.4.2)
+      activemodel (= 7.0.4.2)
+      activerecord (= 7.0.4.2)
+      activestorage (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      bundler (>= 1.15.0)
+      railties (= 7.0.4.2)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.5.0)
+      loofah (~> 2.19, >= 2.19.1)
+    railties (7.0.4.2)
+      actionpack (= 7.0.4.2)
+      activesupport (= 7.0.4.2)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
     rake (13.0.6)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -20,15 +149,33 @@ GEM
     rspec-mocks (3.12.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
+    rspec-rails (6.0.1)
+      actionpack (>= 6.1)
+      activesupport (>= 6.1)
+      railties (>= 6.1)
+      rspec-core (~> 3.11)
+      rspec-expectations (~> 3.11)
+      rspec-mocks (~> 3.11)
+      rspec-support (~> 3.11)
     rspec-support (3.12.0)
+    thor (1.2.1)
+    timeout (0.3.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
   camille!
+  rails
   rake (~> 13.0)
   rspec (~> 3.0)
+  rspec-rails
 
 BUNDLED WITH
    2.2.33

data/Rakefile

@@ -3,6 +3,21 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+spec_gem_task = RSpec::Core::RakeTask.new(:spec_gem)
+spec_gem_task.exclude_pattern = 'spec/camille/rails/*_spec.rb'
+
+spec_rails_task = RSpec::Core::RakeTask.new(:spec_rails)
+spec_rails_task.pattern = 'spec/camille/rails/*_spec.rb'
 
 task default: :spec
+
+task :spec do
+  Rake::Task[:spec_gem].invoke
+
+  ENV['RAILS_ENV'] = 'test'
+  Rake::Task[:spec_rails].invoke
+
+  ENV['RAILS_ENV'] = 'development'
+  Rake::Task[:spec_rails].reenable
+  Rake::Task[:spec_rails].invoke
+end

data/lib/camille/basic_type.rb

@@ -0,0 +1,40 @@
+module Camille
+  # This class specifies the methods available for all types includeing built-in and custom ones.
+  class BasicType
+    class InvalidTypeError < ::ArgumentError; end
+
+    def | other
+      Camille::Types::Union.new(self, other)
+    end
+
+    def []
+      Camille::Types::Array.new(self)
+    end
+
+    def self.| other
+      Camille::Type.instance(self) | other
+    end
+
+    def self.[]
+      Camille::Type.instance(self)[]
+    end
+
+    def self.directly_instantiable?
+      instance_method(:initialize).arity == 0
+    end
+
+    def self.instance value
+      if value.is_a? ::Hash
+        Camille::Types::Object.new(value)
+      elsif value.is_a? ::Array
+        Camille::Types::Tuple.new(value)
+      elsif value.is_a? Camille::BasicType
+        value
+      elsif value.is_a?(Class) && value < Camille::BasicType && value.directly_instantiable?
+        value.new
+      else
+        raise InvalidTypeError.new("#{value} cannot be converted to a type instance.")
+      end
+    end
+  end
+end

data/lib/camille/code_generator.rb

@@ -0,0 +1,22 @@
+require 'stringio'
+
+module Camille
+  module CodeGenerator
+    def self.generate_ts
+      io = StringIO.new
+      io.puts "// This file is automatically generated."
+      io.puts Camille::Configuration.ts_header
+      io.puts
+      Camille::Types.literal_lines.each do |line|
+        io.puts "export #{line}"
+      end
+      io.puts
+      io.print "export default "
+      Camille::Schemas.literal_lines.each do |line|
+        io.puts line
+      end
+      io.string
+    end
+
+  end
+end

data/lib/camille/configuration.rb

@@ -0,0 +1,22 @@
+
+module Camille
+  class Configuration
+    class << self
+      def ts_header= string
+        @ts_header = string
+      end
+
+      def ts_header
+        @ts_header
+      end
+
+      def ts_location= string
+        @ts_location = string
+      end
+
+      def ts_location
+        @ts_location
+      end
+    end
+  end
+end

data/lib/camille/controller_extension.rb

@@ -0,0 +1,46 @@
+module Camille
+  module ControllerExtension
+    class TypeError < ::StandardError; end
+    class ArgumentError < ::ArgumentError; end
+
+    def camille_schema
+      @camille_schema ||= Camille::Loader.controller_name_to_schema_map[self.class.name]
+    end
+
+    def camille_endpoint
+      camille_schema && camille_schema.endpoints[action_name.to_sym]
+    end
+
+    def render *args
+      if endpoint = camille_endpoint
+        render_options = args.last
+        if value = render_options[:json]
+          error = endpoint.response_type.check(value)
+          if error
+            Camille::TypeErrorPrinter.new(error).print
+            raise TypeError.new("Type check failed for response.")
+          else
+            if value.is_a? Hash
+              value.deep_transform_keys!{|k| k.to_s.camelize(:lower)}
+            end
+            super(json: value)
+          end
+        else
+          raise ArgumentError.new("Expected key :json for `render` call.")
+        end
+      else
+        super
+      end
+    end
+
+    def process_action(*)
+      if endpoint = camille_endpoint
+        params.deep_transform_keys!{|key| key.to_s.underscore}
+        super
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/camille/core_ext.rb

@@ -0,0 +1,33 @@
+module Camille
+  module CoreExt
+    module NULL_VALUE; end
+
+    refine ::Hash do
+      def [] key = NULL_VALUE
+        if key == NULL_VALUE
+          Camille::Types::Object.new(self)[]
+        else
+          super
+        end
+      end
+
+      def | other
+        Camille::Types::Union.new(Camille::Types::Object.new(self), other)
+      end
+    end
+
+    refine ::Array do
+      def [] key = NULL_VALUE
+        if key == NULL_VALUE
+          Camille::Types::Tuple.new(self)[]
+        else
+          super
+        end
+      end
+
+      def | other
+        Camille::Types::Union.new(Camille::Types::Tuple.new(self), other)
+      end
+    end
+  end
+end

data/lib/camille/endpoint.rb

@@ -0,0 +1,50 @@
+module Camille
+  class Endpoint
+    class ArgumentError < ::ArgumentError; end
+    class UnknownResponseError < ::ArgumentError; end
+
+    attr_reader :params_type, :response_type, :verb, :name, :schema
+
+    def initialize schema, verb, name
+      @verb = verb
+      @name = name
+      @schema = schema
+    end
+
+    def signature
+      unless @response_type
+        raise UnknownResponseError.new("Endpoint lacking a `response` definition.")
+      end
+      if @params_type
+        "#{ActiveSupport::Inflector.camelize @name, false}(params: #{@params_type.literal}): Promise<#{@response_type.literal}>"
+      else
+        "#{ActiveSupport::Inflector.camelize @name, false}(): Promise<#{@response_type.literal}>"
+      end
+    end
+
+    def path
+      "#{@schema.path}/#{name}"
+    end
+
+    def function
+      if @params_type
+        "#{signature}{ return request('#{@verb}', '#{path}', params) }"
+      else
+        "#{signature}{ return request('#{@verb}', '#{path}', {}) }"
+      end
+    end
+
+    private
+      def params type
+        if type.is_a?(::Hash)
+          @params_type = Camille::Type.instance type
+        else
+          raise ArgumentError.new("`params` requires a hash as input, got #{type.inspect}.")
+        end
+      end
+
+      def response type
+        @response_type = Camille::Type.instance type
+      end
+  end
+end

data/lib/camille/line.rb

@@ -0,0 +1,43 @@
+module Camille
+  # lines with indentation
+  class Line
+    attr_reader :string, :indent
+
+    def initialize string, indent = 0
+      @string = string
+      @indent = indent
+    end
+
+    def do_indent
+      @indent += 2
+      self
+    end
+
+    def == other
+      @string == other.string && @indent == other.indent
+    end
+
+    def prepend str
+      @string = str + @string
+      self
+    end
+
+    def append str
+      @string = @string + str
+      self
+    end
+
+    def to_s
+      ' ' * @indent + @string
+    end
+
+    def self.join lines, delimiter
+      size = lines.size
+      lines.each_with_index do |line, index|
+        if index < size - 1
+          line.append(delimiter)
+        end
+      end
+    end
+  end
+end

data/lib/camille/loader.rb

@@ -0,0 +1,92 @@
+require 'thread'
+require 'monitor'
+
+module Camille
+  module Loader
+    extend MonitorMixin
+
+    class << self
+      def setup_zeitwerk_loader app
+        synchronize do
+          loader = Zeitwerk::Loader.new
+          loader.enable_reloading if !app.config.cache_classes
+          loader.push_dir "#{app.root}/config/camille/types", namespace: Camille::Types
+          loader.push_dir "#{app.root}/config/camille/schemas", namespace: Camille::Schemas
+
+          loader.setup
+          @zeitwerk_loader = loader
+          @configuration_location = "#{app.root}/config/camille/configuration.rb"
+
+          eager_load
+          construct_controller_name_to_schema_map
+        end
+      end
+
+      def eager_load
+        @eager_loading = true
+        load @configuration_location
+        @zeitwerk_loader.eager_load
+        @eager_loading = false
+      end
+
+      def eager_loading?
+        @eager_loading
+      end
+
+      def reload_types_and_schemas
+        synchronize do
+          Camille::Loader.loaded_types.clear
+          Camille::Loader.loaded_schemas.clear
+          @zeitwerk_loader.reload
+          eager_load
+          construct_controller_name_to_schema_map
+        end
+      end
+
+      def register_routes router_context
+        Camille::Loader.loaded_schemas.each do |schema|
+          schema.endpoints.each do |name, endpoint|
+            router_context.public_send(endpoint.verb, endpoint.path, controller: schema.path.gsub(/^\//, ''), action: endpoint.name, as: false)
+          end
+        end
+      end
+
+      def loaded_types
+        synchronize do
+          @loaded_types ||= []
+        end
+      end
+
+      def loaded_schemas
+        synchronize do
+          @loaded_schemas ||= []
+        end
+      end
+
+      def controller_name_to_schema_map
+        synchronize do
+          @controller_name_to_schema_map ||= {}
+        end
+      end
+
+      def construct_controller_name_to_schema_map
+        synchronize do
+          controller_name_to_schema_map.clear
+          loaded_schemas.each do |schema|
+            controller_class_name = "#{schema.klass_name}Controller"
+            controller_name_to_schema_map[controller_class_name] = schema
+          end
+        end
+      end
+
+      def reload
+        synchronize do
+          reload_types_and_schemas
+          Rails.application.reload_routes!
+        end
+      end
+
+    end
+
+  end
+end

data/lib/camille/main_controller.rb

@@ -0,0 +1,13 @@
+require 'action_controller'
+
+module Camille
+  class MainController < ActionController::Base
+    def endpoints_ts
+      if Rails.env.development?
+        render plain: Camille::CodeGenerator.generate_ts
+      else
+        head 404
+      end
+    end
+  end
+end

data/lib/camille/railtie.rb

@@ -0,0 +1,33 @@
+require "rails"
+
+module Camille
+  class Railtie < ::Rails::Railtie
+
+    initializer "camille.configure_rails" do |app|
+      ActionController::API.include(Camille::ControllerExtension)
+      ActionController::Base.include(Camille::ControllerExtension)
+
+      Camille::Loader.setup_zeitwerk_loader(app)
+
+      app.routes.prepend do
+        get '/camille/endpoints.ts' => 'camille/main#endpoints_ts'
+        Camille::Loader.register_routes(self)
+      end
+
+      dir = "#{Rails.root}/config/camille"
+
+      update_checker = ActiveSupport::FileUpdateChecker.new([], {dir => ['rb']}) do
+        Camille::Loader.reload
+      end
+
+      app.reloaders << update_checker
+
+      app.reloader.to_run do
+        require_unload_lock!
+        update_checker.execute_if_updated
+      end
+
+    end
+
+  end
+end

data/lib/camille/schema.rb

@@ -0,0 +1,60 @@
+module Camille
+  class Schema
+    class AlreadyDefinedError < ::ArgumentError; end
+
+    include Camille::Types
+
+    def self.endpoints
+      @endpoints ||= {}
+    end
+
+    def self.const_missing name
+      if Camille::Loader.eager_loading?
+        Camille::Types.const_get(name)
+      else
+        super
+      end
+    end
+
+    def self.path
+      "/#{ActiveSupport::Inflector.underscore klass_name}"
+    end
+
+    def self.klass_name
+      self.name.gsub(/^Camille::Schemas::/, '')
+    end
+
+    def self.literal_lines
+      [
+        Camille::Line.new('{'),
+        *endpoints.map do |k, e|
+          Camille::Line.new("#{e.function},")
+        end.map(&:do_indent),
+        Camille::Line.new('}')
+      ]
+    end
+
+    def self.inherited klass
+      Camille::Loader.loaded_schemas << klass
+    end
+
+    private
+      def self.define_endpoint verb, name, &block
+        if endpoints[name]
+          raise AlreadyDefinedError.new("Endpoint `#{name}` has already been defined.")
+        end
+        endpoint = Camille::Endpoint.new self, verb, name
+        endpoint.instance_exec &block
+
+        endpoints[name] = endpoint
+      end
+
+      def self.get name, &block
+        define_endpoint :get, name, &block
+      end
+
+      def self.post name, &block
+        define_endpoint :post, name, &block
+      end
+  end
+end

data/lib/camille/schemas.rb

@@ -0,0 +1,47 @@
+module Camille
+  module Schemas
+    def self.literal_lines
+      [
+        Camille::Line.new('{'),
+        tree_literal_lines(namespace_tree).map(&:do_indent),
+        Camille::Line.new('}')
+      ]
+    end
+
+    private
+      def self.namespace_tree
+        tree = {}
+
+        Camille::Loader.loaded_schemas.sort_by(&:klass_name).each do |s|
+          path = s.klass_name.split('::')
+          *namespaces, schema_name = path
+
+          level = namespaces.inject(tree) do |level, namespace|
+            level[namespace] ||= {}
+            level[namespace]
+          end
+
+          level[schema_name] = s
+        end
+
+        tree
+      end
+
+      def self.tree_literal_lines tree
+        tree.map do |key, value|
+          if value.is_a? ::Hash
+            [
+              Camille::Line.new("#{ActiveSupport::Inflector.camelize(key, false)}: {"),
+              tree_literal_lines(value).map(&:do_indent),
+              Camille::Line.new('},')
+            ]
+          else
+            value.literal_lines.tap do |lines|
+              lines.first.prepend("#{ActiveSupport::Inflector.camelize(key, false)}: ")
+              lines.last.append(',')
+            end
+          end
+        end.flatten
+      end
+  end
+end

data/lib/camille/type.rb

@@ -0,0 +1,45 @@
+module Camille
+  # This class represents all custom types defined by the user.
+  class Type < BasicType
+    class NotImplementedError < ::NotImplementedError; end
+    include Camille::Types
+
+    attr_reader :underlying
+
+    def initialize
+      raise NotImplementedError.new("Missing `alias_of` definition for type.")
+    end
+
+    def self.alias_of type
+      underlying = Camille::Type.instance(type)
+
+      define_method(:initialize) do
+        @underlying = underlying
+      end
+    end
+
+    def check value
+      @underlying.check value
+    end
+
+    def self.klass_name
+      name.gsub(/^Camille::Types::/, '')
+    end
+
+    def literal
+      self.class.klass_name.gsub(/::/, '_')
+    end
+
+    def self.const_missing name
+      if Camille::Loader.eager_loading?
+        Camille::Types.const_get(name)
+      else
+        super
+      end
+    end
+
+    def self.inherited klass
+      Camille::Loader.loaded_types << klass
+    end
+  end
+end

data/lib/camille/type_error.rb

@@ -0,0 +1,21 @@
+module Camille
+  class TypeError
+    class ArgumentError < ::ArgumentError; end
+
+    attr_reader :message, :components
+
+    def initialize message = nil, **components
+      if message.is_a? String
+        @message = message
+      elsif !components.empty?
+        @components = components
+      else
+        raise ArgumentError.new("Expecting one string or one hash.")
+      end
+    end
+
+    def basic?
+      !!@message
+    end
+  end
+end

data/lib/camille/type_error_printer.rb

@@ -0,0 +1,29 @@
+module Camille
+  class TypeErrorPrinter
+    INDENTATION = 2
+
+    def initialize error
+      @error = error
+    end
+
+    def print io = STDOUT
+      if @error.basic?
+        io.puts @error.message
+      else
+        print_composite_error io, @error, 0
+      end
+    end
+
+    private
+      def print_composite_error io, error, indentation
+        error.components.each do |key, error|
+          if error.basic?
+            io.puts ' ' * indentation + "#{key}: #{error.message}"
+          else
+            io.puts ' ' * indentation + "#{key}:"
+            print_composite_error io, error, indentation + 2
+          end
+        end
+      end
+  end
+end

data/lib/camille/types/any.rb

@@ -0,0 +1,12 @@
+module Camille
+  module Types
+    class Any < Camille::BasicType
+      def check value
+      end
+
+      def literal
+        "any"
+      end
+    end
+  end
+end

data/lib/camille/types/array.rb

@@ -0,0 +1,26 @@
+module Camille
+  module Types
+    class Array < Camille::BasicType
+      attr_reader :content
+
+      def initialize content
+        @content = Camille::Type.instance content
+      end
+
+      def check value
+        if value.is_a? ::Array
+          errors = value.map.with_index{|e, i| ["array[#{i}]", @content.check(e)]}.select{|x| x[1]}
+          unless errors.empty?
+            Camille::TypeError.new(**errors.to_h)
+          end
+        else
+          Camille::TypeError.new("Expected array, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "#{@content.literal}[]"
+      end
+    end
+  end
+end

data/lib/camille/types/boolean.rb

@@ -0,0 +1,15 @@
+module Camille
+  module Types
+    class Boolean < Camille::BasicType
+      def check value
+        unless value == false || value == true
+          Camille::TypeError.new("Expected boolean, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "boolean"
+      end
+    end
+  end
+end

data/lib/camille/types/null.rb

@@ -0,0 +1,15 @@
+module Camille
+  module Types
+    class Null < Camille::BasicType
+      def check value
+        unless value == nil
+          Camille::TypeError.new("Expected nil, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "null"
+      end
+    end
+  end
+end

data/lib/camille/types/number.rb

@@ -0,0 +1,16 @@
+module Camille
+  module Types
+    class Number < Camille::BasicType
+
+      def check value
+        unless value.is_a?(Integer) || value.is_a?(Float)
+          Camille::TypeError.new("Expected number, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "number"
+      end
+    end
+  end
+end

data/lib/camille/types/object.rb

@@ -0,0 +1,46 @@
+module Camille
+  module Types
+    class Object < Camille::BasicType
+      attr_reader :fields
+
+      def initialize fields
+        @fields = normalize_fields fields
+      end
+
+      def check value
+        if value.is_a? Hash
+          errors = @fields.map do |key, type|
+            [key.to_s, type.check(value[key])]
+          end.select{|x| x[1]}
+
+          unless errors.empty?
+            Camille::TypeError.new(**errors.to_h)
+          end
+        else
+          Camille::TypeError.new("Expected hash, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "{#{@fields.map{|k,v| "#{ActiveSupport::Inflector.camelize k.to_s, false}: #{v.literal}"}.join(', ')}}"
+      end
+
+      private
+        def normalize_fields fields
+          fields.map do |key, value|
+            type = Camille::Type.instance(value)
+            if key.end_with?('?')
+              new_key = remove_question_mark(key)
+              [new_key, type | Camille::Types::Undefined.new]
+            else
+              [key, type]
+            end
+          end.to_h
+        end
+
+        def remove_question_mark sym
+          sym.to_s.gsub(/\?$/, '').to_sym
+        end
+    end
+  end
+end

data/lib/camille/types/string.rb

@@ -0,0 +1,15 @@
+module Camille
+  module Types
+    class String < Camille::BasicType
+      def check value
+        unless value.is_a? ::String
+          Camille::TypeError.new("Expected string, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "string"
+      end
+    end
+  end
+end

data/lib/camille/types/tuple.rb

@@ -0,0 +1,29 @@
+module Camille
+  module Types
+    class Tuple < Camille::BasicType
+      attr_reader :elements
+
+      def initialize elements
+        @elements = elements.map{|e| Camille::Type.instance e}
+      end
+
+      def check value
+        if value.is_a? ::Array
+          errors = @elements.map.with_index do |type, index|
+            ["tuple[#{index}]", type.check(value[index])]
+          end.select{|x| x[1]}
+
+          unless errors.empty?
+            Camille::TypeError.new(**errors.to_h)
+          end
+        else
+          Camille::TypeError.new("Expected array, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "[#{elements.map(&:literal).join(', ')}]"
+      end
+    end
+  end
+end

data/lib/camille/types/undefined.rb

@@ -0,0 +1,15 @@
+module Camille
+  module Types
+    class Undefined < Camille::BasicType
+      def check value
+        unless value == nil
+          Camille::TypeError.new("Expected nil, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        "undefined"
+      end
+    end
+  end
+end

data/lib/camille/types/union.rb

@@ -0,0 +1,29 @@
+module Camille
+  module Types
+    class Union < Camille::BasicType
+      attr_reader :left, :right
+
+      def initialize left, right
+        @left = Camille::Type.instance left
+        @right = Camille::Type.instance right
+      end
+
+      def check value
+        left_result = @left.check value
+        if left_result
+          right_result = @right.check value
+          if right_result
+            Camille::TypeError.new(
+              'union.left' => left_result,
+              'union.right' => right_result
+            )
+          end
+        end
+      end
+
+      def literal
+        "#{@left.literal} | #{@right.literal}"
+      end
+    end
+  end
+end

data/lib/camille/types.rb

@@ -0,0 +1,10 @@
+module Camille
+  module Types
+    def self.literal_lines
+      Camille::Loader.loaded_types.sort_by(&:klass_name).map do |type|
+        instance = type.new
+        Camille::Line.new("type #{instance.literal} = #{instance.underlying.literal}")
+      end
+    end
+  end
+end

data/lib/camille/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Camille
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/lib/camille.rb

@@ -1,8 +1,43 @@
 # frozen_string_literal: true
 
+require "active_support"
+
 require_relative "camille/version"
+require_relative "camille/basic_type"
+require_relative "camille/types"
+require_relative "camille/types/number"
+require_relative "camille/types/string"
+require_relative "camille/types/boolean"
+require_relative "camille/types/array"
+require_relative "camille/types/object"
+require_relative "camille/types/null"
+require_relative "camille/types/undefined"
+require_relative "camille/types/union"
+require_relative "camille/types/tuple"
+require_relative "camille/types/any"
+require_relative "camille/type"
+require_relative "camille/type_error"
+require_relative "camille/type_error_printer"
+require_relative "camille/core_ext"
+require_relative "camille/endpoint"
+require_relative "camille/schema"
+require_relative "camille/schemas"
+require_relative "camille/line"
+require_relative "camille/railtie"
+require_relative "camille/controller_extension"
+require_relative "camille/loader"
+require_relative "camille/configuration"
+require_relative "camille/code_generator"
+require_relative "camille/main_controller"
 
 module Camille
   class Error < StandardError; end
-  # Your code goes here...
+
+  def self.configure &block
+    Camille::Configuration.instance_eval &block
+  end
+
+  def self.generate_ts
+    Camille::CodeGenerator.generate_ts
+  end
 end

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: camille
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - 辻彩
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-27 00:00:00.000000000 Z
-dependencies: []
+date: 2023-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
 description: ''
 email:
 - cichol@live.cn
@@ -25,9 +45,36 @@ files:
 - bin/console
 - bin/setup
 - lib/camille.rb
+- lib/camille/basic_type.rb
+- lib/camille/code_generator.rb
+- lib/camille/configuration.rb
+- lib/camille/controller_extension.rb
+- lib/camille/core_ext.rb
+- lib/camille/endpoint.rb
+- lib/camille/line.rb
+- lib/camille/loader.rb
+- lib/camille/main_controller.rb
+- lib/camille/railtie.rb
+- lib/camille/schema.rb
+- lib/camille/schemas.rb
+- lib/camille/type.rb
+- lib/camille/type_error.rb
+- lib/camille/type_error_printer.rb
+- lib/camille/types.rb
+- lib/camille/types/any.rb
+- lib/camille/types/array.rb
+- lib/camille/types/boolean.rb
+- lib/camille/types/null.rb
+- lib/camille/types/number.rb
+- lib/camille/types/object.rb
+- lib/camille/types/string.rb
+- lib/camille/types/tuple.rb
+- lib/camille/types/undefined.rb
+- lib/camille/types/union.rb
 - lib/camille/version.rb
 homepage: https://github.com/onyxblade/camille
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/onyxblade/camille
   source_code_uri: https://github.com/onyxblade/camille
@@ -49,5 +96,5 @@ requirements: []
 rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
-summary: ''
+summary: Typed API schema for Rails with TypeScript codegen
 test_files: []