fabulator-grammar 0.0.1

data/README.markdown

@@ -0,0 +1,73 @@
+Fabulator Grammar Extension
+---------------------------
+
+This extension provides basic support for regular expressions modeled
+loosely after [Perl 6 grammars][].
+
+For now, this extension provides a single function: 'match(regex, string)'.  
+This function returns true or false depending on whether or not the regular
+expression matches the given string.
+
+The current implementation compiled regular expressions into Ruby
+RegExp objects for faster execution.  This may change as new capabilities
+are added that might not be supportable by pure Ruby regular expressions.
+
+The goal of the grammar extension is to provide a rich environment for
+writing parsers that can be integrated into the Fabulator environment.
+
+Namespace: "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+
+
+Regular Expressions
+===================
+
+The following characters are considered special and should be escaped if
+you are not using for their special meaning:
+
+  Parenthesis    ( )
+  Brackets       [ ]
+  Curly Brackets { }
+  Angle Brackets < >
+  Dot            .
+  Question       ?
+  Caret          ^
+  Dollar         $
+  Asterisk       *
+  Plus           +
+  
+
+Additionally, the hyphen '-' should be the first character in a character
+class if it is matching itself instead of indicated a range.  It can not
+be used as either the beginning or end of a range at present.
+
+Whitespace can separate tokens in the regular expression, but the amount of
+Whitespace is not significant.  All tokens assume the possible existance of
+whitespace in the string being matched and will not fail due to the
+whitespace being there.
+
+[Perl 6 grammars]: http://feather.perl6.nl/syn/S05.html
+
+LICENSE:
+========
+
+Copyright (c) 2010 Texas A&M University
+
+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/Rakefile

@@ -0,0 +1,63 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fabulator-grammar"
+    gem.summary = %Q{Grammar extension to Fabulator.}
+    gem.description = %Q{The grammar Fabulator extension provides regular expression support.}
+    gem.email = "jgsmith@tamu.edu"
+    gem.homepage = "http://github.com/jgsmith/ruby-fabulator-grammar"
+    gem.authors = ["James Smith"]
+    gem.add_dependency(%q<fabulator>, [">= 0.0.1"]) 
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. This is only required if you plan to package fabulator-exhibit as a gem."
+end
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+require 'cucumber'
+require 'cucumber/rake/task'
+
+task :features => 'spec:integration'
+
+namespace :spec do
+  
+  desc "Run the Cucumber features"
+  Cucumber::Rake::Task.new(:integration) do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+    # t.feature_pattern = "#{extension_root}/features/**/*.feature"
+    t.profile = "default"
+  end
+
+end
+
+namespace :update do
+  desc "update the manifest"
+  task :manifest do
+    system %q[touch Manifest.txt; rake check_manifest | grep -v "(in " | patch]
+  end
+end
+
+desc 'Generate documentation for the fabulator exhibit extension.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fabulator'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# For extensions that are in transition
+desc 'Test the fabulator exhibit extension.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+# Load any custom rakefiles for extension
+Dir[File.dirname(__FILE__) + '/tasks/*.rake'].sort.each { |f| require f }

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/features/grammar.feature

@@ -0,0 +1,88 @@
+Feature: Basic regex parsing
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (foo)
+   Then it should match "foo"
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (foo+)
+   Then it should match "foo"
+    And it should match "foooo"
+    And it should not match "fo"
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (foo+?)
+   Then it should match "fooooooo"
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (foo{1,4}$)
+   Then it should match "foo"
+   Then it should match "fooooo"
+   Then it should not match "foooooo"
+   Then it should not match "fo"
+
+  @chars
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (^[Ff]o[-a-zA-F01234-9]+?)
+   Then it should match "foo"
+    And it should match "Foo"
+    And it should match "FoF03z-"
+    And it should not match "hellofoo"
+
+  @chars
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (^[^0-9][a-z][0-9]$)
+   Then it should match "fo0"
+    And it should not match "0l0"
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (^[^0-9].[0-9]$)
+   Then it should match "fo0"
+    And it should not match "0l0"
+    And it should not match "00"
+
+  @chars
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex ([\[-\]]o[a-z\]A-F01234-9]+?)
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (<foo><g:bar>*)
+
+  Scenario: Parsing a simple text string
+   Given a context
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I parse the regex (bar ( <foo> <g:bar> ) *)
+
+  Scenario: Adding two numbers together as a union
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I run the expression (g:match('^foo', 'fooo'))
+   Then I should get 1 item
+     And item 0 should be true
+
+  Scenario: Adding two numbers together as a union
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the prefix g as "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+   When I run the expression (g:match('^foo', 'bfooo'))
+   Then I should get 1 item
+     And item 0 should be false

data/features/step_definitions/expression_steps.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+
+Transform /^(expression|context) \((.*)\)$/ do |n, arg|
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^\[(.*)\]$/ do |arg|
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^(\d+)$/ do |arg|
+  arg.to_i
+end
+
+Given 'a context' do
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+  @grammar_parser ||= Fabulator::Grammar::Parser.new
+end
+
+Given /the prefix (\S+) as "([^"]+)"/ do |p,h|
+  @context ||= Fabulator::Expr::Context.new
+  @context.set_ns(p, h)
+end
+
+Given /that (\[.*\]) is set to (\[.*\])/ do |l,r|
+  @context.set_value(l, r)
+end
+
+When /I run the (expression \(.*\)) in the (context \(.*\))/ do |exp, cp|
+  @expr = exp
+  if cp.nil? || cp == ''
+    @result = []
+    @cp = @context.root
+  else
+    @cp = cp.run(@context).first || @context.root
+    @result = @expr.run(@context.with_root(@cp))
+  end
+end
+
+When /I run the (expression \(.*\))/ do |exp|
+  ## assume '/' as the context here
+  @expr = exp
+  @cp = @data
+  #puts YAML::dump(@expr)
+  @result = @expr.run(@context.with_root(@cp))
+  #puts YAML::dump(@result)
+end
+
+When /I unify the types? (.*)/ do |ts|
+  types = ts.split(/\s*,\s*/)
+  typea = types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  @type_result = Fabulator::ActionLib.unify_types(
+    types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  )
+end
+
+Then /I should get the type (.*)/ do |t|
+  pn = t.split(/:/, 2)
+  @type_result[0].should == @context.get_ns(pn[0])
+  @type_result[1].should == pn[1]
+end
+
+Then /I should get (\d+) items?/ do |count|
+  @result.length.should == count
+end
+
+Then /item (\d+) should be (\[.*\])/ do |i,t|
+  test = t.run(@context.with_root(@cp)).first
+   #puts "Result: #{@result[i.to_i].to_s.class.to_s}"
+  @result[i.to_i].to_s.should == test.to_s
+end
+
+Then /item (\d+) should be false/ do |i|
+  (!!@result[i.to_i].value).should == false
+end
+
+Then /item (\d+) should be true/ do |i|
+  (!!@result[i.to_i].value).should == true
+end
+
+Then /the (expression \(.*\)) should equal (\[.*\])/ do |x, y|
+  a = x.run(@context)
+  b = y.run(@context)
+  #puts YAML::dump(a)
+  #puts YAML::dump(b)
+  #puts YAML::dump(@context)
+  a.first.value.should == b.first.value
+end
+
+Then /the (expression \(.*\)) should be nil/ do |x|
+  x.run(@context).first.should == nil
+end

data/features/step_definitions/grammar_steps.rb

@@ -0,0 +1,18 @@
+require 'yaml'
+
+When /^I parse the regex \((.*)\)$/ do |regex|
+  @context ||= Fabulator::Expr::Context.new
+  @grammar_parser ||= Fabulator::Grammar::Parser.new
+  @regex = @grammar_parser.parse(regex, @context)
+#  puts YAML::dump(r)
+#  puts @regex.to_regex
+#  pending # express the regexp above with the code you wish you had
+end
+
+Then /^it should match "(.*)"$/ do |str|
+  str.should =~ @regex.to_regex
+end
+
+Then /^it should not match "(.*)"$/ do |str|
+  str.should_not =~ @regex.to_regex
+end

data/features/step_definitions/template_steps.rb

@@ -0,0 +1,25 @@
+Given /^the template$/ do |doc_xml|
+  @template_text = doc_xml
+end
+
+When /^I render the template$/ do
+  parser = Fabulator::Template::Parser.new
+  @template_result = parser.parse(@context, @template_text)
+end
+
+When /^I set the captions to:$/ do |caption_table|
+  captions = { }
+  caption_table.hashes.each do |h|
+    captions[h['path']] = h['caption']
+  end
+
+  @template_result.add_captions(captions)
+end
+
+Then /^the rendered text should equal$/ do |doc|
+  @template_result.to_s.should == %{<?xml version="1.0" encoding="UTF-8"?>\n} + doc + "\n"
+end
+
+Then /^the rendered html should equal$/ do |doc|
+  @template_result.to_html.should == doc
+end

data/features/step_definitions/xml_steps.rb

@@ -0,0 +1,23 @@
+Given /the statemachine/ do |doc_xml|
+  @context ||= Fabulator::Expr::Context.new
+
+  if @sm.nil?
+    @sm = Fabulator::Core::StateMachine.new.compile_xml(doc_xml)
+  else
+    @sm.compile_xml(doc_xml)
+  end
+  @sm.init_context(@context)
+end
+
+When /I run it with the following params:/ do |param_table|
+  params = { }
+  param_table.hashes.each do |hash|
+    params[hash['key']] = hash['value']
+  end
+  @sm.run(params)
+  #puts YAML::dump(@sm)
+end
+
+Then /it should be in the '(.*)' state/ do |s|
+  @sm.state.should == s
+end

data/features/support/env.rb

@@ -0,0 +1,7 @@
+# This file makes it possible to install RubyCAS-Client as a Rails plugin.
+
+$: << File.expand_path(File.dirname(__FILE__))+'/../../lib'
+
+require 'fabulator'
+require 'fabulator/grammar'
+require 'spec/expectations'

data/lib/fabulator/grammar.rb

@@ -0,0 +1,16 @@
+require 'fabulator/grammar/parser'
+require 'fabulator/grammar/actions'
+require 'fabulator/grammar/expr/rules'
+require 'fabulator/grammar/expr/rule'
+require 'fabulator/grammar/expr/rule_ref'
+require 'fabulator/grammar/expr/text'
+require 'fabulator/grammar/expr/sequence'
+require 'fabulator/grammar/expr/char_set'
+require 'fabulator/grammar/expr/any'
+
+module Fabulator
+  module Grammar
+    class ParserError < StandardError
+    end
+  end
+end

data/lib/fabulator/grammar/actions.rb

@@ -0,0 +1,65 @@
+#require 'fabulator/grammar/actions/grammar'
+
+module Fabulator
+  GRAMMAR_NS = "http://dh.tamu.edu/ns/fabulator/grammar/1.0#"
+  module Grammar
+    module Actions
+      class Lib
+        include Fabulator::ActionLib
+
+        register_namespace GRAMMAR_NS
+
+        #action 'grammar', Grammar
+
+        ## reference a grammar name
+        function 'match' do |ctx, args|
+          # first arg is the regex or <rule name>
+          regex = args[0].to_s
+          parser = Fabulator::Grammar::Parser.new
+          compiled = parser.parse(regex, ctx).to_regex
+          if args[1].is_a?(Array)
+            args[1].collect{|a|
+              if a.to_s =~ compiled
+                ctx.root.anon_node(true)
+              else
+                ctx.root.anon_node(false)
+              end
+            }
+          elsif args[1].to_s =~ compiled
+            [ ctx.root.anon_node(true) ]
+          else
+            [ ctx.root.anon_node(false) ]
+          end
+        end
+
+#        function 'tokenize' do |ctx, args|
+#        end
+      end
+    end
+  end
+end
+
+# modifiers: g:minimal, g:ignore-case, g:space, g:ratchet
+
+# need the concept of hypotheticals here
+
+# <g:grammar g:namespace=''>
+#   <g:token|g:regex g:name=''>
+#     <g:literal />
+#     <g:capture>...</g:capture>
+#     <g:group>...</g:group>
+#     <g:before>...</g:before>
+#     <g:after>...</g:after>
+#     <g:not-before>...</g:not-before>
+#     <g:not-after>...</g:not-after>
+#     <g:alternatives>...</g:alternatives>
+#     <g:token />
+#     <g:one-or-more>...</g:one-or-more>
+#     <g:zero-or-more>...</g:zero-or-more>
+#     <g:zero-or-one>...</g:zero-or-one>
+#     <g:many g:min='' g:max=''>...</g:many>
+#   </g:token>
+#   <g:rule g:name=''>
+#     <g:when><g:pattern>...</g:pattern>...</g:when>
+#   </g:rule>
+# </g:grammar>