litl 0.1.0

data/lib/lit/builder/option.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LIT
+  module Builder
+    # @api private
+    # @since 0.1.0
+    class Option
+      def initialize(mod, type)
+        @type_checker = TypeChecker.new(mod)
+        @type = type
+      end
+
+      def build
+        mod = Module.new do
+          include ::LIT::Object::Option
+        end
+
+        type_checker = @type_checker
+        type = @type
+
+        mod::Some.define_method(:check_type!) do |value|
+          # NOTE: actually covered, but SimpleCov cannot detect that
+          # :nocov:
+          type_checker.check_type!(type, value)
+          # :nocov:
+        end
+
+        mod
+      end
+    end
+  end
+end

data/lib/lit/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  TypeError = Class.new(::TypeError)
+
+  InvalidASTError = Class.new(StandardError)
+  InvalidObjectError = Class.new(StandardError)
+  InvalidTypeError = Class.new(StandardError)
+end

data/lib/lit/loader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  class Loader
+    FILE_EXTENSION = ".lit"
+
+    def initialize
+      loader = self
+
+      @target_module = Module.new do
+        include ::LIT::Object
+
+        define_singleton_method(:reload_file) do |file_path|
+          loader.reload_file(file_path)
+        end
+
+        define_singleton_method(:serialize) do |object|
+          Serializer.new(object).serialize
+        end
+
+        define_singleton_method(:deserialize_request) do |data|
+          RequestDeserializer.new(data, self).deserialize_request
+        end
+      end
+
+      @working_module = @target_module
+    end
+
+    def load_directory(dir_path)
+      glob = File.join("**", "*#{FILE_EXTENSION}")
+      @base_dir = Pathname.new(dir_path)
+
+      Dir.glob(glob, base: dir_path) do |filename|
+        load_file(filename)
+      end
+
+      @target_module
+    end
+
+    def reload_file(file_path)
+      @working_module = @target_module
+      load_file(file_path)
+    end
+
+    private
+
+    def load_file(filename)
+      file_path = Pathname.new(File.expand_path(filename, @base_dir))
+      relative_path = file_path.relative_path_from(@base_dir).to_s
+      namespace = [*File.dirname(relative_path).split(File::SEPARATOR).slice(1),
+                   File.basename(relative_path, FILE_EXTENSION)]
+
+      if namespace == %w[main]
+        load_main_file(file_path)
+      else
+        load_regular_file(file_path, namespace)
+      end
+    end
+
+    def load_main_file(file_path)
+      ast = Parser.parse_file(file_path)
+      Builder::Object.new(ast, @target_module).build
+    end
+
+    def load_regular_file(file_path, namespace)
+      namespace.each do |mod|
+        @working_module = Utils.const_reset(@working_module, Utils.camelize(mod), Module.new)
+      end
+
+      ast = Parser.parse_file(file_path)
+
+      Builder::Object.new(ast, @working_module).build
+      @working_module.include(@target_module)
+    end
+  end
+end

data/lib/lit/module_observer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  module ModuleObserver
+    def self.included(object)
+      object.define_singleton_method(:observe) do |target_module|
+        namespace = target_module.name.split("::")
+
+        define_singleton_method(:const_missing) do |const_name|
+          mod = namespace.reduce(self) do |mod, child_name|
+            mod.const_get(child_name)
+          end
+
+          mod.const_get(const_name)
+        end
+      end
+    end
+  end
+end

data/lib/lit/object.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  module Object
+    require_relative "object/array"
+    require_relative "object/enum"
+    require_relative "object/enum_variant"
+    require_relative "object/map"
+    require_relative "object/option"
+    require_relative "object/struct"
+  end
+end

data/lib/lit/object/array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    # @api public
+    # @since 0.1.0
+    class Array
+      def initialize(*values)
+        values.each { |v| check_type!(v) }
+        @values = values
+      end
+
+      def each(&block)
+        @values.each(&block)
+      end
+
+      def to_a
+        @values
+      end
+
+      def [](index)
+        @values[index]
+      end
+
+      def __values__
+        @values
+      end
+
+      private
+
+      def check_type!(value); end
+    end
+  end
+end

data/lib/lit/object/enum.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    # @api public
+    # @since 0.1.0
+    module Enum; end
+  end
+end

data/lib/lit/object/enum_variant.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    # @api public
+    # @since 0.1.0
+    module EnumVariant; end
+  end
+end

data/lib/lit/object/map.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    # @api public
+    # @since 0.1.0
+    class Map
+      attr_reader :values
+
+      def initialize(values = {})
+        values = Utils::MapHash.new(values)
+        values.each { |k, v| check_type!(k, v) }
+        @values = values
+      end
+
+      def [](key)
+        @values[key]
+      end
+
+      def __values__
+        @values.to_h
+      end
+
+      private
+
+      def check_type!(key, value); end
+    end
+  end
+end

data/lib/lit/object/option.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    def self.included(object)
+      object.define_singleton_method(:Some) { |value| Option::Some.new(value) }
+      Utils.const_reset(object, "None", Option::None)
+      Utils.const_reset(object, "Some", Class.new(Option::Some))
+    end
+
+    # @api public
+    # @since 0.1.0
+    module Option
+      def self.included(object)
+        object.define_singleton_method(:Some) { |value| Some.new(value) }
+        Utils.const_reset(object, "Some", Class.new(Some))
+      end
+
+      None = Class.new
+
+      class Some
+        attr_reader :value
+
+        def initialize(value)
+          check_type!(value)
+          @value = value
+        end
+
+        def __value__
+          @value
+        end
+
+        private
+
+        def check_type!(value); end
+      end
+    end
+  end
+end

data/lib/lit/object/struct.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LIT
+  module Object
+    # @api public
+    # @since 0.1.0
+    class Struct; end
+  end
+end

data/lib/lit/request_deserializer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  class RequestDeserializer
+    AST = Parser::AST
+
+    def initialize(raw_request, type_root)
+      # { action, payload }
+      @raw_request = raw_request
+      @type_root = type_root
+    end
+
+    def deserialize_request
+      action_namespace = @raw_request.fetch("action").split(".").map { |x| Utils.camelize(x) }
+      action_type = action_namespace.reduce(@type_root) do |object, namespace|
+        object.const_get(namespace)
+      end
+
+      request_type = action_type.const_get("Request")
+      @type_module = action_type.const_get("DefinedIn")
+
+      deserialize(request_type, @raw_request.fetch("payload"))
+    end
+
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def deserialize(type, payload)
+      if type.is_a?(Module)
+        if type <= Object::Struct
+          deserialize_struct(type, payload)
+        elsif type <= Object::Enum
+          deserialize_enum(type, payload)
+        elsif type == AST::Type::Primitive::String ||
+              type == AST::Type::Primitive::Integer ||
+              type == AST::Type::Primitive::Float ||
+              type == AST::Type::Primitive::Boolean
+          payload
+        else
+          deserialize(type::TYPE, payload)
+        end
+      elsif type.is_a?(AST::Type::Alias)
+        deserialize(@type_module.const_get(type.name), payload)
+      elsif type.is_a?(AST::Type::Primitive::Array)
+        deserialize_array(type, payload)
+      elsif type.is_a?(AST::Type::Primitive::Map)
+        deserialize_map(type, payload)
+      elsif type.is_a?(AST::Type::Primitive::Option)
+        deserialize_option(type.type, payload)
+      else
+        raise InvalidTypeError, "invalid type: #{type}"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def deserialize_struct(struct_klass, struct_data)
+      params = struct_data.reduce({}) do |acc, (key, value)|
+        field_name = key.to_sym
+        field_type = struct_klass.__fields__[field_name]
+        acc.merge(field_name => deserialize(field_type, value))
+      end
+
+      struct_klass.new(params)
+    end
+
+    def deserialize_enum(enum_module, enum_data)
+      variant_name = Utils.camelize(enum_data.fetch("kind"))
+      variant = enum_module.const_get(variant_name)
+
+      if variant.__kind__ == :unit
+        variant
+      elsif variant.__kind__ == :struct
+        deserialize_struct(variant, enum_data.fetch("data"))
+      end
+    end
+
+    def deserialize_option(type, data)
+      if data.nil?
+        Object::Option::None
+      else
+        deserialized_data = deserialize(type, data)
+        option = Builder::Option.new(@type_module, type).build
+        option::Some.new(deserialized_data)
+      end
+    end
+
+    def deserialize_map(type, data)
+      map = Builder::Map.new(@type_module, type.key_type, type.value_type).build
+
+      deserialized_data = data.reduce({}) do |acc, (key, value)|
+        acc.merge(deserialize(type.key_type, key) => deserialize(type.value_type, value))
+      end
+
+      map.new(deserialized_data)
+    end
+
+    def deserialize_array(type, data)
+      array = Builder::Array.new(@type_module, type.type).build
+      array.new(*data.map { |x| deserialize(type.type, x) })
+    end
+  end
+end

data/lib/lit/serializer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module LIT
+  # @api public
+  # @since 0.1.0
+  class Serializer
+    def initialize(object)
+      @object = object
+    end
+
+    def serialize
+      serialize_object(@object)
+    end
+
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def serialize_object(object)
+      if object.is_a?(Object::Struct)
+        if object.is_a?(Object::EnumVariant)
+          serialize_enum_variant(object)
+        else
+          serialize_struct(object)
+        end
+      elsif object.is_a?(Module) && object <= Object::EnumVariant
+        serialize_enum_variant(object)
+      elsif object.is_a?(Object::Array)
+        serialize_array(object)
+      elsif object.is_a?(Object::Map)
+        serialize_map(object)
+      elsif object.is_a?(Object::Option::Some) || object == Object::Option::None
+        serialize_option(object)
+      elsif object.is_a?(String) ||
+            object.is_a?(Integer) ||
+            object.is_a?(Float) ||
+            object == true ||
+            object == false
+        object
+      else
+        raise InvalidObjectError, "invalid object: #{object}"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def serialize_struct(struct)
+      struct.instance_variables.reduce({}) do |hsh, ivar|
+        field_name = ivar.to_s.sub("@", "").to_sym
+        hsh.merge(field_name => serialize_object(struct.public_send(field_name)))
+      end
+    end
+
+    def serialize_enum_variant(variant)
+      data =
+        if variant.__kind__ == :struct
+          serialize_struct(variant)
+        else
+          nil
+        end
+
+      { kind: variant.__name__, data: data }
+    end
+
+    def serialize_array(array)
+      array.__values__.map { |value| serialize_object(value) }
+    end
+
+    def serialize_map(map)
+      map.__values__.reduce({}) do |acc, (key, value)|
+        acc.merge(serialize_object(key) => serialize_object(value))
+      end
+    end
+
+    def serialize_option(option)
+      if option == Object::Option::None
+        nil
+      else
+        serialize_object(option.__value__)
+      end
+    end
+  end
+end