render 0.0.8 → 0.0.9

data/lib/render/attributes/hash_attribute.rb

@@ -3,12 +3,16 @@ require "render/attributes/attribute"
 
 module Render
   class HashAttribute < Attribute
+    attr_accessor :required
+
     def initialize(options = {})
       super
 
       self.name = options.keys.first
       options = options[name]
-      process_type!(options)
+
+      process_options!(options)
+      self.required = !!options[:required]
 
       initialize_schema!(options) if nested_schema?(options)
     end
@@ -33,7 +37,7 @@ module Render
           value = (explicit_value || default_value)
         end
 
-        { name.to_sym => value }
+        { name.to_sym => Type.to(types, value) }
       end
     end
 

data/lib/render/definition.rb

@@ -9,21 +9,27 @@ module Render
         Dir.glob("#{directory}/**/*.json").each do |definition_file|
           Render.logger.info("Reading #{definition_file} definition")
           definition_string = File.read(definition_file)
-          json_definition = JSON.parse(definition_string)
-          parsed_definition = Extensions::DottableHash.new(json_definition).recursively_symbolize_keys!
+          parsed_definition = JSON.parse(definition_string, { symbolize_names: true })
           load!(parsed_definition)
         end
       end
 
       def load!(definition)
-        title = definition.fetch(:universal_title, definition.fetch(:title)).to_sym
-        self.instances[title] = definition
+        self.instances.merge!({ parse_id!(definition) => definition })
       end
 
-      def find(title)
-        instances.fetch(title.to_sym)
+      def find(id, raise_error = true)
+        instances.fetch(id)
       rescue KeyError => error
-        raise Errors::DefinitionNotFound.new(title)
+        raise Errors::Definition::NotFound.new(id) if raise_error
+      end
+
+      def parse_id!(definition)
+        parse_id(definition) || (raise Errors::Definition::NoId.new(definition))
+      end
+
+      def parse_id(definition)
+        definition[:id]
       end
 
     end

data/lib/render/errors.rb

@@ -40,19 +40,46 @@ module Render
       end
     end
 
-    class DefinitionNotFound < StandardError
-      attr_accessor :title
+    module Definition
+      class NoId < StandardError
+        attr_accessor :definition
 
-      def initialize(title)
-        self.title = title
+        def initialize(definition)
+          self.definition = definition
+        end
+
+        def to_s
+          "id keyword must be used to differentiate loaded schemas -- none found in: #{definition}"
+        end
       end
 
-      def to_s
-        "Schema with title #{title} is not loaded"
+      class NotFound < StandardError
+        attr_accessor :title
+
+        def initialize(title)
+          self.title = title
+        end
+
+        def to_s
+          "Schema with title #{title} is not loaded"
+        end
       end
     end
 
     class Schema
+      class InvalidRequire < StandardError
+        attr_accessor :schema_definition
+
+        def initialize(schema_definition)
+          self.schema_definition = schema_definition
+        end
+
+        def to_s
+          required_attributes = schema_definition.fetch(:required, [])
+          "Could not require the following attributes: #{required_attributes}. This should be an array of attributes for #{schema_definition}"
+        end
+      end
+
       class RequestError < StandardError
         attr_accessor :endpoint, :response
 

data/lib/render/generator.rb

@@ -3,11 +3,13 @@
 
 require "uuid"
 require "render/errors"
+require "render/type"
 require "date"
 
 module Render
   class Generator
     @instances = []
+    FAUX_DATA_MAX = 1_000_000.freeze
 
     class << self
       attr_accessor :instances
@@ -25,12 +27,17 @@ module Render
 
       def trigger(type, to_match, algorithm_argument = nil)
         generator = find(type, to_match)
-        generator.trigger(algorithm_argument)
+        if generator
+          generator.trigger(algorithm_argument)
+        else
+          Render.logger.warn("Could not find generator for type #{type} with matcher for #{to_match}, using nil")
+          nil
+        end
       end
 
       def find(type, to_match)
         instances.detect do |generator|
-          generator.type.to_s.match(/#{type}/i) && to_match.match(generator.matcher)
+          (type == generator.type) && to_match.to_s.match(generator.matcher)
         end
       end
     end
@@ -57,14 +64,66 @@ module Render
       end
     end
 
-    # Default set to ensure each type can generate fake data.
-    Generator.create!(String, /.*/, proc { |attribute| "#{attribute.name} (generated)" })
-    Generator.create!(Integer, /.*/, proc { rand(100) })
-    Generator.create!(Float, /.*/, proc { rand(0.1..99).round(2) })
-    Generator.create!(UUID, /.*/, proc { UUID.generate })
-    Generator.create!(Time, /.*/, proc { |attribute| time = Time.now; (attribute.type == String) ? time.to_s : time })
+
+    def self.least_multiple(multiple_of, min)
+      lowest_multiple = multiple_of
+      until (lowest_multiple > min)
+        lowest_multiple += multiple_of
+      end
+      lowest_multiple
+    end
+
+    # Ensure each type can generate fake data.
+    # Standard JSON types
+    Generator.create!(String, /.*/, proc { |attribute|
+      min_length = attribute.min_length || -1
+      max_length = (attribute.max_length.to_i - 1)
+      "#{attribute.name} (generated)".ljust(min_length, "~")[0..max_length]
+    })
+
+    Generator.create!(Integer, /.*/, proc { |attribute|
+      min = attribute.minimum.to_i
+      max = attribute.maximum || FAUX_DATA_MAX
+      min += 1 if attribute.exclusive_minimum
+      max -= 1 if attribute.exclusive_maximum
+
+      if attribute.multiple_of
+        least_multiple(attribute.multiple_of, min)
+      else
+        rand(min..max)
+      end
+    })
+
+    # parsed from number
+    Generator.create!(Float, /.*/, proc { |attribute|
+      rounding_factor = 2
+      least_significant_number = 10 ** -rounding_factor
+
+      min = attribute.minimum.to_f
+      max = attribute.maximum || FAUX_DATA_MAX
+      min += least_significant_number if attribute.exclusive_minimum
+      max -= least_significant_number if attribute.exclusive_maximum
+
+      if attribute.multiple_of
+        least_multiple(attribute.multiple_of, min)
+      else
+        rand(min..max).round(rounding_factor)
+      end
+    })
+
     Generator.create!(Type::Boolean, /.*/, proc { [true, false].sample })
+    Generator.create!(NilClass, /.*/, proc {}) # parsed from null
+    # Standard JSON formats
+    Generator.create!(DateTime, /.*/, proc { DateTime.now.to_s })
+    Generator.create!(URI, /.*/, proc { "http://localhost" })
+    Generator.create!(Type::Hostname, /.*/, proc { "localhost" })
+    Generator.create!(Type::Email, /.*/, proc { "you@localhost" })
+    Generator.create!(Type::IPv4, /.*/, proc { "127.0.0.1" })
+    Generator.create!(Type::IPv6, /.*/, proc { "::1" })
     Generator.create!(Type::Enum, /.*/, proc { |attribute| attribute.enums.sample })
+    # Extended
+    Generator.create!(UUID, /.*/, proc { UUID.generate })
+    Generator.create!(Time, /.*/, proc { |attribute| time = Time.now; (attribute.type == String) ? time.to_s : time })
     Generator.create!(Type::Date, /.*/, proc { Time.now.to_date })
   end
 end

data/lib/render/graph.rb

@@ -1,19 +1,18 @@
+require "addressable/template"
+
 require "render/schema"
 require "render/errors"
 require "render/extensions/dottable_hash"
 
 module Render
   class Graph
-    PARAM = %r{:(?<param>[\w_]+)}
-    PARAMS = %r{#{PARAM}[\/\;\&]?}
-
     attr_accessor :schema,
       :raw_endpoint,
       :relationships,
       :graphs,
-      :inherited_data,
       :config,
-      :rendered_data
+      :rendered_data,
+      :relationship_info
 
     def initialize(schema_or_definition, options = {})
       self.schema = determine_schema(schema_or_definition)
@@ -21,60 +20,61 @@ module Render
       self.graphs = (options.delete(:graphs) || [])
       self.raw_endpoint = (options.delete(:endpoint) || schema.definition[:endpoint]).to_s
       self.config = options
-
-      self.inherited_data = {}
+      self.relationship_info = {}
     end
 
     def title
-      schema.universal_title || schema.title
+      schema.id || schema.title
     end
 
-    def render!(inherited_properties = nil)
-      self.inherited_data = inherited_properties
+    def serialize!(explicit_data = nil, parental_data = nil)
+      process_relationship_info!(parental_data)
+
       if (schema.type == Array)
-        explicit_data = inherited_data
+        schema.render!(explicit_data, endpoint)
       else
-        explicit_data = inherited_data.is_a?(Hash) ? inherited_data : {}
-        explicit_data = explicit_data.merge!(relationship_data_from_parent)
+        explicit_data ||= {}
+        schema.render!(explicit_data.merge(relationship_info), endpoint)
       end
+    end
 
-      graph_data = Extensions::DottableHash.new
-
-      rendered_data = schema.render!(explicit_data, endpoint) do |parent_data|
-        loop_with_configured_threading(graphs) do |graph|
-          if parent_data.is_a?(Array)
-            graph_data[graph.title] = parent_data.inject([]) do |nested_data, element|
-              nested_data << graph.render!(element)[graph.title]
-            end
-          else
-            nested_data = graph.render!(parent_data)
-            graph_data.merge!(nested_data)
-          end
+    def render!(explicit_data = nil, parental_data = nil, as_array = false)
+      if as_array
+        data = parental_data.inject([]) do |accumulator, parental_element|
+          accumulator << serialize!(explicit_data, parental_element)
         end
+      else
+        data = serialize!(explicit_data, parental_data)
+      end
+
+      loop_with_configured_threading(graphs) do |graph|
+        graph.render!(explicit_data, data, (schema.type == Array))
       end
 
-      self.rendered_data = graph_data.merge!(rendered_data)
+      self.rendered_data = graphs.inject(Extensions::DottableHash.new) do |data, graph|
+        data[graph.title] = graph.rendered_data
+      end
+      self.rendered_data[title] = data
+      rendered_data
     end
 
     private
 
     def endpoint
-      raw_endpoint.gsub!(":host", config.fetch(:host)) if raw_endpoint.match(":host")
-      uri = URI(raw_endpoint)
+      template = Addressable::Template.new(raw_endpoint)
+      variables = config.merge(relationship_info)
+      undefined_variables = (template.variables - variables.keys.collect(&:to_s))
+      raise Errors::Graph::EndpointKeyNotFound.new(undefined_variables) if (undefined_variables.size > 0)
+      template.expand(variables).to_s
+    end
 
-      uri.path.gsub!(PARAMS) do |param|
-        key = param_key(param)
-        param.gsub(PARAM, param_value(key).to_s)
-      end
+    def process_relationship_info!(data)
+      return if !data
 
-      if uri.query
-        uri.query.gsub!(PARAMS) do |param|
-          key = param_key(param)
-          "#{key}=#{param_value(key)}&"
-        end.chop!
+      self.relationship_info = relationships.inject({}) do |info, (parent_key, child_key)|
+        value = data.is_a?(Hash) ? data.fetch(parent_key, nil) : data
+        info.merge!({ child_key => value })
       end
-
-      uri.to_s
     end
 
     def loop_with_configured_threading(elements)
@@ -101,30 +101,5 @@ module Render
       end
     end
 
-    def relationship_data_from_parent
-      relationships.inject({}) do |data, (parent_key, child_key)|
-        data.merge({ child_key => value_from_inherited_data(child_key) })
-      end
-    end
-
-    def param_key(string)
-      string.match(PARAM)[:param].to_sym
-    end
-
-    def param_value(key)
-      value_from_inherited_data(key) || config[key] || raise(Errors::Graph::EndpointKeyNotFound.new(key))
-    end
-
-    def value_from_inherited_data(key)
-      relationships.each do |parent_key, child_key|
-        if !inherited_data.is_a?(Hash)
-          return inherited_data
-        elsif (child_key == key)
-          return inherited_data.fetch(parent_key, nil)
-        end
-      end
-      nil
-    end
-
   end
 end

data/lib/render/json_schema.rb

@@ -0,0 +1,12 @@
+require "render"
+
+module Render
+  module JSONSchema
+    Definition.load_from_directory!("lib/json/draft-04")
+
+    CORE = Schema.new("http://json-schema.org/draft-04/schema#")
+    HYPER = Schema.new("http://json-schema.org/draft-04/hyper-schema#")
+    PROPERTIES = [CORE.attributes.collect(&:name), HYPER.attributes.collect(&:name)].flatten.uniq
+
+  end
+end

data/lib/render/schema.rb

@@ -8,44 +8,45 @@ require "render/extensions/dottable_hash"
 module Render
   class Schema
     DEFAULT_TITLE = "untitled".freeze
+    CONTAINER_KEYWORDS = %w(items properties).freeze
+    ROOT_POINTER = "#".freeze
+    POINTER_SEPARATOR = %r{\/}.freeze
 
     attr_accessor :title,
       :type,
       :definition,
       :array_attribute,
       :hash_attributes,
-      :universal_title,
-      :raw_data,
-      :serialized_data,
-      :rendered_data
+      :id
 
     def initialize(definition_or_title)
       Render.logger.debug("Loading #{definition_or_title}")
 
-      self.definition = determine_definition(definition_or_title)
-      title_or_default = definition.fetch(:title, DEFAULT_TITLE)
-      self.title = title_or_default.to_sym
+      process_definition!(definition_or_title)
+      interpolate_refs!(definition)
+
+      self.title = definition.fetch(:title, DEFAULT_TITLE)
+      self.id = Definition.parse_id(definition)
       self.type = Type.parse(definition[:type]) || Object
-      self.universal_title = definition.fetch(:universal_title, nil)
 
-      if definition.keys.include?(:items)
+      if array_schema?
         self.array_attribute = ArrayAttribute.new(definition)
       else
         self.hash_attributes = definition.fetch(:properties).collect do |name, attribute_definition|
           HashAttribute.new({ name => attribute_definition })
         end
+        require_attributes!
       end
     end
 
     def serialize!(explicit_data = nil)
       if (type == Array)
-        self.serialized_data = array_attribute.serialize(explicit_data)
+        array_attribute.serialize(explicit_data)
       else
-        self.serialized_data = hash_attributes.inject({}) do |processed_explicit_data, attribute|
-          explicit_data ||= {}
+        explicit_data ||= {}
+        hash_attributes.inject({}) do |processed_explicit_data, attribute|
           value = explicit_data.fetch(attribute.name, nil)
           maintain_nil = explicit_data.has_key?(attribute.name)
-
           serialized_attribute = attribute.serialize(value, maintain_nil)
           processed_explicit_data.merge!(serialized_attribute)
         end
@@ -53,27 +54,92 @@ module Render
     end
 
     def render!(explicit_data = nil, endpoint = nil)
-      self.raw_data = Render.live ? request(endpoint) : explicit_data
-      serialize!(raw_data)
-      yield serialized_data if block_given?
-      self.rendered_data = Extensions::DottableHash.new(hash_with_title_prefixes(serialized_data))
+      raw_data = Render.live ? request(endpoint) : explicit_data
+      data = serialize!(raw_data)
+      data.is_a?(Array) ? data : Extensions::DottableHash.new(data)
+    end
+
+    def attributes
+      array_schema? ? array_attribute : hash_attributes
     end
 
     private
 
-    def determine_definition(definition_or_title)
-      if (definition_or_title.is_a?(Hash) && !definition_or_title.empty?)
-        definition_or_title
+    def require_attributes!
+      definition.fetch(:required, []).each do |required_attribute|
+        attribute = attributes.detect { |attribute| attribute.name == required_attribute.to_sym }
+        attribute.required = true
+      end
+    rescue
+      raise Errors::Schema::InvalidRequire.new(definition)
+    end
+
+    def process_definition!(title_or_definition)
+      raw_definition = determine_definition(title_or_definition)
+
+      if container?(raw_definition)
+        self.definition = raw_definition
       else
-        Definition.find(definition_or_title)
+        partitions = raw_definition.partition { |(key, value)| container?(value) }
+        subschemas, container = partitions.map { |partition| Hash[partition] }
+        container[:type] = Object
+        container[:properties] = subschemas
+
+        self.definition = container
+      end
+    end
+
+    def interpolate_refs!(working_definition, current_scope = [])
+      return unless working_definition.is_a?(Hash)
+
+      working_definition.each do |(instance_name, instance_value)|
+        next unless instance_value.is_a?(Hash)
+
+        if instance_value.has_key?(:$ref)
+          ref = instance_value.fetch(:$ref)
+          ref_definition = Definition.find(ref, false) || find_local_schema(ref, current_scope)
+          instance_value.replace(ref_definition)
+        end
+
+        interpolate_refs!(instance_value, current_scope.dup << instance_name)
       end
     end
 
-    def hash_with_title_prefixes(data)
-      if universal_title
-        { universal_title => { title => data } }
+    def find_local_schema(ref, scopes)
+      paths = ref.split(POINTER_SEPARATOR)
+      if (paths.first == ROOT_POINTER)
+        paths.shift
+        find_at_path(paths) || {}
       else
-        { title => data }
+        find_at_closest_scope(paths, scopes) || {}
+      end
+    end
+
+    def find_at_closest_scope(path, scopes)
+      return if scopes.empty?
+      find_at_path(scopes + path) || find_at_closest_scope(path, scopes[0...-1])
+    end
+
+    def find_at_path(paths)
+      paths.reduce(definition) do |reduction, path|
+        reduction[path.to_sym] || return
+      end
+    end
+
+    def container?(definition)
+      return false unless definition.is_a?(Hash)
+      definition.any? { |(key, value)| CONTAINER_KEYWORDS.include?(key.to_s) }
+    end
+
+    def array_schema?
+      definition.keys.include?(:items)
+    end
+
+    def determine_definition(definition_or_title)
+      if (definition_or_title.is_a?(Hash) && !definition_or_title.empty?)
+        definition_or_title
+      else
+        Definition.find(definition_or_title)
       end
     end
 
@@ -84,12 +150,7 @@ module Render
     def default_request(endpoint)
       response = Net::HTTP.get_response(URI(endpoint))
       if response.kind_of?(Net::HTTPSuccess)
-        response = JSON.parse(response.body.to_s)
-        if response.is_a?(Array)
-          Extensions::SymbolizableArray.new(response).recursively_symbolize_keys!
-        else
-          Extensions::DottableHash.new(response).recursively_symbolize_keys!
-        end
+        JSON.parse(response.body.to_s, { symbolize_names: true })
       else
         raise Errors::Schema::RequestError.new(endpoint, response)
       end