try to convert to pure rust -- all the errors

Author: NullVoxPopuli

ext/case_transform/src/lib.rs

@@ -3,56 +3,68 @@ extern crate ruru;
 extern crate inflector;
 
 // // dash: kebab-case
-// use inflector::cases::kebabcase::to_kebab_case;
+use inflector::cases::kebabcase::to_kebab_case;
 // // underscore: snake_case
-// use inflector::cases::snakecase::to_snake_case;
+use inflector::cases::snakecase::to_snake_case;
 // // camel_lower: camelCase
-// use inflector::cases::camelcase::to_camel_case;
+use inflector::cases::camelcase::to_camel_case;
 // // camel: ClassCase (PascalCase)
-// use inflector::cases::classcase::to_class_case;
-use inflector::Inflector;
+use inflector::cases::classcase::to_class_case;
 
-use ruru::{Class, Object, RString, Hash};
+use ruru::{Class, Object, RString, Hash, Array, Symbol, AnyObject, VM};
+use ruru::types::ValueType;
+
+class!(CaseTransform);
 
 methods! (
-    RString,
+    CaseTransform,
     itself,
 
-    fn toSnakeCase() -> RString {
-        RString::new(&itself.to_string().to_snake_case())
-    }
+    fn deepTransformKeys(hash: Hash, block: &Fn(String) -> String) -> Hash {
+        let result = Hash::new();
 
-    fn toCamelCase() -> RString {
-        RString::new(&itself.to_string().to_camel_case())
-    }
+        hash.unwrap().each(|key, value| {
+            let newValue = if value.ty() == ValueType::Hash { deepTransformKeys(value, block).to_any_object() } else { value };
+            let newKey = RString::new(block(key.unwrap().to_string()));
+            result.store(newKey, newValue);
+        });
 
-    fn toClassCase() -> RString {
-        RString::new(&itself.to_string().to_class_case())
+        result
     }
 
-    fn toKebabCase() -> RString {
-        RString::new(&itself.to_string().to_kebab_case())
+    fn transform(
+        value: AnyObject,
+        objectTransform: &Fn(AnyObject) -> AnyObject,
+        keyTransform: &Fn(String) -> String
+    ) -> AnyObject {
+        match value.unwrap().ty() {
+            ValueType::Array => value.map(|item| objectTransform(item)).to_any_object(),
+            ValueType::Hash => deepTransformKeys(value, &|key| objectTransform(key)).to_any_object(),
+            ValueType::Symbol => Symbol::new(objectTransform(value.to_string)).to_any_object(),
+            ValueType::RString => keyTransform(value).to_any_object(),
+            ValueType::Object => value
+        }
     }
-);
 
-// methods! (
-//     Hash,
-//     itself,
-//
-//     fn deepTransformKeys() -> Hash {
-//         let result = Hash::new()
-//         itself.each(|key, value| {
-//             result.store(key, value)
-//         });
-//     }
-// );
+    fn toPascalCase(key: String) -> String { to_class_case(to_snake_case(key.unwrap())) }
+    fn toCamelCase(key: String) -> String { to_camel_case(to_snake_case(key.unwrap())) }
+    fn toDashedCase(key: String) -> String { to_kebab_case(to_snake_case(key.unwrap())) }
+    fn toKebabCase(key: String) -> String { to_kebab_case(to_snake_case(key.unwrap())) }
+
+    fn camel(value: AnyObject) -> AnyObject { transform(value.unwrap().to_any_object(), &camel, &toPascalCase) }
+    fn camelLower(value: AnyObject) -> AnyObject { transform(value.unwrap().to_any_object(), &camelLower, &toCamelCase) }
+    fn dash(value: AnyObject) -> AnyObject { transform(value.unwrap().to_any_object(), &dash, &toDashedCase) }
+    fn underscore(value: AnyObject) -> AnyObject { transform(value.unwrap(), &underscore, &toKebabCase) }
+    fn unaltered(value: AnyObject) -> AnyObject { value.unwrap().to_any_object() }
+);
 
 #[no_mangle]
 pub extern fn initialize_case_transform() {
-    Class::from_existing("String").define(|itself| {
-        itself.def("to_snake_case", toSnakeCase);
-        itself.def("to_camel_case", toCamelCase);
-        itself.def("to_class_case", toClassCase);
-        itself.def("to_kebab_case", toKebabCase);
+    Class::new("CaseTransform", None).define(|itself| {
+        itself.def_self("camel", camel);
+        itself.def_self("camel_lower", camelLower);
+        itself.def_self("dash", dash);
+        itself.def_self("underscore", underscore);
+        itself.def_self("unaltered", unaltered);
     });
 }

lib/case_transform.rb

@@ -14,70 +14,3 @@
   [], Fiddle::TYPE_VOIDP
 )
 func.call
-
-module CaseTransform
-  module_function
-
-  def deep_transform_keys(hash, &block)
-    result = {}
-    hash.each do |key, value|
-      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
-    end
-    result
-  end
-
-  def transform(value, via)
-    case value
-    when Array then value.map { |item| send(via, item) }
-    when Hash then deep_transform_keys(value) { |key| send(via, key) }
-    when Symbol then send(via, value.to_s).to_sym
-    when String then yield(value)
-    else value
-    end
-  end
-
-  # Transforms values to UpperCamelCase or PascalCase.
-  #
-  # @example:
-  #    "some_key" => "SomeKey",
-  def camel(value)
-    transform(value, :camel) do |v|
-      v.to_snake_case.to_class_case
-    end
-  end
-
-  # Transforms values to camelCase.
-  #
-  # @example:
-  #    "some_key" => "someKey",
-  def camel_lower(value)
-    transform(value, :camel_lower) do |v|
-      v.to_snake_case.to_camel_case
-    end
-  end
-
-  # Transforms values to dashed-case.
-  # This is the default case for the JsonApi adapter.
-  #
-  # @example:
-  #    "some_key" => "some-key",
-  def dash(value)
-    transform(value, :dash) do |v|
-      v.to_snake_case.to_kebab_case
-    end
-  end
-
-  # Transforms values to underscore_case.
-  # This is the default case for deserialization in the JsonApi adapter.
-  #
-  # @example:
-  #    "some-key" => "some_key",
-  def underscore(value)
-    transform(value, :underscore, &:to_snake_case)
-  end
-
-  # Returns the value unaltered
-  def unaltered(value)
-    value
-  end
-end