camille 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5779c76d0ca3c695e1e15d0870d94be5739449f7ad1b9422ab9944d139f3a6d1
-  data.tar.gz: 855906b19324060e4fb8578451e1fd77f692918f6722a81b9f3fbdc5cbf48fd3
+  metadata.gz: 2370ceb41fe8fdd701b99671f1d4d82678fc103218e96a10a52e60b9b2d1ad1f
+  data.tar.gz: ef8fe63ad679a1744fdef8c58971148d3642be0be2c5e23ff53b510dfef2b449
 SHA512:
-  metadata.gz: e555aebf740ecd06dcf96928a3aeafe414430a7d439a83679da90d2e60e23a97cd28bc583a473ddab76c60275e31668b76f9220ca2278c21ecceb8f2f11743fa
-  data.tar.gz: 00bf823aa9f394c1198cd492f42cd716b8bd59c08fe7e704df64aa92cdb927198ad87761f867de9b59153cba96490190292296755ef1642bd9c759820b00ecc0
+  metadata.gz: 6b8068692bd238a82cded511bad5e15d3f0993640a487b335cfd7d1592fe3c8cb45f88924753a1b580ae7448a59d58e423c29332842fa9be09472585bc810ea7
+  data.tar.gz: 71bc242a3a3fc9224c0d2e7d3598d9e4be378ff7b2a028e02b55833927cfb516d6309c44bbc7b2296b0b9b780ffe07458435e40a89a1953d6044a465621e7ef9

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.4.1
+
+### Added
+
+* Added utility types Pick and Omit
+
+### Fixed
+
+* Prevent loader errors from being silently rescued by Rails in development environment
+
+## 0.4.0
+
+The first stable release

data/Gemfile

@@ -9,5 +9,4 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
-gem "rails"
 gem "rspec-rails"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    camille (0.3.0)
+    camille (0.4.1)
       rails (>= 6.1, < 8)
 
 GEM
@@ -172,7 +172,6 @@ PLATFORMS
 
 DEPENDENCIES
   camille!
-  rails
   rake (~> 13.0)
   rspec (~> 3.0)
   rspec-rails

data/README.md

@@ -1,8 +1,33 @@
 # Camille
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/camille`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Why?
 
-TODO: Delete this and the text above, and describe your gem
+Traditionally, the JSON response from a Rails API server isn't typed. So even if we have TypeScript at the front-end, we still have little guarantee that our back-end would return the correct type and structure of data.
+
+In order to eliminate type mismatch between both ends, Camille provides a syntax for you to define type schema for your Rails API, and uses these schemas to generate the TypeScript functions for calling the API.
+
+For example, an endpoint defined in Ruby, where `data` is a controller action,
+
+```ruby
+get :data do
+  params(
+    id: Number
+  )
+  response(
+    name: String
+  )
+end
+```
+
+will become a function in TypeScript:
+
+```typescript
+data(params: {id: number}): Promise<{name: string}>
+```
+
+Therefore, if the front-end requests the API by calling `data`, we have guarantee that `id` is presented in `params`, and Camille will require the response to contain a string `name`, so the front-end can receive the correct type of data.
+
+By using these request functions, we also don't need to know about HTTP verbs and paths. It's impossible to have unrecognized routes, since Camille will make sure that each function handled by the correct Rails action.
 
 ## Installation
 
@@ -14,22 +39,215 @@ gem 'camille'
 
 And then execute:
 
-    $ bundle install
+```bash
+bundle install
+bundle exec rails g camille:install
+```
 
-Or install it yourself as:
+## Usage
 
-    $ gem install camille
+### Schemas
 
-## Usage
+A schema defines the type of `params` and `response` for a controller action. The following commands will generate schema definition files in `config/camille/schemas`.
 
-TODO: Write usage instructions here
+```bash
+# to generate a schema for ProductsController
+bundle exec rails g camille:schema products
+# to generate a schema for Api::ProductController
+bundle exec rails g camille:schema api/products
+```
 
-## Development
+An example of schema definition:
+
+```ruby
+using Camille::Syntax
+
+class Camille::Schemas::Api::Products < Camille::Schema
+  include Camille::Types
+
+  get :data do
+    params(
+      id: Number
+    )
+    response(
+      name: String
+    )
+  end
+end
+```
+
+The `Api::Products` schema defines one endpoint `data` and its params and response type. This endpoint corresponds to the `data` action on `Api::ProductsController`. Inside the action, you can assume that `params[:id]` is a number, and you will need to `render json: {name: 'some string'}` in order to pass the typecheck.
+
+When generating TypeScript request functions, the `data` endpoint will become a function having the following signature:
+
+```typescript
+data(params: {id: number}): Promise<{name: string}>
+```
+
+Therefore, the front-end user is required to provide an `id` when they call this function. And they can expect to get a `name` from the response of this request. There are no more type mismatch between both ends.
+
+The `params` type for an endpoint is required to be an object type, or a hash in Ruby, while `response` type can be any supported type, for example a `Boolean`.
+
+Camille will automatically add a Rails route for each endpoint. You don't need to do anything other than having the schema file in place.
+
+When defining an endpoint, you can also use `post` instead of `get` for non-idempotent requests. However, no other HTTP verbs are supported, because verbs in RESTful like `patch` and `delete` indicate what we do on resources, but in RPC-style design each request is merely a function call that does not concern RESTful resources.
+
+### Custom types
+
+In addition to primitive types, you can define custom types in Camille. The following commands will generate type definition files in `config/camille/types`.
+
+```bash
+# to generate a type named Product
+rails g camille:type product
+# to generate a type named Nested::Product
+rails g camille:type nested/product
+```
+
+An example of custom type definition:
+
+```ruby
+using Camille::Syntax
+
+class Camille::Types::Product < Camille::Type
+  include Camille::Types
+
+  alias_of(
+    id: Number,
+    name: String
+  )
+end
+```
+
+Each custom type is considered a type alias in TypeScript. And `alias_of` defines what this type is aliasing. In this case, the `Product` type is an alias of an object type having fields `id` as `Number` and `name` as `String`. When generating TypeScript, it will be converted to the following:
+
+```typescript
+type Product = {id: number, name: string}
+```
+
+### Available syntax for types
+
+Camille supports most of the type syntax in TypeScript. Below is a list of types that you can use in type and schema definition.
+
+```ruby
+params(
+  # primitive types in TypeScript
+  number: Number,
+  string: String,
+  boolean: Boolean,
+  null: Null,
+  undefined: Undefined,
+  any: Any,
+  # an array type is a type name followed by '[]'
+  array: Number[],
+  # an object type looks like hash
+  object: {
+    field: Number
+  },
+  # an array of objects also works
+  object_array: {
+    field: Number
+  }[]
+  # a union type is two types connected by '|'
+  union: Number | String,
+  # a tuple type is several types put inside '[]'
+  tuple: [Number, String, Boolean],
+  # a field followed by '?' is optional, the same as in TypeScript
+  optional?: Number,
+  # literal types
+  number_literal: 1,
+  string_literal: 'hello',
+  # a custom type we defined above
+  product: Product,
+  # Pick and Omit use [] to enclose parameters instead of <>
+  pick: Pick[{a: 1, b: 2}, 'a' | 'b'],
+  omit: Omit[Product, 'id']
+)
+```
+
+### TypeScript generation
+
+After you have your types and schemas in place, you can visit `/camille/endpoints.ts` in development environment to have the TypeScript request functions generated.
+
+An example from our previously defined type and schema will be:
+
+```typescript
+import request from './request'
+
+export type Product = {id: number, name: string}
+
+export default {
+  api: {
+    data(params: {id: number}): Promise<{name: string}> {
+      return request('get', '/api/products/data', params)
+    }
+  }
+}
+```
+
+The first line of `import` is configurable as `config.ts_header` in `config/camille/configuration.rb`. You would need to implement a `request` function that performs the HTTP request.
+
+### Conversion between camelCase and snake_case
+
+In TypeScript world, people usually use camelCase to name functions and variables, while in Ruby the convention is to use snake_case. Camille will automatically convert between these two when processing request.
+
+For example,
+
+```ruby
+get :special_data do
+  params(
+    long_id: Number
+  )
+  response(
+    long_name: String
+  )
+end
+```
+
+will have TS signature:
+
+```typescript
+specialData(params: {longId: number}): Promise<{longName: string}>
+```
+
+In the Rails action you still use `params[:long_id]` to access the parameter and return `long_name` in response.
+
+### Typechecking
+
+If a controller action has a corresponding schema, Camille will raise an error if the returned JSON doesn't match the response type specified in the schema.
+
+For example for
+```ruby
+response(
+  object: {
+    array: Number[]
+  }
+)
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+if we return such a JSON in our action
+```ruby
+render json: {
+  object: {
+    array: [1, 2, '3']
+  }
+}
+```
+
+Camille will print the following error:
+```
+object:
+  array:
+    [2]: Expected number, got "3".
+```
+
+### Reloading
+
+Everything in `config/camille/types` and `config/camille/schemas` will automatically reload after changes in development environment, just like other files in Rails.
+
+## Development
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Run tests with `bundle exec rake`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/camille.
+Bug reports and pull requests are welcome on GitHub at https://github.com/onyxblade/camille.

data/gemfiles/rails-6.1

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rspec-rails"
+
+gem 'rails', '~> 6.1.0'

data/gemfiles/rails-7.0

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rspec-rails"
+
+gem 'rails', '~> 7.0.0'

data/lib/camille/basic_type.rb

@@ -24,13 +24,18 @@ module Camille
     end
 
     def self.instance value
-      if value.is_a? ::Hash
+      case
+      when value.is_a?(::Hash)
         Camille::Types::Object.new(value)
-      elsif value.is_a? ::Array
+      when value.is_a?(::Array)
         Camille::Types::Tuple.new(value)
-      elsif value.is_a? Camille::BasicType
+      when value.is_a?(Integer) || value.is_a?(Float)
+        Camille::Types::NumberLiteral.new(value)
+      when value.is_a?(::String)
+        Camille::Types::StringLiteral.new(value)
+      when value.is_a?(Camille::BasicType)
         value
-      elsif value.is_a?(Class) && value < Camille::BasicType && value.directly_instantiable?
+      when value.is_a?(Class) && value < Camille::BasicType && value.directly_instantiable?
         value.new
       else
         raise InvalidTypeError.new("#{value} cannot be converted to a type instance.")

data/lib/camille/controller_extension.rb

@@ -17,8 +17,9 @@ module Camille
         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.")
+            string_io = StringIO.new
+            Camille::TypeErrorPrinter.new(error).print(string_io)
+            raise TypeError.new("\nType check failed for response.\n#{string_io.string}")
           else
             if value.is_a? Hash
               value.deep_transform_keys!{|k| k.to_s.camelize(:lower)}
@@ -34,6 +35,7 @@ module Camille
     end
 
     def process_action(*)
+      Camille::Loader.check_and_raise_exception
       if endpoint = camille_endpoint
         params.deep_transform_keys!{|key| key.to_s.underscore}
         super

data/lib/camille/generators/install_generator.rb

@@ -10,12 +10,12 @@ module Camille
         copy_file "configuration.rb", "config/camille/configuration.rb"
       end
 
-      def copy_type_example
-        copy_file "type_example.rb", "config/camille/types/example.rb"
+      def create_types_folder
+        copy_file ".keep", "config/camille/types/.keep"
       end
 
-      def copy_schema_example
-        copy_file "schema_example.rb", "config/camille/schemas/examples.rb"
+      def create_schemas_folder
+        copy_file ".keep", "config/camille/schemas/.keep"
       end
 
     end

data/lib/camille/generators/templates/schema_template.erb

@@ -1,4 +1,4 @@
-using Camille::CoreExt
+using Camille::Syntax
 
 class Camille::Schemas::<%= class_name %> < Camille::Schema
   include Camille::Types

data/lib/camille/generators/templates/type_template.erb

@@ -1,9 +1,9 @@
-using Camille::CoreExt
+using Camille::Syntax
 
 class Camille::Types::<%= class_name %> < Camille::Type
   include Camille::Types
 
-  alias_of(
-    # id: Number
-  )
+  # alias_of(
+  #   id: Number
+  # )
 end

data/lib/camille/loader.rb

@@ -41,11 +41,23 @@ module Camille
 
       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
+          begin
+            @exception = nil
+            Camille::Loader.loaded_types.clear
+            Camille::Loader.loaded_schemas.clear
+            @zeitwerk_loader.reload
+            eager_load
+            construct_controller_name_to_schema_map
+          rescue Exception => e
+            @exception = e
+            raise e
+          end
+        end
+      end
+
+      def check_and_raise_exception
+        if @exception
+          raise @exception
         end
       end
 

data/lib/camille/main_controller.rb

@@ -3,6 +3,7 @@ require 'action_controller'
 module Camille
   class MainController < ActionController::Base
     def endpoints_ts
+      Camille::Loader.check_and_raise_exception
       render plain: Camille::CodeGenerator.generate_ts
     end
   end

data/lib/camille/pick_and_omit.rb

@@ -0,0 +1,51 @@
+module Camille
+  # shared base class for Pick and Omit
+  class PickAndOmit < Camille::BasicType
+    class ArgumentError < ::ArgumentError; end
+
+    def initialize type, keys
+      @type = Camille::Type.instance(type)
+      case
+      when @type.is_a?(Camille::Types::Object)
+        @target_object = @type
+      when @type.is_a?(Camille::Type) && @type.underlying.is_a?(Camille::Types::Object)
+        @target_object = @type.underlying
+      else
+        raise ArgumentError.new("Currently onle an object type or an alias of object type is supported in #{klass_name}. Got #{type.inspect}.")
+      end
+
+      @keys = Camille::Type.instance(keys)
+      case
+      when @keys.is_a?(Camille::Types::StringLiteral)
+        @keys_array = [@keys.value].map(&:to_sym)
+      when @keys.is_a?(Camille::Types::Union)
+        unfolded = unfold_union(@keys).flatten
+        if unfolded.all?{|x| x.is_a?(Camille::Types::StringLiteral)}
+          @keys_array = unfolded.map(&:value).map(&:to_sym)
+        else
+          raise ArgumentError.new("The second argument of #{klass_name} has to be a string literal or an union of string literals. Got #{keys.inspect}.")
+        end
+      else
+        raise ArgumentError.new("The second argument of #{klass_name} has to be a string literal or an union of string literals. Got #{keys.inspect}.")
+      end
+    end
+
+    def literal
+      "#{klass_name}<#{@type.literal}, #{@keys.literal}>"
+    end
+
+    def self.[] type, keys
+      self.new type, keys
+    end
+
+    private
+      def unfold_union type
+        if type.is_a?(Camille::Types::Union)
+          [unfold_union(type.left), unfold_union(type.right)]
+        else
+          [type]
+        end
+      end
+
+  end
+end

data/lib/camille/syntax.rb

@@ -0,0 +1,75 @@
+module Camille
+  module Syntax
+    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
+
+    refine Integer do
+      def [] key = NULL_VALUE
+        if key == NULL_VALUE
+          Camille::Types::NumberLiteral.new(self)[]
+        else
+          super
+        end
+      end
+
+      def | other
+        Camille::Types::Union.new(Camille::Types::NumberLiteral.new(self), other)
+      end
+    end
+
+    refine Float do
+      def [] key = NULL_VALUE
+        if key == NULL_VALUE
+          Camille::Types::NumberLiteral.new(self)[]
+        else
+          super
+        end
+      end
+
+      def | other
+        Camille::Types::Union.new(Camille::Types::NumberLiteral.new(self), other)
+      end
+    end
+
+    refine ::String do
+      def [] key = NULL_VALUE
+        if key == NULL_VALUE
+          Camille::Types::StringLiteral.new(self)[]
+        else
+          super
+        end
+      end
+
+      def | other
+        Camille::Types::Union.new(Camille::Types::StringLiteral.new(self), other)
+      end
+    end
+  end
+end

data/lib/camille/type_error_printer.rb

@@ -18,9 +18,9 @@ module Camille
       def print_composite_error io, error, indentation
         error.components.each do |key, error|
           if error.basic?
-            io.puts ' ' * indentation + "#{key}: #{error.message}"
+            io.puts "\u00A0" * indentation + "#{key}: #{error.message}"
           else
-            io.puts ' ' * indentation + "#{key}:"
+            io.puts "\u00A0" * indentation + "#{key}:"
             print_composite_error io, error, indentation + 2
           end
         end

data/lib/camille/types/number.rb

@@ -4,7 +4,7 @@ module Camille
 
       def check value
         unless value.is_a?(Integer) || value.is_a?(Float)
-          Camille::TypeError.new("Expected number, got #{value.inspect}.")
+          Camille::TypeError.new("Expected an integer or a float, got #{value.inspect}.")
         end
       end
 

data/lib/camille/types/number_literal.rb

@@ -0,0 +1,27 @@
+module Camille
+  module Types
+    class NumberLiteral < Camille::BasicType
+      class ArgumentError < ::ArgumentError; end
+
+      attr_reader :value
+
+      def initialize value
+        if value.is_a?(Integer) || value.is_a?(Float)
+          @value = value
+        else
+          raise ArgumentError.new("Expecting an integer or a float, got #{value.inspect}")
+        end
+      end
+
+      def check value
+        unless value == @value
+          Camille::TypeError.new("Expected number literal #{@value.inspect}, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        @value.to_s
+      end
+    end
+  end
+end

data/lib/camille/types/omit.rb

@@ -0,0 +1,20 @@
+module Camille
+  module Types
+    class Omit < PickAndOmit
+      def check value
+        processed_object.check(value)
+      end
+
+      private
+        def klass_name
+          'Omit'
+        end
+
+        def processed_object
+          fields = @target_object.fields.reject{|k, _| @keys_array.include?(k)}
+          Camille::Types::Object.new(fields)
+        end
+
+    end
+  end
+end

data/lib/camille/types/pick.rb

@@ -0,0 +1,20 @@
+module Camille
+  module Types
+    class Pick < PickAndOmit
+      def check value
+        processed_object.check(value)
+      end
+
+      private
+        def klass_name
+          'Pick'
+        end
+
+        def processed_object
+          fields = @target_object.fields.select{|k, _| @keys_array.include?(k)}
+          Camille::Types::Object.new(fields)
+        end
+
+    end
+  end
+end

data/lib/camille/types/string_literal.rb

@@ -0,0 +1,27 @@
+module Camille
+  module Types
+    class StringLiteral < Camille::BasicType
+      class ArgumentError < ::ArgumentError; end
+
+      attr_reader :value
+
+      def initialize value
+        if value.is_a?(::String)
+          @value = value
+        else
+          raise ArgumentError.new("Expecting a string, got #{value.inspect}")
+        end
+      end
+
+      def check value
+        unless value == @value
+          Camille::TypeError.new("Expected string literal #{@value.inspect}, got #{value.inspect}.")
+        end
+      end
+
+      def literal
+        @value.inspect
+      end
+    end
+  end
+end

data/lib/camille/version.rb

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

data/lib/camille.rb

@@ -15,10 +15,15 @@ require_relative "camille/types/undefined"
 require_relative "camille/types/union"
 require_relative "camille/types/tuple"
 require_relative "camille/types/any"
+require_relative "camille/types/number_literal"
+require_relative "camille/types/string_literal"
+require_relative "camille/pick_and_omit"
+require_relative "camille/types/pick"
+require_relative "camille/types/omit"
 require_relative "camille/type"
 require_relative "camille/type_error"
 require_relative "camille/type_error_printer"
-require_relative "camille/core_ext"
+require_relative "camille/syntax"
 require_relative "camille/endpoint"
 require_relative "camille/schema"
 require_relative "camille/schemas"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: camille
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - 辻彩
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-16 00:00:00.000000000 Z
+date: 2023-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,33 +38,36 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- gemfiles/rails-6.1
+- gemfiles/rails-7.0
 - 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/generators/install_generator.rb
 - lib/camille/generators/schema_generator.rb
+- lib/camille/generators/templates/.keep
 - lib/camille/generators/templates/configuration.rb
-- lib/camille/generators/templates/schema_example.rb
 - lib/camille/generators/templates/schema_template.erb
-- lib/camille/generators/templates/type_example.rb
 - lib/camille/generators/templates/type_template.erb
 - lib/camille/generators/type_generator.rb
 - lib/camille/line.rb
 - lib/camille/loader.rb
 - lib/camille/main_controller.rb
+- lib/camille/pick_and_omit.rb
 - lib/camille/railtie.rb
 - lib/camille/schema.rb
 - lib/camille/schemas.rb
+- lib/camille/syntax.rb
 - lib/camille/type.rb
 - lib/camille/type_error.rb
 - lib/camille/type_error_printer.rb
@@ -74,8 +77,12 @@ files:
 - lib/camille/types/boolean.rb
 - lib/camille/types/null.rb
 - lib/camille/types/number.rb
+- lib/camille/types/number_literal.rb
 - lib/camille/types/object.rb
+- lib/camille/types/omit.rb
+- lib/camille/types/pick.rb
 - lib/camille/types/string.rb
+- lib/camille/types/string_literal.rb
 - lib/camille/types/tuple.rb
 - lib/camille/types/undefined.rb
 - lib/camille/types/union.rb

data/lib/camille/core_ext.rb

@@ -1,33 +0,0 @@
-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/generators/templates/schema_example.rb

@@ -1,35 +0,0 @@
-using Camille::CoreExt
-
-class Camille::Schemas::Examples < Camille::Schema
-  include Camille::Types
-
-  get :find do
-    params(
-      id: Number
-    )
-
-    response(
-      example?: Example
-    )
-  end
-
-  get :list do
-    response(
-      examples: Example[]
-    )
-  end
-
-  post :update do
-    params(
-      id: Number,
-      example: Example
-    )
-
-    response(
-      success: Boolean,
-      errors: {
-        message: String
-      }[]
-    )
-  end
-end

data/lib/camille/generators/templates/type_example.rb

@@ -1,10 +0,0 @@
-using Camille::CoreExt
-
-class Camille::Types::Example < Camille::Type
-  include Camille::Types
-
-  alias_of(
-    id: Number,
-    name: String,
-  )
-end