swissparser 0.11.1 → 1.0.0

data/examples/uniprot_param_demo.rb

@@ -1,85 +0,0 @@
-=begin
-Copyright (C) 2009 Paradigmatic
-
-This file is part of SwissParser.
-
-SwissParser is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-SwissParser is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
-#!/usr/bin/ruby -w
-
-require 'yaml'
-require 'swissparser.rb'
-
-class Protein
-
-  attr_accessor :id, :size, :species, :taxonomy, :sequence
-
-  def initialize
-    @taxonomy = []
-    @sequence = ""
-  end
-
-end
-
-
-uniprot_parser = Swiss::Parser.define do
-
-  new_entry do
-    puts param(:msg)
-    Protein.new
-  end
-
-  rules do 
-
-    with("ID") do |content,protein|
-      content =~ /([A-Z]\w+)\D+(\d+)/
-      protein.id = $1
-      protein.size = $2.to_i
-    end
-    
-    with("OS") do |content,protein|
-      content =~ /(\w+ \w+)/
-      protein.species = $1
-    end
-    
-    with("OC") do |content,protein|
-      ary = content.gsub(".","").split("; ")
-      protein.taxonomy += ary
-    end
-    
-    with_text_after("SQ") do |content,protein|
-      puts param(:found_seq)
-      seq = content.strip.gsub(" ","")
-      protein.sequence += seq
-    end
-
-  end
-
-end
-
-
-if $0 == __FILE__
-
-  filename = ARGV.shift
-
-  entries = uniprot_parser.parse_file( filename, :msg => "Hello", :found_seq => "Youpie" )
-
-  puts entries.size
-
-  entries.each do |e|
-    puts e.to_yaml
-  end
-
-end

data/features/parser_extension.feature

@@ -1,83 +0,0 @@
-Feature: Parser Extension
-  I can extend existing parser
-  And replace existing rules
-
-  Background:
-   Given input data 
-     """
-     XX a1
-     YY b1
-     c1
-     //
-     XX a1
-     YY b2
-     c2
-     //
-     """
- 
-  Scenario: Extension without redefinition
-    Given a simple parser
-    When I extend it
-    Then the extended parser should parse it as the original one
-
-  Scenario: With replacing separator
-    Given a simple parser
-    When I extend it
-      And I replace with("XX") to return always 'foo'
-      And I replace with("YY") to do nothing
-      And I run the extended parser on data
-    Then the result should be "[{ 'XX' => 'foo'}, { 'XX' => 'foo'}]"   
- 
-  Scenario: Text after replacing
-    Given a simple parser
-    When I extend it
-      And I replace with("XX") to do nothing
-      And I replace with("YY") to return always 'bar'
-      And I replace with_text_after("YY") to return always 'foo'
-      And I run the extended parser on data
-    Then the result should be "[{ 'YY' => 'bar', 'txt-YY' => 'foo'}, { 'YY' => 'bar', 'txt-YY' => 'foo'}]" 
-
-  Scenario: Separator replacement
-    Given a simple parser
-      And input data 
-        """
-        XX a1
-        YY b1
-        c1
-        %
-        XX a1
-        YY b2
-        c2
-        %
-        """
-     When I extend it
-       And I set the separator to '%'
-       And I run the extended parser on data
-     Then the result should contain '2' entries
-
-  Scenario: Using custom entries objects
-    Given a simple parser
-    When I extend it
-      And I replace with("XX") to do nothing
-      And I replace with("YY") to do nothing
-      And I return "foo" in new entry
-      And I run the extended parser on data
-    Then the result should be "['foo','foo']"
-
-  Scenario: Changing the container
-    Given a simple parser
-    When I extend it
-      And I replace the container with a counter
-      And I run the extended parser on data
-    Then the result should be "2"
-
-  Scenario: Changing the entry finalization
-    Given a simple parser
-    When I extend it
-      And entry finalize always returns "foo"
-      And I run the extended parser on data
-    Then the result should be "['foo', 'foo']"
-
-
-
-      

data/features/parsing_context.feature

@@ -1,48 +0,0 @@
-Feature: Sharing context
-  During parsing, rules share a context object.
-
-  Background:
-   Given input data 
-     """
-     XX a1
-     YY b1
-     c1
-     //
-     XX a2
-     YY b2
-     c2
-     //
-     """
- 
-  Scenario: Helper Method
-    Given a simple parser
-    When I extend it
-      And I define 'foo' helper
-      And I call 'foo' helper in after action
-      And I run the extended parser on data
-    Then the result should be "'foo'"
-
-  Scenario: Parsing Parameters
-    Given a simple parser
-    When I extend it
-      And I return param "foo" in after action
-      And I run the extended parser on data with param "foo" = "bar"
-    Then the result should be "'bar'"
-
-  Scenario: Instance variables
-    Given a simple parser
-    When I extend it
-      And the before action sets @foo="bar"
-      And the after action returns @foo
-      And I run the extended parser on data
-    Then the result should be "'bar'"
-
-  Scenario: Skipping entries
-    Given a simple parser
-    When I extend it
-      And I set it to skip entries with("XX") containing "a1"
-      And I run the extended parser on data
-    Then the result should contain '1' entries
-
-
-

data/features/polite.feature

@@ -1,16 +0,0 @@
-Feature: Politeness
-  SwissParser is polite and reporst errors
-
-Scenario: Missing
-  Given input data 
-    """
-    XX a1
-    YY b1
-    c1
-    //
-    XX a2
-    YY b2
-    c2
-    """
-    And a simple parser
-  Then the simple parser should raise an error when parsing data

data/features/step_definitions/core.rb

@@ -1,71 +0,0 @@
-require 'lib/swissparser'
-require 'spec/expectations'
-require 'spec/mocks'
-
-
-Given /^a simple parser$/ do
-  @simple_parser = Swiss::Parser.define do
-    rules do
-      with("XX") {|c,e| e["XX"] = c}
-      with("YY") {|c,e| e["YY"] = c}
-    end
-  end
-end
-
-Given /^input data$/ do |string|
-  @data = string
-end
-
-When /^I extend it$/ do
-  @ext_parser = @simple_parser.extend {}
-end
-
-When /^I run the simple parser on data$/ do
-  @result = @simple_parser.parse(@data)
-end
-
-
-When /^I run the extended parser on data$/ do
-  @result = @ext_parser.parse(@data)
-end
-
-When /^I run the extended parser on data with param "([^\"]*)" = "([^\"]*)"$/ do |key, val|
-   @result = @ext_parser.parse(@data, key => val)
-end
-
-
-When /^I run it on file "([^\"]*)"$/ do |filename|
-  File.stub!(:open).and_return(@data)
-  @result = @simple_parser.parse_file( filename )
-end
-
-
-When /^I run it on a remote file "([^\"]*)"$/ do |arg1|
-  OpenURI.stub!(:open).and_return(@data)
-end
-
-Then /^the extended parser should parse it as the original one$/ do
-  @simple_parser.parse( @data ).should == @ext_parser.parse( @data )
-end
-
-Then /^the result should be "([^\"]*)"$/ do |ruby_exp|
-  result = eval(ruby_exp)
-  @result.should == result
-end
-
-Then /^the result should contain '([^\']*)' entries$/ do |n|
-  @result.size.should == n.to_i
-end
-
-
-Then /^File\.open should be called with "([^\"]*)"$/ do |filename|
-  File.should_receive(:open).with(filename,'w')
-end
-
-Then /^OpenUri\.open should be called with "([^\"]*)"$/ do |filename|
-  OpenURI.should_receive(:open).with(filename)  
-end
-
-Then /^the simple parser should raise an error when parsing data$/ do
-  lambda{@simple_parser.parse(@data)}.should raise_error
-end

data/features/step_definitions/definitions.rb

@@ -1,68 +0,0 @@
-require 'lib/swissparser'
-require 'spec/expectations'
-
-When /^I replace with\("([^\"]*)"\) to return always '([^\']*)'$/ do |key,out|
-  @ext_parser = @ext_parser.extend do
-    rules do
-      with( key ) {|c,e| e[key] = out }
-    end
-  end
-end
-
-When /^I replace with\("([^\"]*)"\) to do nothing$/ do |key|
-  @ext_parser = @ext_parser.extend do 
-    rules do
-      with( key ) {|c,e| }
-    end
-  end
-end
-
-When /^I replace with_text_after\("([^\"]*)"\) to return always '([^\']*)'$/ do |key,out|
-  text_key = "txt-#{key}"
-  @ext_parser = @ext_parser.extend do 
-    rules do
-      with_text_after( key ) {|c,e| e[text_key] = out }
-    end
-  end
-end
-
-When /^I set the separator to '([^\']*)'$/ do |sep|
-  @ext_parser = @ext_parser.extend do 
-    rules do
-      set_separator( sep )
-    end
-  end
-end
-
-When /^I return "([^\"]*)" in new entry$/ do |value|
-  @ext_parser = @ext_parser.extend do
-    new_entry { value }
-  end
-end
-
-When /^I replace the container with a counter$/ do
-  class Counter
-    def initialize
-      @n = 0
-    end
-    def <<(i)
-      @n += 1
-    end
-    def count
-      @n
-    end
-  end
-  @ext_parser = @ext_parser.extend do
-    before { Counter.new }
-    after {|c| c.count }
-  end 
-end
-
-When /^entry finalize always returns "([^\"]*)"$/ do |val|
-   @ext_parser = @ext_parser.extend do
-    finish_entry {|e,c| c << val }
-  end 
-end
-
-
-

data/features/step_definitions/extra.rb

@@ -1,56 +0,0 @@
-require 'lib/swissparser'
-require 'spec/expectations'
-
-When /^I define '([^\']*)' helper$/ do |name|
-  @ext_parser = @ext_parser.extend do 
-    helper(name.to_sym) do
-      name
-    end
-  end
-end
-
-When /^I call '([^\']*)' helper in after action$/ do |name|
-  l = eval("lambda { |x| #{name} }")
-  @ext_parser = @ext_parser.extend do 
-    after(&l)
-  end
-end
-
-When /^I return param "([^\"]*)" in after action$/ do |name|
-  l = eval("lambda { |x| param(#{name}) }")
-  @ext_parser = @ext_parser.extend do 
-    after(&l)
-  end
-
-end
-
-When /^the before action sets @foo="([^\"]*)"$/ do |val|
-   @ext_parser = @ext_parser.extend do 
-    before { @foo=val; [] }
-  end 
-end
-
-When /^the after action returns @foo$/ do
-  @ext_parser = @ext_parser.extend do 
-    after { @foo }
-  end 
-end
-
-When /^set with\("([^\"]*)"\) to skip the entry$/ do |key|
-  
-end
-
-
-
-
-When /^I set it to skip entries with\("([^\"]*)"\) containing "([^\"]*)"$/ do |key, val|
- @ext_parser = @ext_parser.extend do 
-    rules do
-      with(key) do |c,e|
-        if c.include?(val)
-          skip_entry!
-        end
-      end
-    end
-  end
-end

data/lib/swiss_parser.rb

@@ -1,13 +0,0 @@
-Msg = <<HERE
-
-=====================================================
-Since version 0.7, SwissParser is now required with:
-
-  require 'swissparser'
-
-Please update your code.
-=====================================================
-HERE
-
-
-fail(Msg)