moonrope 1.4.1 → 2.0.0

data/test/tests/structures_param_extensions_test.rb

@@ -0,0 +1,159 @@
+class StructuresParamExtensionsTest < Test::Unit::TestCase
+  def setup
+    @base = Moonrope::Base.new do
+      structure :animal do
+        basic :id
+        full :color
+        expansion :user, :structure => :user
+      end
+      structure :user do
+        basic :id
+      end
+      controller :users do
+        action :info do
+          action do
+            structure @auth_user
+          end
+        end
+      end
+    end
+    @user = User.new(:id => 456)
+    @animal = Animal.new(:id => 123, :user => @user, :color => 'blue')
+  end
+
+  def test_no_expansions_occur_by_default_with_array
+    request = FakeRequest.new(:params => {'_expansions' => ['user']})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    structure = environment.structure(:animal, @animal)
+    assert_equal nil, structure[:user]
+  end
+
+  def test_default_behaviour_when_paramable_is_only_option
+    request = FakeRequest.new(:params => {})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # From nil
+    structure = environment.structure(:animal, @animal, :paramable => true)
+    assert_equal nil, structure[:user]
+    assert_equal nil, structure[:color]
+  end
+
+  def test_no_expansions_occur_by_default_with_true
+    request = FakeRequest.new(:params => {'_expansions' => true})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    structure = environment.structure(:animal, @animal)
+    assert_equal nil, structure[:user]
+  end
+
+  def test_expansions_use_paramable_value_as_default
+    request = FakeRequest.new(:params => {})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # From nil
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => nil})
+    assert_equal nil, structure[:user]
+    # From true
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => true})
+    assert_equal Hash, structure[:user].class
+    # From a list
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:user]})
+    assert_equal Hash, structure[:user].class
+  end
+
+  def test_all_expansions_are_provided_when_paramable_is_true
+    request = FakeRequest.new(:params => {"_expansions" => true})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    structure = environment.structure(:animal, @animal, :paramable => true)
+    assert_equal Hash, structure[:user].class
+  end
+
+  def test_using_array_as_expansions_param
+    request = FakeRequest.new(:params => {'_expansions' => ['user']})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # Works
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:user]})
+    assert_equal Hash, structure[:user].class
+    # Works
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => true})
+    assert_equal Hash, structure[:user].class
+    # Shouldn't ret
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:other]})
+    assert_equal nil, structure[:user]
+  end
+
+  def test_surpressing_default_expansions_with_empty_array
+    request = FakeRequest.new(:params => {'_expansions' => []})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # Shouldn't return the user structure because we've asked for none
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:user]})
+    assert_equal nil, structure[:user]
+    # Shouldn't return the user structure because we've asked for none
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => true})
+    assert_equal nil, structure[:user]
+  end
+
+  def test_surpressing_default_expansions_with_false
+    request = FakeRequest.new(:params => {'_expansions' => false})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # Shouldn't return the user structure because we've asked for none
+    structure = environment.structure(:animal, @animal, :paramable => true)
+    assert_equal nil, structure[:user]
+    # Shouldn't return the user structure because we've asked for none
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:user]})
+    assert_equal nil, structure[:user]
+    # Shouldn't return the user structure because we've asked for none
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => true})
+    assert_equal nil, structure[:user]
+  end
+
+
+  def test_using_true_as_expansions_param_to_return_all_suitable_expansions
+    request = FakeRequest.new(:params => {'_expansions' => true})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # Requesting all with no default
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => nil})
+    assert_equal Hash, structure[:user].class
+    # Requesting all with no array default
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => [:user]})
+    assert_equal Hash, structure[:user].class
+    # Requesting all with true default
+    structure = environment.structure(:animal, @animal, :paramable => {:expansions => true})
+    assert_equal Hash, structure[:user].class
+  end
+
+  def test_empty_paramable_array
+    request = FakeRequest.new(:params => {'_expansions' => true})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # Should not return anything because paramable doesn't specify expansions
+    # as a suitable option
+    structure = environment.structure(:animal, @animal, :paramable => {})
+    assert_equal nil, structure[:user]
+  end
+
+  def test_returning_full_data_by_default
+    request = FakeRequest.new()
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    structure = environment.structure(:animal, @animal, :paramable => {:full => true, :expansions => false})
+    assert_equal String, structure[:color].class
+  end
+
+  def test_full_value_provides_full_access
+    request = FakeRequest.new(:params => {'_full' => true})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    # No full value set
+    structure = environment.structure(:animal, @animal, :paramable => {})
+    assert_equal nil, structure[:color]
+    # With full set as default
+    structure = environment.structure(:animal, @animal, :paramable => {:full => true})
+    assert_equal String, structure[:color].class
+    # With full set as hidden by default
+    structure = environment.structure(:animal, @animal, :paramable => {:full => false})
+    assert_equal String, structure[:color].class
+  end
+
+  def test_supressing_default_full_data
+    request = FakeRequest.new(:params => {'_full' => false})
+    environment = Moonrope::EvalEnvironment.new(@base, request)
+    structure = environment.structure(:animal, @animal, :paramable => {:full => true})
+    assert_equal nil, structure[:color]
+  end
+
+end

data/test/tests/structures_test.rb

@@ -0,0 +1,335 @@
+class StructuresTest < Test::Unit::TestCase
+
+  def setup
+    @base = Moonrope::Base.new
+  end
+
+  def test_structure_creation
+    structure = Moonrope::Structure.new(@base, :user) do
+      basic { {:id => o.id} }
+      full  { {:username => o.username} }
+    end
+    assert_equal Moonrope::Structure, structure.class
+    assert structure.basic.is_a?(Proc)
+    assert structure.full.is_a?(Proc)
+  end
+
+  def test_structure_hash_with_basic_data
+    structure = Moonrope::Structure.new(@base, :user) do
+      basic { {:id => o.id} }
+      full  { {:username => o.username} }
+    end
+
+    user = User.new(:id => 1, :username => 'adam')
+
+    hash = structure.hash(user)
+    assert_equal user.id, hash[:id]
+    assert_equal false, hash.keys.include?(:username)
+
+    hash = structure.hash(user, :full => true)
+    assert_equal user.id, hash[:id]
+    assert_equal user.username, hash[:username]
+  end
+
+  def test_passing_the_version
+    structure = Moonrope::Structure.new(@base, :user) do
+      basic do
+        {
+          :id => o.id,
+          :username => (version == 1 ? o.username : "@#{o.username}")
+        }
+      end
+    end
+    user = User.new(:id => 1, :username => 'adam')
+    # check version 2
+    request = FakeRequest.new(:version => 2)
+    hash = structure.hash(user, :request => request)
+    assert_equal "@#{user.username}", hash[:username]
+    # check version 1
+    request = FakeRequest.new(:version => 1)
+    hash = structure.hash(user, :request => request)
+    assert_equal user.username, hash[:username]
+  end
+
+  def test_structure_hash_with_expansions
+    user = User.new(:id => 1, :username => 'dave')
+    animal1 = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginder', :user => user)
+    animal2 = Animal.new(:id => 2, :name => 'Jess', :color => 'Black & White', :user => user)
+    user.animals << animal1
+    user.animals << animal2
+
+    base = Moonrope::Base.new do
+      structure :user do
+        basic { {:id => o.id, :username => o.username } }
+        expansion :animals do
+          o.animals.map { |a| structure(:animal, a) }
+        end
+      end
+
+      structure :animal do
+        basic { {:id => o.id, :name => o.name} }
+        full { {:color => o.color, :user => structure(:user, o.user)} }
+      end
+    end
+
+    animal_structure = base.structure(:animal)
+
+    # Test the full animal structure includes the user
+    hash = animal_structure.hash(animal1, :full => true)
+    assert_equal animal1.name, hash[:name]
+    assert_equal user.username, hash[:user][:username]
+
+    # Test that a user structure with expansions includes the
+    # animals which are included
+    user_structure = base.structure(:user)
+    hash = user_structure.hash(user, :expansions => true)
+    assert hash[:animals].is_a?(Array), "hash[:animals] is not an array"
+    assert_equal hash[:animals][0][:name], 'Fido'
+    assert_equal hash[:animals][1][:name], 'Jess'
+
+    # Test that when expansions was false
+    hash = user_structure.hash(user, :expansions => false)
+    assert_equal nil, hash[:animals], "hash[:animals] is present"
+
+    # Test cases when expansions are provided as an array
+    hash = user_structure.hash(user, :expansions => [:something, :else])
+    assert_equal nil, hash[:animals], "hash[:animals] is present"
+    hash = user_structure.hash(user, :expansions => [:animals])
+    assert_equal Array, hash[:animals].class, "hash[:animals] is present"
+  end
+
+  def test_structured_structures
+    base = Moonrope::Base.new do
+      structure :animal do
+        basic :id, :description => "The ID of the aniaml object", :example => 1, :type => Integer
+        basic :name, :description => "The name of the animal", :example => "Boris", :type => String
+        full :hair_color, :description => "The color of the animal's hair", :example => "Blue", :type => String, :source_attribute => :color
+        expansion :user, :type => Hash, :structure => :user
+
+        group :colors do
+          basic :eye, :example => "Green", :type => String, :source_attribute => :color
+          full :hair, :example => "Blue", :type => String, :source_attribute => :color
+          expansion :owner, :structure => :user, :type => Hash, :source_attribute => :user
+        end
+      end
+
+      structure :user do
+        basic :id, :example => 1, :type => Integer
+        basic :username, :example => "adam", :type => String
+        expansion :animals, :type => Array, :structure => :animal, :structure_opts => {:full => true}
+      end
+    end
+
+    user = User.new(:id => 1, :username => 'adam', :private_code => 9876)
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger', :user => user)
+    user.animals << animal
+    animal2 = Animal.new(:id => 2, :name => 'Boris', :color => 'Black', :user => user)
+    user.animals << animal2
+
+    # a full hash with all expansions
+    hash = base.structure(:animal).hash(animal, :full => true, :expansions => true)
+    # standard attributes
+    assert_equal 1, hash[:id]
+    assert_equal 'Fido', hash[:name]
+    assert_equal 'Ginger', hash[:hair_color]
+    # expansion in a group
+    assert_equal Hash, hash[:colors][:owner].class
+    # normal expansion
+    assert_equal Hash, hash[:user].class
+    assert_equal 'adam', hash[:user][:username]
+    assert_equal nil, hash[:user][:animals]
+    # group
+    assert_equal Hash, hash[:colors].class
+    assert_equal 'Ginger', hash[:colors][:eye]
+    assert_equal 'Ginger', hash[:colors][:hair]
+
+    # basic hash
+    hash = base.structure(:animal).hash(animal)
+    # normal attributes
+    assert_equal 1, hash[:id]
+    assert_equal 'Fido', hash[:name]
+    # groups
+    assert_equal Hash, hash[:colors].class
+    assert_equal 'Ginger', hash[:colors][:eye]
+    assert_equal nil, hash[:colors][:hair]
+
+    # a full user hash with all expansions
+    hash = base.structure(:user).hash(user, :full => true, :expansions => true)
+    # arrays
+    assert_equal Array, hash[:animals].class
+    assert_equal 'Fido', hash[:animals][0][:name]
+    assert_equal 'Boris', hash[:animals][1][:name]
+    assert_equal 'Black', hash[:animals][1][:hair_color]
+  end
+
+  def test_ifs
+    base = Moonrope::Base.new do
+      structure :animal do
+        condition Proc.new { true } do
+          basic :id1, :example => 1, :type => Integer, :source_attribute => :id
+        end
+
+        condition Proc.new { false } do
+          basic :id2, :example => 2, :type => Integer, :source_attribute => :id
+        end
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal)
+    assert_equal 1, hash[:id1]
+    assert_equal nil, hash[:id2]
+  end
+
+  def test_ifs_with_expansion
+    base = Moonrope::Base.new do
+      structure :animal do
+        condition Proc.new { true } do
+          expansion :example do
+            {:hello => 'world'}
+          end
+        end
+
+        condition Proc.new { false } do
+          expansion :example2 do
+            {:hello => 'land'}
+          end
+        end
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal, :expansions => true)
+    assert_equal true, hash.keys.include?(:example)
+    assert_equal false, hash.keys.include?(:example2)
+  end
+
+  def test_condition_with_description
+    base = Moonrope::Base.new do
+      structure :animal do
+        condition Proc.new { false }, "An example description" do
+          basic :id
+          expansion :example do
+            {:hello => 'land'}
+          end
+        end
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal, :expansions => true)
+    assert_equal false, hash.keys.include?(:example)
+    assert_equal false, hash.keys.include?(:id)
+  end
+
+  def test_condition_with_access_rule
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { true }
+        rule(:default, "NotPermitted") { true }
+        rule(:false_rule, "MustNotBeFalse") { false }
+      end
+      structure :animal do
+        condition :default => :false_rule do
+          basic :id
+        end
+
+        condition :default => :default do
+          basic :name
+        end
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal, :expansions => true)
+    assert_equal false, hash.keys.include?(:id)
+    assert_equal true, hash.keys.include?(:name)
+  end
+
+  def test_condition_with_access_rule_and_default_authenticator
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { true }
+        rule(:default, "NotPermitted") { true }
+        rule(:false_rule, "MustNotBeFalse") { false }
+      end
+      structure :animal do
+        condition :false_rule do
+          basic :id
+        end
+
+        condition :default do
+          basic :name
+        end
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal, :expansions => true)
+    assert_equal false, hash.keys.include?(:id)
+    assert_equal true, hash.keys.include?(:name)
+  end
+
+
+  def test_scopes
+    base = Moonrope::Base.new do
+      structure :animal do
+        group :group1 do
+          basic :id
+          basic :name
+          group :group2 do
+            basic :id_g2, :source_attribute => :id
+            basic :name2, :source_attribute => :name
+            group :group3 do
+              basic :id_g3, :source_attribute => :id
+              basic :name3, :source_attribute => :name
+            end
+          end
+        end
+
+        condition Proc.new { false } do
+          basic :id2, :name => :id
+        end
+      end
+    end
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal, :full => true)
+
+    assert_equal 1, hash[:group1][:id]
+    assert_equal 1, hash[:group1][:group2][:id_g2]
+    assert_equal 1, hash[:group1][:group2][:group3][:id_g3]
+
+    assert_equal 'Fido', hash[:group1][:name]
+    assert_equal 'Fido', hash[:group1][:group2][:name2]
+    assert_equal 'Fido', hash[:group1][:group2][:group3][:name3]
+
+    # id2 shouldn't exist because it's if block returns false
+    assert_equal false, hash.keys.include?(:id2)
+  end
+
+  def test_passing_values_from_the_definition
+    base = Moonrope::Base.new do
+      structure :animal do
+        basic :example, :value => 1234
+        basic :example_with_block, :value => Proc.new { "#{o.name}!!!" }
+      end
+    end
+
+    animal = Animal.new(:id => 1, :name => 'Fido', :color => 'Ginger')
+    hash = base.structure(:animal).hash(animal)
+    assert_equal 1234, hash[:example]
+    assert_equal "Fido!!!", hash[:example_with_block]
+  end
+
+  def test_creating_a_structure_with_description
+    base = Moonrope::Base.new do
+      structure :animal do
+        basic :example, "Hello there!", :value => 1234
+        basic :example2, :description => "Bananas!"
+      end
+    end
+    assert_equal "Hello there!", base.structure(:animal).attributes[:basic].select { |a| a.name == :example }.first.description
+    assert_equal "Bananas!", base.structure(:animal).attributes[:basic].select { |a| a.name == :example2 }.first.description
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moonrope
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2016-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -28,14 +28,14 @@ dependencies:
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
@@ -66,71 +66,70 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.3'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-- !ruby/object:Gem::Dependency
-  name: rack-test
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
 description: A full library allowing you to create sexy DSLs to define your RPC-like
   APIs.
 email:
 - adam@atechmedia.com
-executables: []
+executables:
+- moonrope
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
+- Gemfile.lock
+- MIT-LICENCE
+- README.md
 - Rakefile
+- bin/moonrope
+- docs/authentication.md
+- docs/controllers.md
+- docs/exceptions.md
+- docs/introduction.md
+- docs/structures.md
+- example/authentication.rb
+- example/controllers/meta_controller.rb
+- example/controllers/users_controller.rb
+- example/structures/pet_structure.rb
+- example/structures/user_structure.rb
+- html/assets/lock.svg
+- html/assets/reset.css
+- html/assets/style.css
+- html/assets/tool.svg
+- html/assets/try.js
+- html/authenticators/default.html
+- html/controllers/meta.html
+- html/controllers/meta/version.html
+- html/controllers/users.html
+- html/controllers/users/create.html
+- html/controllers/users/list.html
+- html/controllers/users/show.html
+- html/controllers/users/update.html
+- html/index.html
+- html/moonrope.txt
+- html/structures/pet.html
+- html/structures/user.html
 - lib/moonrope.rb
 - lib/moonrope/action.rb
 - lib/moonrope/action_result.rb
+- lib/moonrope/authenticator.rb
 - lib/moonrope/base.rb
 - lib/moonrope/before_action.rb
 - lib/moonrope/controller.rb
+- lib/moonrope/doc_context.rb
+- lib/moonrope/doc_server.rb
 - lib/moonrope/dsl/action_dsl.rb
+- lib/moonrope/dsl/authenticator_dsl.rb
 - lib/moonrope/dsl/base_dsl.rb
 - lib/moonrope/dsl/controller_dsl.rb
+- lib/moonrope/dsl/filterable_dsl.rb
 - lib/moonrope/dsl/structure_dsl.rb
 - lib/moonrope/errors.rb
 - lib/moonrope/eval_environment.rb
 - lib/moonrope/eval_helpers.rb
+- lib/moonrope/eval_helpers/filter_helper.rb
+- lib/moonrope/guard.rb
 - lib/moonrope/helper.rb
+- lib/moonrope/html_generator.rb
 - lib/moonrope/param_set.rb
 - lib/moonrope/rack_middleware.rb
 - lib/moonrope/railtie.rb
@@ -138,6 +137,41 @@ files:
 - lib/moonrope/structure.rb
 - lib/moonrope/structure_attribute.rb
 - lib/moonrope/version.rb
+- moonrope.gemspec
+- spec/spec_helper.rb
+- spec/specs/action_spec.rb
+- spec/specs/base_spec.rb
+- spec/specs/controller_spec.rb
+- spec/specs/param_set_spec.rb
+- templates/basic/_action_form.erb
+- templates/basic/_errors_table.erb
+- templates/basic/_structure_attributes_list.erb
+- templates/basic/action.erb
+- templates/basic/assets/lock.svg
+- templates/basic/assets/reset.css
+- templates/basic/assets/style.css
+- templates/basic/assets/tool.svg
+- templates/basic/assets/try.js
+- templates/basic/authenticator.erb
+- templates/basic/controller.erb
+- templates/basic/index.erb
+- templates/basic/layout.erb
+- templates/basic/structure.erb
+- test/test_helper.rb
+- test/tests/action_access_test.rb
+- test/tests/actions_test.rb
+- test/tests/authenticators_test.rb
+- test/tests/base_test.rb
+- test/tests/controllers_test.rb
+- test/tests/eval_environment_test.rb
+- test/tests/evel_helpers_test.rb
+- test/tests/examples_test.rb
+- test/tests/helpers_test.rb
+- test/tests/param_set_test.rb
+- test/tests/rack_middleware_test.rb
+- test/tests/request_test.rb
+- test/tests/structures_param_extensions_test.rb
+- test/tests/structures_test.rb
 homepage: http://adamcooke.io
 licenses:
 - MIT
@@ -158,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: An API server DSL.