sexpr 0.2.0

data/lib/sexpr/terminal.rb

@@ -0,0 +1,35 @@
+module Sexpr
+  class Terminal
+    include Element
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def inspect
+      "(terminal #{value.inspect})"
+    end
+
+    def match?(sexp)
+      terminal_match?(sexp)
+    end
+
+    def eat(sexp)
+      match?(sexp.first) ? sexp[1..-1] : nil
+    end
+
+    private
+
+    def terminal_match?(term)
+      case @value
+      when Regexp
+        @value === term rescue false
+      when TrueClass, FalseClass, NilClass
+        @value == term
+      end
+    end
+
+  end # class Terminal
+end # module Sexpr

data/lib/sexpr/version.rb

@@ -0,0 +1,14 @@
+module Sexpr
+  module Version
+
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    def self.to_s
+      [ MAJOR, MINOR, TINY ].join('.')
+    end
+
+  end
+  VERSION = Version.to_s
+end

data/sexpr.gemspec

@@ -0,0 +1,188 @@
+# We require your library, mainly to have access to the VERSION number.
+# Feel free to set $version manually.
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require "sexpr/version"
+$version = Sexpr::Version.to_s
+
+#
+# This is your Gem specification. Default values are provided so that your library
+# should be correctly packaged given what you have described in the .noespec file.
+#
+Gem::Specification.new do |s|
+
+  ################################################################### ABOUT YOUR GEM
+
+  # Gem name (required)
+  s.name = "sexpr"
+
+  # Gem version (required)
+  s.version = $version
+
+  # A short summary of this gem
+  #
+  # This is displayed in `gem list -d`.
+  s.summary = "A compilation framework around s-expressions"
+
+  # A long description of this gem (required)
+  #
+  # The description should be more detailed than the summary.  For example,
+  # you might wish to copy the entire README into the description.
+  s.description = "Sexpr helps manipulating s-expressions in ruby."
+
+  # The URL of this gem home page (optional)
+  s.homepage = "https://github.com/blambeau/sexp"
+
+  # Gem publication date (required but auto)
+  #
+  # Today is automatically used by default, uncomment only if
+  # you know what you do!
+  #
+  # s.date = Time.now.strftime('%Y-%m-%d')
+
+  # The license(s) for the library.  Each license must be a short name, no
+  # more than 64 characters.
+  #
+  # s.licences = %w{}
+
+  # The rubyforge project this gem lives under (optional)
+  #
+  # s.rubyforge_project = nil
+
+  ################################################################### ABOUT THE AUTHORS
+
+  # The list of author names who wrote this gem.
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  s.authors = ["Bernard Lambeau"]
+
+  # Contact emails for this gem
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  # NOTE: Somewhat strangly this attribute is always singular!
+  #       Don't replace by s.emails = ...
+  s.email  = ["blambeau@gmail.com"]
+
+  ################################################################### PATHS, FILES, BINARIES
+
+  # Paths in the gem to add to $LOAD_PATH when this gem is
+  # activated (required).
+  #
+  # The default 'lib' is typically sufficient.
+  s.require_paths = ["lib"]
+
+  # Files included in this gem.
+  #
+  # By default, we take all files included in the Manifest.txt file on root
+  # of the project. Entries of the manifest are interpreted as Dir[...]
+  # patterns so that lazy people may use wilcards like lib/**/*
+  #
+  here = File.expand_path(File.dirname(__FILE__))
+  s.files = File.readlines(File.join(here, 'Manifest.txt')).
+                 inject([]){|files, pattern| files + Dir[File.join(here, pattern.strip)]}.
+                 collect{|x| x[(1+here.size)..-1]}
+
+  # Test files included in this gem.
+  #
+  s.test_files = Dir["test/**/*"] + Dir["spec/**/*"]
+
+  # The path in the gem for executable scripts (optional)
+  #
+  s.bindir = "bin"
+
+  # Executables included in the gem.
+  #
+  s.executables = (Dir["bin/*"]).collect{|f| File.basename(f)}
+
+  ################################################################### REQUIREMENTS & INSTALL
+  # Remember the gem version requirements operators and schemes:
+  #   =  Equals version
+  #   != Not equal to version
+  #   >  Greater than version
+  #   <  Less than version
+  #   >= Greater than or equal to
+  #   <= Less than or equal to
+  #   ~> Approximately greater than
+  #
+  # Don't forget to have a look at http://lmgtfy.com/?q=Ruby+Versioning+Policies
+  # for setting your gem version.
+  #
+  # For your requirements to other gems, remember that
+  #   ">= 2.2.0"              (optimistic:  specify minimal version)
+  #   ">= 2.2.0", "< 3.0"     (pessimistic: not greater than the next major)
+  #   "~> 2.2"                (shortcut for ">= 2.2.0", "< 3.0")
+  #   "~> 2.2.0"              (shortcut for ">= 2.2.0", "< 2.3.0")
+  #
+
+  #
+  # One call to add_dependency('gem_name', 'gem version requirement') for each
+  # runtime dependency. These gems will be installed with your gem.
+  # One call to add_development_dependency('gem_name', 'gem version requirement')
+  # for each development dependency. These gems are required for developers
+  #
+  s.add_development_dependency("epath", "~> 0.0.1")
+  s.add_development_dependency("rake", "~> 0.9.2")
+  s.add_development_dependency("rspec", "~> 2.8.0")
+  s.add_development_dependency("wlang", "~> 0.10.2")
+  
+
+  # The version of ruby required by this gem
+  #
+  # Uncomment and set this if your gem requires specific ruby versions.
+  #
+  # s.required_ruby_version = ">= 0"
+
+  # The RubyGems version required by this gem
+  #
+  # s.required_rubygems_version = ">= 0"
+
+  # The platform this gem runs on.  See Gem::Platform for details.
+  #
+  # s.platform = nil
+
+  # Extensions to build when installing the gem.
+  #
+  # Valid types of extensions are extconf.rb files, configure scripts
+  # and rakefiles or mkrf_conf files.
+  #
+  s.extensions = []
+
+  # External (to RubyGems) requirements that must be met for this gem to work.
+  # It’s simply information for the user.
+  #
+  s.requirements = nil
+
+  # A message that gets displayed after the gem is installed
+  #
+  # Uncomment and set this if you want to say something to the user
+  # after gem installation
+  #
+  s.post_install_message = nil
+
+  ################################################################### SECURITY
+
+  # The key used to sign this gem.  See Gem::Security for details.
+  #
+  # s.signing_key = nil
+
+  # The certificate chain used to sign this gem.  See Gem::Security for
+  # details.
+  #
+  # s.cert_chain = []
+
+  ################################################################### RDOC
+
+  # An ARGV style array of options to RDoc
+  #
+  # See 'rdoc --help' about this
+  #
+  s.rdoc_options = []
+
+  # Extra files to add to RDoc such as README
+  #
+  s.extra_rdoc_files = Dir["README.md"] + Dir["CHANGELOG.md"] + Dir["LICENCE.md"]
+
+end

data/sexpr.noespec

@@ -0,0 +1,25 @@
+template-info:
+  name: "ruby"
+  version: 1.7.0
+  links:
+    source: https://github.com/blambeau/noe
+variables:
+  lower:
+    sexpr
+  upper:
+    Sexpr
+  version:
+    0.2.0
+  summary: |-
+    A compilation framework around s-expressions
+  description: |-
+    Sexpr helps manipulating s-expressions in ruby.
+  authors:
+    - {name: Bernard Lambeau, email: blambeau@gmail.com}
+  links:
+    - https://github.com/blambeau/sexp
+  dependencies:
+    - {name: epath,     version: "~> 0.0.1",  groups: [development]}
+    - {name: rake,      version: "~> 0.9.2",  groups: [development]}
+    - {name: rspec,     version: "~> 2.8.0",  groups: [development]}
+    - {name: wlang,     version: "~> 0.10.2", groups: [development]}

data/spec/alternative/test_eat.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr
+  describe Alternative, "eat" do
+
+    let(:alt1){ Terminal.new(nil)            }
+    let(:alt2){ Terminal.new(/^[a-z]+$/)     }
+    let(:rule){ Alternative.new [alt1, alt2] }
+
+    it 'returns the subarray when match' do
+      rule.eat(["hello", "world"]).should eq(["world"])
+      rule.eat([nil, "world"]).should eq(["world"])
+    end
+
+    it 'returns nil when no match' do
+      rule.eat([]).should be_nil
+      rule.eat(["12"]).should be_nil
+    end
+
+  end
+end

data/spec/alternative/test_match_q.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Sexpr
+  describe Alternative, "match?" do
+
+    let(:alt1){ Terminal.new(nil)            }
+    let(:alt2){ Terminal.new(/^[a-z]+$/)     }
+    let(:rule){ Alternative.new [alt1, alt2] }
+
+    it 'returns true if one matches' do
+      rule.should be_match("hello")
+      rule.should be_match(nil)
+    end
+
+    it 'returns false on no match' do
+      rule.should_not be_match("12")
+      rule.should_not be_match([])
+    end
+
+  end
+end

data/spec/bool_expr.yml

@@ -0,0 +1,19 @@
+bool_expr:
+  - bool_and
+  - bool_or
+  - bool_not
+  - var_ref
+  - bool_lit
+bool_and:
+  - [ bool_expr+ ]
+bool_or:
+  - [ bool_expr+ ]
+bool_not:
+  - [ bool_expr ]
+var_ref:
+  - [ var_name ]
+var_name:
+  !ruby/regexp /^[a-z]+$/
+bool_lit:
+  - true
+  - false

data/spec/grammar.yml

@@ -0,0 +1,24 @@
+rule:
+  - non_terminal
+  - terminal
+non_terminal:
+  - [ a_rule  ]
+  - [ a_rule+ ]
+  - [ a_rule* ]
+  - [ "a_rule?" ]
+  - [ a_rule, a_rule, a_rule ]
+a_rule:
+  - [ terminal, non_terminal ]
+terminal:
+  - regexp_nt
+  - true_nt
+  - false_nt
+  - nil_nt
+regexp_nt:
+  !ruby/regexp /^[a-z]+$/
+true_nt:
+  true
+false_nt:
+  false
+nil_nt:
+  ~

data/spec/grammar/test_compile_rule.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Sexpr
+  class Grammar; public :compile_rule; end
+  describe Grammar, "compile_rule" do
+
+    def compile(name, arg)
+      Grammar.new.compile_rule(name, arg)
+    end
+
+    it 'keep alternatives unchanged' do
+      compile(:hello, Alternative.new([]) ).should be_a(Alternative)
+    end
+
+    it 'keep terminals unchanged' do
+      compile(:hello, Terminal.new(true) ).should be_a(Terminal)
+    end
+
+    it 'keep creates a Rule englobing sequences' do
+      compiled = compile(:hello, Sequence.new([]) )
+      compiled.should be_a(Rule)
+      compiled.name.should eq(:hello)
+    end
+
+  end
+end

data/spec/grammar/test_compile_rule_defn.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+module Sexpr
+  class Grammar; public :compile_rule_defn; end
+  describe Grammar, "compile_rule_defn" do
+
+    let(:grammar){ Grammar.new }
+    subject{ grammar.compile_rule_defn(arg) }
+
+    context 'with an Element' do
+      let(:arg){ Terminal.new(//) }
+      it 'returns arg itself' do
+        subject.should eq(arg)
+      end
+    end
+
+    context "with true" do
+      let(:arg){ true }
+      it 'gives it true' do
+        subject.should be_a(Terminal)
+        subject.value.should eq(true)
+      end
+    end
+
+    context "with false" do
+      let(:arg){ false }
+      it 'gives it false' do
+        subject.should be_a(Terminal)
+        subject.value.should eq(false)
+      end
+    end
+
+    context "with nil" do
+      let(:arg){ nil }
+      it 'gives it nil' do
+        subject.should be_a(Terminal)
+        subject.value.should eq(nil)
+      end
+    end
+
+    context 'with an alternative array' do
+      let(:arg){ [true, false, nil] }
+      it 'factors an Alternative' do
+        subject.should be_a(Alternative)
+      end
+      it 'compiles its elements' do
+        subject.terms.size.should eq(3)
+        subject.terms.all?{|x| x.is_a?(Terminal)}.should be_true
+      end
+    end
+
+    context 'with a sequence array' do
+      let(:arg){ [[true, false, nil]] }
+      it 'factors a Sequence' do
+        subject.should be_a(Sequence)
+      end
+      it 'compiles its elements' do
+        subject.terms.size.should eq(3)
+        subject.terms.all?{|x| x.is_a?(Terminal)}.should be_true
+      end
+    end
+
+    context 'with subalternatives' do
+      let(:arg){ [ ["a_rule", [false, true, nil] ]] }
+      it 'compiles the last as an Alternative' do
+        subject.terms.last.should be_a(Alternative)
+      end
+    end
+
+    context 'with a reference to a non-terminal' do
+      let(:arg){ "a_rule" }
+      it 'factors a Reference' do
+        subject.should be_a(Reference)
+      end
+      it 'refers to the appropriate rule name' do
+        subject.rule_name.should eq(:a_rule)
+      end
+      it 'refers to the appropriate grammar' do
+        subject.grammar.should eq(grammar)
+      end
+    end
+
+    context 'with a stared non-terminal' do
+      let(:arg){ "a_rule+" }
+      it 'factors a Many' do
+        subject.should be_a(Many)
+      end
+      it 'refers to the appropriate rule' do
+        subject.term.should be_a(Reference)
+        subject.term.rule_name.should eq(:a_rule)
+      end
+      it 'refers to the appropriate multiplicities' do
+        subject.min.should eq(1)
+        subject.max.should be_nil
+      end
+    end
+
+  end
+end