oso-oso 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: ec2b2b33a484c1770041164811415985e0e6c135a3fb03688d40813d0b332772
-  data.tar.gz: 960bcf13f984e19b359da8da1ac6478702c48d68f1ed9f1150250d0d4d0d1df4
+SHA1:
+  metadata.gz: 919322c6735cfeb3615da5dd85b4188c59e8716d
+  data.tar.gz: 1c881b365f4098e3bbdad3152168e82ab31df87f
 SHA512:
-  metadata.gz: 9b49f6a116fb1e542674a19047c16484f8f08a54dda51f83918644abfca808e164e628c164fcfd6ad0b2497549c3192a5a194264b138b018c01adbbea8b38cd7
-  data.tar.gz: 30d9fe7a3c625c1245140415c010066c21a388f79b5edce8b6376631712f33ca1bfc82f208e10244c6094b671588e6d1448e241bc11377e2b58c5a154b1afa66
+  metadata.gz: b898b3636cdb1cfa5fe909634292cf030bd60ccf768e964cb258c7e1c076d34b52e953bf8b37b27e2cc42926c44efdbd7b600dc21fea63e7144834870d80db1f
+  data.tar.gz: 1e38944c4a55b81b3dbecbf1864be035632bd840e0f709380c8b14bfaecf657a1abb273b74b171aae35df9210beddb7e42f4c3547af74e482d0db4b214ca987f

data/.rubocop.yml

@@ -0,0 +1,7 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  Exclude:
+    - '**/*~'
+    - 'bin/oso'
+    - 'vendor/**/*'
+  NewCops: enable

data/Gemfile

@@ -3,4 +3,3 @@
 source 'https://rubygems.org'
 
 gemspec
-

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    oso-oso (0.2.2)
+    oso-oso (0.4.0)
       ffi (~> 1.0)
 
 GEM
@@ -12,18 +12,18 @@ GEM
     benchmark (0.1.0)
     byebug (11.1.3)
     coderay (1.1.3)
-    diff-lcs (1.3)
+    diff-lcs (1.4.4)
     e2mmap (0.1.0)
     ffi (1.13.1)
     jaro_winkler (1.5.4)
     maruku (0.7.3)
     method_source (1.0.0)
     mini_portile2 (2.4.0)
-    nokogiri (1.10.9)
+    nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
-    parallel (1.19.1)
-    parser (2.7.1.3)
-      ast (~> 2.4.0)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -49,19 +49,19 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.3)
-    rubocop (0.85.1)
+    rubocop (0.89.0)
       parallel (~> 1.10)
-      parser (>= 2.7.0.1)
+      parser (>= 2.7.1.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.7)
       rexml
-      rubocop-ast (>= 0.0.3)
+      rubocop-ast (>= 0.1.0, < 1.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (0.0.3)
-      parser (>= 2.7.0.1)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
     ruby-progressbar (1.10.1)
-    solargraph (0.39.8)
+    solargraph (0.39.13)
       backport (~> 1.1)
       benchmark
       bundler (>= 1.17.2)
@@ -88,6 +88,7 @@ DEPENDENCIES
   pry-byebug (~> 3.9.0)
   rake (~> 12.0)
   rspec (~> 3.0)
+  rubocop (~> 0.89.0)
   solargraph (~> 0.39.8)
   yard (~> 0.9.25)
 

data/Makefile

@@ -1,16 +1,19 @@
-CARGO_FLAGS := $(shell [ -z $${RELEASE} ] && echo "" || echo "--all-features --release")
-export CARGO_FLAGS
-TARGET_DIR := $(shell [ -z $${RELEASE} ] && echo "debug" || echo "release")
-LIB_EXT := $(shell [ $$(uname) = "Linux" ] && echo "so" || echo "dylib")
+.PHONY: rust install test lint typecheck repl
 
-.PHONY: install rust-build test
-
-rust-build:
+rust:
 	$(MAKE) -C ../.. rust-build
-	cp ../../target/$(TARGET_DIR)/libpolar.$(LIB_EXT) ext/oso-oso/lib/libpolar.$(LIB_EXT)
 
-install: rust-build
+install: rust
 	bundle install
 
 test: install
 	bundle exec rake spec
+
+lint:
+	bundle exec rubocop
+
+typecheck:
+	bundle exec solargraph typecheck
+
+repl: install
+	bundle exec oso

data/README.md

@@ -1,4 +1,4 @@
-# Oso::Oso
+# oso-oso
 
 ## Installation
 
@@ -18,13 +18,10 @@ Or install it yourself as:
 
 ## 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.
+After checking out the repo, run `bundle install` to install dependencies.
+Then, run `bundle exec rake spec` to run the tests. You can also run `bundle
+exec oso` for an interactive REPL 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](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
+New releases are minted and pushed to RubyGems via GitHub Actions workflows.

data/Rakefile

@@ -6,4 +6,3 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
-

data/bin/oso

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S bundle exec ruby
+#-*-ruby-*-
+
+require 'bundler/setup'
+require 'oso'
+
+Oso.new.repl(load: true)

data/lib/oso/http.rb

@@ -3,7 +3,7 @@
 module Oso
   # An HTTP resource.
   class Http
-    def initialize(hostname: nil, path: nil, query: nil)
+    def initialize(hostname, path, query)
       @hostname = hostname
       @path = path
       @query = query

data/lib/oso/oso.rb

@@ -1,47 +1,21 @@
 # frozen_string_literal: true
 
+require_relative 'polar/polar'
+
 module Oso
   # Oso authorization API.
-  class Oso
+  class Oso < Polar::Polar
     def initialize
-      @polar = ::Oso::Polar.new
+      super
       register_class(Http, name: 'Http')
       register_class(PathMapper, name: 'PathMapper')
     end
 
-    def load_file(file)
-      polar.load_file(file)
-    end
-
-    def load_str(str)
-      polar.load_str(str)
-    end
-
-    def register_class(cls, name: nil) # rubocop:disable Naming/MethodParameterName
-      if block_given?
-        polar.register_class(cls, name: name, from_polar: Proc.new)
-      else
-        polar.register_class(cls, name: name)
-      end
-    end
-
-    def allow(actor:, action:, resource:)
-      polar.query_pred('allow', args: [actor, action, resource]).next
+    def allowed?(actor:, action:, resource:)
+      query_rule('allow', actor, action, resource).next
       true
     rescue StopIteration
       false
     end
-
-    def query_predicate(name, *args)
-      polar.query_pred(name, args: args)
-    end
-
-    def load_queued_files
-      polar.load_queued_files
-    end
-
-    private
-
-    attr_reader :polar
   end
 end

data/lib/oso/path_mapper.rb

@@ -4,7 +4,7 @@ module Oso
   # Map from a template string with capture groups of the form
   # `{name}` to a dictionary of the form `{name: captured_value}`
   class PathMapper
-    def initialize(template:)
+    def initialize(template)
       capture_group = /({([^}]+)})/
 
       template = template.dup

data/lib/oso/polar.rb

@@ -2,6 +2,7 @@
 
 require 'oso/polar/errors'
 require 'oso/polar/ffi'
+require 'oso/polar/host'
 require 'oso/polar/polar'
 require 'oso/polar/predicate'
 require 'oso/polar/query'

data/lib/oso/polar/errors.rb

@@ -5,16 +5,12 @@ module Oso
     # Base error type for Oso::Polar.
     class Error < ::RuntimeError
       attr_reader :stack_trace
-      
+
       # @param message [String]
       # @param details [Hash]
       def initialize(message = nil, details: nil)
         @details = details
-        if details and details.key?("stack_trace")
-          @stack_trace = details['stack_trace']
-        else
-          @stack_trace = nil
-        end
+        @stack_trace = details&.fetch('stack_trace', nil)
         super(message)
       end
     end
@@ -40,12 +36,32 @@ module Oso
     class DuplicateInstanceRegistrationError < PolarRuntimeError; end
     class InvalidCallError < PolarRuntimeError; end
     class InvalidConstructorError < PolarRuntimeError; end
+    class InvalidQueryTypeError < PolarRuntimeError; end
     class InlineQueryFailedError < PolarRuntimeError; end
     class NullByteInPolarFileError < PolarRuntimeError; end
     class UnexpectedPolarTypeError < PolarRuntimeError; end
+    class PolarFileAlreadyLoadedError < PolarRuntimeError # rubocop:disable Style/Documentation
+      # @param file [String]
+      def initialize(file)
+        super("File #{file} has already been loaded.")
+      end
+    end
+    class PolarFileContentsChangedError < PolarRuntimeError # rubocop:disable Style/Documentation
+      # @param file [String]
+      def initialize(file)
+        super("A file with the name #{file}, but different contents, has already been loaded.")
+      end
+    end
+    class PolarFileNameChangedError < PolarRuntimeError # rubocop:disable Style/Documentation
+      # @param file [String]
+      # @param existing [String]
+      def initialize(file, existing)
+        super("A file with the same contents as #{file} named #{existing} has already been loaded.")
+      end
+    end
     class PolarFileExtensionError < PolarRuntimeError # rubocop:disable Style/Documentation
-      def initialize
-        super('Polar files must have .pol or .polar extension.')
+      def initialize(file)
+        super("Polar files must have .polar extension. Offending file: #{file}")
       end
     end
     class PolarFileNotFoundError < PolarRuntimeError # rubocop:disable Style/Documentation
@@ -58,7 +74,7 @@ module Oso
       # @param as [String]
       # @param old [Class]
       # @param new [Class]
-      def initialize(name:, old:, new:) # rubocop:disable Naming/MethodParameterName
+      def initialize(name:, old:, new:)
         super("Attempted to alias #{new} as '#{name}', but #{old} already has that alias.")
       end
     end

data/lib/oso/polar/ffi.rb

@@ -5,8 +5,12 @@ require 'ffi'
 module Oso
   module Polar
     module FFI
-      LIB = ::FFI::Platform::LIBPREFIX + 'polar.' + ::FFI::Platform::LIBSUFFIX
-      LIB_PATH = File.expand_path(File.join(__dir__, "../../../ext/oso-oso/lib/#{LIB}"))
+      LIB = "#{::FFI::Platform::LIBPREFIX}polar.#{::FFI::Platform::LIBSUFFIX}"
+      RELEASE_PATH = File.expand_path(File.join(__dir__, "../../../ext/oso-oso/lib/#{LIB}"))
+      DEV_PATH = File.expand_path(File.join(__dir__, "../../../../../target/debug/#{LIB}"))
+      # If the lib exists in the ext/ dir, use it. Otherwise, fall back to
+      # checking the local Rust target dir.
+      LIB_PATH = File.file?(RELEASE_PATH) ? RELEASE_PATH : DEV_PATH
 
       # Wrapper classes defined upfront to fix Ruby loading issues. Actual
       # implementations live in the sibling `ffi/` directory and are `require`d

data/lib/oso/polar/ffi/error.rb

@@ -22,7 +22,7 @@ module Oso
         #
         # @return [::Oso::Polar::Error] if there's an FFI error.
         # @return [::Oso::Polar::FFIErrorNotFound] if there isn't one.
-        def self.get # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def self.get # rubocop:disable Metrics/MethodLength
           error = Rust.get
           return ::Oso::Polar::FFIErrorNotFound if error.null?
 
@@ -48,7 +48,7 @@ module Oso
         # @param msg [String]
         # @param details [Hash<String, Object>]
         # @return [::Oso::Polar::ParseError] the object converted into the expected format.
-        private_class_method def self.parse_error(kind, msg:, details:) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        private_class_method def self.parse_error(kind, msg:, details:) # rubocop:disable Metrics/MethodLength
           case kind
           when 'ExtraToken'
             ::Oso::Polar::ParseError::ExtraToken.new(msg, details: details)

data/lib/oso/polar/ffi/polar.rb

@@ -11,11 +11,10 @@ module Oso
 
           attach_function :new, :polar_new, [], FFI::Polar
           attach_function :load_str, :polar_load, [FFI::Polar, :string, :string], :int32
-          attach_function :next_inline_query, :polar_next_inline_query, [FFI::Polar], FFI::Query
+          attach_function :next_inline_query, :polar_next_inline_query, [FFI::Polar, :uint32], FFI::Query
           attach_function :new_id, :polar_get_external_id, [FFI::Polar], :uint64
-          attach_function :new_query_from_str, :polar_new_query, [FFI::Polar, :string], FFI::Query
-          attach_function :new_query_from_term, :polar_new_query_from_term, [FFI::Polar, :string], FFI::Query
-          attach_function :new_query_from_repl, :polar_query_from_repl, [FFI::Polar], FFI::Query
+          attach_function :new_query_from_str, :polar_new_query, [FFI::Polar, :string, :uint32], FFI::Query
+          attach_function :new_query_from_term, :polar_new_query_from_term, [FFI::Polar, :string, :uint32], FFI::Query
           attach_function :register_constant, :polar_register_constant, [FFI::Polar, :string, :string], :int32
           attach_function :free, :polar_free, [FFI::Polar], :int32
         end
@@ -41,7 +40,7 @@ module Oso
         # @return [nil] if there are no remaining inline queries.
         # @raise [FFI::Error] if the FFI call returns an error.
         def next_inline_query
-          query = Rust.next_inline_query(self)
+          query = Rust.next_inline_query(self, 0)
           query.null? ? nil : query
         end
 
@@ -60,7 +59,7 @@ module Oso
         # @return [FFI::Query]
         # @raise [FFI::Error] if the FFI call returns an error.
         def new_query_from_str(str)
-          query = Rust.new_query_from_str(self, str)
+          query = Rust.new_query_from_str(self, str, 0)
           raise FFI::Error.get if query.null?
 
           query
@@ -70,16 +69,7 @@ module Oso
         # @return [FFI::Query]
         # @raise [FFI::Error] if the FFI call returns an error.
         def new_query_from_term(term)
-          query = Rust.new_query_from_term(self, JSON.dump(term))
-          raise FFI::Error.get if query.null?
-
-          query
-        end
-
-        # @return [FFI::Query]
-        # @raise [FFI::Error] if the FFI call returns an error.
-        def new_query_from_repl
-          query = Rust.new_query_from_repl(self)
+          query = Rust.new_query_from_term(self, JSON.dump(term), 0)
           raise FFI::Error.get if query.null?
 
           query

data/lib/oso/polar/ffi/query.rb

@@ -12,6 +12,7 @@ module Oso
           attach_function :debug_command, :polar_debug_command, [FFI::Query, :string], :int32
           attach_function :call_result, :polar_call_result, [FFI::Query, :uint64, :string], :int32
           attach_function :question_result, :polar_question_result, [FFI::Query, :uint64, :int32], :int32
+          attach_function :application_error, :polar_application_error, [FFI::Query, :string], :int32
           attach_function :next_event, :polar_next_query_event, [FFI::Query], FFI::QueryEvent
           attach_function :free, :query_free, [FFI::Query], :int32
         end
@@ -41,6 +42,14 @@ module Oso
           raise FFI::Error.get if res.zero?
         end
 
+        # @param result [Boolean]
+        # @param call_id [Integer]
+        # @raise [FFI::Error] if the FFI call returns an error.
+        def application_error(message)
+          res = Rust.application_error(self, message)
+          raise FFI::Error.get if res.zero?
+        end
+
         # @return [::Oso::Polar::QueryEvent]
         # @raise [FFI::Error] if the FFI call returns an error.
         def next_event

data/lib/oso/polar/host.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Oso
+  module Polar
+    # Translate between Polar and the host language (Ruby).
+    class Host # rubocop:disable Metrics/ClassLength
+      protected
+
+      # @return [FFI::Polar]
+      attr_reader :ffi_polar
+      # @return [Hash<String, Class>]
+      attr_reader :classes
+      # @return [Hash<String, Object>]
+      attr_reader :constructors
+      # @return [Hash<Integer, Object>]
+      attr_reader :instances
+
+      public
+
+      def initialize(ffi_polar)
+        @ffi_polar = ffi_polar
+        @classes = {}
+        @constructors = {}
+        @instances = {}
+      end
+
+      def initialize_copy(other)
+        @ffi_polar = other.ffi_polar
+        @classes = other.classes.dup
+        @constructors = other.constructors.dup
+        @instances = other.instances.dup
+      end
+
+      # Fetch a Ruby class from the {#classes} cache.
+      #
+      # @param name [String]
+      # @return [Class]
+      # @raise [UnregisteredClassError] if the class has not been registered.
+      def get_class(name)
+        raise UnregisteredClassError, name unless classes.key? name
+
+        classes[name]
+      end
+
+      # Store a Ruby class in the {#classes} cache.
+      #
+      # @param cls [Class] the class to cache
+      # @param name [String] the name to cache the class as. Defaults to the name of the class.
+      # @return [String] the name the class is cached as.
+      # @raise [UnregisteredClassError] if the class has not been registered.
+      def cache_class(cls, name:, constructor:) # rubocop:disable Metrics/MethodLength
+        name = cls.name if name.nil?
+        raise DuplicateClassAliasError, name: name, old: get_class(name), new: cls if classes.key? name
+
+        classes[name] = cls
+        if constructor.nil?
+          constructors[name] = :new
+        elsif constructor.respond_to? :call
+          constructors[name] = constructor
+        else
+          raise InvalidConstructorError
+        end
+        name
+      end
+
+      # Fetch a constructor from the {#constructors} cache.
+      #
+      # @param name [String]
+      # @return [Symbol] if constructor is the default of `:new`.
+      # @return [Proc] if a custom constructor was registered.
+      # @raise [UnregisteredConstructorError] if the constructor has not been registered.
+      def get_constructor(name)
+        raise MissingConstructorError, name unless constructors.key? name
+
+        constructors[name]
+      end
+
+      # Check if an instance has been cached.
+      #
+      # @param id [Integer]
+      # @return [Boolean]
+      def instance?(id)
+        case id
+        when Integer
+          instances.key? id
+        else
+          instances.value? id
+        end
+      end
+
+      # Fetch a Ruby instance from the {#instances} cache.
+      #
+      # @param id [Integer]
+      # @return [Object]
+      # @raise [UnregisteredInstanceError] if the ID has not been registered.
+      def get_instance(id)
+        raise UnregisteredInstanceError, id unless instance? id
+
+        instances[id]
+      end
+
+      # Cache a Ruby instance, fetching a {#new_id} if one isn't provided.
+      #
+      # @param instance [Object]
+      # @param id [Integer]
+      # @return [Integer]
+      def cache_instance(instance, id: nil)
+        id = ffi_polar.new_id if id.nil?
+        instances[id] = instance
+        id
+      end
+
+      # Construct and cache a Ruby instance.
+      #
+      # @param cls_name [String]
+      # @param initargs [Hash<String, Hash>]
+      # @param id [Integer]
+      # @raise [PolarRuntimeError] if instance construction fails.
+      def make_instance(cls_name, initargs:, id:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        constructor = get_constructor(cls_name)
+        instance = if constructor == :new
+                     if initargs.empty?
+                       get_class(cls_name).__send__(:new)
+                     elsif initargs.is_a? Array
+                       get_class(cls_name).__send__(:new, *initargs)
+                     elsif initargs.is_a? Hash
+                       get_class(cls_name).__send__(:new, **initargs)
+                     else
+                       raise PolarRuntimeError, "Bad initargs: #{initargs}"
+                     end
+                   elsif initargs.empty?
+                     constructor.call
+                   elsif initargs.is_a? Array
+                     constructor.call(*initargs)
+                   elsif initargs.is_a? Hash
+                     constructor.call(**initargs)
+                   else
+                     raise PolarRuntimeError, "Bad initargs: #{initargs}"
+                   end
+        cache_instance(instance, id: id)
+      rescue StandardError => e
+        raise PolarRuntimeError, "Error constructing instance of #{cls_name}: #{e}"
+      end
+
+      # Check if the left class is more specific than the right class
+      # with respect to the given instance.
+      #
+      # @param instance_id [Integer]
+      # @param left_tag [String]
+      # @param right_tag [String]
+      # @return [Boolean]
+      def subspecializer?(instance_id, left_tag:, right_tag:)
+        mro = get_instance(instance_id).class.ancestors
+        mro.index(get_class(left_tag)) < mro.index(get_class(right_tag))
+      rescue StandardError
+        false
+      end
+
+      # Check if instance is an instance of class.
+      #
+      # @param instance [Hash<String, Object>]
+      # @param class_tag [String]
+      # @return [Boolean]
+      def isa?(instance, class_tag:)
+        instance = to_ruby(instance)
+        cls = get_class(class_tag)
+        instance.is_a? cls
+      rescue PolarRuntimeError
+        false
+      end
+
+      # Check if two instances unify
+      #
+      # @param left_instance_id [Integer]
+      # @param right_instance_id [Integer]
+      # @return [Boolean]
+      def unify?(left_instance_id, right_instance_id)
+        left_instance = get_instance(left_instance_id)
+        right_instance = get_instance(right_instance_id)
+        left_instance == right_instance
+      rescue PolarRuntimeError
+        false
+      end
+
+      # Turn a Ruby value into a Polar term that's ready to be sent across the
+      # FFI boundary.
+      #
+      # @param value [Object]
+      # @return [Hash<String, Object>]
+      def to_polar_term(value) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        value = case true # rubocop:disable Lint/LiteralAsCondition
+                when value.instance_of?(TrueClass) || value.instance_of?(FalseClass)
+                  { 'Boolean' => value }
+                when value.instance_of?(Integer)
+                  { 'Number' => { 'Integer' => value } }
+                when value.instance_of?(Float)
+                  { 'Number' => { 'Float' => value } }
+                when value.instance_of?(String)
+                  { 'String' => value }
+                when value.instance_of?(Array)
+                  { 'List' => value.map { |el| to_polar_term(el) } }
+                when value.instance_of?(Hash)
+                  { 'Dictionary' => { 'fields' => value.transform_values { |v| to_polar_term(v) } } }
+                when value.instance_of?(Predicate)
+                  { 'Call' => { 'name' => value.name, 'args' => value.args.map { |el| to_polar_term(el) } } }
+                when value.instance_of?(Variable)
+                  # This is supported so that we can query for unbound variables
+                  { 'Variable' => value }
+                else
+                  { 'ExternalInstance' => { 'instance_id' => cache_instance(value), 'repr' => value.to_s } }
+                end
+        { 'value' => value }
+      end
+
+      # Turn a Polar term passed across the FFI boundary into a Ruby value.
+      #
+      # @param data [Hash<String, Object>]
+      # @option data [Integer] :id
+      # @option data [Integer] :offset Character offset of the term in its source string.
+      # @option data [Hash<String, Object>] :value
+      # @return [Object]
+      # @raise [UnexpectedPolarTypeError] if type cannot be converted to Ruby.
+      def to_ruby(data) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        tag, value = data['value'].first
+        case tag
+        when 'String', 'Boolean'
+          value
+        when 'Number'
+          value.values.first
+        when 'List'
+          value.map { |el| to_ruby(el) }
+        when 'Dictionary'
+          value['fields'].transform_values { |v| to_ruby(v) }
+        when 'ExternalInstance'
+          get_instance(value['instance_id'])
+        when 'Call'
+          Predicate.new(value['name'], args: value['args'].map { |a| to_ruby(a) })
+        when 'Variable'
+          Variable.new(value['name'])
+        else
+          raise UnexpectedPolarTypeError, tag
+        end
+      end
+    end
+  end
+end