apia 3.0.0

data/lib/apia/field_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'apia/errors/field_spec_parse_error'
+
+module Apia
+  class FieldSpec
+
+    attr_reader :paths
+    attr_reader :excludes
+    attr_reader :parsed_string
+
+    def initialize(paths, excludes: [], parsed_string: nil)
+      @paths = paths
+      @excludes = excludes
+      @parsed_string = parsed_string
+    end
+
+    def include_field?(field_path)
+      if field_path.is_a?(String)
+        path = field_path.split('.')
+      else
+        path = field_path.map { |r| r.name.to_s }
+      end
+
+      # If the field path matches exactly any item in the list of paths
+      # allowed, then allow this path.
+      return true if @paths.include?(path.join('.'))
+
+      # If the field is purposely excluded, we'll check that and ensure that it
+      # isn't included.
+      return false if @excludes.include?(path.join('.'))
+
+      # If there's a wildcard at the root we can allow it at this point
+      # return true if @paths.include?('*')
+
+      # Check to see whether we're allowing a wildcard to be permitted at any
+      # point in the chain
+      path.size.times do |i|
+        parts = path[0, path.size - i - 1]
+
+        next unless @paths.include?((parts + ['*']).join('.'))
+
+        next_parts = path[0, path.size - i]
+        unless @paths.include?(next_parts.join('.'))
+          return true
+        end
+      end
+
+      false
+    end
+
+    class Parser
+
+      def initialize(string)
+        @string = string
+        @paths = Set.new
+        @excludes = Set.new
+        @type = :normal
+        @last_word = ''
+        @sections = []
+      end
+
+      def parse
+        @string.each_char do |character|
+          case character
+          when ','
+            next if @last_word.empty?
+
+            add_last_word
+
+          when '['
+            if @last_word.empty?
+              raise FieldSpecParseError, '[ requires a word before it'
+            end
+
+            @sections << @last_word
+            @paths << @sections.join('.')
+            @last_word = ''
+
+          when ']'
+            if @sections.last.nil?
+              raise FieldSpecParseError, 'unopened bracket closure'
+            end
+
+            add_last_word unless @last_word.empty?
+
+            @sections.pop
+
+          when /\s+/
+            # Ignore whitespace
+
+          when '-'
+            if @last_word.empty?
+              @type = :exclude
+            else
+              add_last_word
+            end
+
+          when 'a'..'z', '0'..'9', '_', '*'
+            @last_word += character
+
+          else
+            raise FieldSpecParseError, "invalid character #{character}"
+          end
+        end
+
+        unless @sections.empty?
+          raise FieldSpecParseError, 'unbalanced brackets'
+        end
+
+        add_last_word
+
+        FieldSpec.new(@paths, excludes: @excludes, parsed_string: @string)
+      end
+
+      private
+
+      def add_last_word
+        return if @last_word.empty?
+
+        case @type
+        when :exclude
+          destination = @excludes
+        else
+          destination = @paths
+        end
+
+        if @sections.empty?
+          destination << @last_word
+        else
+          destination << "#{@sections.join('.')}.#{@last_word}"
+        end
+
+        @last_word = ''
+        @type = :normal
+      end
+
+    end
+
+    class << self
+
+      # data_center                       # => Return all default attributes for data center
+      # data_center[name]                 # => Only return name for data center
+      # data_center[+country[id,name]]    # => Add the country to the default parameters with it only containing id and name
+      # data_center[-country]             # => Remove country from the default parameters (assuming it is part of them)
+      # data_center[name,+country]        # => Pointless but should return name plus the default country params (same as name,country)
+      def parse(string)
+        parser = Parser.new(string)
+        parser.parse
+      end
+
+    end
+
+  end
+end

data/lib/apia/helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'apia/scalars'
+
+module Apia
+  module Helpers
+
+    class << self
+
+      # Convert a ruby class name into an ID for use by objects
+      #
+      # @param name [String]
+      # @return [String]
+      def class_name_to_id(name)
+        name.to_s.gsub('::', '/')
+      end
+
+      # Convert a string into CamelCase
+      #
+      # @param string [String, nil]
+      # @return [String, nil]
+      def camelize(string)
+        return nil if string.nil?
+
+        string = string.to_s.sub(/^[a-z\d]*/) { |match| match.capitalize }
+        string.gsub(/(?:_)([a-z\d]*)/) do
+          Regexp.last_match(1).capitalize.to_s
+        end
+      end
+
+    end
+
+  end
+end

data/lib/apia/hook_set.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Apia
+  class HookSet
+
+    def initialize
+      @hooks = []
+    end
+
+    def add(block_by_var = nil, &block)
+      @hooks << block_by_var if block_by_var.is_a?(Proc)
+      @hooks << block if block_given?
+    end
+
+    def call(*args)
+      @hooks.map do |hook|
+        hook.call(*args)
+      end
+    end
+
+    def include?(proc)
+      @hooks.include?(proc)
+    end
+
+    def size
+      @hooks.size
+    end
+
+  end
+end

data/lib/apia/lookup_argument_set.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'apia/argument_set'
+require 'apia/definitions/lookup_argument_set'
+require 'apia/lookup_environment'
+
+module Apia
+  class LookupArgumentSet < ArgumentSet
+
+    class << self
+
+      # Return the definition for this argument set
+      #
+      # @return [Apia::Definitions::ArgumentSet]
+      def definition
+        @definition ||= Definitions::LookupArgumentSet.new(Helpers.class_name_to_id(name))
+      end
+
+      # Finds all objects referenced by this argument set and add them
+      # to the provided set.
+      #
+      # @param set [Apia::ObjectSet]
+      # @return [void]
+      def collate_objects(set)
+        super
+
+        definition.potential_errors.each do |error|
+          set.add_object(error)
+        end
+      end
+
+    end
+
+    def resolve(*args)
+      return if self.class.definition.resolver.nil?
+
+      environment.call(@request, *args, &self.class.definition.resolver)
+    end
+
+    def environment
+      @environment ||= LookupEnvironment.new(self)
+    end
+
+    def validate(argument, index: nil)
+      if @source.empty?
+        raise InvalidArgumentError.new(argument, issue: :missing_lookup_value, index: index, path: @path)
+      end
+
+      if @source.values.compact.size > 1
+        raise InvalidArgumentError.new(argument, issue: :ambiguous_lookup_values, index: index, path: @path)
+      end
+
+      true
+    end
+
+  end
+end

data/lib/apia/lookup_environment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'apia/environment_error_handling'
+
+module Apia
+  class LookupEnvironment
+
+    include EnvironmentErrorHandling
+
+    def initialize(set)
+      @set = set
+    end
+
+    def call(request, *args, &block)
+      return unless block_given?
+
+      instance_exec(@set, request, *args, &block)
+    end
+
+    private
+
+    def potential_error_sources
+      [@set.class]
+    end
+
+  end
+end

data/lib/apia/manifest_errors.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'apia/errors/manifest_error'
+
+module Apia
+  class ManifestErrors
+
+    attr_reader :errors
+
+    def initialize
+      @errors = {}
+    end
+
+    def add(object, code, message)
+      @errors[object] ||= Errors.new
+      @errors[object].add(code: code, message: message)
+    end
+
+    def for(object)
+      @errors[object] || Errors.new
+    end
+
+    def empty?
+      @errors.empty?
+    end
+
+    def raise_if_needed
+      return if empty?
+
+      raise ManifestError, self
+    end
+
+    class Errors
+
+      def initialize
+        @errors = []
+      end
+
+      def add(code:, message:)
+        @errors << { code: code, message: message }
+      end
+
+      def include?(code)
+        @errors.any? { |e| e[:code] == code }
+      end
+
+      def empty?
+        @errors.empty?
+      end
+
+      def each(&block)
+        @errors.each(&block)
+      end
+
+      def map(&block)
+        @errors.map(&block)
+      end
+
+    end
+
+  end
+end

data/lib/apia/mock_request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'apia/request'
+
+module Apia
+  class MockRequest < Request
+
+    def json_body
+      @json_body ||= {}
+    end
+
+    def ip
+      @ip ||= '127.0.0.1'
+    end
+    attr_writer :ip
+
+  end
+end

data/lib/apia/object.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'apia/helpers'
+require 'apia/definitions/object'
+require 'apia/defineable'
+
+module Apia
+  class Object
+
+    extend Defineable
+
+    class << self
+
+      # Return the definition for this type
+      #
+      # @return [Apia::Definitions::Object]
+      def definition
+        @definition ||= Definitions::Object.new(Helpers.class_name_to_id(name))
+      end
+
+      # Collate all objects that this type references and add them to the
+      # given object set
+      #
+      # @param set [Apia::ObjectSet]
+      # @return [void]
+      def collate_objects(set)
+        definition.fields.each_value do |field|
+          set.add_object(field.type.klass) if field.type.usable_for_field?
+        end
+      end
+
+    end
+
+    # Initialize an instance of this type with the value provided
+    #
+    # @param value [Object, Hash]
+    # @return [Apia::Object]
+    def initialize(value)
+      @value = value
+    end
+
+    # Return the raw value object for this type
+    #
+    # @return [Object, Hash]
+    attr_reader :value
+
+    # Generate a hash based on the fields defined in this type
+    #
+    # @param request [Apia::Request] the associated request
+    # @return [Hash]
+    def hash(request: nil, path: [])
+      self.class.definition.fields.generate_hash(@value, request: request, path: path)
+    end
+
+    # Should this type be included in any output?
+    #
+    # @param request [Apia::Request]
+    # @return [Boolean]
+    def include?(request)
+      return true if self.class.definition.conditions.empty?
+
+      self.class.definition.conditions.all? do |cond|
+        cond.call(@value, request) == true
+      end
+    end
+
+  end
+end