render 0.0.4 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDFmMmYyYWI1MWI3ODE2YjRkNDAwOGEzODAwYWVkYTBiOTYwZjhkOA==
+    OTJlZmIxMGY4MTViYTcxMTc1ZDQ1Y2NiMzQyOWIwOTJiNjkzODM1Yw==
   data.tar.gz: !binary |-
-    ZTI2MzAwODM2ODAwOGQ3OWM5MmI2ODViNmIxMTg5YmJkM2IwOWY0ZQ==
+    OGRkZWY2MWQ2Y2NlY2MxNGJmYThmNzIwMmY3MjAyMTI5NDEwYWVkNw==
 SHA512:
   metadata.gz: !binary |-
-    NzFjZWJiMDVjMjNkZTczODBhZTA3OWRiOGEzYTJhYjc3YzBkZTI3OWRkYzUz
-    NDUzZjMxYzBiYjM5MzAxM2Q4YzVjYjVjYzlmYjIwNjhhOTVlNGQwOWRjYzhk
-    NTJkN2UzYjAwMzBjMDE3MGMxNTllYzVhYjQwMTI5NGRlMzRlM2E=
+    NzdlN2JkNWU3MDdlOTUzYWUwY2RkZTYyOTFiN2U3ZGE5MTNiYTIwMzgzNmQ1
+    YmM3MzE3ZDYyODU3NTNjYTI2NjM0NjY3ZjJkNDA4ZDc5Nzg1YjY2ZGIzODgx
+    ZWQ2YjhkMDdkNzk5OTg0NTM5MDQ3YjA5YjkzYjZhNGRjMGEwYWQ=
   data.tar.gz: !binary |-
-    MjJlZGMxYmNhMWMxMmU1ZjdlYWI2ODMxMWU0M2M1ZDJlM2U2NGZlZTgyYTlh
-    ZDgxOGNjOTVhODk4YzNlZjA4YmI3NTA1ZjVmZTYxZjk1OGE1NDFlYjljY2Jm
-    ZTUxYzU3NmM1NzdkNmQ4ZjMwMzY1ZDFjZDZmNmI0MjFjMWZkZjk=
+    ZjMwNDIyNDdmZDg1ZGIyNDExMjYwODkzYjY2YTY3ZjllYWUzY2RkMmI4NjE0
+    NDQ0NTc2MzVhZjQzZTA0MGZhOTkzMzIxYzk4MTdlNTEwZTViYmM5MjVkNDgx
+    YzlhNDVjMWEwODkzMWJiMDZmZWQwNThhMGZhMjE3ODk5OTk4OTg=

data/Gemfile

@@ -1,4 +1,4 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in representation.gemspec
+# Specify your gem's dependencies in render.gemspec
 gemspec

data/lib/render.rb

@@ -1,68 +1,30 @@
-# Render allows one to define object Graphs with Schema/endpoint information.
-# Once defined and constructed, a Graph can be built at once that will:
-#  - Query its endpoint to construct a hash for its Schema
-#  - Add nested Graphs by interpreting/sending data they need
-
-require "extensions/enumerable"
-require "extensions/boolean"
-require "extensions/hash"
+require "uuid"
+require "date"
+require "logger"
 
 require "render/version"
-require "render/graph"
+require "render/errors"
+require "render/extensions/dottable_hash"
+require "render/type"
 require "render/generator"
-require "logger"
-require "date"
+require "render/definition"
+require "render/graph"
 
 module Render
   @live = true
-  @definitions = {}
-  @generators = []
-  @logger = ::Logger.new($stdout)
+  @logger = ::Logger.new("/dev/null")
   @threading = true
 
   class << self
-    attr_accessor :live,
-      :definitions,
-      :generators,
-      :logger,
-      :threading
+    attr_accessor :live, :logger, :threading
 
     def threading?
       threading == true
     end
 
-    def load_definitions!(directory)
-      Dir.glob("#{directory}/**/*.json").each do |definition_file|
-        logger.info("Reading #{definition_file} definition")
-        definition_string = File.read(definition_file)
-        parsed_definition = JSON.parse(definition_string).recursive_symbolize_keys!
-        load_definition!(parsed_definition)
-      end
+    def live?
+      @live == true
     end
 
-    def load_definition!(definition)
-      title = definition.fetch(:universal_title, definition.fetch(:title)).to_sym
-      self.definitions[title] = definition
-    end
-
-    def definition(title)
-      definitions.fetch(title.to_sym)
-    rescue KeyError => error
-      raise Errors::DefinitionNotFound.new(title)
-    end
-
-    # TODO better type parsing
-    def parse_type(type)
-      return type unless type.is_a?(String)
-
-      return UUID if type.match(/uuid/i)
-      return Boolean if type.match(/boolean/i)
-      return Float if type.match(/number/i)
-      return Time if type.match(/date.*time/i)
-      Object.const_get(type.capitalize)
-    rescue NameError => error
-      raise Errors::InvalidType.new(type)
-    end
   end
-
 end

data/lib/render/{array_attribute.rb → attributes/array_attribute.rb}

@@ -1,4 +1,4 @@
-require "render/attribute"
+require "render/attributes/attribute"
 
 module Render
   class ArrayAttribute < Attribute
@@ -10,10 +10,9 @@ module Render
       super
 
       self.name = options.fetch(:title, :render_array_attribute_untitled).to_sym
+      self.required = options.fetch(:required, nil)
       options = options.fetch(:items)
-      self.type = Render.parse_type(options[:type])
-      self.format = Render.parse_type(options[:format]) rescue nil
-      self.enums = options[:enum]
+      process_type!(options)
 
       if options.keys.include?(:properties)
         self.schema = Schema.new(options)

data/lib/render/attributes/attribute.rb

@@ -0,0 +1,48 @@
+require "uuid"
+
+module Render
+  class Attribute
+    SCHEMA_IDENTIFIERS = [:properties, :items].freeze
+
+    attr_accessor :name,
+      :type,
+      :schema,
+      :enums,
+      :format,
+      :required
+
+    def initialize(options = {})
+      Render.logger.debug("Initializing attribute #{options}")
+      self.required = false
+    end
+
+    def bias_type
+      format || type
+    end
+
+    def default_value
+      Render.live ? nil : faux_value
+    end
+
+    def nested_schema?(options = {})
+      options.any? { |name, value| SCHEMA_IDENTIFIERS.include?(name) }
+    end
+
+    private
+
+    def process_type!(options)
+      self.type = Type.parse!(options[:type])
+      self.format = Type.parse(options[:format])
+
+      if (options[:enum])
+        self.enums = options[:enum]
+        self.format = Type::Enum
+      end
+    end
+
+    def faux_value
+      Generator.trigger(bias_type, name, self)
+    end
+
+  end
+end

data/lib/render/{hash_attribute.rb → attributes/hash_attribute.rb}

@@ -1,5 +1,5 @@
 require "render"
-require "render/attribute"
+require "render/attributes/attribute"
 
 module Render
   class HashAttribute < Attribute
@@ -8,9 +8,7 @@ module Render
 
       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]
+      process_type!(options)
 
       initialize_schema!(options) if nested_schema?(options)
     end

data/lib/render/definition.rb

@@ -0,0 +1,31 @@
+module Render
+  class Definition
+    @instances = {}
+
+    class << self
+      attr_accessor :instances
+
+      def load_from_directory!(directory)
+        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!
+          load!(parsed_definition)
+        end
+      end
+
+      def load!(definition)
+        title = definition.fetch(:universal_title, definition.fetch(:title)).to_sym
+        self.instances[title] = definition
+      end
+
+      def find(title)
+        instances.fetch(title.to_sym)
+      rescue KeyError => error
+        raise Errors::DefinitionNotFound.new(title)
+      end
+
+    end
+  end
+end

data/lib/render/extensions/dottable_hash.rb

@@ -0,0 +1,82 @@
+require "render/extensions/symbolizable_hash"
+require "render/extensions/symbolizable_array"
+
+module Render
+  module Extensions
+    class DottableHash < SymbolizableHash
+      class << self
+        def new(element_to_hash = {})
+          symbolize_hash = SymbolizableHash.new.merge!(element_to_hash)
+          symbolize_hash.symbolize_keys!
+          hash = super().merge!(symbolize_hash)
+
+          hash.each do |key, value|
+            hash[key] = initialize_element(value)
+          end
+
+          hash
+        end
+
+        def initialize_element(value)
+          case value
+          when Hash
+            new(value)
+          when Array
+            values = value.collect do |v|
+              initialize_element(v)
+            end
+            SymbolizableArray.new(values)
+          else
+            value
+          end
+        end
+      end
+
+      def []=(key, value)
+        key = key.to_sym
+        value = self.class.initialize_element(value)
+        super
+      end
+
+      def [](key)
+        key = key.to_sym
+        super
+      end
+
+      def delete(key)
+        key = key.to_sym
+        super
+      end
+
+      def has_key?(key)
+        super(key.to_sym)
+      end
+
+      def merge!(other_hash)
+        other_hash = SymbolizableHash.new().merge!(other_hash)
+        super(other_hash.recursively_symbolize_keys!)
+      end
+
+      def merge(other_hash)
+        other_hash = SymbolizableHash.new().merge!(other_hash)
+        super(other_hash.recursively_symbolize_keys!)
+      end
+
+      def method_missing(method, *arguments)
+        if method.match(/\=$/)
+          self[method.to_s.chop] = arguments.first
+        elsif has_key?(method)
+          self[method]
+        else
+          super
+        end
+      end
+
+      def fetch(key, *args)
+        key = key.to_sym
+        super
+      end
+
+    end
+  end
+end

data/lib/render/extensions/symbolizable_array.rb

@@ -0,0 +1,26 @@
+module Render
+  module Extensions
+    class SymbolizableArray < Array
+      class << self
+        def new(array)
+          array.inject(super()) do |accumulator, item|
+            if item.is_a?(Array)
+              accumulator << new(item)
+            elsif item.is_a?(Hash)
+              accumulator << DottableHash.new(item)
+            else
+              accumulator << item
+            end
+          end
+        end
+      end
+
+      def recursively_symbolize_keys!
+        each do |item|
+          item.recursively_symbolize_keys! if item.respond_to?(:recursively_symbolize_keys!)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/render/extensions/symbolizable_hash.rb

@@ -0,0 +1,28 @@
+module Render
+  module Extensions
+    class SymbolizableHash < Hash
+      def initialize
+        super()
+      end
+
+      def symbolize_keys!
+        keys.each do |key|
+          self[(key.to_sym rescue key) || key] = delete(key)
+        end
+        self
+      end
+
+      def symbolize_keys
+        dup.symbolize_keys!
+      end
+
+      def recursively_symbolize_keys!
+        symbolize_keys!
+        values.each do |value|
+          value.recursively_symbolize_keys! if value.respond_to?(:recursively_symbolize_keys!)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/render/generator.rb

@@ -1,14 +1,68 @@
+# Generators make fake data in non-live mode.
+# They are used for attributes of a specified type, and whose name matches its defined matcher.
+
+require "uuid"
 require "render/errors"
 
 module Render
   class Generator
+    @instances = []
+
+    class << self
+      attr_accessor :instances
+
+      # When in non-live mode, e.g. testing, you can use custom generators to make fake data for a given attribute type
+      # and name-matcher.
+      # @param type [Class] Use generator exclusively for this type of data
+      # @param matcher [Regexp] Use generator for attribute whose name matches this
+      # @param algorithm [Proc, #call] Call this to generate a value
+      def create!(type, matcher, algorithm)
+        generator = new(type, matcher, algorithm)
+        instances.unshift(generator)
+        generator
+      end
+
+      def trigger(type, to_match, algorithm_argument = nil)
+        generator = find(type, to_match)
+        generator.trigger(algorithm_argument)
+      end
+
+      def find(type, to_match)
+        instances.detect do |generator|
+          (generator.type == type) && to_match.match(generator.matcher)
+        end
+      end
+    end
+
     attr_accessor :type, :matcher, :algorithm
 
-    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)
+    def initialize(type, matcher, algorithm)
+      self.type = type
+      self.matcher = matcher
+      set_algorithm!(algorithm)
+    end
+
+    def trigger(algorithm_argument = nil)
+      algorithm[algorithm_argument]
+    end
+
+    private
+
+    def set_algorithm!(algorithm)
+      if algorithm.respond_to?(:call)
+        self.algorithm = algorithm
+      else
+        raise Errors::Generator::MalformedAlgorithm.new(algorithm)
+      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 })
+    Generator.create!(Type::Boolean, /.*/, proc { [true, false].sample })
+    Generator.create!(Type::Enum, /.*/, proc { |attribute| attribute.enums.sample })
   end
 end