CamelSnakeStruct

Easily access camelCased hashes in a ruby_friendly_way. Main focus is handling responses from APIs that use camelCased keys.

Installation

Add this line to your application's Gemfile:

gem 'camel_snake_struct'

And then execute:

$ bundle install

Or install it yourself as:

$ gem install camel_snake_struct

Usage

For once of hashes

  result = CamelSnakeStruct.new('version' => 1, 'rubyVersion' => '2.5.0', 
                                'sites' => [{ 'url' => "https://duckduckgo.com", 'searchEngine' => true }, 
                                            { 'url' => "https://d.tube/", 'searchEngine' => false }])

  puts result.version # 1
  puts result.ruby_version # 2.5.0
  puts result['version'] # 1

  if result.sites?
    puts result.sites[0].url # https://duckduckgo.com
    puts result.sites[1].url # https://d.tube/
  end

  puts result.people? # false
  puts result.people # NoMethodError

Or Learning Structs

MyLearningStruct = Class.new(CamelSnakeStruct)

result1 = MyLearningStruct.new('data' => [{ 'name' => 'Jeff' }])
puts result1.data.map(&:name) # ["Jeff"]
# never received errors key before
puts result.errors # NoMethodError

result2 = MyLearningStruct.new('errors' => ['failed to get response'])
# it remembers the shape from the first succesfull request
puts result2.data.map(&:name) # []
puts result.errors # ["failed to get response"]

MyLoadedStruct = Class.new(CamelSnakeStruct)

MyLoadedStruct.example('data' => [{ 'name' => 'Jeff' }], 'errors' => [], 'date' => { 'timezone' => 'UTC', 'unixTime' => 0})

result3 = MyLoadedStruct.new({'date' => { }})
puts result3.data # []
puts result3.errors # []
puts result3.date.timezone # nil
puts result3.date.unix_time # nil

Learning Structs store meta data about the shape of the hash from the examples provided. This can be used with tapioca custom DSL compilers to generate sorbet types

MyLoadedStruct = Class.new(CamelSnakeStruct)
MyLoadedStruct.example('data' => [{ 'name' => 'Jeff' }], 'errors' => [], 'date' => { 'timezone' => 'UTC', 'unixTime' => 0})

puts MyLoadedStruct.types_meta_data
# {"data"=>#<struct CamelSnakeStruct::Type__Meta__Data class_types=#<Set: {MyLoadedStruct::Datum}>, array=true>, "errors"=>#<struct CamelSnakeStruct::Type__Meta__Data class_types=#<Set: {}>, array=true>, "date"=>#<struct CamelSnakeStruct::Type__Meta__Data class_types=#<Set: {MyLoadedStruct::Date}>, array=false>}

# typed: true

module Tapioca
  module Compilers
    class CamelSnakeStructCompiler < Tapioca::Dsl::Compiler
      extend T::Sig

      ConstantType = type_member {{ fixed: T.class_of(CamelSnakeStruct) }}

      sig { override.returns(T::Enumerable[Module]) }
      def self.gather_constants
        all_classes.select do |c| 
          c < ::CamelSnakeStruct && !c.types_meta_data.empty?
        end
      end

      sig { override.void }
      def decorate
        root.create_path(constant) do |klass|
          klass.create_method('to_h', parameters: [], return_type: "T::Hash[String, T.untyped]")

          constant.types_meta_data.each do |name, meta_data|
            classes = meta_data.classes.to_a.map{|a| [TrueClass,FalseClass].include?(a) ? "T::Boolean" : a.to_s }.uniq
            return_type = if classes.size == 1
              classes.first.to_s
            else
              "T.any(#{classes.join(', ')})"
            end
            if meta_data.array
              klass.create_method(name.to_s, parameters: [], return_type: "T::Array[#{return_type}]")
            elsif return_type == 'NilClass' || return_type == 'String'
              klass.create_method(name.to_s, parameters: [], return_type: 'T.nilable(String)')
            else
              klass.create_method(name.to_s, parameters: [], return_type: return_type)
            end
            klass.create_method("#{name}?", parameters: [], return_type: 'T::Boolean')
          end
        end
      end
    end
  end
end

Limitations

Expects to receive a hash
Only works with string keys
Does not work well with keys that point to array of arrays
expects the hash to always have the same struct for learning structs

Development

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.

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 tags, and push the .gem file to rubygems.org.

Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/camel_snake.