render 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+*.swp
+tags

data/.rspec

@@ -0,0 +1 @@
+--color -I spec -I . -r support -r initialize

data/.ruby-gemset

@@ -0,0 +1 @@
+render

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    render (0.0.1)
+      uuid (= 2.3.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    columnize (0.3.6)
+    crack (0.4.1)
+      safe_yaml (~> 0.9.0)
+    debugger (1.5.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.0)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.3)
+    diff-lcs (1.2.4)
+    macaddr (1.6.1)
+      systemu (~> 2.5.0)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.1)
+    safe_yaml (0.9.4)
+    systemu (2.5.2)
+    uuid (2.3.7)
+      macaddr (~> 1.0)
+    webmock (1.13.0)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  debugger
+  rake
+  render!
+  rspec
+  webmock

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Steve Weber
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/extensions/boolean.rb

@@ -0,0 +1,3 @@
+class Boolean
+end
+

data/extensions/dottable_hash.rb

@@ -0,0 +1,113 @@
+class DottableHash < Hash
+  class << self
+    def new(element_to_hash = {})
+      hash = super().merge!(element_to_hash.symbolize_keys)
+      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
+        value.collect { |v| initialize_element(v) }
+      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)
+    super(other_hash.symbolize_keys)
+  end
+
+  def merge(other_hash)
+    super(other_hash.symbolize_keys)
+    self
+  end
+
+  def method_missing(method, *arguments)
+    if method.match(/\=$/)
+      self[method.to_sym.chop] = arguments.first
+    elsif has_key?(method)
+      self[method]
+    else
+      super
+    end
+  end
+
+  def fetch(key)
+    key = key.to_sym
+    raise KeyError.new("Invalid key: #{key}") unless has_key?(key)
+    super
+  end
+
+  def fetch_path(full_path)
+    begin
+      fetch_path!(full_path)
+    rescue KeyError
+      nil
+    end
+  end
+
+  def fetch_path!(full_path)
+    full_path.split(".").inject(self) do |hash, path|
+      raise(KeyError) unless hash.is_a?(Hash)
+
+      hash.fetch(path)
+    end
+  end
+
+  def set_path(full_path, value)
+    self.dup.set_path!(full_path, value)
+  end
+
+  def set_path!(full_path, value)
+    built_hash_for_value = full_path.split(".").reverse.inject({}) do |cumulative, path_to_symource|
+      if cumulative.empty?
+        { path_to_symource.to_sym => value }
+      else
+        { path_to_symource.to_sym => cumulative }
+      end
+    end
+
+    deep_merge!(built_hash_for_value)
+  end
+
+  protected
+
+  def deep_merge(other_hash)
+    merge(other_hash) do |key, oldval, newval|
+      oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+      newval = newval.to_hash if newval.respond_to?(:to_hash)
+      oldval.is_a?(Hash) && newval.is_a?(Hash) ? self.class.new(oldval).deep_merge(newval) : self.class.new(newval)
+    end
+  end
+
+  def deep_merge!(other_hash)
+    replace(deep_merge(other_hash))
+  end
+end

data/extensions/enumerable.rb

@@ -0,0 +1,36 @@
+::Enumerable.module_eval do
+  # This is named the same as its Hash counterpart for a reason. I'm not
+  # going to tell you why, consider it my riddle for you.
+  def recursive_symbolize_keys!
+    each do |item|
+      item.recursive_symbolize_keys! if item.respond_to?(:recursive_symbolize_keys!)
+    end
+    self
+  end
+
+  def recursive_stringify_keys!
+    each do |item|
+      item.recursive_stringify_keys! if item.respond_to?(:recursive_stringify_keys!)
+    end
+  end
+
+  def hardcode(enumerable)
+    dup.hardcode!(enumerable)
+  end
+
+  def hardcode!(enumerable)
+    if self.empty? && enumerable.any?
+      enumerable
+    else
+      each_with_index do |a, index|
+        if a.is_a?(Hash)
+          self[index] = a.hardcode(enumerable[index]) if enumerable[index]
+        elsif a.is_a?(Enumerable)
+          self[index] = a.collect { |v| a.hardcode(enumerable[index]) }
+        else
+          self[index] = enumerable[index] if enumerable[index]
+        end
+      end
+    end
+  end
+end

data/extensions/hash.rb

@@ -0,0 +1,52 @@
+class ::Hash
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  def recursive_stringify_keys!
+    stringify_keys!
+    values.each do |value|
+      value.recursive_stringify_keys! if value.respond_to?(:recursive_stringify_keys!)
+    end
+    self
+  end
+
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  def recursive_symbolize_keys!
+    symbolize_keys!
+    values.each do |value|
+      value.recursive_symbolize_keys! if value.respond_to?(:recursive_symbolize_keys!)
+    end
+    self
+  end
+
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  def hardcode(other_hash)
+    dup.hardcode!(other_hash)
+  end
+
+  def hardcode!(other_hash)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      self[k] = tv.respond_to?(:hardcode) && v.respond_to?(:hardcode) ? tv.hardcode(v) : v
+    end
+    self
+  end
+
+end

data/initialize.rb

@@ -0,0 +1,7 @@
+%w(. ./lib/).each do |path|
+  $: << path
+end
+
+Dir.glob("extensions/*").sort.each { |file| require file }
+
+require "render"

data/lib/render/attribute.rb

@@ -0,0 +1,99 @@
+# 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.
+
+require "uuid"
+
+module Render
+  class Attribute
+    attr_accessor :name, :type, :schema, :archetype, :enums
+
+    # 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
+
+    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
+    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 }
+    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])
+    end
+
+    private
+
+    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)
+      when("String") then "A String"
+      when("Integer") then rand(1000)
+      when("UUID") then UUID.generate
+      when("Boolean") then [true, false].sample
+      end
+    end
+
+    def generator_value
+      generator = Render.generators.detect do |generator|
+        generator.type == type && name.match(generator.matcher)
+      end
+      generator.algorithm.call if generator
+    end
+
+  end
+end
+

data/lib/render/errors.rb

@@ -0,0 +1,64 @@
+module Render
+  module Errors
+    class Generator
+      class MalformedAlgorithm < StandardError
+        attr_accessor :algorithm
+
+        def initialize(algorithm)
+          self.algorithm = algorithm
+        end
+
+        def to_s
+          "Algorithms must respond to #call, which #{algorithm.inspect} does not."
+        end
+      end
+    end
+
+    class Graph
+      class EndpointKeyNotFound < StandardError
+        attr_accessor :config_key
+
+        def initialize(config_key)
+          self.config_key = config_key
+        end
+
+        def to_s
+          "No value for key #{config_key} found in config or parental_attributes."
+        end
+      end
+    end
+
+    class Schema
+      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
+
+      class RequestError < StandardError
+        attr_accessor :endpoint, :response
+
+        def initialize(endpoint, response)
+          self.endpoint = endpoint
+          self.response = response
+        end
+
+        def to_s
+          "Could not reach #{endpoint} because #{response}."
+        end
+      end
+
+      class InvalidResponse < RequestError
+        def to_s
+          "Could not parse #{response.inspect} from #{endpoint}"
+        end
+      end
+    end
+  end
+end

data/lib/render/generator.rb

@@ -0,0 +1,14 @@
+require "render/errors"
+
+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]) }
+      raise Errors::Generator::MalformedAlgorithm.new(algorithm) if !algorithm.respond_to?(:call)
+    end
+
+  end
+end

data/lib/render/graph.rb

@@ -0,0 +1,106 @@
+# The Graph is the top-level model that defines a Schema and correlating Graphs.
+# It also includes particular metadata:
+#  - Endpoint to query for its schema's data
+#  - Config for this endpoint, e.g. an access token
+#  - Relationships between it and a Graph that includes it
+
+require "render/schema"
+require "render/errors"
+
+module Render
+  class Graph
+    PARAM = %r{:(?<param>[\w_]+)}
+    PARAMS = %r{#{PARAM}[\/\;\&]?}
+
+    attr_accessor :schema,
+      :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!
+    end
+
+    def endpoint
+      uri = URI(raw_endpoint)
+
+      uri.path.gsub!(PARAMS) do |param|
+        key = param_key(param)
+        param.gsub(PARAM, param_value(key))
+      end
+
+      if uri.query
+        uri.query.gsub!(PARAMS) do |param|
+          key = param_key(param)
+          "#{key}=#{param_value(key)}&"
+        end.chop!
+      end
+
+      uri.to_s
+    end
+
+    def pull(inherited_attributes = {})
+      calculate_parental_params!(inherited_attributes)
+      graph_attributes = schema.pull(inherited_attributes.merge(parental_params.merge({ endpoint: endpoint })))
+
+      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.pull(element)
+            end
+            key = data.first.keys.first
+            attributes[title] = data.collect { |d| d[key] }
+          else
+            data = nested_graph.pull(parent_data)
+            parent_data.merge!(data)
+          end
+        end
+        threads.collect(&:join)
+        DottableHash.new(attributes)
+      end
+    end
+
+    private
+
+    def initialize_params!
+      self.params = raw_endpoint.scan(PARAMS).flatten.inject({}) do |params, param|
+        params.merge({ param.to_sym => nil })
+      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] })
+      end
+    end
+
+    def param_key(string)
+      string.match(PARAM)[:param].to_sym
+    end
+
+    def param_value(key)
+      parental_params[key] || config[key] || raise(Errors::Graph::EndpointKeyNotFound.new(key))
+    end
+
+  end
+end