camille 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a179a530118d866cdd0d5baa3b90a454a3d4c2a5c77b47d43b3be4132587b13
-  data.tar.gz: 82341acb5d71fa1209c32c9c2fa09fdde41bbe71890fa13cfe8469b43842489b
+  metadata.gz: 7812549c03ae51c6ea3883e982770259b1757ce13b9014e63f21bf87a6522e02
+  data.tar.gz: b562c295c761474368defa4aaa5ba544a5c82d54ad013eafcd1fee5305a68b82
 SHA512:
-  metadata.gz: 744ac81f6d267007676d123e4b9111a462989adde5f060e58bde32b749c6204f6912bd2b17fcba298b2aca0ee34f91fc534356ce6d3d3acb01d450e24e839168
-  data.tar.gz: 6bcd20cd62ff6de5c7ffd15666f1f6bf0a4c2d453acc682c109cad901b9cf8e77c488685b97ad8353efbff98ef810e30e4f4286a6e03f9428d11077319989622
+  metadata.gz: 924f63558e9540098f5073ed9b806b3e73169324ad5dea5da1967f275922396f81e21db4968ba3298baa3443d65ae09561c8612a87da15dfa1549ea1404cfafb
+  data.tar.gz: 60fe1b8a0baf1df20417518f74e977431f7f9df30b1d5a6087bdef96a78b40d6782f2677f9bbdcac44e674cd676456b50c719ec0e194b069edaa8960afc7e7c5

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.6.1
+
+### Fixed
+
+* Tuple type checking now checks length.
+
 ## 0.6.0
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    camille (0.5.16)
+    camille (0.6.0)
       rails (>= 6.1, < 8.1)
 
 GEM

data/benchmarks/checking_class_of_object.rb

@@ -1,6 +1,9 @@
 require "benchmark/ips"
 
 class A
+  def is_A?
+    true
+  end
 end
 
 a = A.new
@@ -22,5 +25,9 @@ Benchmark.ips do |x|
     a.class.equal?(A)
   end
 
+  x.report("is_A?") do
+    a.is_A?
+  end
+
   x.compare!
 end

data/lib/camille/basic_type.rb

@@ -1,8 +1,16 @@
+require 'digest/md5'
+
 module Camille
   # This class specifies the methods available for all types includeing built-in and custom ones.
   class BasicType
     class InvalidTypeError < ::ArgumentError; end
 
+    attr_reader :fingerprint
+
+    def initialize
+      @fingerprint = Digest::MD5.hexdigest self.class.name
+    end
+
     def | other
       Camille::Types::Union.new(self, other)
     end
@@ -15,11 +23,6 @@ module Camille
       Camille::Types::Array.new(self)
     end
 
-    def transform_and_check value
-      transformed = transform value
-      [check(value), transformed]
-    end
-
     def transform value
       value
     end

data/lib/camille/checked.rb

@@ -0,0 +1,18 @@
+module Camille
+  class Checked
+    attr_reader :fingerprint, :value
+
+    def initialize fingerprint, value
+      @fingerprint = fingerprint
+      @value = value
+    end
+
+    def checked?
+      true
+    end
+
+    def type_error?
+      false
+    end
+  end
+end

data/lib/camille/controller.rb

@@ -19,13 +19,13 @@ module Camille
         if intended_status == 200 || intended_status == :ok
           if render_options.has_key? :json
             value = render_options[:json]
-            error, transformed = endpoint.response_type.transform_and_check(value)
-            if error
+            result = endpoint.response_type.check(value)
+            if result.type_error?
               string_io = StringIO.new
-              Camille::TypeErrorPrinter.new(error).print(string_io)
+              Camille::TypeErrorPrinter.new(result).print(string_io)
               raise TypeError.new("\nType check failed for response.\n#{string_io.string}")
             else
-              super(json: transformed)
+              super(json: result.value)
             end
           else
             raise ArgumentError.new("Expected key :json for `render` call.")

data/lib/camille/intersection_preprocessor.rb

@@ -0,0 +1,61 @@
+module Camille
+  class IntersectionPreprocessor
+    class TypeNotCompatibleError < ArgumentError; end
+
+    class << self
+      def process left, right
+        if left.instance_of?(Camille::Types::Object) && right.instance_of?(Camille::Types::Object)
+          overlapping_keys = left.fields.keys & right.fields.keys
+
+          new_left_fields = []
+          new_left_optional_keys = []
+          new_right_fields = []
+          new_right_optional_keys = []
+
+          (left.fields.keys - overlapping_keys).each do |key|
+            new_left_fields << [key, left.fields[key]]
+            new_left_optional_keys << key if left.optional_keys.include?(key)
+          end
+
+          (right.fields.keys - overlapping_keys).each do |key|
+            new_right_fields << [key, right.fields[key]]
+            new_right_optional_keys << key if right.optional_keys.include?(key)
+          end
+
+          overlapping_keys.map do |key|
+            processed_left, processed_right = IntersectionPreprocessor.process(left.fields[key], right.fields[key])
+            new_left_fields << [key, processed_left]
+            new_right_fields << [key, processed_right]
+
+            if left.optional_keys.include?(key) && right.optional_keys.include?(key)
+              new_left_optional_keys << key
+              new_right_optional_keys << key
+            end
+          end
+
+          [
+            Camille::Types::Object.new(**(apply_optional_to_fields new_left_fields, new_left_optional_keys).to_h),
+            Camille::Types::Object.new(**(apply_optional_to_fields new_right_fields, new_right_optional_keys).to_h)
+          ]
+        else
+          if left.literal == right.literal
+            [left, Camille::Types::Any.new]
+          else
+            raise TypeNotCompatibleError.new "Cannot reconcile type #{left.literal} and type #{right.literal}."
+          end
+        end
+      end
+
+      private
+        def apply_optional_to_fields fields, optional_keys
+          fields.map do |key, type|
+            if optional_keys.include?(key)
+              ["#{key.to_s}?".to_sym, type]
+            else
+              [key, type]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/camille/intersection_solver.rb

@@ -0,0 +1,50 @@
+module Camille
+  class IntersectionSolver
+    class TypeNotCompatibleError < ArgumentError; end
+
+    class << self
+      def solve a, b
+        if a.instance_of?(Camille::Types::Object) && b.instance_of?(Camille::Types::Object)
+          overlapping_keys = a.fields.keys & b.fields.keys
+
+          new_fields = []
+          new_optional_keys = []
+
+          [a, b].each do |x|
+            (x.fields.keys - overlapping_keys).each do |key|
+              new_fields << [key, x.fields[key]]
+              new_optional_keys << key if x.optional_keys.include?(key)
+            end
+          end
+
+          overlapping_keys.map do |key|
+            solved = IntersectionSolver.solve(a.fields[key], b.fields[key])
+            new_fields << [key, solved]
+            if a.optional_keys.include?(key) && b.optional_keys.include?(key)
+              new_optional_keys << key
+            end
+          end
+
+          Camille::Types::Object.new(**(apply_optional_to_fields new_fields, new_optional_keys).to_h)
+        else
+          if a.literal == b.literal
+            a
+          else
+            raise TypeNotCompatibleError.new "Cannot reconcile type #{a.literal} and type #{b.literal}."
+          end
+        end
+      end
+
+      private
+        def apply_optional_to_fields fields, optional_keys
+          fields.map do |key, type|
+            if optional_keys.include?(key)
+              ["#{key.to_s}?".to_sym, type]
+            else
+              [key, type]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/camille/pick_and_omit.rb

@@ -18,6 +18,11 @@ module Camille
         raise ArgumentError.new("The second argument of #{klass_name} has to be an array of symbols. Got #{keys.inspect}.")
       end
       @keys = keys
+      @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@type.fingerprint}#{@keys.sort}"
+    end
+
+    def check value
+      processed_object.check(value)
     end
 
     def literal

data/lib/camille/type.rb

@@ -11,24 +11,22 @@ module Camille
 
     def self.alias_of type
       underlying = Camille::Type.instance(type)
+      fingerprint = underlying.fingerprint
 
       define_method(:initialize) do
         @underlying = underlying
+        @fingerprint = fingerprint
       end
     end
 
     def check value
-      @underlying.check value
-    end
-
-    def transform_and_check value
-      transformed = transform value
-      @underlying.transform_and_check transformed
+      normalized = transform value
+      @underlying.check normalized
     end
 
     def test value
-      error, _ = transform_and_check value
-      error
+      result = check value
+      result.type_error? ? result : nil
     end
 
     def self.test value

data/lib/camille/type_error.rb

@@ -27,5 +27,13 @@ module Camille
     def to_s
       inspect
     end
+
+    def checked?
+      false
+    end
+
+    def type_error?
+      true
+    end
   end
 end

data/lib/camille/types/any.rb

@@ -2,6 +2,7 @@ module Camille
   module Types
     class Any < Camille::BasicType
       def check value
+        Camille::Checked.new(fingerprint, value)
       end
 
       def literal

data/lib/camille/types/array.rb

@@ -5,25 +5,30 @@ module Camille
 
       def initialize content
         @content = Camille::Type.instance content
+        @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@content.fingerprint}"
       end
 
-      def transform_and_check value
+      def check value
         if value.is_a? ::Array
-          transform_and_check_results = value.map.with_index do |element, index|
-            [index, @content.transform_and_check(element)]
+          results = value.map.with_index do |element, index|
+            [index, @content.check(element)]
           end
-          errors = transform_and_check_results.map do |index, (error, transformed)|
-            ["array[#{index}]", error]
-          end.select{|x| x[1]}
+
+          errors = results.map do |index, result|
+            if result.type_error?
+              ["array[#{index}]", result]
+            else
+              nil
+            end
+          end.compact
 
           if errors.empty?
-            transformed = transform_and_check_results.map{|_, (_, transformed)| transformed}
-            [nil, transformed]
+            Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
           else
-            [Camille::TypeError.new(**errors.to_h), nil]
+            Camille::TypeError.new(**errors.to_h)
           end
         else
-          [Camille::TypeError.new("Expected array, got #{value.inspect}."), nil]
+          Camille::TypeError.new("Expected array, got #{value.inspect}.")
         end
       end
 

data/lib/camille/types/boolean.rb

@@ -2,7 +2,9 @@ module Camille
   module Types
     class Boolean < Camille::BasicType
       def check value
-        unless value == false || value == true
+        if value == false || value == true
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected boolean, got #{value.inspect}.")
         end
       end

data/lib/camille/types/boolean_literal.rb

@@ -8,13 +8,16 @@ module Camille
       def initialize value
         if value == true || value == false
           @value = value
+          @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@value}"
         else
           raise ArgumentError.new("Expecting true or false, got #{value.inspect}")
         end
       end
 
       def check value
-        unless value == @value
+        if value == @value
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected boolean literal #{@value.inspect}, got #{value.inspect}.")
         end
       end

data/lib/camille/types/intersection.rb

@@ -8,24 +8,23 @@ module Camille
       def initialize left, right
         @left = Camille::Type.instance left
         @right = Camille::Type.instance right
+        @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{[@left.fingerprint, @right.fingerprint].sort}"
       end
 
-      def transform_and_check value
-        left_error, left_transformed = @left.transform_and_check value
-        if left_error
-          error = Camille::TypeError.new(
-            'intersection.left' => left_error
+      def check value
+        left_result = @left.check value
+        if left_result.type_error?
+          Camille::TypeError.new(
+            'intersection.left' => left_result
           )
-          [error, nil]
         else
-          right_error, right_transformed = @right.transform_and_check left_transformed
-          if right_error
-            error = Camille::TypeError.new(
-              'intersection.right' => right_error
+          right_result = @right.check left_result.value
+          if right_result.type_error?
+            Camille::TypeError.new(
+              'intersection.right' => right_result
             )
-            [error, nil]
           else
-            [nil, right_transformed]
+            Camille::Checked.new(fingerprint, right_result.value)
           end
         end
       end

data/lib/camille/types/null.rb

@@ -2,7 +2,9 @@ module Camille
   module Types
     class Null < Camille::BasicType
       def check value
-        unless value == nil
+        if value == nil
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected nil, got #{value.inspect}.")
         end
       end

data/lib/camille/types/number.rb

@@ -1,9 +1,10 @@
 module Camille
   module Types
     class Number < Camille::BasicType
-
       def check value
-        unless value.is_a?(Integer) || value.is_a?(Float)
+        if value.is_a?(Integer) || value.is_a?(Float)
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected an integer or a float, got #{value.inspect}.")
         end
       end

data/lib/camille/types/number_literal.rb

@@ -8,13 +8,16 @@ module Camille
       def initialize value
         if value.is_a?(Integer) || value.is_a?(Float)
           @value = value
+          @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@value}"
         else
           raise ArgumentError.new("Expecting an integer or a float, got #{value.inspect}")
         end
       end
 
       def check value
-        unless value == @value
+        if value == @value
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected number literal #{@value.inspect}, got #{value.inspect}.")
         end
       end

data/lib/camille/types/object.rb

@@ -7,37 +7,43 @@ module Camille
       def initialize fields
         @optional_keys = []
         @fields = normalize_fields fields
+        @fingerprint = generate_fingerprint
       end
 
-      def transform_and_check value
+      def check value
         if value.is_a? Hash
           keys = (@fields.keys + value.keys).uniq
-          transform_and_check_results = keys.map do |key|
-            if type = @fields[key]
-              if @optional_keys.include?(key) && value[key].nil?
-                nil
-              else
-                [key, type.transform_and_check(value[key])]
-              end
+          keys_to_check, keys_to_skip = keys.partition{|key| @fields[key]}
+
+          results = keys_to_check.map do |key|
+            type = @fields[key]
+            if @optional_keys.include?(key) && value[key].nil?
+              nil
+            else
+              [key, type.check(value[key])]
+            end
+          end.compact
+
+          errors = results.map do |key, result|
+            if result.type_error?
+              [key.to_s, result]
             else
-              [key, [nil, value[key]]]
+              nil
             end
           end.compact
 
-          errors = transform_and_check_results.map do |key, (error, transformed)|
-            [key.to_s, error]
-          end.select{|x| x[1]}
+          skipped_pairs = keys_to_skip.map do |key|
+            [key, value[key]]
+          end
 
           if errors.empty?
-            transformed = transform_and_check_results.map do |key, (error, transformed)|
-              [key, transformed]
-            end.to_h
-            [nil, Camille::ObjectHash[transformed]]
+            object = Camille::ObjectHash[results.map{|key, checked| [key, checked.value]}.concat(skipped_pairs).to_h]
+            Camille::Checked.new(fingerprint, object)
           else
-            [Camille::TypeError.new(**errors.to_h), nil]
+            Camille::TypeError.new(**errors.to_h)
           end
         else
-          [Camille::TypeError.new("Expected hash, got #{value.inspect}."), nil]
+          Camille::TypeError.new("Expected hash, got #{value.inspect}.")
         end
       end
 
@@ -74,6 +80,12 @@ module Camille
             raise ArgumentError.new("Only keys satisfying `key == key.to_s.camelize.underscore` can be used.")
           end
         end
+
+        def generate_fingerprint
+          sorted_fields = @fields.sort_by{|k, v| k}.map{|k, v| [k, v.fingerprint]}
+          sorted_optional_keys = @optional_keys.sort
+          Digest::MD5.hexdigest "#{self.class.name}#{sorted_fields}#{sorted_optional_keys}"
+        end
     end
   end
 end

data/lib/camille/types/omit.rb

@@ -1,9 +1,6 @@
 module Camille
   module Types
     class Omit < PickAndOmit
-      def transform_and_check value
-        processed_object.transform_and_check(value)
-      end
 
       private
         def klass_name

data/lib/camille/types/pick.rb

@@ -1,9 +1,6 @@
 module Camille
   module Types
     class Pick < PickAndOmit
-      def transform_and_check value
-        processed_object.transform_and_check(value)
-      end
 
       private
         def klass_name

data/lib/camille/types/record.rb

@@ -7,27 +7,31 @@ module Camille
       def initialize key, value
         @key = Camille::Type.instance key
         @value = Camille::Type.instance value
+        @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@key.fingerprint}#{@value.fingerprint}"
       end
 
-      def transform_and_check value
+      def check value
         if value.is_a? ::Hash
 
-          transform_and_check_results = value.map.with_index do |(k, v), index|
-            [index, transform_and_check_pair(k, v)]
+          results = value.map.with_index do |(k, v), index|
+            [index, check_pair(k, v)]
           end
 
-          errors = transform_and_check_results.map do |index, (error, transformed)|
-            ["record[#{index}]", error]
-          end.select{|x| x[1]}
+          errors = results.map do |index, result|
+            if result.instance_of?(Camille::TypeError)
+              ["record[#{index}]", result]
+            else
+              nil
+            end
+          end.compact
 
           if errors.empty?
-            transformed = transform_and_check_results.map{|_, (_, transformed)| transformed}.to_h
-            [nil, transformed]
+            Camille::Checked.new(fingerprint, results.map{|_, result| [result[0].value, result[1].value]}.to_h)
           else
-            [Camille::TypeError.new(**errors.to_h), nil]
+            Camille::TypeError.new(**errors.to_h)
           end
         else
-          [Camille::TypeError.new("Expected hash, got #{value.inspect}."), nil]
+          Camille::TypeError.new("Expected hash, got #{value.inspect}.")
         end
       end
 
@@ -40,17 +44,16 @@ module Camille
       end
 
       private
-        def transform_and_check_pair key, value
-          key_error, key_transformed = @key.transform_and_check key
-          value_error, value_transformed = @value.transform_and_check value
+        def check_pair key, value
+          key_result = @key.check key
+          value_result = @value.check value
 
-          if key_error.nil? && value_error.nil?
-            [nil, [key_transformed, value_transformed]]
+          if key_result.checked? && value_result.checked?
+            [key_result, value_result]
           else
-            errors = [['record.key', key_error], ['record.value', value_error]].select{|x| x[1]}.to_h
+            errors = [['record.key', key_result], ['record.value', value_result]].select{|x| x[1].type_error?}.to_h
 
-            error = Camille::TypeError.new(**errors)
-            [error, nil]
+            Camille::TypeError.new(**errors)
           end
         end
     end

data/lib/camille/types/string.rb

@@ -2,7 +2,9 @@ module Camille
   module Types
     class String < Camille::BasicType
       def check value
-        unless value.is_a?(::String) || value.is_a?(Symbol)
+        if value.is_a?(::String) || value.is_a?(Symbol)
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected string, got #{value.inspect}.")
         end
       end

data/lib/camille/types/string_literal.rb

@@ -8,6 +8,7 @@ module Camille
       def initialize value
         if value.is_a?(::String)
           @value = value
+          @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@value}"
         else
           raise ArgumentError.new("Expecting a string, got #{value.inspect}")
         end
@@ -15,7 +16,9 @@ module Camille
 
       def check value
         transformed = value.is_a?(Symbol) ? value.to_s : value
-        unless transformed == @value
+        if transformed == @value
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected string literal #{@value.inspect}, got #{value.inspect}.")
         end
       end

data/lib/camille/types/tuple.rb

@@ -5,26 +5,30 @@ module Camille
 
       def initialize elements
         @elements = elements.map{|e| Camille::Type.instance e}
+        @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{@elements.map(&:fingerprint)}"
       end
 
-      def transform_and_check value
-        if value.is_a? ::Array
-          transform_and_check_results = @elements.map.with_index do |type, index|
-            [index, type.transform_and_check(value[index])]
+      def check value
+        if value.is_a?(::Array) && value.size == @elements.size
+          results = @elements.map.with_index do |type, index|
+            [index, type.check(value[index])]
           end
 
-          errors = transform_and_check_results.map do |index, (error, transformed)|
-            ["tuple[#{index}]", error]
-          end.select{|x| x[1]}
+          errors = results.map do |index, result|
+            if result.type_error?
+              ["tuple[#{index}]", result]
+            else
+              nil
+            end
+          end.compact
 
           if errors.empty?
-            transformed = transform_and_check_results.map{|index, (error, transformed)| transformed}
-            [nil, transformed]
+            Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
           else
-            [Camille::TypeError.new(**errors.to_h), nil]
+            Camille::TypeError.new(**errors.to_h)
           end
         else
-          [Camille::TypeError.new("Expected array, got #{value.inspect}."), nil]
+          Camille::TypeError.new("Expected array of size #{@elements.size}, got #{value.inspect}.")
         end
       end
 

data/lib/camille/types/undefined.rb

@@ -2,7 +2,9 @@ module Camille
   module Types
     class Undefined < Camille::BasicType
       def check value
-        unless value == nil
+        if value == nil
+          Camille::Checked.new(fingerprint, value)
+        else
           Camille::TypeError.new("Expected nil, got #{value.inspect}.")
         end
       end

data/lib/camille/types/union.rb

@@ -6,23 +6,23 @@ module Camille
       def initialize left, right
         @left = Camille::Type.instance left
         @right = Camille::Type.instance right
+        @fingerprint = Digest::MD5.hexdigest "#{self.class.name}#{[@left.fingerprint, @right.fingerprint].sort}"
       end
 
-      def transform_and_check value
-        left_error, left_transformed = @left.transform_and_check value
-        if left_error
-          right_error, right_transformed = @right.transform_and_check value
-          if right_error
-            error = Camille::TypeError.new(
-              'union.left' => left_error,
-              'union.right' => right_error
+      def check value
+        left_result = @left.check value
+        if left_result.type_error?
+          right_result = @right.check value
+          if right_result.type_error?
+            Camille::TypeError.new(
+              'union.left' => left_result,
+              'union.right' => right_result
             )
-            [error, nil]
           else
-            [nil, right_transformed]
+            Camille::Checked.new(fingerprint, right_result.value)
           end
         else
-          [nil, left_transformed]
+          Camille::Checked.new(fingerprint, left_result.value)
         end
       end
 

data/lib/camille/version.rb

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

data/lib/camille.rb

@@ -4,6 +4,7 @@ require "active_support"
 
 require_relative "camille/version"
 require_relative "camille/object_hash"
+require_relative "camille/checked"
 require_relative "camille/basic_type"
 require_relative "camille/types"
 require_relative "camille/types/number"
@@ -14,6 +15,8 @@ require_relative "camille/types/object"
 require_relative "camille/types/null"
 require_relative "camille/types/undefined"
 require_relative "camille/types/union"
+require_relative "camille/intersection_solver"
+require_relative "camille/intersection_preprocessor"
 require_relative "camille/types/intersection"
 require_relative "camille/types/tuple"
 require_relative "camille/types/any"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: camille
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - merely
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-13 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,7 @@ files:
 - gemfiles/rails-8.0
 - lib/camille.rb
 - lib/camille/basic_type.rb
+- lib/camille/checked.rb
 - lib/camille/code_generator.rb
 - lib/camille/configuration.rb
 - lib/camille/controller.rb
@@ -65,6 +66,8 @@ files:
 - lib/camille/generators/templates/schema_template.erb
 - lib/camille/generators/templates/type_template.erb
 - lib/camille/generators/type_generator.rb
+- lib/camille/intersection_preprocessor.rb
+- lib/camille/intersection_solver.rb
 - lib/camille/key_converter.rb
 - lib/camille/line.rb
 - lib/camille/loader.rb