ruby_scribe 0.0.4 → 0.1.0

data/lib/ruby_scribe/sexp_helpers.rb

@@ -0,0 +1,285 @@
+module RubyScribe
+  
+  # Various helpers for matching and constructing S-expressions without having to deal with 
+  # array soup
+  module SexpHelpers
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def module!(name, body = nil)
+        s(:module, generate_module_or_class_name(name), ensure_scope_wrapped(body))
+      end
+      
+      def class!(name, extends = nil, body = nil)
+        s(:class, generate_module_or_class_name(name), generate_class_extend_from(extends), ensure_scope_wrapped(body))
+      end
+      
+      def method!(name, arguments = nil, body = nil)
+        s(:defn, name.to_sym, method_args!(arguments), method_body!(body))
+      end
+      
+      def method_on!(on, name, arguments = nil, body = nil)
+        s(:defs, on, name.to_sym, method_args!(arguments), method_body!(body))
+      end
+      
+      def method_args!(arguments = nil)
+        arguments ||= []
+        options = arguments.extract_options!
+        
+        s(*([:args] + arguments.map(&:to_sym))).tap do |args|
+          args.push s(*([:block] + options.map {|k, v| s(:lasgn, k.to_sym, v) })) if options && !options.empty?
+        end
+      end
+      
+      def method_body!(body = nil)
+        if body.is_a?(Sexp) && body.kind == :scope
+          body
+        elsif body.is_a?(Sexp) && body.kind == :block
+          ensure_scope_wrapped(body)
+        elsif body.is_a?(Sexp)
+          method_body!(s(:block, body))
+        elsif body.is_a?(Array)
+          method_body!(s(*([:block] + body)))
+        else
+          method_body!(s(:block, s(:nil)))
+        end
+      end
+      
+      def call!(name, arguments = nil, body = nil)
+        call_on!(nil, name.to_sym, arguments, body)
+      end
+      
+      def call_on!(receiver, name, arguments = nil, body = nil)
+        s(:call, receiver, name.to_sym, call_args!(arguments))
+      end
+      
+      def call_args!(arguments = nil)
+        arguments ||= []
+        
+        if arguments.is_a?(Sexp) && arguments.kind == :arglist
+          arguments
+        elsif arguments.is_a?(Sexp)
+          s(:arglist, arguments)
+        elsif arguments.is_a?(Array)
+          s(*([:arglist] + arguments))
+        else
+          s(:arglist)
+        end
+      end
+      
+      
+      protected
+      
+      def generate_module_or_class_name(name)
+        if name.nil?
+          nil
+        elsif name.is_a?(Sexp) or name.is_a?(Symbol)
+          name
+        elsif name.to_s !~ /::/
+          name.to_sym
+        else
+          RubyParser.new.parse(name)
+        end
+      end
+      
+      def generate_class_extend_from(name)
+        if name.nil?
+          nil
+        elsif name.is_a?(Sexp) or name.is_a?(Symbol)
+          name
+        else
+          RubyParser.new.parse(name)
+        end
+      end
+      
+      def ensure_scope_wrapped(sexp)
+        if sexp.is_a?(Sexp) && sexp.kind == :scope
+          sexp
+        elsif sexp.nil?
+          s(:scope)
+        else
+          s(:scope, sexp)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      def kind
+        sexp_type.to_sym
+      end
+      
+      def body
+        sexp_body
+      end
+      
+      def name
+        case kind
+        when :call
+          body[1]
+        when :lasgn, :iasgn, :class, :module
+          body[0]
+        when :iter
+          body[0].name
+        else
+          nil
+        end
+      end
+      
+      def receiver
+        case kind
+        when :call
+          body[0]
+        else
+          nil
+        end
+      end
+      
+      def arguments
+        case kind
+        when :call, :defs
+          body[2]
+        when :defn, :iter
+          body[1]
+        else
+          nil
+        end
+      end
+      
+      def to_args
+        emit_as_args_array(arguments)
+      end
+      
+      def block
+        case kind
+        when :defn
+          strip_scope_wrapper(body[2])
+        when :defs
+          strip_scope_wrapper(body[3])
+        when :class
+          strip_scope_wrapper(body[2])
+        when :module
+          strip_scope_wrapper(body[1])
+        else
+          nil
+        end
+      end
+      
+      def call!(name, arguments = nil, body = nil)
+        Sexp.call_on!(self, name, arguments, body)
+      end
+      
+      def module?(name = nil)
+        kind == :module && 
+        (name.nil? || match_expression(body[0], name))
+      end
+      
+      def class?(name = nil, options = {})
+        kind == :class && 
+        (name.nil? || match_expression(body[0], name))
+      end
+      
+      def method?(name = nil)
+        (kind == :defn && (name.nil? || match_expression(body[0], name))) || 
+        (kind == :defs && (name.nil? || match_expression(body[1], name)))
+      end
+      
+      def call?(name = nil, options = {})
+        call_without_block?(name, options) || call_with_block?(name, options)
+      end
+      
+      def call_without_block?(name = nil, options = {})
+        kind == :call && 
+        (name.nil? || match_expression(body[1], name)) &&
+        (options[:arguments].nil? || match_arguments_expression(self, options[:arguments])) &&
+        (!options[:block])
+      end
+      
+      def call_with_block?(name = nil, options = {})
+        kind == :iter && body[0] && body[0].kind == :call &&
+        (name.nil? || match_expression(body[0].name, name)) &&
+        (options[:arguments].nil? || match_arguments_expression(body[0], options[:arguments])) &&
+        (options[:block].nil? || match_arguments_expression(self, options[:block]))
+      end
+      
+      def rescue?
+        kind == :rescue
+      end
+      
+      def conditional?(options = {})
+        kind == :if && 
+        (options[:type].nil? || match_conditional_type(self, options[:type]))
+      end
+      
+      def case?
+        kind == :case
+      end
+      
+      
+      protected
+      
+      def emit_as_args_array(e)
+        return e unless e.is_a?(Sexp)
+        
+        case e.kind
+        when :arglist, :args
+          e.body.map {|c| emit_as_args_array(c) }.flatten
+        when :lasgn
+          [e.body[0]]
+        when :masgn
+          e.body[0].body.map {|c| emit_as_args_array(c) }.flatten
+        when :lit
+          [e.body[0]]
+        else
+          [e]
+        end
+      end
+      
+      def match_expression(match_against, expression)
+        case expression
+        when String
+          match_against.to_s == expression
+        when Regexp
+          match_against.to_s =~ expression
+        when Array
+          expression.map(&:to_s).include?(match_against.to_s)
+        else
+          false
+        end
+      end
+      
+      def match_arguments_expression(match_against, expression)
+        case expression
+        when Fixnum
+          expression == match_against.to_args.size
+        when Range
+          expression.include?(match_against.to_args.size)
+        when Array
+          expression == match_against.to_args
+        when TrueClass
+          match_against.to_args.size > 0
+        when FalseClass
+          match_against.to_args.size == 0
+        else
+          false
+        end
+      end
+      
+      def match_conditional_type(match_against, expression)
+        case expression
+        when :if
+          !match_against.body[1].nil? && match_against.body[2].nil?
+        when :unless
+          match_against.body[1].nil? && !match_against.body[2].nil?
+        when :if_else
+          !match_against.body[1].nil? && !match_against.body[2].nil?
+        else
+          false
+        end
+      end
+      
+      def strip_scope_wrapper(e)
+        e.kind == :scope ? strip_scope_wrapper(e.body[0]) : e
+      end
+    end
+  end
+end

data/lib/ruby_scribe/version.rb

@@ -1,3 +1,3 @@
 module RubyScribe
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/lib/ruby_scribe.rb

@@ -2,7 +2,9 @@ require "rubygems"
 require "active_support"
 require "ruby_parser"
 
+require "ruby_scribe/sexp_helpers"
 require "ruby_scribe/emitter_helpers"
+require "ruby_scribe/emitter_config"
 require "ruby_scribe/emitter"
 require "ruby_scribe/transformer_helpers"
 require "ruby_scribe/transformer"

data/spec/ruby_scribe/sexp_helpers_spec.rb

@@ -0,0 +1,256 @@
+require "spec_helper"
+
+describe RubyScribe::SexpHelpers do
+  context "generating" do
+    context "module" do
+      describe "with string name" do
+        subject { Sexp.module!("MyModule") }
+        it { should == s(:module, :MyModule, s(:scope)) }
+      end
+      
+      describe "with string colonized name" do
+        subject { Sexp.module!("Namespace::MyModule") }
+        it { should == s(:module, s(:colon2, s(:const, :Namespace), :MyModule), s(:scope)) }
+      end
+      
+      describe "with string double-colonized name" do
+        subject { Sexp.module!("Double::Namespace::MyModule") }
+        it { should == s(:module, s(:colon2, s(:colon2, s(:const, :Double), :Namespace), :MyModule), s(:scope)) }
+      end
+      
+      describe "with sexp name" do
+        subject { Sexp.module!(s(:colon2, s(:const, :Namespace), :MyModule)) }
+        it { should == s(:module, s(:colon2, s(:const, :Namespace), :MyModule), s(:scope)) }
+      end
+      
+      describe "with single-statement body passed" do
+        subject { Sexp.module!("MyModule", s(:lit, 1)) }
+        it { should == s(:module, :MyModule, s(:scope, s(:lit, 1))) }
+      end
+      
+      describe "with single-statement scoped body passed" do
+        subject { Sexp.module!("MyModule", s(:scope, s(:lit, 1))) }
+        it { should == s(:module, :MyModule, s(:scope, s(:lit, 1))) }
+      end
+      
+      describe "with block body passed" do
+        subject { Sexp.module!("MyModule", s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist)))) }
+        it { should == s(:module, :MyModule, s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+        specify { subject.block.should == s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))) }
+      end
+    end
+    
+    context "class" do
+      describe "with string name" do
+        subject { Sexp.class!("MyClass") }
+        it { should == s(:class, :MyClass, nil, s(:scope)) }
+      end
+      
+      describe "with string colonized name" do
+        subject { Sexp.class!("Namespace::MyClass") }
+        it { should == s(:class, s(:colon2, s(:const, :Namespace), :MyClass), nil, s(:scope)) }
+      end
+      
+      describe "with string double-colonized name" do
+        subject { Sexp.class!("Double::Namespace::MyClass") }
+        it { should == s(:class, s(:colon2, s(:colon2, s(:const, :Double), :Namespace), :MyClass), nil, s(:scope)) }
+      end
+      
+      describe "with sexp name" do
+        subject { Sexp.class!(s(:colon2, s(:const, :Namespace), :MyClass)) }
+        it { should == s(:class, s(:colon2, s(:const, :Namespace), :MyClass), nil, s(:scope)) }
+      end
+      
+      describe "with single-statement body passed" do
+        subject { Sexp.class!("MyClass", nil, s(:lit, 1)) }
+        it { should == s(:class, :MyClass, nil, s(:scope, s(:lit, 1))) }
+      end
+      
+      describe "with single-statement scoped body passed" do
+        subject { Sexp.class!("MyClass", nil, s(:scope, s(:lit, 1))) }
+        it { should == s(:class, :MyClass, nil, s(:scope, s(:lit, 1))) }
+      end
+      
+      describe "with block body passed" do
+        subject { Sexp.class!("MyClass", nil, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist)))) }
+        it { should == s(:class, :MyClass, nil, s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+        specify { subject.block.should == s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))) }
+      end
+      
+      describe "extending a string name" do
+        subject { Sexp.class!("MyClass", "Base") }
+        it { should == s(:class, :MyClass, s(:const, :Base), s(:scope)) }
+      end
+      
+      describe "extending a colonized string name" do
+        subject { Sexp.class!("MyClass", "Base::Two") }
+        it { should == s(:class, :MyClass, s(:colon2, s(:const, :Base), :Two), s(:scope)) }
+      end
+      
+      describe "extending an sexp name" do
+        subject { Sexp.class!("MyClass", s(:const, :Base)) }
+        it { should == s(:class, :MyClass, s(:const, :Base), s(:scope)) }
+      end
+    end
+    
+    context "method" do
+      describe "blank method" do
+        subject { Sexp.method!("my_method") }
+        it { should == s(:defn, :my_method, s(:args), s(:scope, s(:block, s(:nil)))) }
+      end
+
+      describe "method with arguments" do
+        subject { Sexp.method!("my_method", [:arg1, :arg2]) }
+        it { should == s(:defn, :my_method, s(:args, :arg1, :arg2), s(:scope, s(:block, s(:nil)))) }
+      end
+      
+      describe "method with argument default" do
+        subject { Sexp.method!("my_method", [:arg1, :arg2, {:arg2 => s(:lit,  1)}]) }
+        it { should == s(:defn, :my_method, s(:args, :arg1, :arg2, s(:block, s(:lasgn, :arg2, s(:lit, 1)))), s(:scope, s(:block, s(:nil)))) }
+      end
+      
+      describe "method with single-statement body" do
+        subject { Sexp.method!("my_method", [], s(:lit, 1)) }
+        it { should == s(:defn, :my_method, s(:args), s(:scope, s(:block, s(:lit, 1)))) }
+      end
+      
+      describe "method with multiple-statement body as sexp" do
+        subject { Sexp.method!("my_method", [], s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist)))) }
+        it { should == s(:defn, :my_method, s(:args), s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+      end
+      
+      describe "method with multiple-statement body including scope" do
+        subject { Sexp.method!("my_method", [], s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+        it { should == s(:defn, :my_method, s(:args), s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+      end
+      
+      describe "method with multiple-statement body as array" do
+        subject { Sexp.method!("my_method", [], [s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))]) }
+        it { should == s(:defn, :my_method, s(:args), s(:scope, s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))))) }
+        specify { subject.block.should == s(:block, s(:call, nil, :one, s(:arglist)), s(:call, nil, :two, s(:arglist))) }
+      end
+    end
+    
+    context "method call" do
+      describe "without arguments" do
+        subject { Sexp.call!("my_method") }
+        it { should == s(:call, nil, :my_method, s(:arglist)) }
+      end
+      
+      describe "with arguments as sexp" do
+        subject { Sexp.call!("my_method", s(:arglist, s(:lit, 1), s(:lit, 2))) }
+        it { should == s(:call, nil, :my_method, s(:arglist, s(:lit, 1), s(:lit, 2))) }
+      end
+      
+      describe "with arguments as array" do
+        subject { Sexp.call!("my_method", [s(:lit, 1), s(:lit, 2)]) }
+        it { should == s(:call, nil, :my_method, s(:arglist, s(:lit, 1), s(:lit, 2))) }
+      end
+      
+      describe "with explicit self" do
+        subject { s(:self).call!("my_method") }
+        it { should == s(:call, s(:self), :my_method, s(:arglist)) }
+      end
+      
+      describe "with receiver" do
+        subject { s(:lit, 1).call!("my_method") }
+        it { should == s(:call, s(:lit, 1), :my_method, s(:arglist)) }
+      end
+    end
+  end
+  
+  context "an s-expression for" do
+    context "module" do
+      subject { s(:module, :MyModule, s(:scope, s(:lit, 1))) }
+      it { should be_module }
+      it { should be_module("MyModule") }
+      it { should be_module(/dul/) }
+      it { should be_module([:MyModule, :YourModule]) }
+    end
+    
+    context "class" do
+      subject { s(:class, :MyClass, nil, s(:scope, s(:lit, 1))) }
+      it { should be_class }
+      it { should be_class("MyClass") }
+      it { should be_class(/las/) }
+      it { should be_class([:MyClass, :YourClass]) }
+    end
+    
+    context "instance method" do
+      subject { s(:defn, :my_method, s(:args, :arg), s(:scope, s(:block, s(:lit, 1)))) }
+      it { should be_method }
+      it { should be_method("my_method") }
+      it { should be_method(/met/) }
+      it { should be_method([:my_method, :your_method]) }
+      specify { subject.to_args.should == [:arg] }
+      
+      describe "with two arguments" do
+        subject { s(:defn, :my_method, s(:args, :one, :two), s(:scope, s(:block, s(:lit, 1)))) }
+        specify { subject.to_args.should == [:one, :two] }
+      end
+    end
+    
+    context "class method" do
+      subject { s(:defs, s(:self), :my_method, s(:args, :arg), s(:scope, s(:block, s(:lit, 1)))) }
+      it { should be_method }
+      it { should be_method("my_method") }
+      it { should be_method(/met/) }
+      it { should be_method([:my_method, :your_method]) }
+    end
+    
+    context "method call" do
+      describe "with one argument" do
+        subject { s(:call, nil, :invoke, s(:arglist, s(:lit, 1))) }
+        it { should be_call }
+        it { should be_call("invoke") }
+        it { should be_call(/vok/) }
+        it { should be_call([:invoke, :another]) }
+        it { should be_call("invoke", :arguments => true) }
+        it { should be_call("invoke", :arguments => 1) }
+        it { should_not be_call("invoke", :arguments => 2) }
+        it { should_not be_call("invoke", :block => true) }
+      end
+      
+      describe "with block" do
+        subject { s(:iter, s(:call, nil, :each, s(:arglist)), s(:lasgn, :i), s(:lit, 1)) }
+        it { should be_call }
+        it { should be_call("each") }
+        it { should be_call("each", :block => true) }
+        it { should be_call("each", :block => 1) }
+        it { should_not be_call("each", :block => 2) }
+        specify { subject.to_args.should == [:i] }
+      end
+      
+      describe "with block (2 arguments) and 1 method argument" do
+        subject { s(:iter, s(:call, nil, :inject, s(:arglist, s(:lit, 1))), s(:masgn, s(:array, s(:lasgn, :b), s(:lasgn, :i))), s(:lit, 1)) }
+        it { should be_call(nil, :block => true) }
+        it { should be_call(nil, :arguments => true) }
+        it { should be_call(nil, :arguments => 1, :block => 2) }
+        it { should_not be_call(nil, :arguments => 2, :block => 2) }
+        specify { subject.to_args.should == [:b, :i] }
+      end
+    end
+    
+    context "conditional" do
+      describe "if-else" do
+        subject { s(:if, s(:true), s(:lit, 1), s(:lit, 2)) }
+        it { should be_conditional(:type => :if_else) }
+      end
+      
+      describe "if" do
+        subject { s(:if, s(:true), s(:lit, 1), nil) }
+        it { should be_conditional(:type => :if) }
+      end
+      
+      describe "unless" do
+        subject { s(:if, s(:true), nil, s(:lit, 2)) }
+        it { should be_conditional(:type => :unless) }
+      end
+    end
+    
+    context "case statement" do
+      subject { s(:case, nil, s(:when, s(:array, s(:true)), s(:lit, 1)), s(:lit, 2)) }
+      it { should be_case }
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby_scribe
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Ben Hughes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-28 00:00:00 +03:00
+date: 2010-11-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -74,16 +74,11 @@ extra_rdoc_files: []
 
 files: 
 - lib/ruby_scribe/emitter.rb
+- lib/ruby_scribe/emitter_config.rb
 - lib/ruby_scribe/emitter_helpers.rb
 - lib/ruby_scribe/ext/sexp.rb
 - lib/ruby_scribe/runner.rb
-- lib/ruby_scribe/transformer.rb
-- lib/ruby_scribe/transformer_helpers.rb
-- lib/ruby_scribe/transformers/block_method_to_procifier.rb
-- lib/ruby_scribe/transformers/custom.rb
-- lib/ruby_scribe/transformers/eachifier.rb
-- lib/ruby_scribe/transformers/symbol_names.rb
-- lib/ruby_scribe/transformers/tapifier.rb
+- lib/ruby_scribe/sexp_helpers.rb
 - lib/ruby_scribe/version.rb
 - lib/ruby_scribe.rb
 - spec/examples/identity.rb
@@ -93,12 +88,7 @@ files:
 - spec/matchers/should_transform_to.rb
 - spec/ruby_scribe/emitter_examples_spec.rb
 - spec/ruby_scribe/emitter_spec.rb
-- spec/ruby_scribe/transformer_spec.rb
-- spec/ruby_scribe/transformers/block_method_to_procifier_spec.rb
-- spec/ruby_scribe/transformers/custom_spec.rb
-- spec/ruby_scribe/transformers/eachifier_spec.rb
-- spec/ruby_scribe/transformers/symbol_names_spec.rb
-- spec/ruby_scribe/transformers/tapifier_spec.rb
+- spec/ruby_scribe/sexp_helpers_spec.rb
 - spec/spec_helper.rb
 - LICENSE
 - Rakefile

data/lib/ruby_scribe/transformer.rb

@@ -1,18 +0,0 @@
-module RubyScribe
-  
-  # Takes a raw S-expression and transforms it (replaces the node with the return value of the process method).
-  # This is meant to be subclassed, and in the process method you should either return a transformed version of the node, 
-  # or just call super which will leave the node in place and iterate through the children.
-  # 
-  class Transformer
-    include TransformerHelpers
-    
-    def transform(sexp)
-      if sexp.is_a?(Sexp)
-        Sexp.new(*([sexp.kind] + sexp.body.map {|c| transform(c) }))
-      else
-        sexp
-      end
-    end
-  end
-end

data/lib/ruby_scribe/transformer_helpers.rb

@@ -1,7 +0,0 @@
-module RubyScribe
-  module TransformerHelpers
-    def sexp?(e)
-      e.is_a?(Sexp)
-    end
-  end
-end

data/lib/ruby_scribe/transformers/block_method_to_procifier.rb

@@ -1,43 +0,0 @@
-module RubyScribe
-  module Transformers
-    
-    # = Block Method To Proc Transform
-    # Looks for cases where we're calling a single method on a single-parameter block argument.
-    # These instances can use the Ruby 1.9 and ActiveSupport "Symbol#to_proc" trick.
-    # 
-    # Example:
-    # 
-    #   collection.map {|d| d.name }
-    # 
-    # Transforms To:
-    #   
-    #   collect.map(&:name)
-    #    
-    class BlockMethodToProcifier < Transformer
-      def transform(e)
-        if matches_block_to_use_tap?(e)
-          super transform_block_to_use_tap(e)
-        else
-          super
-        end
-      end
-      
-      def matches_block_to_use_tap?(e)
-        e.is_a?(Sexp) && e.kind == :iter &&  # Calls block
-        e.body[2] && e.body[2].kind == :call &&  # Body of block is a simple method call
-        e.body[2].body[0].kind == :lvar &&  # Simple method call is on a local variable
-        e.body[1].kind == :lasgn &&  # Block parameter is a single assign
-        e.body[2].body[0].body[0] == e.body[1].body[0]  # Local variable is identical to the first block argument
-      end
-      
-      def transform_block_to_use_tap(e)
-        s(:call, 
-          e.body[0].body[0], 
-          e.body[0].body[1], 
-          s(:arglist, s(:block_pass, s(:lit, e.body[2].body[1])))
-        )
-      end
-    end
-    
-  end
-end