grammoire 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+# Test requirements
+gem 'mocha', :group => "test"
+gem 'rspec', :group => "test"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.5)
+    metaclass (0.0.1)
+    mocha (0.11.3)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+    rdoc (3.10)
+      json (~> 1.4)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.8.3)
+  mocha
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Paulo Schneider
+
+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/README.md

@@ -0,0 +1,4 @@
+grammoire
+=========
+
+A context-sensitive grammar library for producing randomised objects

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rspec/core/rake_task'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "grammoire"
+  gem.homepage = "http://github.com/moonpxi/grammoire"
+  gem.license = "MIT"
+  gem.summary = %Q{A context-sensitive grammar library for producing randomised objects}
+  gem.description = %Q{A context-sensitive grammar library for producing randomised objects}
+  gem.email = "paulo.schneider@gmail.com"
+  gem.authors = ["moonpxi"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w{--format s --color}
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/features/conditions.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+
+grammar = Grammoire.define do
+  rule(:conditionals) do
+    pre_condition { data(:variable) == 5 }
+    produce {'You got 5!'}
+  end
+  rule(:conditionals) do
+    pre_condition { data(:variable) < 5 }
+    produce {'You got less then 5. :('}
+  end
+  rule(:conditionals) do
+    pre_condition { data(:variable) > 5 }
+    produce {'You got more then 5. :)'}
+  end
+  rule(:conditionals) { produce {'I am always valid.'} }
+end
+
+[5, 2, 8].each do |number|
+  puts "Variable #{number} gives #{grammar.evaluate(:conditionals, :variable => number)}"
+end

data/examples/features/custom_context.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+
+class ArrayEvaluationContext < Grammoire::EvaluationContext
+  def one_of(*productions)
+    production = productions[rand(productions.size)] 
+    evaluated_results =  production.collect do |element|
+      if element.kind_of? Symbol
+        eval(element)
+      else
+        element
+      end
+    end
+    return evaluated_results.join
+  end
+end
+
+
+grammar = Grammoire.define do
+  context ArrayEvaluationContext
+
+  rule(:s) { produce { one_of([:s, :s], ['(', :s, ')'], ['()']) } }
+end
+
+10.times { puts grammar.evaluate(:s) + "\n\n" }

data/examples/features/data_points.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+
+grammar = Grammoire.define do
+  rule(:full_name) { produce { eval(:first_name) + ' ' + eval(:last_name) } }
+  rule(:first_name) { produce { data(:first) } }
+  rule(:last_name) { produce { data(:last) } }
+end
+
+puts grammar.evaluate(:full_name, :first => "Jonny", :last => "Data")

data/examples/features/probability.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+
+grammar = Grammoire.define do
+  rule(:s) { produce { 'a' + eval(:s) }; weights 4 }
+  rule(:s) { produce { 'b' + eval(:s) } }
+  rule(:s) { produce { eval(:end) } }
+  
+  rule(:end) { produce { 'x' }; weights 10 }
+  rule(:end) { produce { 'y' } }
+end
+
+10.times { puts grammar.evaluate(:s) + "\n\n" }

data/examples/features/single_rule.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+
+grammar = Grammoire.define do
+  rule(:s) { produce { eval(:s) + eval(:s) } }
+  rule(:s) { produce { "(#{eval(:s)})" } }
+  rule(:s) { produce { '()' } }
+  rule(:s) { produce { "[#{eval(:s)}]" } }
+  rule(:s) { produce { '[]' } }
+end
+
+10.times { puts grammar.evaluate(:s) + "\n\n" }

data/grammoire.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{grammoire}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{moonpxi}]
+  s.date = %q{2012-04-28}
+  s.description = %q{A context-sensitive grammar library for producing randomised objects}
+  s.email = %q{paulo.schneider@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "examples/features/conditions.rb",
+    "examples/features/custom_context.rb",
+    "examples/features/data_points.rb",
+    "examples/features/probability.rb",
+    "examples/features/single_rule.rb",
+    "grammoire.gemspec",
+    "lib/grammoire.rb",
+    "lib/grammoire/evaluation_context.rb",
+    "lib/grammoire/grammar.rb",
+    "lib/grammoire/rule.rb",
+    "lib/grammoire/rule_chooser.rb",
+    "lib/grammoire/util/random_generator.rb",
+    "spec/grammoire/evaluation_context_spec.rb",
+    "spec/grammoire/grammar_spec.rb",
+    "spec/grammoire/rule_chooser_spec.rb",
+    "spec/grammoire/rule_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/moonpxi/grammoire}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{A context-sensitive grammar library for producing randomised objects}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+  end
+end
+

data/lib/grammoire.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/grammoire/util/random_generator')
+require File.expand_path(File.dirname(__FILE__) + '/grammoire/grammar')
+require File.expand_path(File.dirname(__FILE__) + '/grammoire/rule')
+require File.expand_path(File.dirname(__FILE__) + '/grammoire/evaluation_context')
+require File.expand_path(File.dirname(__FILE__) + '/grammoire/rule_chooser')
+
+class GrammarError < StandardError; end
+
+module Grammoire
+  def self.define(&block)
+    grammar = Grammar.new
+    grammar.instance_eval &block
+    grammar
+  end
+end

data/lib/grammoire/evaluation_context.rb

@@ -0,0 +1,26 @@
+module Grammoire
+
+  class EvaluationContext
+
+    def initialize(grammar)
+      @grammar = grammar
+      with_data_points({})
+    end
+    
+    def with_data_points(data)
+      @data = data
+    end
+    
+    def data(name)
+      raise GrammarError.new("Data point '#{name}' doesn't exist in the evaluation context.") unless @data.has_key? name
+
+      return @data[name]
+    end
+        
+    def eval(rule)
+      @grammar.evaluate(rule, @data)
+    end
+
+  end
+  
+end

data/lib/grammoire/grammar.rb

@@ -0,0 +1,34 @@
+module Grammoire
+  class Grammar
+
+    def initialize(random_generator = RandomGenerator.new)
+      @rules = []
+      @chooser = RuleChooser.new(random_generator)
+      context(EvaluationContext)
+    end
+
+    def context(context_class)
+      @context = context_class.new(self)
+    end
+    
+    def rule(name, &action)
+      @rules << Rule.new(name, &action)
+    end
+
+    def evaluate(rule_name, data = {})
+      @context.with_data_points(data)
+
+      return @chooser.select_from(rules_for(rule_name)).evaluate(@context)
+    end
+
+   private
+   
+    def rules_for(name)
+      rules = @rules.select { |rule| rule.name == name && rule.applies?(@context) }
+      raise GrammarError.new("Rule '#{name}' doesn't exist in the grammar or don't have valid pre-conditions.") if rules.empty?
+
+      return rules
+    end
+
+  end
+end

data/lib/grammoire/rule.rb

@@ -0,0 +1,34 @@
+module Grammoire
+  class Rule
+    attr_reader :name, :weight
+
+    def initialize(name, &setup)
+      @name = name
+      weights(1)
+      pre_condition { true }
+      
+      instance_eval &setup if block_given?
+    end
+
+    def weights(weight)
+      @weight = weight
+    end
+
+    def pre_condition(&condition)
+      @condition = condition 
+    end
+
+    def applies?(context)
+      context.instance_eval &@condition
+    end
+   
+    def produce(&action)
+      @action = action
+    end
+
+    def evaluate(context)
+      context.instance_eval &@action
+    end
+
+  end
+end

data/lib/grammoire/rule_chooser.rb

@@ -0,0 +1,25 @@
+class RuleChooser
+
+  def initialize(random_generator = RandomGenerator.new)
+    @random_generator = random_generator
+  end
+
+  def select_from(rules)
+    return nil if rules.empty?
+
+    selected_weight_index = @random_generator.number_up_to(total_weight_from(rules))
+    max_weight_index = 0
+
+    rules.each do |rule|
+      max_weight_index += rule.weight
+      return rule if selected_weight_index < max_weight_index
+    end
+  end
+
+ private
+
+  def total_weight_from(rules)
+    rules.inject(0) { |sum, rule| sum + rule.weight }
+  end
+  
+end

data/lib/grammoire/util/random_generator.rb

@@ -0,0 +1,9 @@
+class RandomGenerator
+  def number_up_to(max)
+    rand(max)
+  end
+
+  def one_of(options)
+    options[number_up_to(options.size)]
+  end
+end

data/spec/grammoire/evaluation_context_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe EvaluationContext do
+  let(:grammar) { mock() }
+  let(:context) { EvaluationContext.new(grammar) }
+
+  it 'should evaluate rule in context by evaluating from the grammar' do
+    grammar.expects(:evaluate).with(:some_rule, {}).returns("some result")
+
+    context.eval(:some_rule).should == "some result"
+  end
+
+  it 'should raise error when access inexistent data point' do
+    lambda { context.data(:dont_exist) }.should raise_error(GrammarError, "Data point 'dont_exist' doesn't exist in the evaluation context.")
+  end
+
+  it 'should access data point' do
+    context.with_data_points(:point_a => "abc", :point_b => 123)
+
+    context.data(:point_a).should == "abc"
+    context.data(:point_b).should == 123
+  end
+
+  it 'should forward data point when producing rule' do
+    data = {:should => 'keep', :this => 'data'}
+    context.with_data_points(data)
+
+    grammar.expects(:evaluate).with(:rule_with_data, data)
+
+    context.eval(:rule_with_data)
+  end
+end

data/spec/grammoire/grammar_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Grammar do
+  let(:grammar) { Grammar.new }
+  
+  describe '(validation)' do
+    it 'should raise an exception when trying to evaluate output for non existent rule' do
+      lambda { grammar.evaluate(:no_such_rule) }.should raise_error(GrammarError, "Rule 'no_such_rule' doesn't exist in the grammar or don't have valid pre-conditions.")
+    end
+
+    it 'should raise an exception when evaluating a rule without valid productions' do
+      grammar.rule(:invalid) { pre_condition { false }; produce { 'not valid' } }
+
+      lambda { grammar.evaluate(:invalid) }.should raise_error(GrammarError, "Rule 'invalid' doesn't exist in the grammar or don't have valid pre-conditions.")
+    end
+  end
+
+  describe '(producing)' do
+    it 'should evaluate terminal symbol of a rule' do
+      grammar.rule(:terminal) { produce { 'terminal' } }
+
+      grammar.evaluate(:terminal).should == 'terminal'
+    end
+
+    it 'should evaluate and substitute symbols when producing a non-terminal rule' do
+      grammar.rule(:non_terminal) { produce { 'non-' + eval(:terminal) } }
+      grammar.rule(:terminal) { produce { 'terminal' } }
+
+      grammar.evaluate(:non_terminal).should == 'non-terminal'
+    end
+
+    it 'should select one of the production rules' do
+      random_generator = StubRandomGenerator.should_produce(0, 1, 1)
+      grammar = Grammar.new(random_generator)
+
+      grammar.rule(:two_choices) { produce { 'terminal x' } }
+      grammar.rule(:two_choices) { produce { 'terminal y' } }
+
+      grammar.evaluate(:two_choices).should == 'terminal x'
+      grammar.evaluate(:two_choices).should == 'terminal y'
+      grammar.evaluate(:two_choices).should == 'terminal y'
+    end
+
+    it 'should evaluate rules that pass the pre condition check' do
+      grammar.rule(:condition) { pre_condition { false }; produce { 'not running' } }
+      grammar.rule(:condition) { pre_condition { true }; produce { 'I am true!' } }
+      grammar.rule(:condition) { pre_condition { false }; produce { 'I am false' }; weights 1000 }
+
+      grammar.evaluate(:condition).should == 'I am true!'  
+    end
+    
+  end
+
+  describe '(data points)' do
+    it 'should evaluate with data points' do
+      grammar.rule(:with_data) { produce { data(:some_data) } }
+
+      grammar.evaluate(:with_data, :some_data => 123).should == 123
+    end
+  end
+
+  describe '(context)' do
+    it 'should define custom context for productions to be executed' do
+      class CustomContext < EvaluationContext
+        def custom_method
+          "hello there"
+        end
+      end
+
+      grammar.context(CustomContext)
+      grammar.rule(:custom) { produce { custom_method } }
+
+      grammar.evaluate(:custom).should == "hello there"
+    end
+  end
+
+end

data/spec/grammoire/rule_chooser_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RuleChooser do
+  let(:generator) { StubRandomGenerator.new }
+  let(:chooser) { RuleChooser.new(generator) }
+
+  it 'should return nil if no rule is given' do
+    chooser.select_from([]).should be_nil
+  end
+
+  it 'should select only rule if only one rule is given' do
+    generator.returning_results(0, 1)
+
+    rule = Rule.new(:name)
+
+    chooser.select_from([rule]).should == rule
+  end
+
+  it 'should select rule based on the probability over the weightings' do
+    generator.returning_results(0, 1, 2, 3)
+
+    heavier_rule = Rule.new(:heavy) { weights 3 }
+    lighter_rule = Rule.new(:heavy) { weights 1 }
+    rules = [heavier_rule, lighter_rule]
+    
+    chooser.select_from(rules).should == heavier_rule
+    chooser.select_from(rules).should == heavier_rule
+    chooser.select_from(rules).should == heavier_rule
+    chooser.select_from(rules).should == lighter_rule
+  end
+
+end

data/spec/grammoire/rule_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Rule do
+  let(:context) { mock() }
+  let(:rule) { Rule.new(:rule_name) }
+
+  it 'should construct rule with a setup block' do
+    rule = Rule.new(:my_name) do
+      weights 5
+      produce { 'production' }
+    end
+
+    rule.name.should == :my_name
+    rule.weight == 5
+    rule.evaluate('any context').should == 'production'
+  end
+
+  describe '(weighting)' do
+    it 'should have default weight of 1' do
+      rule.weight.should == 1
+    end
+
+    it 'should allow changing the weight' do
+      rule.weights(3)
+
+      rule.weight.should == 3
+    end
+  end
+
+  describe '(conditions)' do
+    it 'should always applies when pre conditions not specified' do
+      rule.applies?(context).should be_true
+    end
+
+    it 'should apply only if pre condition is valid within context' do
+      context.expects(:data).with(:number).returns(30)
+
+      rule.pre_condition { data(:number) == 30 }
+
+      rule.applies?(context).should be_true
+    end
+
+    it 'should not apply if pre condition is invalid within context' do
+      context.expects(:data).with(:number).returns(42)
+      
+      rule.pre_condition { data(:number) == 30 }
+
+      rule.applies?(context).should be_false
+    end
+  end
+
+  describe '(evaluation)' do
+    it 'should evaluate production in the given context' do
+      context.expects(:inside_context).returns('context response')
+
+      rule.produce { inside_context }
+
+      rule.evaluate(context).should == 'context response'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+require 'mocha'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/grammoire")
+include Grammoire
+
+class StubRandomGenerator < RandomGenerator
+  
+  def returning_results(*results)
+    @results = results
+    return self
+  end
+
+  def self.should_produce(*results)
+    StubRandomGenerator.new.returning_results(*results)
+  end
+
+  def number_up_to(max)
+    @results.shift
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: grammoire
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- moonpxi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70237364121240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70237364121240
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70237364120520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70237364120520
+description: A context-sensitive grammar library for producing randomised objects
+email: paulo.schneider@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- examples/features/conditions.rb
+- examples/features/custom_context.rb
+- examples/features/data_points.rb
+- examples/features/probability.rb
+- examples/features/single_rule.rb
+- grammoire.gemspec
+- lib/grammoire.rb
+- lib/grammoire/evaluation_context.rb
+- lib/grammoire/grammar.rb
+- lib/grammoire/rule.rb
+- lib/grammoire/rule_chooser.rb
+- lib/grammoire/util/random_generator.rb
+- spec/grammoire/evaluation_context_spec.rb
+- spec/grammoire/grammar_spec.rb
+- spec/grammoire/rule_chooser_spec.rb
+- spec/grammoire/rule_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/moonpxi/grammoire
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 443293151484266560
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A context-sensitive grammar library for producing randomised objects
+test_files: []