render 0.0.1

data/lib/render/schema.rb

@@ -0,0 +1,114 @@
+# The Schema defines a collection of attributes.
+# It is responsible for returning its attributes' values back to its Graph.
+
+require "net/http"
+require "json"
+require "render"
+require "render/attribute"
+
+module Render
+  class Schema
+    attr_accessor :title,
+      :type,
+      :attributes,
+      :schema
+
+    # 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])
+
+      if array_of_schemas?(schema[:elements])
+        self.attributes = [Attribute.new({ elements: schema[:elements] })]
+      else
+        definitions = schema[:attributes] || schema[:elements]
+        self.attributes = definitions.collect do |key, value|
+          Attribute.new({ key => value })
+        end
+      end
+    end
+
+    def array_of_schemas?(definition = {})
+      return false unless definition
+      definition.keys.include?(:attributes)
+    end
+
+    def pull(options = {})
+      endpoint = options.delete(:endpoint)
+      data = Render.live ? request(endpoint) : options
+      { title.to_sym => serialize(data) }
+    end
+
+    def serialize(data)
+      # data.is_a?(Array) ? to_array(data) : to_hash(data)
+      (type == Array) ? to_array(data) : to_hash(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
+      else
+        raise Errors::Schema::RequestError.new(endpoint, response)
+      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)
+      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
+    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)
+      end
+    end
+
+    def stubbed_array
+      elements = []
+      rand(1..3).times { elements << nil }
+      elements
+    end
+  end
+end

data/lib/render/version.rb

@@ -0,0 +1,3 @@
+module Render
+  VERSION = "0.0.1"
+end

data/lib/render.rb

@@ -0,0 +1,42 @@
+# 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 "render/version"
+require "render/graph"
+require "render/generator"
+
+module Render
+  @live = true
+  @schemas = {}
+  @generators = []
+
+  class << self
+    attr_accessor :live, :schemas, :generators
+
+    def load_schemas!(directory)
+      Dir.glob("#{directory}/**/*.json").each do |schema_file|
+        parsed_schema = parse_schema(File.read(schema_file))
+        schema_title = parsed_schema[:title].to_sym
+        # TODO Throw an error in the event of conflicts?
+        self.schemas[schema_title] = parsed_schema
+      end
+    end
+
+    def parse_schema(json)
+      JSON.parse(json).recursive_symbolize_keys!
+    end
+
+    def parse_type(type)
+      if type.is_a?(String)
+        return UUID if type == "uuid"
+        return Boolean if type == "boolean"
+        Object.const_get(type.capitalize) # TODO better type parsing
+      else
+        type
+      end
+    end
+  end
+
+end

data/rakefile.rb

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task default: :spec
+
+module RSpec::Core
+  RakeTask.new(:spec) do |config|
+    config.verbose = false
+    config.rspec_opts = ["--order rand"]
+  end
+end

data/readme.md

@@ -0,0 +1,90 @@
+# Render
+
+Create and test API requests simply with schemas.
+
+```ruby
+Representation.load_schemas!("spec/schemas") # JSON schema directory
+Representation::Graph.new(:film, { endpoint: "http://films.local/films" }).pull
+# or stub out schema-specific data
+Representation.live = false
+Representation::Graph.new(:film).pull
+```
+
+*Use with caution* (Representation is under initial development) by updating your Gemfile:
+
+    gem "representation"
+
+## Usage
+
+Try out examples with `Representation.live = false`.
+
+*Simple*
+
+```ruby
+schema = Representation::Schema.new({
+  title: :film,
+  type: Object,
+  attributes: {
+    id: { type: UUID },
+    title: { type: String }
+  }
+})
+
+options = {
+  endpoint: "http://films.local/films/:id"
+}
+
+Representation::Graph.new(schema, options).pull({ id: "4cb6b490-d706-0130-2a93-7c6d628f9b06" })
+```
+
+*Nested*
+
+```ruby
+film_schema = Representation::Schema.new({
+  title: :film,
+  type: Object,
+  attributes: {
+    id: { type: UUID },
+    title: { type: String }
+  }
+})
+
+films_schema = Representation::Schema.new({
+  title: :films,
+  type: Array,
+  elements: {
+    title: :film,
+    type: Object,
+    attributes: {
+      id: { type: UUID }
+    }
+  }
+})
+
+films_graph = Representation::Graph.new(films_schema, { endpoint: "http://films.local/films" })
+film_graph = Representation::Graph.new(film_schema, { endpoint: "http://films.local/films/:id", relationships: { id: :id } })
+films_graph.graphs << film_graph
+films_graph.pull
+```
+*Autoload schemas*
+
+```ruby
+Representation.load_schemas!("path/to/json/schemas")
+Representation::Graph.new(:schema_title, { endpoint: "http://films.local/films" }).pull
+```
+
+*Variable interpolation*
+
+```ruby
+options = { endpoint: "http://films.local/films/:id?:client_token", client_token: "token" }
+graph = Representation::Graph.new(:schema_title, options)
+graph.pull({ id: "an-id" })
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/render.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'render/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "render"
+  spec.version       = Render::VERSION
+  spec.authors       = ["Steve Weber"]
+  spec.email         = ["steve@copyright1984.com"]
+  spec.description   = %q{Simple management of API calls.}
+  spec.summary       = %q{With a JSON schema, Render will manage requests, dependent request and build meaningful, extensible sample data for testing.}
+  spec.homepage      = "https://github.com/stevenweber/render"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "uuid", "2.3.7"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "debugger"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+end

data/spec/functional/representation/attribute_spec.rb

@@ -0,0 +1,29 @@
+module Render
+  describe Attribute do
+    context "generators" do
+      before(:each) do
+        @original_generators = Render.generators
+        @original_live = Render.live
+        Render.live = false
+      end
+
+      after(:each) do
+        Render.generators = @original_generators
+        Render.live = @original_live
+      end
+
+      it "uses matching generator for #faux_value" do
+        name = "Canada Dry"
+        generator = Generator.new({ type: String, matcher: %r{.*name.*}, algorithm: proc { name } })
+        Render.generators << generator
+
+        Attribute.new({ name: { type: String } }).default_value.should == name
+      end
+
+      it "uses really bare-boned type if no generator is found" do
+        bare_boned_string = "A String"
+        Attribute.new({ foo: { type: String } }).default_value.should == bare_boned_string
+      end
+    end
+  end
+end

data/spec/functional/representation/nested_schemas_spec.rb

@@ -0,0 +1,103 @@
+require "render/schema"
+
+module Render
+  describe Schema do
+    before(:each) do
+      Render.stub({ live: false })
+    end
+
+    it "parses nested schemas" do
+      schema = {
+        title: "person",
+        type: Object,
+        attributes: {
+          contact: {
+            type: Object,
+            attributes: {
+              name: { type: String },
+              phone: { type: String }
+            }
+          }
+        }
+      }
+
+      contact_name = "Home"
+      contact_phone = "9675309"
+      data = {
+        extraneous_name: "Tommy Tutone",
+        contact: {
+          name: contact_name,
+          phone: contact_phone,
+          extraneous_details: "aka 'Jenny'"
+        }
+      }
+
+      Schema.new(schema).pull(data).should == {
+        person: {
+          contact: {
+            name: contact_name,
+            phone: contact_phone
+          }
+        }
+      }
+    end
+
+    it "parses nested arrays" do
+      schema = {
+        title: "people",
+        type: Array,
+        elements: {
+          title: :person,
+          type: Object,
+          attributes: {
+            name: { type: String },
+            nicknames: {
+              title: "nicknames",
+              type: Array,
+              elements: {
+                title: :formalized_name,
+                type: Object,
+                attributes: {
+                  name: { type: String },
+                  age: { type: Integer }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      zissou = {
+        name: "Steve Zissou",
+        nicknames: [
+          { name: "Stevezies", age: 2 },
+          { name: "Papa Steve", age: 1 }
+        ]
+      }
+      ned = {
+        name: "Ned Plimpton",
+        nicknames: [
+          { name: "Kinsley", age: 4 }
+        ]
+      }
+      people = [zissou, ned]
+
+      Schema.new(schema).pull(people).should == {
+        people: [{
+            name: "Steve Zissou",
+            nicknames: [
+              { name: "Stevezies", age: 2 },
+              { name: "Papa Steve", age: 1 }
+            ]
+          },
+          {
+            name: "Ned Plimpton",
+            nicknames: [
+              { name: "Kinsley", age: 4 }
+            ]
+          }
+        ]
+      }
+    end
+  end
+end

data/spec/functional/representation/schema_spec.rb

@@ -0,0 +1,86 @@
+require "render/schema"
+
+module Render
+  describe Schema do
+    before(:each) do
+      Render.stub({ live: false })
+    end
+
+    it "parses hash data" do
+      schema = Schema.new({
+        title: "television",
+        type: Object,
+        attributes: {
+          brand: { type: String }
+        }
+      })
+
+      brand_name = "Sony"
+      response = { brand: brand_name }
+
+      schema.pull(response).should == {
+        television: { brand: brand_name }
+      }
+    end
+
+    it "parses simple arrays" do
+      schema = Schema.new({
+        title: "televisions",
+        type: Array,
+        elements: {
+          type: UUID
+        }
+      })
+
+      television_ids = rand(10).times.collect { UUID.generate }
+
+      schema.pull(television_ids).should == {
+        televisions: television_ids
+      }
+    end
+
+    it "parses arrays of objects" do
+      schema = Schema.new({
+        title: :televisions,
+        type: Array,
+        elements: {
+          title: :television,
+          type: Object,
+          attributes: {
+            brand: { type: String }
+          }
+        }
+      })
+
+      brand_1, brand_2 = *%w(Sony Samsung)
+      response = [{ brand: brand_1 }, { brand: brand_2 }]
+
+      schema.pull(response).should == {
+        televisions: [{ brand: brand_1 }, { brand: brand_2 }]
+      }
+    end
+
+    it "parses nested object data" do
+      schema = Schema.new({
+        title: :television,
+        type: Object,
+        attributes: {
+          brand: {
+            title: :brand,
+            type: Object,
+            attributes: {
+              name: { type: String }
+            }
+          }
+        }
+      })
+
+      brand_name = "Sony"
+      response = { brand: { name: brand_name } }
+
+      schema.pull(response).should == {
+        television: { brand: { name: brand_name } }
+      }
+    end
+  end
+end

data/spec/integration/nested_graph_spec.rb

@@ -0,0 +1,77 @@
+require "render"
+
+describe Render do
+  before(:all) do
+    Render.load_schemas!(Helpers::SCHEMA_DIRECTORY)
+  end
+
+  after(:all) do
+    Render.schemas = {}
+  end
+
+  describe "request" do
+    before(:each) do
+      @films_endpoint = "http://films.local/films"
+      @film_endpoint = "http://films.local/films/:id"
+      @aquatic_id = UUID.generate
+      @darjeeling_id = UUID.generate
+    end
+
+    it "returns structured data for nested queries" do
+      stub_request(:get, @films_endpoint).to_return({ body: [{ id: @aquatic_id }, { id: @darjeeling_id }].to_json })
+
+      aquatic_name = "The Life Aquatic with Steve Zissou"
+      aquatic_uri = @film_endpoint.gsub(":id", @aquatic_id)
+      stub_request(:get, aquatic_uri).to_return({ body: { name: aquatic_name }.to_json })
+
+      darjeeling_name = "The Darjeeling Limited"
+      darjeeling_uri = @film_endpoint.gsub(":id", @darjeeling_id)
+      stub_request(:get, darjeeling_uri).to_return({ body: { name: darjeeling_name }.to_json })
+
+      options = {
+        graphs: [Render::Graph.new(:film, { endpoint: @film_endpoint, relationships: { id: :id }})],
+        endpoint: @films_endpoint
+      }
+      graph = Render::Graph.new(:films, options)
+      graph.pull.should == {
+        films: [
+          { name: aquatic_name, year: nil },
+          { name: darjeeling_name, year: nil }
+        ]
+      }
+    end
+
+    it "makes subsequent calls from archetype array data" do
+      pending "Simple arrays need to be able to make multiple calls"
+
+      stub_request(:get, @films_endpoint).to_return({ body: [@aquatic_id, @darjeeling_id].to_json })
+
+      aquatic = @film_endpoint.gsub("id", @aquatic_id)
+      stub_request(:get, aquatic).to_return({ body: { name: @aquatic_name }.to_json })
+
+      darjeeling = @film_endpoint.gsub("id", @darjeeling_id)
+      stub_request(:get, darjeeling).to_return({ body: { name: @darjeeling_name }.to_json })
+
+      films = Representation::Schema.new({
+        title: :films,
+        type: Array,
+        elements: {
+          type: UUID
+        }
+      })
+
+      film = Representation::Schema.new({
+        title: :film,
+        type: Object,
+        attributes: {
+          title: { type: String }
+        }
+      })
+
+      films = Representation::Graph.new(films, { endpoint: @films_endpoint })
+      films.graphs << Representation::Graph.new(film, { endpoint: @film_endpoint, relationships: { films: :id } })
+      films.pull.should == {}
+    end
+
+  end
+end

data/spec/integration/single_graph_spec.rb

@@ -0,0 +1,75 @@
+require "render"
+
+describe Render do
+  before(:all) do
+    Render.load_schemas!(Helpers::SCHEMA_DIRECTORY)
+  end
+
+  after(:all) do
+    Render.schemas = {}
+  end
+
+  before(:each) do
+    @film_id = UUID.generate
+    @film_name = "The Life Aqautic with Steve Zissou"
+
+    # Typically in environmental config
+    @secret_code = "3892n-2-n2iu1bf1cSdas0dDSAF"
+    @films_endpoint = "http://films.local/films?:secret_code"
+    @film_endpoint = "http://films.local/films/:id?:secret_code"
+  end
+
+  describe "requests" do
+    it "returns structured data" do
+      aquatic_uri = @films_endpoint.gsub(":secret_code", "secret_code=#{@secret_code}")
+      stub_request(:get, aquatic_uri).to_return({ body: [{ id: @film_id }].to_json })
+
+      graph = Render::Graph.new(:films, { endpoint: @films_endpoint, secret_code: @secret_code })
+      graph.pull.should == { films: [{ id: @film_id }] }
+    end
+
+    it "returns structured data for specific resources" do
+      id = UUID.generate
+      aquatic_uri = @film_endpoint.gsub(":id", id).gsub(":secret_code", "secret_code=#{@secret_code}")
+      stub_request(:get, aquatic_uri).to_return({ body: { name: @film_name }.to_json })
+
+      graph = Render::Graph.new(:film, { id: id, endpoint: @film_endpoint, secret_code: @secret_code })
+      graph.pull.should == { film: { name: @film_name, year: nil } }
+    end
+  end
+
+  describe "stubbed responses" do
+    before(:each) do
+      Render.stub({ live: false })
+    end
+
+    it "use meaningful values" do
+      response = Render::Graph.new(:film).pull({ name: @film_name })
+
+      stub_request(:post, "http://films.local/create").to_return({ body: response.to_json })
+      response = post_film(:anything)["film"]
+
+      response["name"].should be_a(String)
+      response["year"].should be_a(Integer)
+    end
+
+    it "allows users to specify specific values" do
+      response = Render::Graph.new(:film).pull({ name: @film_name })
+
+      data = { name: @film_name }.to_json
+      stub_request(:post, "http://films.local/create").with({ body: data }).to_return({ body: response.to_json })
+      response = post_film(data)["film"]
+
+      response["name"].should == @film_name
+    end
+  end
+
+  def post_film(data)
+    response = Net::HTTP.start("films.local", 80) do |http|
+      request = Net::HTTP::Post.new("/create")
+      request.body = data
+      http.request(request)
+    end
+    JSON.parse(response.body)
+  end
+end

data/spec/schemas/film.json

@@ -0,0 +1,8 @@
+{
+  "title": "film",
+  "type": "object",
+  "attributes": {
+    "name": { "type": "string" },
+    "year": { "type": "integer" }
+  }
+}

data/spec/schemas/films.json

@@ -0,0 +1,13 @@
+{
+  "title": "films",
+  "type": "array",
+  "elements": {
+    "title": "film",
+    "type" : "object",
+    "attributes" : {
+      "id" : {
+        "type": "uuid"
+      }
+    }
+  }
+}

data/spec/support/helpers.rb

@@ -0,0 +1,3 @@
+module Helpers
+  SCHEMA_DIRECTORY = File.expand_path("../../schemas", __FILE__)
+end