talk 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7fc025a61346588f9645f6ecd1bb9450f092bf1
-  data.tar.gz: f6e49406e45c550e9a4492936af318650133be43
+  metadata.gz: d526ec8ff5dcfbc0df84597b909908878533ff1c
+  data.tar.gz: 0e3149f3d0ec39651885ac9b8423b0f1d31b75fa
 SHA512:
-  metadata.gz: f3e3c0f6acff21efb2bbe29249489b7db50183ba5745cbccf5a6cc4c9f62b79576796942451784ae8c083e6017764a4281806f2b4172a2e0cf2b459dad3ac1a9
-  data.tar.gz: 5dc5c0994dba93d32f4699ec1e5c14935e6babd945cd09b093e5205ac233a45e7b20410ee31f926801c0802ad285f254cf652561fa8db9f5a8c3a2c9d1dba6e5
+  metadata.gz: 85f753134c46ee61b44350daf3c81a5b080c2eea7612647cfb0cc6d6e7f7ec01d77408757bfa8fe687edd00c1d47fc05b4ef91e7cfdf0e627c86477ab0b0ab54
+  data.tar.gz: bfa8165d934932f43af1867bdcd99a0374a74beb77b86d644c27fbc69fe780da5bae33f833024fba385c9f984a61b4b82cd2dc97f3b0f7f363bf3fc5f5948350

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+Gemfile.lock
+.bundle
+

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'trollop'
+gem 'json'
+
+group :test do
+  gem 'cucumber'
+  gem 'rspec'
+  gem 'rake'
+end

data/README.md

@@ -0,0 +1,6 @@
+talk
+====
+
+Compile-to-source protocol contract specification language
+
+[![Build Status](https://travis-ci.org/jonasacres/talk.png?branch=master)](https://travis-ci.org/jonasacres/talk)

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+task :default => :features

data/features/class-field.feature

@@ -0,0 +1,226 @@
+Feature: @class -> @field
+  Scenario Outline: Define a field
+    Given I have defined a valid class
+    And I give it a field named <name> of type <type> and description <description>
+    When I get the result hash
+    Then the field <name> should have type <type> and description <description>
+
+    Examples:
+    | name      | type   | description |
+    | foobar8   | int8   | I am an 8-bit integer |
+    | foobarU16 | uint16 | I am a 16-bit unsigned integer |
+
+  Scenario Outline: Define a field with implicit description
+    Given I have defined a valid class
+    And I give it a field named <name> of type <type> and implicit description <description>
+    When I get the result hash
+    Then the field <name> should have type <type> and description <description>
+
+    Examples:
+    | name | type | description |
+    | foobar8 | int8 | I am an 8-bit integer |
+    | foobarU16 | uint16 | I am a 16-bit unsigned integer |
+
+  Scenario Outline: Define a field with a valid primitive type
+    Given I have defined a valid class
+    And I give it a valid field named foobar of type <type>
+    When I get the result hash
+    Then the field foobar should have type <type>
+
+    Examples:
+    | type       |
+    | uint8      |
+    | uint16     |
+    | uint32     |
+    | uint64     |
+    | int8       |
+    | int16      |
+    | int32      |
+    | int64      |
+    | string     |
+    | object     |
+    | talkobject |
+    | real       |
+    | bool       |
+
+  Scenario Outline: Define a field with an invalid type
+    Given I have defined a valid class
+    And I give it a valid field named foobar of type <type>
+    When I get the result hash
+    Then there should be a parse error
+
+    Examples:
+    | type          |
+    | Lies          |
+    | IAmTheDevil   |
+    | LookMaNoParse |
+
+  Scenario Outline: Define a field with a sibling class
+    Given I have defined a valid class named <sibling>
+    And I have defined a valid class
+    And I give it a valid field named foobar of type <sibling>
+    When I get the result hash
+    Then the field foobar should have type <sibling>
+
+    Examples:
+    | sibling              |
+    | Brother              |
+    | Sister               |
+    | GenderNeutralSibling |
+
+  Scenario Outline: Define a field with a sibling class referenced by abbreviation
+    Given I have defined a valid class named <sibling>
+    And I have defined a valid class
+    And I give it a valid field named foobar of type <abbrev>
+    When I get the result hash
+    Then the field foobar should have type <sibling>
+
+    Examples:
+    | sibling             | abbrev              |
+    | com.example.Sibling | Sibling             |
+    | com.example.Sibling | example.Sibling     |
+    | com.example.Sibling | com.example.Sibling |
+
+  Scenario: Define a field that refers to its container class
+    Given I have defined a valid class named Container
+    And I give it a valid field named foobar of type Container
+    When I get the result hash
+    Then the field foobar should have type Container
+
+  Scenario Outline: Define a field with an @see class
+    Given I have defined a valid class named <other>
+    And I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see class <other>
+    When I get the result hash
+    Then the field foobar should have an @see class <other>
+
+    Examples:
+    | other     |
+    | AClass    |
+    | CoolClass |
+    | LameClass |
+
+  Scenario: Define a field with an @see class that doesn't exist
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see class DoesntExist
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario Outline: Define a field with an @see glossary
+    Given I have defined a valid glossary named <other>
+    And I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see glossary <other>
+    When I get the result hash
+    Then the field foobar should have an @see glossary <other>
+
+    Examples:
+    | other                |
+    | BestBabyNamesFor2014 |
+    | LexiconOfCthulhu     |
+    | AdorableAnimals      |
+
+  Scenario: Define a field with an @see glossary that doesn't exist
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see glossary DoesntExist
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario Outline: Define a field with an @see enumeration
+    Given I have defined a valid enumeration named <other>
+    And I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see enumeration <other>
+    When I get the result hash
+    Then the field foobar should have an @see enumeration <other>
+
+    Examples:
+    | other                |
+    | BestBabyNamesFor2014 |
+    | LexiconOfCthulhu     |
+    | AdorableAnimals      |
+
+  Scenario Outline: Define a field with an @see enum
+    Given I have defined a valid enumeration named <other>
+    And I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see enum <other>
+    When I get the result hash
+    Then the field foobar should have an @see enumeration <other>
+
+    Examples:
+    | other                |
+    | HowILoveThee         |
+    | MarksEvilBitmasks    |
+    | WaysToLeaveYourLover |
+
+  Scenario: Define a field with an @see enumeration that doesn't exist
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @see enumeration DoesntExist
+    When I get the result hash
+    Then there should be a parse error  
+
+  Scenario Outline: Define a field with @caveats
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @caveat <message_1>
+    And I give foobar @caveat <message_2>
+    When I get the result hash
+    Then the field foobar should have a @caveat <message_1>
+    And the field foobar should have a @caveat <message_2>
+
+    Examples:
+    | message_1               | message_2                                                 |
+    | This field is pure evil | May contain null, as well as fatal amounts of arsenic     |
+    | Field might be garbage  | Field might also have the information you need to survive |
+
+  Scenario Outline: Define a field as @deprecated
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @deprecated <message>
+    When I get the result hash
+    Then the field foobar should have @deprecated <message>
+
+    Examples:
+    | message                                                                                                           |
+    | It wasn't working out                                                                                             |
+    | It's not the field, it's us                                                                                       |
+    | We still want to be friends with this field and hope it moves on to other classes that will love it for who it is |
+
+  Scenario: Define a field as @deprecated twice
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @deprecated once
+    And I give foobar @deprecated again
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario Outline: Define a field with an @version
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @version <version>
+    When I get the result hash
+    Then the field foobar should have @version <version>
+
+    Examples:
+    | version                 |
+    | 1                       |
+    | 3.0                     |
+    | sheepishly stroked lion |
+
+  Scenario Outline: Define a field with two @version tags
+    Given I have defined a valid class
+    And I give it a valid field named foobar
+    And I give foobar @version <version_1>
+    And I give foobar @version <version_2>
+    When I get the result hash
+    Then there should be a parse error
+
+    Examples:
+    | version_1 | version_2 |
+    | 1.0       | 1.0       |
+    | 1.0       | 2.0       |

data/features/class.feature

@@ -0,0 +1,95 @@
+Feature: @class
+  Scenario Outline: Define a class with an explicit @description
+    Given I have defined a class named <name>
+    And I have given <description> as a @description
+    When I get the result hash 
+    Then there should be a class named <name>
+    And it should have description <description>
+
+    Examples:
+    | name                  | description                            |
+    | Lumberjack            | I am a lumberjack, and I am acceptable |
+    | com.example.JavaClass | I have a hierarchical name             |
+
+  Scenario Outline: Define a class with an implicit @description
+    Given I have defined a class named <name>
+    And I have given <description> as an implied description
+    When I get the result hash 
+    Then there should be a class named <name>
+    And it should have description <description>
+
+    Examples:
+    | name                  | description                            |
+    | Lumberjack            | I am a lumberjack, and I am acceptable |
+    | com.example.JavaClass | I have a hierarchical name             |
+
+  Scenario: Define a class without a description
+    Given I have defined a class named NoDescriptionClsas
+    But I don't give a description
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario: Define a class with a duplicate name
+    Given I have defined a class named DuplicateClass
+    And I have given it some random bullshit as a @description
+    And I define another class also named DuplicateClass
+    When I get the result hash 
+    Then there should be a parse error
+
+  Scenario Outline: Define a class with @inherits
+    Given I have defined a valid class named <base>
+    And I have defined a valid class named ChildClass
+    And I give it @inherits <base>
+    When I get the result hash
+    Then the class ChildClass should have @inherits <base>
+
+    Examples:
+    | base      |
+    | BaseClass |
+    | YourDaddy |
+
+  Scenario Outline: Define a class that @inherits from an undefined class
+    Given I have defined a valid class named ChildClass
+    And I give it @inherits <base>
+    When I get the result hash
+    Then there should be a parse error
+
+    Examples:
+    | base        |
+    | DoesntExist |
+    | uint16      |
+    | string      |
+    | talkobject  |
+
+  Scenario Outline: Define a class that @inherits twice
+    Given I have defined a valid class named BaseClass1
+    And I have defined a valid class named BaseClass2
+    And I have defined a valid class named ChildClass
+    And I give it @inherits <base_1>
+    And I give it @inherits <base_2>
+    When I get the result hash
+    Then there should be a parse error
+
+    Examples:
+    | base_1     | base_2     |
+    | BaseClass1 | BaseClass1 |
+    | BaseClass1 | BaseClass2 |
+
+  Scenario Outline: Define a class that sets @implement
+    Given I have defined a valid class named NoImplementClass
+    And I give it @implement <implement>
+    When I get the result hash
+    Then the class NoImplementClass should have @implement <value>
+
+    Examples:
+    | implement | value |
+    | 0         | false |
+    | off       | false |
+    | false     | false |
+    | no        | false |
+    | NO        | false |
+    | False     | false |
+    | 1         | true  |
+    | on        | true  |
+    | true      | true  |
+    | yes       | true  |

data/features/enumeration-constant.feature

@@ -0,0 +1,76 @@
+Feature: @enumeration -> @constant
+  
+  Scenario Outline: Define a constant
+    Given I have defined a valid enumeration named <enumeration>
+    And I define a constant named <constant> with value <value> and description <description>
+    When I get the result hash
+    Then the enumeration <enumeration> should contain a constant named <constant>
+    And the constant <constant> of enumeration <enumeration> should have value <value>
+    And the constant <constant> of enumeration <enumeration> should have description <description>
+
+    Examples:
+    | enumeration        | constant        | value | description         |
+    | AnEnumeration      | AConstant       | 1     | A description       |
+    | AnotherEnumeration | AnotherConstant | 4     | Another description |
+
+  Scenario Outline: Define multiple constants
+    Given I have defined a valid enumeration named <enumeration>
+    And I define a constant named <constant_1> with value <value_1> and description <description_1>
+    And I define a constant named <constant_2> with value <value_2> and description <description_2>
+    When I get the result hash
+    Then the enumeration <enumeration> should contain a constant named <constant_1>
+    And the constant <constant_1> of enumeration <enumeration> should have value <value_1>
+    And the constant <constant_1> of enumeration <enumeration> should have description <description_1>
+    And the enumeration <enumeration> should contain a constant named <constant_2>
+    And the constant <constant_2> of enumeration <enumeration> should have value <value_2>
+    And the constant <constant_2> of enumeration <enumeration> should have description <description_2>
+
+    Examples:
+    | enumeration        | constant_1  | value_1 | description_1 | constant_2  | value_2 | description_2       |
+    | AnEnumeration      | Constant1   | 1       | A Description | Constant2   | 2       | Another Description |
+    | AnotherEnumeration | ConstantA   | 2       | A Description | ConstantB   | 1       | Another Description |
+    | AThirdEnumeration  | ConstantOne | 2       | Numeral two   | ConstantTwo | 2       | Ordinal two         |
+
+  Scenario: Define constants with implied values
+    Given I have defined a valid enumeration named AnEnumeration
+    And I define a valid constant named Constant0
+    And I define a valid constant named Constant1
+    And I define a valid constant named Constant2
+    When I get the result hash
+    Then the constant Constant0 of enumeration AnEnumeration should have value 0
+    Then the constant Constant1 of enumeration AnEnumeration should have value 1
+    Then the constant Constant2 of enumeration AnEnumeration should have value 2
+
+
+  Scenario Outline: Define constants with mixed explicit and implied values
+    Given I have defined a valid enumeration named AnEnumeration
+    And I define a valid constant named Constant1 with value <value1>
+    And I define a valid constant named Constant2
+    And I define a valid constant named Constant3
+    And I define a valid constant named Constant4 with value <value4>
+    And I define a valid constant named Constant5
+    When I get the result hash
+    Then the constant Constant1 of enumeration AnEnumeration should have value <value1>
+    And the constant Constant2 of enumeration AnEnumeration should have value <expected2>
+    And the constant Constant3 of enumeration AnEnumeration should have value <expected3>
+    And the constant Constant4 of enumeration AnEnumeration should have value <value4>
+    And the constant Constant5 of enumeration AnEnumeration should have value <expected5>
+
+    Examples:
+    | value1 | expected2 | expected3 | value4 | expected5 |
+    | 1      | 2         | 3         | 4      | 5         |
+    | 0      | 1         | 2         | 10     | 11        |
+
+  Scenario Outline: Define a constant with an interpreted expression
+    Given I have defined a valid enumeration named AnEnumeration
+    And I define a valid constant named Expressive with value <expression>
+    When I get the result hash
+    Then the constant Expressive should have value <output>
+
+    Examples:
+    | expression  | output |
+    | 0           | 0      |
+    | Math.cos(0) | 1      |
+    | 0x10        | 16     |
+    | 1 << 8      | 256    |
+