render 0.0.2 → 0.0.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    render (0.0.2)
+    render (0.0.3)
       uuid (= 2.3.7)
 
 GEM
@@ -11,10 +11,10 @@ GEM
     columnize (0.3.6)
     crack (0.4.1)
       safe_yaml (~> 0.9.0)
-    debugger (1.5.0)
+    debugger (1.6.1)
       columnize (>= 0.3.1)
       debugger-linecache (~> 1.2.0)
-      debugger-ruby_core_source (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.3)
     debugger-linecache (1.2.0)
     debugger-ruby_core_source (1.2.3)
     diff-lcs (1.2.4)

data/lib/render/array_attribute.rb

@@ -0,0 +1,52 @@
+require "render/attribute"
+
+module Render
+  class ArrayAttribute < Attribute
+    FAUX_DATA_UPPER_LIMIT = 5.freeze
+
+    attr_accessor :archetype
+
+    def initialize(options = {})
+      super
+
+      self.name = options.fetch(:title, :render_array_attribute_untitled).to_sym
+      options = options[:items]
+      self.type = Render.parse_type(options[:type])
+      self.format = Render.parse_type(options[:format]) rescue nil
+      self.enums = options[:enum]
+
+      if options.keys.include?(:properties)
+        self.schema = Schema.new(options)
+      else
+        self.archetype = true
+      end
+    end
+
+    def serialize(explicit_values = nil)
+      explicit_values = faux_array_data if (Render.live == false && explicit_values.nil?)
+      if archetype
+        explicit_values.collect do |value|
+          value || default_value
+        end
+      else
+        explicit_values.collect do |value|
+          schema.serialize!(value)
+        end
+      end
+    end
+
+    private
+
+    def faux_array_data
+      rand(lower_limit..FAUX_DATA_UPPER_LIMIT).times.collect do
+        archetype ? nil : {}
+      end
+    end
+
+    def lower_limit
+      # lower_limit = (required ? 1 : 0)
+      1
+    end
+
+  end
+end

data/lib/render/attribute.rb

@@ -1,89 +1,52 @@
 # An Attribute represents a specific key and value as part of a Schema.
-# It is responsible for casting its value and generating sample (default) data when not in live-mode.
+# It is responsible for casting its value and generating sample data.
 
 require "uuid"
 
 module Render
   class Attribute
-    attr_accessor :name, :type, :schema, :archetype, :enums
+    SCHEMA_IDENTIFIERS = [:properties, :items].freeze
 
-    # Initialize take a few different Hashes
-    # { name: { type: UUID } } for standard Hashes to be aligned
-    # { type: UUID } for elements in an array to be parsed
-    # { name: { type: Object, attributes { ... } } for nested schemas
-    def initialize(options = {})
-      self.name = options.keys.first
-      if (options.keys.first == :type && !options[options.keys.first].is_a?(Hash)) # todo there has to be a better way to do this
-        initialize_as_archetype(options)
-      else
-        self.type = Render.parse_type(options[name][:type])
-        self.enums = options[name][:enum]
-        initialize_schema!(options) if schema_value?(options)
-      end
-    end
-
-    def initialize_as_archetype(options)
-      self.type = Render.parse_type(options[:type])
-      self.enums = options[:enum]
-      self.archetype = true
-    end
+    attr_accessor :name,
+      :type,
+      :schema,
+      :enums,
+      :format,
+      :required
 
-    def initialize_schema!(options)
-      schema_options = {
-        title: name,
-        type: type
-      }
-
-      definition = options[name]
-      if definition.keys.include?(:attributes)
-        schema_options.merge!({ attributes: definition[:attributes] })
-      else
-        schema_options.merge!({ elements: definition[:elements] })
-      end
-
-      self.schema = Schema.new(schema_options)
-    end
-
-    def serialize(explicit_value)
-      if archetype
-        explicit_value || default_value
-      else
-        to_hash(explicit_value)
-      end
+    def initialize(options = {})
+      Render.logger.debug("Initializing attribute #{options}")
+      self.required = false
     end
 
-    def to_hash(explicit_value = nil)
-      value = if schema_value?
-        schema.serialize(explicit_value)
-      else
-        # TODO guarantee type for explicit value
-        (explicit_value || default_value)
-      end
-
-      { name.to_sym => value }
+    def bias_type
+      format || type
     end
 
     def default_value
       Render.live ? nil : faux_value
     end
 
-    def schema_value?(options = {})
-      return true if schema
-      options[name].is_a?(Hash) && (options[name][:attributes] || options[name][:elements])
+    def nested_schema?(options = {})
+      options.any? { |name, value| SCHEMA_IDENTIFIERS.include?(name) }
     end
 
     private
 
+    # TODO implement better #faux_value
     def faux_value
-      # TODO implement better #faux_value
       return enums.sample if enums
       return generator_value if generator_value # todo optimize generator_value call
 
-      case(type.name)
+      case(bias_type.name)
       when("String") then "A String"
       when("Integer") then rand(1000)
       when("UUID") then UUID.generate
       when("Boolean") then [true, false].sample
+      when("Float") then rand(0.1..99)
+      when("Time")
+        time = Time.now
+        (type == String) ? time.to_s : time
       end
     end
 
@@ -93,7 +56,6 @@ module Render
       end
       generator.algorithm.call if generator
     end
-
   end
-end
 
+end

data/lib/render/dottable_hash.rb

@@ -59,9 +59,8 @@ module Render
       end
     end
 
-    def fetch(key)
+    def fetch(key, *args)
       key = key.to_sym
-      raise KeyError.new("Invalid key: #{key}") unless has_key?(key)
       super
     end
 

data/lib/render/errors.rb

@@ -1,5 +1,17 @@
 module Render
   module Errors
+    class InvalidType < StandardError
+      attr_accessor :name
+
+      def initialize(name)
+        self.name = name
+      end
+
+      def to_s
+        "Cannot parse type: #{name}."
+      end
+    end
+
     class Generator
       class MalformedAlgorithm < StandardError
         attr_accessor :algorithm
@@ -23,24 +35,24 @@ module Render
         end
 
         def to_s
-          "No value for key #{config_key} found in config or parental_attributes."
+          "No value for key #{config_key} found in config or parental_properties."
         end
       end
     end
 
-    class Schema
-      class NotFound < StandardError
-        attr_accessor :title
+    class DefinitionNotFound < StandardError
+      attr_accessor :title
 
-        def initialize(title)
-          self.title = title
-        end
+      def initialize(title)
+        self.title = title
+      end
 
-        def to_s
-          "Schema with title #{title} is not loaded"
-        end
+      def to_s
+        "Schema with title #{title} is not loaded"
       end
+    end
 
+    class Schema
       class RequestError < StandardError
         attr_accessor :endpoint, :response
 

data/lib/render/generator.rb

@@ -4,9 +4,9 @@ module Render
   class Generator
     attr_accessor :type, :matcher, :algorithm
 
-    def initialize(attributes = {})
-      attributes.symbolize_keys!
-      %w(type matcher algorithm).each { |attribute| self.__send__("#{attribute}=", attributes[attribute.to_sym]) }
+    def initialize(properties = {})
+      properties.symbolize_keys!
+      %w(type matcher algorithm).each { |attribute| self.__send__("#{attribute}=", properties[attribute.to_sym]) }
       raise Errors::Generator::MalformedAlgorithm.new(algorithm) if !algorithm.respond_to?(:call)
     end
 

data/lib/render/graph.rb

@@ -17,24 +17,18 @@ module Render
       :raw_endpoint,
       :relationships,
       :graphs,
-      :params,
-      :parental_params, # TODO rename this to inherited_params
-      :config
-
-    def initialize(schema, attributes = {})
-      self.schema = if schema.is_a?(Symbol)
-        Schema.new(schema)
-      else
-        schema
-      end
-
-      self.relationships = (attributes.delete(:relationships) || {})
-      self.raw_endpoint = (attributes.delete(:endpoint) || "")
-      self.graphs = (attributes.delete(:graphs) || [])
-      self.config = attributes
-      self.parental_params = {}
-
-      initialize_params!
+      :inherited_data,
+      :config,
+      :rendered_data
+
+    def initialize(schema_or_definition, options = {})
+      self.schema = determine_schema(schema_or_definition)
+      self.relationships = (options.delete(:relationships) || {})
+      self.graphs = (options.delete(:graphs) || [])
+      self.raw_endpoint = options.delete(:endpoint).to_s
+      self.config = options
+
+      self.inherited_data = {}
     end
 
     def endpoint
@@ -55,44 +49,60 @@ module Render
       uri.to_s
     end
 
-    def render(inherited_attributes = {})
-      calculate_parental_params!(inherited_attributes)
-      graph_attributes = schema.render(inherited_attributes.merge(parental_params.merge({ endpoint: endpoint })))
+    def render(inherited_properties = {})
+      self.inherited_data = inherited_properties
 
-      graph = graphs.inject(graph_attributes) do |attributes, nested_graph|
-        threads = []
-        # TODO threading should be configured so people may also think about Thread.abort_on_transaction!
-        threads << Thread.new do
-          title = schema.title.to_sym
-          parent_data = attributes[title]
-          nested_graph_data = if parent_data.is_a?(Array)
-            data = parent_data.collect do |element|
-              nested_graph.render(element)
+      graph_data = DottableHash.new
+      inherited_data = relationship_data_from_parent.merge({ endpoint: endpoint })
+      rendered_data = schema.render!(inherited_data) 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
-            key = data.first.keys.first
-            attributes[title] = data.collect { |d| d[key] }
           else
-            data = nested_graph.render(parent_data)
-            parent_data.merge!(data)
+            nested_data = graph.render(parent_data)
+            graph_data.merge!(nested_data)
+          end
+        end
+      end
+
+      self.rendered_data = graph_data.merge!(rendered_data)
+    end
+
+    def loop_with_configured_threading(elements)
+      if Render.threading?
+        threads = []
+        elements.each do |element|
+          threads << Thread.new do
+            yield element
           end
         end
         threads.collect(&:join)
-        attributes
+      else
+        elements.each do |element|
+          yield element
+        end
       end
-      DottableHash.new(graph)
+    end
+
+    def title
+      schema.universal_title || schema.title
     end
 
     private
 
-    def initialize_params!
-      self.params = raw_endpoint.scan(PARAMS).flatten.inject({}) do |params, param|
-        params.merge({ param.to_sym => nil })
+    def determine_schema(schema_or_definition)
+      if schema_or_definition.is_a?(Schema)
+        schema_or_definition
+      else
+        Schema.new(schema_or_definition)
       end
     end
 
-    def calculate_parental_params!(inherited)
-      self.parental_params = relationships.inject(inherited) do |attributes, (parent_key, child_key)|
-        attributes.merge({ child_key => inherited[parent_key] })
+    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
 
@@ -101,7 +111,18 @@ module Render
     end
 
     def param_value(key)
-      parental_params[key] || config[key] || raise(Errors::Graph::EndpointKeyNotFound.new(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)
+        end
+      end
+      nil
     end
 
   end

data/lib/render/hash_attribute.rb

@@ -0,0 +1,38 @@
+require "render"
+require "render/attribute"
+
+module Render
+  class HashAttribute < Attribute
+    def initialize(options = {})
+      super
+
+      self.name = options.keys.first
+      options = options[name]
+      self.type = Render.parse_type(options[:type])
+      self.format = Render.parse_type(options[:format]) rescue nil
+      self.enums = options[:enum]
+
+      initialize_schema!(options) if nested_schema?(options)
+    end
+
+    def initialize_schema!(options)
+      schema_options = {
+        title: name,
+        type: bias_type
+      }
+
+      self.schema = Schema.new(schema_options.merge(options))
+    end
+
+    def serialize(explicit_value)
+      if !!schema
+        value = schema.serialize!(explicit_value)
+        { name.to_sym => value }
+      else
+        value = (explicit_value || default_value)
+        { name.to_sym => value }
+      end
+    end
+
+  end
+end

data/lib/render/schema.rb

@@ -1,114 +1,100 @@
-# The Schema defines a collection of attributes.
-# It is responsible for returning its attributes' values back to its Graph.
+# The Schema defines a collection of properties.
+# It is responsible for returning its properties' values back to its Graph.
 
 require "net/http"
 require "json"
 require "render"
 require "render/attribute"
+require "render/array_attribute"
+require "render/hash_attribute"
+require "render/dottable_hash"
 
 module Render
   class Schema
+    DEFAULT_TITLE = "untitled".freeze
+
     attr_accessor :title,
       :type,
-      :attributes,
-      :schema
+      :definition,
+      :array_attribute,
+      :hash_attributes,
+      :universal_title,
+      :raw_data,
+      :serialized_data,
+      :rendered_data
+
+    # TODO When given { ids: [1,2] }, parental_mapping { ids: id } means to make 2 calls
+    def initialize(definition_or_title)
+      Render.logger.debug("Loading #{definition_or_title}")
 
-    # The schema need to know where its getting a value from
-    # an Attribute, e.g. { foo: "bar" } => { foo: { type: String } }
-    # an Archetype, e.g. [1,2,3] => { type: Integer } # could this be a pass-through?
-    # an Attribute-Schema, e.g. { foo: { bar: "baz" } } => { foo: { type: Object, attributes: { bar: { type: String } } }
-    # an Attribute-Array, e.g. [{ foo: "bar" }] => { type: Array, elements: { type: Object, attributes: { foo: { type: String } } } }
-    # and we need to identify when given { ids: [1,2] }, parental_mapping { ids: id } means to make 2 calls
-    def initialize(schema_or_title)
-      self.schema = schema_or_title.is_a?(Hash) ? schema_or_title : find_schema(schema_or_title)
-      self.title = schema[:title]
-      self.type = Render.parse_type(schema[:type])
+      self.definition = determine_definition(definition_or_title)
+      title_or_default = definition.fetch(:title, DEFAULT_TITLE)
+      self.title = title_or_default.to_sym
+      self.type = Render.parse_type(definition[:type])
+      self.universal_title = definition.fetch(:universal_title, nil)
 
-      if array_of_schemas?(schema[:elements])
-        self.attributes = [Attribute.new({ elements: schema[:elements] })]
+      if definition.keys.include?(:items)
+        self.array_attribute = ArrayAttribute.new(definition)
       else
-        definitions = schema[:attributes] || schema[:elements]
-        self.attributes = definitions.collect do |key, value|
-          Attribute.new({ key => value })
+        self.hash_attributes = definition.fetch(:properties).collect do |name, attribute_definition|
+          HashAttribute.new({ name => attribute_definition })
         end
       end
     end
 
-    def array_of_schemas?(definition = {})
-      return false unless definition
-      definition.keys.include?(:attributes)
-    end
-
-    def render(options = {})
-      endpoint = options.delete(:endpoint)
-      data = Render.live ? request(endpoint) : options
-      { title.to_sym => serialize(data) }
+    def serialize!(explicit_data = nil)
+      if (type == Array)
+        self.serialized_data = array_attribute.serialize(explicit_data)
+      else
+        self.serialized_data = hash_attributes.inject({}) do |processed_explicit_data, attribute|
+          explicit_data ||= {}
+          value = explicit_data.fetch(attribute.name, nil)
+          serialized_attribute = attribute.serialize(value)
+          processed_explicit_data.merge!(serialized_attribute)
+        end
+      end
     end
 
-    def serialize(data)
-      # data.is_a?(Array) ? to_array(data) : to_hash(data)
-      (type == Array) ? to_array(data) : to_hash(data)
+    def render!(options_and_explicit_data = nil)
+      endpoint = options_and_explicit_data.delete(:endpoint) if options_and_explicit_data.is_a?(Hash)
+      self.raw_data = Render.live ? request(endpoint) : options_and_explicit_data
+      serialize!(raw_data)
+      yield serialized_data if block_given?
+      self.rendered_data = DottableHash.new(hash_with_title_prefixes(serialized_data))
     end
 
     private
 
-    def find_schema(title)
-      loaded_schema = Render.schemas[title.to_sym]
-      raise Errors::Schema::NotFound.new(title) if !loaded_schema
-      loaded_schema
-    end
-
-    def request(endpoint)
-      response = Net::HTTP.get_response(URI(endpoint))
-      if response.kind_of?(Net::HTTPSuccess)
-        response = JSON.parse(response.body).recursive_symbolize_keys!
-        if (response.is_a?(Array) || (response[title.to_sym] == nil))
-          response
-        else
-          response[title.to_sym]
-        end
+    def determine_definition(definition_or_title)
+      if (definition_or_title.is_a?(Hash) && !definition_or_title.empty?)
+        definition_or_title
       else
-        raise Errors::Schema::RequestError.new(endpoint, response)
+        Render.definition(definition_or_title)
       end
-    rescue JSON::ParserError => error
-      raise Errors::Schema::InvalidResponse.new(endpoint, response.body)
-    end
-
-    def to_array(elements)
-      # elements.first.is_a?(Hash) ? to_array_of_schemas(elements) : to_array_of_elements(elements)
-      attributes.first.schema_value? ? to_array_of_schemas(elements) : to_array_of_elements(elements)
     end
 
-    def to_array_of_elements(elements)
-      (elements = stubbed_array) if !Render.live && (!elements || elements.empty?)
-      archetype = attributes.first # there should only be one in the event that it's an array schema
-      elements.collect do |element|
-        archetype.serialize(element)
+    def hash_with_title_prefixes(data)
+      if universal_title
+        { universal_title => { title => data } }
+      else
+        { title => data }
       end
     end
 
-    def to_array_of_schemas(elements)
-      (elements = stubbed_array) if !Render.live && (!elements || elements.empty?)
-      elements.collect do |element|
-        attributes.inject({}) do |attributes, attribute|
-          attributes.merge(attribute.to_hash(element)).values.first
-        end
-      end
+    def request(endpoint)
+      default_request(endpoint)
     end
 
-    def to_hash(explicit_values = {})
-      explicit_values ||= {} # !Render.live check
-      attributes.inject({}) do |accum, attribute|
-        explicit_value = explicit_values[attribute.name]
-        hash = attribute.to_hash(explicit_value)
-        accum.merge(hash)
+    def default_request(endpoint)
+      response = Net::HTTP.get_response(URI(endpoint))
+      if response.kind_of?(Net::HTTPSuccess)
+        JSON.parse(response.body).recursive_symbolize_keys!
+      else
+        raise Errors::Schema::RequestError.new(endpoint, response)
       end
+    rescue JSON::ParserError => error
+      raise Errors::Schema::InvalidResponse.new(endpoint, response.body)
     end
 
-    def stubbed_array
-      elements = []
-      rand(1..3).times { elements << nil }
-      elements
-    end
   end
 end

data/lib/render/version.rb

@@ -1,3 +1,3 @@
 module Render
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end