ast_ast 0.1.0 → 0.2.0

data/Rakefile

@@ -1,10 +1,58 @@
 require 'rake'
+require 'rspec/core/rake_task'
 
 require File.expand_path('../lib/ast_ast/version', __FILE__)
 
+desc "Run rspec"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :publish => ['release:pre', 'release:build', 'release:push']
+
+
+# Tag stuff is partially from `gem this`, I would use it but don't
+# think it fits what I need. Nor would I write my own, there
+# are way too many different tools for this sort of thing.
 namespace :release do
+
+  desc 'Last minute checks before pushing'
+  task :pre => [:spec] do
+    require 'highline/import'
+    ok = ask "OK to publish (y/n): "
+    if ok.strip != "y"
+      exit 0
+    end
+    
+    tag = ask "Create tag for ast_ast v#{Ast::VERSION} (y/n): "
+    if tag.strip == "y"
+      Rake::Task['release:tag'].invoke
+    end
+  end
+  
+  desc 'Tag vX.X.X'
   task :tag do
-    system("git tag v#{Ast::VERSION}")
-    system('git push origin --tags')
+    if `git diff --cached`.empty?
+      if `git tag`.split("\n").include?("v#{Ast::VERSION}")
+        raise "Version #{Ast::VERSION} has already been tagged"
+      end
+      system "git tag v#{Ast::VERSION}"
+      system 'git push origin --tags'
+    else
+      raise "Unstaged changes still waiting to be commited"
+    end
+  end
+  
+  desc 'Build gemspec'
+  task :build do
+    system "gem build ast_ast.gemspec"
+    system "mkdir -p pkg"
+    system "mv ast_ast-#{Ast::VERSION}.gem pkg/ast_ast-#{Ast::VERSION}.gem"
+  end
+  
+  desc 'Push to RubyGems'
+  task :push do
+    system "gem push pkg/ast_ast-#{Ast::VERSION}.gem"
   end
 end

data/lib/ast_ast/bnf.rb

@@ -1,4 +1,5 @@
 $: << File.dirname(__FILE__)
+require 'tokens'
 require 'token'
 
 module Ast

data/lib/ast_ast/tokeniser.rb

@@ -3,7 +3,7 @@ module Ast
   class Tokeniser
     
     class Rule  
-      attr_accessor :name, :regex, :block
+      attr_accessor :name, :regex, :proc
       
       # Creates a new Rule instance
       # 
@@ -11,13 +11,13 @@ module Ast
       #   Name of the token to be created.
       # @param regex [Regexp] 
       #    Regular expression to be matched
-      # @param block [Proc]  
-      #    Optional block to be executed with match(es)
+      # @param proc [Proc]  
+      #    Optional proc to be executed with match(es)
       #
-      def initialize(name, regex, &block)
+      def initialize(name, regex, proc=nil, &block)
         @name = name
         @regex = regex
-        @block = block || Proc.new {|i| i}
+        @proc = proc || block
       end
       
       # Runs the block that was given using either, the full match if there
@@ -56,7 +56,7 @@ module Ast
         val = arr unless arr.empty?
         val = arr[0] if arr.size == 1
         val = arr[0] if arr[0] == arr[1] # this happens with /(a|b|c)/ regexs
-        @block.call val
+        @proc.call val
       end
     end
     
@@ -69,8 +69,24 @@ module Ast
     def self.rule(name, regex, &block)
       @rules ||= []
       # make rules with same name overwrite first rule
-      @rules.delete_if {|i| i.name == name} 
-      @rules << Rule.new(name, regex, &block)
+      @rules.delete_if {|i| i.name == name}
+      
+      # Create default block which just returns a value
+      block ||= Proc.new {|i| i}
+      # Make sure to return a token
+      proc = Proc.new {|_i| 
+        block_result = block.call(_i)
+        if block_result.is_a? Array
+          r = []
+          block_result.each do |j|
+            r << Ast::Token.new(name, j)
+          end
+          r
+        else
+          Ast::Token.new(name, block_result) 
+        end
+      }
+      @rules << Rule.new(name, regex, proc)
     end
     
     # @return [Array]
@@ -78,6 +94,26 @@ module Ast
     #
     def self.rules; @rules; end
     
+    # Creates a new token rule, that is the block returns an Ast::Token instance.
+    # 
+    # @example
+    #  
+    #   keywords = ['def', 'next', 'while', 'end']
+    #
+    #   token /[a-z]+/ do |i|
+    #     if keywords.include?(i)
+    #       Ast::Token.new(:keyword, i)
+    #     else
+    #       Ast::Token.new(:word, i)
+    #   end
+    #
+    # @param regex [Regexp]
+    #
+    def self.token(regex, &block)
+      @rules ||= []
+      @rules << Rule.new(nil, regex, block)
+    end
+    
     # Takes the input and uses the rules that were created to scan it.
     #
     # @param [String] 
@@ -98,9 +134,11 @@ module Ast
             ran = i.run(a)
             # split array into separate tokens, *not* values
             if ran.is_a? Array
-              ran.each {|a| result << [i.name, a]}
+              #ran.each {|a| result << [i.name, a]}
+              ran.each {|a| result << a }
             else
-              result << [i.name, ran]
+              #result << [i.name, ran]
+              result << ran
             end
           end
         end

data/lib/ast_ast/version.rb

@@ -1,3 +1,3 @@
 module Ast
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/ast_ast/tokeniser_spec.rb

@@ -11,15 +11,6 @@ describe Ast::Tokeniser::Rule do
     specify { subject.regex.should be_kind_of Regexp }
   end
   
-  describe "#block" do
-    specify { subject.block.should be_kind_of Proc }
-    context "when no block is given" do
-      it "use default proc which returns argument" do
-        subject.block.call(1).should == 1
-      end
-    end
-  end
-  
   describe "#run" do
     
     context "when returning a string" do
@@ -59,9 +50,30 @@ describe Ast::Tokeniser do
     end
   end
   
+  describe ".token" do
+    
+    class KlassToken < Ast::Tokeniser
+      token /[a-z]+/ do |i|
+        if i.include? "a"
+          Ast::Token.new(:a_tok, i)
+        else
+          Ast::Token.new(:not_a, i)
+        end
+      end
+    end
+    
+    it "adds a new rule to list" do
+      KlassToken.rules.map {|i| i.regex}.should include /[a-z]+/
+    end
+    
+  end
+  
   describe ".tokenise" do
   
     class Klass2 < Ast::Tokeniser
+      
+      commands = %w(git commit status)
+    
       rule :long, /--([a-zA-Z0-9]+)/ do |i| 
         i[1]
       end
@@ -70,14 +82,21 @@ describe Ast::Tokeniser do
         i[1].split('')
       end
       
-      rule :word, /[a-zA-Z0-9]+/
+      token /[a-zA-Z0-9]+/ do |i|
+        if commands.include?(i)
+          Ast::Token.new(:command, i)
+        else
+          Ast::Token.new(:word, i)
+        end
+      end
+      
     end
     
     specify { Klass2.tokenise("").should be_kind_of Ast::Tokens }
     
     it "retuns the correct tokens" do
-      r = Klass2.tokenise("--along -sh aword")
-      r.to_a.should == [[:long, "along"], [:short, "s"], [:short, "h"], [:word, "aword"]]
+      r = Klass2.tokenise("git --along -sh aword")
+      r.to_a.should == [[:command, "git"], [:long, "along"], [:short, "s"], [:short, "h"], [:word, "aword"]]
     end
     
     it "runs example in Readme" do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Joshua Hawxwell
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-29 00:00:00 +00:00
+date: 2010-12-07 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency