talk 2.0.1 → 2.0.2

data/features/enumeration.feature

@@ -0,0 +1,35 @@
+Feature: @enumeration
+  Scenario Outline: Define an @enumeration with explicit @description
+    Given I define an enumeration named <name> with description <description>
+    When I get the result hash
+    Then there should be an enumeration named <name>
+    And the enumeration named <name> should have description <description>
+
+    Examples:
+    | name               | description          |
+    | AnEnumeration      | This is a test enum  |
+    | AnotherEnumeration | Here is another one! |
+
+
+  Scenario Outline: Define an @enumeration with implicit description
+    Given I define an enumeration named <name> with implicit description <description>
+    When I get the result hash
+    Then there should be an enumeration named <name>
+    And the enumeration named <name> should have description <description>
+
+    Examples:
+    | name               | description          |
+    | AnEnumeration      | This is a test enum  |
+    | AnotherEnumeration | Here is another one! |
+
+  Scenario: Define an @enumeration with no description
+    Given I define an enumeration named SomeEnumeration
+    But I don't give it a description
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario: Define an @enumeration with no name
+    Given I define an enumeration
+    But I don't give it a name
+    When I get the result hash
+    Then there should be a parse error

data/features/glossary-term.feature

@@ -0,0 +1,46 @@
+Feature: @glossary -> @term
+  Scenario Outline: Define an @term with an explicit @description
+    Given I have defined a valid glossary named <glossary>
+    And I define a term named <term> with value <value> and description <description>
+    When I get the result hash
+    Then the glossary <glossary> should contain a term named <term>
+    And the term <term> of glossary <glossary> should have value <value>
+    And the term <term> of glossary <glossary> should have description <description>
+
+    Examples:
+    | glossary        | term        | value     | description                               |
+    | SomeGlossary    | SomeTerm    | SomeValue | I am a description                        |
+    | AnotherGlossary | AnotherTerm | AValue    | I am a silly description with a silly hat |
+
+  Scenario Outline: Define an @term with no description
+    Given I have defined a valid glossary named TestGlossary
+    And I define a term named <name> with value <value>
+    But I don't give it a description
+    When I get the result hash
+    Then the glossary TestGlossary should contain a term named <name>
+    And the term <name> of glossary TestGlossary should have value <value>
+
+    Examples:
+    | name        | value        |
+    | ATerm       | AValue       |
+    | AnotherTerm | AnotherValue |
+
+  Scenario: Define an @term with no name
+    Given I have defined a valid glossary
+    And I define a term
+    But I don't give it a name
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario Outline: Define an @term with no value
+    Given I have defined a valid glossary named TestGlossary
+    And I define a term named <name>
+    But I don't give it a name
+    When I get the result hash
+    Then the glossary TestGlossary should contain a term named <name>
+    And the term <name> of glossary TestGlossary should have value <name>
+
+    Examples:
+    | name        |
+    | ATerm       |
+    | AnotherTerm |

data/features/glossary.feature

@@ -0,0 +1,35 @@
+Feature: @glossary
+  Scenario Outline: Define an @glossary with an explicit @description
+    Given I define a glossary named <name> with description <description>
+    When I get the result hash
+    Then there should be a glossary named <name>
+    And the glossary named <name> should have description <description>
+
+    Examples:
+    | name            | description         |
+    | AGlossary       | A test glossary     |
+    | AnotherGlossary | More testing please |
+
+  Scenario Outline: Define an @glossary with an implicit description
+    Given I define a glossary named <name> with implicit description <description>
+    When I get the result hash
+    Then there should be a glossary named <name>
+    And the glossary named <name> should have description <description>
+
+    Examples:
+    | name            | description         |
+    | AGlossary       | A test glossary     |
+    | AnotherGlossary | More testing please |
+
+  Scenario: Define an @glossary with no description
+    Given I define a glossary named SomeGlossary
+    But I don't give it a description
+    When I get the result hash
+    Then there should be a parse error
+
+  Scenario: Define an @glossary with no name
+    Given I define a glossary
+    But I don't give it a name
+    When I get the result hash
+    Then there should be a parse error
+    

data/features/step_definitions/class-field.rb

@@ -0,0 +1,74 @@
+Given(/^I give it a field named (\S+) of type (\S+) and description (.+)$/) do |name, type, description|
+  last_class.add_child(make_field(name, type).add_child(make_description(description)))
+end
+
+Then(/^the field (\S+) should have type (\S+) and description (.+)$/) do |name, type, description|
+  field = field_in_result_class("SomeClass", name)
+  expect(field).not_to be_nil
+  expect(field[:description]).to eq(description)
+  expect(field[:type].length).to eq(1)
+  expect(field[:type][0]).to eq(type)
+end
+
+Given(/^I give it a field named (\S+) of type (\S+) and implicit description (.+)$/) do |name, type, description|
+  last_class.add_child(make_field(name, type, description))
+end
+
+Given(/^I give it a valid field named (\S+) of type (\S+)$/) do |name, type|
+  last_class.add_child(make_field(name, type, "A description"))
+end
+
+Then(/^the field (\S+) should have type (\S+)$/) do |name, type|
+  field = field_in_result_class(last_class.words[0], name)
+  expect(field).not_to be_nil
+  expect(field[:type].length).to eq(1)
+  expect(field[:type][0]).to eq(type)
+end
+
+Given(/^I give it a valid field named (\S+)$/) do |name|
+  last_class.add_child(make_field(name, "uint32", "A description"))
+end
+
+Given(/^I give (\S+) @see (\S+) (\S+)$/) do |field_name, ref_type, ref_name|
+  last_class.find_child("@field", field_name, 1).add_child(make_see(ref_type, ref_name))
+end
+
+Then(/^the field (\S+) should have an @see (\S+) (\S+)$/) do |field_name, ref_type, ref_name|
+  ref_type = "enumeration" if(ref_type) == "enum"
+  result_field = field_in_result_class(last_class.words[0], field_name)
+  expect(result_field[:see]).not_to be_nil
+
+  matches = result_field[:see].select { |x| x[:type] == ref_type and x[:name] == ref_name }
+  expect(matches.length).to eq(1)
+end
+
+Given(/^I give (\S+) @caveat (.+)$/) do |field_name, caveat_text|
+  caveat = TalkTag.new("@caveat").add_data(caveat_text)
+  last_class.find_child("@field", field_name, 1).add_child(caveat)
+end
+
+Then(/^the field (\S+) should have a @caveat (.+)$/) do |field_name, caveat_text|
+  field = field_in_result_class("SomeClass", field_name)
+  expect(field[:caveat]).to include(caveat_text)
+end
+
+Given(/^I give (\S+) @deprecated (.+)$/) do |field_name, deprecation_text|
+  deprecated = TalkTag.new("@deprecated").add_data(deprecation_text)
+  last_class.find_child("@field", field_name, 1).add_child(deprecated)
+end
+
+Then(/^the field (\S+) should have @deprecated (.+)$/) do |field_name, deprecation_text|
+  field = field_in_result_class("SomeClass", field_name)
+  expect(field[:deprecated]).to eq(deprecation_text)
+end
+
+Given(/^I give (\S+) @version (.+)$/) do |field_name, version_string|
+  version = TalkTag.new("@version").add_data(version_string)
+  last_class.find_child("@field", field_name, 1).add_child(version)
+end
+
+Then(/^the field (\S+) should have @version (.+)$/) do |field_name, version_string|
+  field = field_in_result_class("SomeClass", field_name)
+  expect(field[:version]).to eq(version_string)
+end
+

data/features/step_definitions/class.rb

@@ -0,0 +1,50 @@
+Given(/^I have defined a class named (.+)$/) do |class_name|
+  make_class(class_name)
+end
+
+Given(/^I have given (.+) as a @description$/) do |description|
+  last_class.add_child(make_description(description))
+end
+
+Then(/^there should be a class named (.+)$/) do |class_name|
+  expect(result_class(class_name)).not_to be_nil
+end
+
+Then(/^it should have description (.+)$/) do |description|
+  expect(result_class(last_class)[:description]).to eq(description)
+end
+
+Given(/^I have given (.+) as an implied description$/) do |description|
+  last_class.add_data(description)
+end
+
+Given(/^I don't give a description$/) do
+end
+
+Given(/^I define another class also named (.+)$/) do |class_name|
+  make_class(class_name).add_data("A description")
+end
+
+Given(/^I give it @inherits (.+)$/) do |base_class|
+  last_class.add_child(TalkTag.new("@inherits").add_data(base_class))
+end
+
+Then(/^the class (.+) should have @inherits (.+)$/) do |child_class, base_class|
+  expect(result_class(child_class)[:inherits]).to eq(base_class)
+end
+
+Given(/^I give it @implement (.+)$/) do |is_implemented|
+  last_class.add_child(TalkTag.new("@implement").add_data(is_implemented))
+end
+
+Then(/^the class (.+) should have @implement (.+)$/) do |class_name, is_implemented|
+  implemented = case is_implemented
+    when 'false'
+      false
+    when 'true'
+      true
+    else
+      'wtf'
+  end
+  expect(result_class(class_name)[:implement]).to eq(implemented)
+end

data/features/step_definitions/enumeration-constant.rb

@@ -0,0 +1,42 @@
+Given(/^I define a valid constant named (\S+)$/) do |constant_name|
+  @enumerations.last.add_child(make_constant(constant_name))
+end
+
+Given(/^I define a valid constant named (\S+) with value (.+)$/) do |constant_name, value|
+  @enumerations.last.add_child(make_constant(constant_name, value))
+end
+
+Given(/^I define a constant named (\S+) with value (\S+) and description (.+)$/) do |constant_name, value, description_text|
+  @enumerations.last.add_child(make_constant(constant_name, value).add_child(make_description(description_text)))
+end
+
+Given(/^I define a constant named (\S+) with value (\S+) and implicit description (.+)$/) do |constant_name, value, description_text|
+  @enumerations.last.add_child(make_constant(constant_name, value, description_text))
+end
+
+Then(/^the enumeration (\S+) should contain a constant named (\S+)$/) do |enumeration_name, constant_name|
+  enum = result_enumeration(enumeration_name)
+  expect(enum).not_to be_nil
+
+  constant = constant_in_result_enumeration(enum, constant_name)
+  expect(constant).not_to be_nil
+end
+
+Then(/^the constant (\S+) should have value (.+)$/) do |constant_name, value|
+  enum = result_enumeration(@enumerations.last)
+  constant = constant_in_result_enumeration(enum, constant_name)
+  expect(constant[:value]).to eq(value.to_f)
+end
+
+Then(/^the constant (\S+) of enumeration (\S+) should have value (\S+)$/) do |constant_name, enumeration_name, value|
+  enum = result_enumeration(enumeration_name)
+  constant = constant_in_result_enumeration(enum, constant_name)
+  expect(constant[:value]).to eq(value.to_f)
+end
+
+Then(/^the constant (\S+) of enumeration (\S+) should have description (.+)$/) do |constant_name, enumeration_name, description_text|
+  enum = result_enumeration(@enumerations.last)
+  constant = constant_in_result_enumeration(enum, constant_name)
+  expect(constant[:description]).to eq(description_text)
+end
+

data/features/step_definitions/enumeration.rb

@@ -0,0 +1,29 @@
+Given(/^I define an enumeration named (\S+) with description (.+)$/) do |enum_name, description_text|
+  make_enumeration(enum_name).add_child(make_description(description_text))
+end
+
+Then(/^there should be an enumeration named (\S+)$/) do |enum_name|
+  expect(result_enumeration(enum_name)).not_to be_nil
+end
+
+Then(/^the enumeration named (\S+) should have description (.+)$/) do |enum_name, description_text|
+  expect(result_enumeration(enum_name)[:description]).to eq(description_text)
+end
+
+Given(/^I define an enumeration named (\S+) with implicit description (.+)$/) do |enum_name, description_text|
+  make_enumeration(enum_name).add_data(description_text)
+end
+
+Given(/^I define an enumeration$/) do
+  make_enumeration
+end
+
+Given(/^I define an enumeration named (\S+)$/) do |enum_name|
+  make_enumeration(enum_name)
+end
+
+Given(/^I don't give it a description$/) do
+end
+
+Given(/^I don't give it a name$/) do
+end

data/features/step_definitions/glossary-term.rb

@@ -0,0 +1,31 @@
+Given(/^I define a term$/) do
+  @glossaries.last.add_child(make_term)
+end
+
+Given(/^I define a term named (\S+)$/) do |term_name|
+  @glossaries.last.add_child(make_term(term_name))
+end
+
+Given(/^I define a term named (\S+) with value (\S+)$/) do |term_name, value|
+  term = make_term(term_name, value)
+  @glossaries.last.add_child(term)
+end
+
+Given(/^I define a term named (\S+) with value (\S+) and description (.+)$/) do |term_name, value, description_text|
+  @glossaries.last.add_child(make_term(term_name, value, description_text))
+end
+
+Then(/^the glossary (\S+) should contain a term named (\S+)$/) do |glossary_name, term_name|
+  term = term_in_result_glossary(result_glossary(glossary_name), term_name)
+  expect(term).not_to be_nil
+end
+
+Then(/^the term (\S+) of glossary (\S+) should have value (\S+)$/) do |term_name, glossary_name, value|
+  term = term_in_result_glossary(result_glossary(glossary_name), term_name)
+  expect(term[:value]).to eq(value)
+end
+
+Then(/^the term (\S+) of glossary (\S+) should have description (.+)$/) do |term_name, glossary_name, description_text|
+  term = term_in_result_glossary(result_glossary(glossary_name), term_name)
+  expect(term[:description]).to eq(description_text)
+end

data/features/step_definitions/glossary.rb

@@ -0,0 +1,23 @@
+Given(/^I define a glossary named (\S+) with description (.+)$/) do |glossary_name, description_text|
+  make_glossary(glossary_name).add_child(make_description(description_text))
+end
+
+Then(/^there should be a glossary named (\S+)$/) do |glossary_name|
+  expect(result_glossary(glossary_name)).not_to be_nil
+end
+
+Then(/^the glossary named (\S+) should have description (.+)$/) do |glossary_name, description_text|
+  expect(result_glossary(glossary_name)[:description]).to eq(description_text)
+end
+
+Given(/^I define a glossary named (\S+) with implicit description (.+)$/) do |glossary_name, description_text|
+  make_glossary(glossary_name).add_data(description_text)
+end
+
+Given(/^I define a glossary$/) do
+  make_glossary
+end
+
+Given(/^I define a glossary named (\S+)$/) do |glossary_name|
+  make_glossary(glossary_name)
+end

data/features/support/env.rb

@@ -0,0 +1,261 @@
+basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
+lib = File.join(basepath, 'lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'talk'
+require 'pp'
+require 'rspec/expectations'
+
+class TalkTag
+  attr_reader :children, :words, :tag
+
+  def initialize(tag)
+    @children = []
+    @words = []
+    @tag = tag
+  end
+
+  def add_child(child)
+    @children.push child
+    self
+  end
+
+  def add_data(new_words)
+    new_words = new_words.split("\s+") if new_words.is_a? String
+    @words += new_words
+    self
+  end
+
+  def render(depth=0)
+    indent = "\t" * depth
+    s  = "#{indent}#{@tag}\n"
+    s += "#{indent}\t#{@words.join(' ')}\n" unless @words.empty?
+    s += (@children.collect { |x| x.render(depth+1) }).join("\n\n") + "\n" unless @children.empty?
+
+    s
+  end
+
+  def find_child(tag, name=nil, index=0)
+    matches = @children.select { |x| x.tag == tag }
+    matches.select! { |x| x.words[index] == name } unless name.nil?
+    matches.last
+  end
+
+  def to_s
+    render
+  end
+end
+
+# Define a new @class
+def make_class(name=nil, description=nil)
+  new_class = TalkTag.new("@class")
+  new_class.add_data(name) unless name.nil?
+  new_class.add_data(description) unless description.nil?
+  @classes.push new_class
+  @last_object = new_class
+end
+
+# Define a new @description
+def make_description(text)
+  @last_object = TalkTag.new("@description").add_data(text)
+end
+
+# Define a new @field
+def make_field(name=nil, type=nil, description=nil)
+  field = TalkTag.new("@field")
+  field.add_data(type) unless type.nil?
+  field.add_data(name) unless name.nil?
+  field.add_data(description) unless description.nil?
+
+  @last_object = field
+end
+
+# Define a new @see
+def make_see(ref_type, ref_name)
+  @last_object = TalkTag.new("@see").add_data([ref_type, ref_name])
+end
+
+# Define a new @glossary
+def make_glossary(name=nil, description=nil)
+  glossary = TalkTag.new("@glossary")
+  glossary.add_data(name) unless name.nil?
+  glossary.add_data(description) unless description.nil?
+  @glossaries.push glossary
+
+  @last_object = glossary
+end
+
+# Define a new @term
+def make_term(name=nil, value=nil, description=nil)
+  term = TalkTag.new("@term")
+  term.add_data(name) unless name.nil?
+  term.add_data(value) unless value.nil?
+  term.add_child(make_description(description)) unless description.nil?
+
+  @last_object = term
+end
+
+# Define a new @constant
+def make_constant(name=nil, value=nil, description=nil)
+  constant = TalkTag.new("@constant")
+  constant.add_data(name) unless name.nil?
+  constant.add_data(value) unless value.nil?
+  constant.add_data(description) unless description.nil?
+
+  @last_object = constant
+end
+
+# Define a new @enumeration
+def make_enumeration(name=nil, description=nil)
+  enumeration = TalkTag.new("@enumeration")
+  enumeration.add_data(name) unless name.nil?
+  enumeration.add_data(description) unless description.nil?
+  @enumerations.push enumeration
+
+  @last_object = enumeration
+end
+
+# Find an @class by name
+def class_named(class_name)
+  @classes.each { |x| return x if x.words[0] == class_name }
+  nil
+end
+
+# Find an @enumeration by name
+def enumeration_named(enumeration_name)
+  @enumerations.each { |x| return x if x.words[0] == enumeration_name }
+  nil
+end
+
+# Find an @glossary by name
+def glossary_named(glossary_name)
+  @glossaries.each { |x| return x if x.words[0] == glossary_name }
+  nil
+end
+
+# Last @class defined via make_class
+def last_class
+  @classes.nil? ? nil : @classes.last
+end
+
+# Last object created using one of the make_* methods
+def last_object
+  @last_object
+end
+
+# Renders actual talk string to give to parser
+def render
+  all_tags = @classes + @glossaries + @enumerations
+  talk = (all_tags.map { |x| x.to_s }).join("\n\n")
+end
+
+# Finds an item with a given name in the specified tag set in the result hash
+def result_object_named_in_set(basis, set)
+  name = basis
+  name = basis.words[0] if basis.is_a? TalkTag
+
+  @results[set].each do |item|
+    return item if item[:name] == name
+  end
+
+  return nil
+end
+
+# Finds a class in the result hash
+def result_class(cls)
+  result_object_named_in_set(cls, :class)
+end
+
+# Finds a class in the result hash
+def result_enumeration(enum)
+  result_object_named_in_set(enum, :enumeration)
+end
+
+# Finds a class in the result hash
+def result_glossary(glossary)
+  result_object_named_in_set(glossary, :glossary)
+end
+
+# Finds a specific field in a result class
+def field_in_result_class(res_cls, field_name)
+  res_cls = result_class(res_cls) if res_cls.is_a? String
+  return nil if res_cls.nil?
+
+  res_cls[:field].each do |f|
+    return f if f[:name] == field_name
+  end
+
+  nil
+end
+
+# Finds a specific term in a result glossary
+def term_in_result_glossary(res_gloss, term_name)
+  res_gloss = result_glossary(res_gloss) if res_gloss.is_a? String
+  return nil if res_gloss.nil?
+
+  res_gloss[:term].each { |t| return t if t[:name] == term_name }
+  nil
+end
+
+# Finds a specific constant in a result enumeration
+def constant_in_result_enumeration(res_enum, constant_name)
+  res_enum = result_enumeration(res_enum) if res_enum.is_a? String
+  return nil if res_enum.nil?
+
+  res_enum[:constant].each { |t| return t if t[:name] == constant_name }
+  nil
+end
+
+# Resets the state so each scenario runs independently
+def clean_slate
+  @classes = []
+  @glossaries = []
+  @enumerations = []
+  @last_object = nil
+  @parser = Talk::Parser.new
+  @exception = nil
+  Talk::Registry.reset
+end
+
+
+## Generic test cases
+
+Before do |scenario|
+  clean_slate
+end
+
+Given(/^I have defined a valid class$/) do
+  make_class("SomeClass").add_data("A description")
+end
+
+Given(/^I have defined a valid class named (\S+)$/) do |class_name|
+  make_class(class_name).add_data("A description")
+end
+
+Given(/^I have defined a valid enumeration$/) do
+  make_enumeration("AnEnumeration", "A description")
+end
+
+Given(/^I have defined a valid enumeration named (\S+)$/) do |enumeration_name|
+  make_enumeration(enumeration_name, "A description")
+end
+
+Given(/^I have defined a valid glossary$/) do
+  make_glossary("AGlossary", "A description")
+end
+
+Given(/^I have defined a valid glossary named (\S+)$/) do |glossary_name|
+  make_glossary(glossary_name, "A description")
+end
+
+When(/^I get the result hash$/) do
+  begin
+    @parser.parse("scenario.talk", render)
+    @results = @parser.results
+  rescue => @exception
+  end
+end
+
+Then(/^there should be a parse error$/) do
+  expect(@exception.is_a? Talk::ParseError).to be true
+end