macros 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c9898a7427d06f00baffd3b44089cb932afb9b9
+  data.tar.gz: de39271f19a73ee5fd2877ebaf231b3904abd477
+SHA512:
+  metadata.gz: d74a8017921471d947eb243c8e3319f827ed70fbbbc8f8a0dd29dcd9a185b2042d089c0920644268bd9d5a88b5f38743c94e09e0f304af8e0e14176b2e189f49
+  data.tar.gz: d309a711b05cbc4c9859983a4d61aac73ed94dc5c4b5f3a48a951f123f74df4253254469a8c5d88894da88d7340058542ae033c925db29386a6fca7522bacba1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    macros (0.1)
+      parser (> 0)
+      unparser (> 0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    ast (2.1.0)
+    concord (0.1.5)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    diff-lcs (1.2.5)
+    equalizer (0.0.11)
+    ice_nine (0.11.1)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    parser (2.2.3.0)
+      ast (>= 1.1, < 3.0)
+    procto (0.0.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    thread_safe (0.3.5)
+    unparser (0.2.4)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.2.5)
+      equalizer (~> 0.0.9)
+      parser (~> 2.2.2)
+      procto (~> 0.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  macros!
+  rspec (~> 3.0)

data/README.md

@@ -0,0 +1,114 @@
+# Macros
+
+Macros for Ruby
+
+## Install
+
+```
+gem install macros
+```
+
+## Usage
+
+Any source file that contains macro definitions, or that requires macro
+expansion, should be loaded with `Macros.require`.
+
+``` ruby
+require 'macros'
+
+Macros.require 'my_macros'
+Macros.require 'my_code_using_macros'
+```
+
+Macros look like normal method definitions, but they are defined inside a
+`Macros do ; end` block.
+
+``` ruby
+# my_macros.rb
+
+Macros do
+  # Replace the +output+ method with the +puts+ method
+  def with_output(ast)
+    treemap(ast) do |node|
+      if smatch? node, s(:send, nil, :output)
+        s(:send, nil, :puts, *node.children.drop(2))
+      else
+        node
+      end
+    end
+  end
+end
+```
+
+Now this code
+
+``` ruby
+# my_code_using_macros.rb
+
+with_output do
+  output "foo"
+  output "bar"
+end
+```
+
+Will be transformed into
+
+``` ruby
+puts "foo"
+puts "bar"
+```
+
+## Helpers
+
+The macro will receive an instance of `Parser::AST::Node`, and must return an
+instance of `Parser::AST::Node`. Inside the macro definition the following
+convenience functions are available:
+
+### `s(type, *children)`
+
+Construct an AST node of given type, with specific children.
+
+### `node?(n)`
+
+Is the given object an AST node?
+
+### `treemap(node, &tranform)`
+
+Similar to `Enumerable#map`, but performs a full tree walk, passing any
+`AST::Node` to the block.
+
+### `treefilter(node, &pred)`
+
+Returns an array of any node in the tree that satisfies the predicate
+
+### `sfind(node, spec)`
+
+`spec` is an Array of symbols, integers, and arrays. It is used a bit like XPath
+or CSS locators.
+
+``` ruby
+node = s(:def, :a_name, s(:args, s(:arg, :x), s(:arg, :y)))
+sfind(node, [:def, 1, :args, [:arg, 0]])
+# => [:x, y]
+```
+
+### `smatch?(node, pattern)`
+
+Checks if the node matches the "pattern"
+
+``` ruby
+node = s(:def, :a_name, s(:args, s(:arg, :x), s(:arg, :y)))
+smatch?(node, s(:def, :a_name))
+# => true
+```
+
+## Is this a joke?
+
+Well, it works, but it's a toy. Working with Ruby syntax trees is pretty
+awkward, and macros can easily lead to a mess. You have been warned!
+
+## License
+
+© Arne Brasseur 2015
+
+Eclipse Public License

data/example/main.rb

@@ -0,0 +1,6 @@
+require_relative '../lib/macros'
+
+$:.unshift File.dirname(__FILE__)
+
+Macros.require 'my_macros'
+Macros.require 'the_code'

data/example/my_macros.rb

@@ -0,0 +1,11 @@
+Macros do
+  def macro1(ast)
+    treemap(ast) do |node|
+      if smatch? node, s(:send, nil, :output)
+        s(:send, nil, :puts, *node.children.drop(2))
+      else
+        node
+      end
+    end
+  end
+end

data/example/the_code.rb

@@ -0,0 +1,4 @@
+macro1 do
+  output 'foo'
+  output 'bar'
+end

data/lib/macros.rb

@@ -0,0 +1,70 @@
+require 'pathname'
+
+require 'parser/current'
+require 'unparser'
+
+MAIN = self
+
+module Macros
+
+  NotFound = Module.new.freeze
+
+  def self.parse(string)
+    Parser::CurrentRuby.parse(string)
+  end
+
+  def self.require(path)
+    @loader ||= Loader.new
+    @loader.require(path)
+  end
+end
+
+class Parser::AST::Node
+  def inspect(indent=0)
+    indented = "  " * indent
+    sexp = "#{indented}s(:#{@type}"
+
+    first_node_child = children.index do |child|
+      child.is_a?(AST::Node) || child.is_a?(Array)
+    end || children.count
+
+    children.each_with_index do |child, idx|
+      if child.is_a?(AST::Node) && idx >= first_node_child
+        sexp << ",\n#{child.inspect(indent + 1)}"
+      else
+        sexp << ", #{child.inspect}"
+      end
+    end
+
+    sexp << ")"
+
+    sexp
+  end
+end
+
+# module Kernel
+#   alias system_require require
+#   def require(name)
+#     $LOAD_PATH.each do |p|
+#       so_file = (Pathname(p) + "#{name}.so")
+#       rb_file = (Pathname(p) + "#{name}.rb")
+
+#       if so_file.file?
+#         system_require(name)
+#         break
+#       end
+
+#       if rb_file.file?
+#         unless $".include? rb_file.to_s
+#           Macros::Loader.new.load(rb_file)
+# $" << rb_file.to_s
+#         end
+#       end
+#     end
+#   end
+# end
+
+require_relative 'macros/sexp'
+require_relative 'macros/compiler'
+require_relative 'macros/expander'
+require_relative 'macros/loader'

data/lib/macros/compiler.rb

@@ -0,0 +1,47 @@
+module Macros
+
+  class Compiler
+    include Sexp
+
+    def collect_defmacros(sexp)
+      Hash[
+        treefilter(sexp, &method(:macros_node?)).flat_map(&method(:compile_macros))
+      ]
+    end
+
+    def reject_defmacros(node)
+      if macros_node?(node)
+        s(:begin)
+      else
+        s(node.type, *node.children.reject(&method(:macros_node?)))
+      end
+    end
+
+    def macros_node?(node)
+      smatch?(node, s(:block, s(:send, nil, :Macros)))
+    end
+
+    def compile_macros(node)
+      treefilter(node) { |n| smatch?(n, s(:def)) }.map(&method(:compile_macro))
+    end
+
+    def compile_macro(node)
+      name, args, body = extract_macro(node)
+      [name,
+       s(:block,
+         s(:send, nil, :lambda),
+         s(:args, *args.map { |a| s(:arg, a) }),
+         body)]
+    end
+
+    def extract_macro(node)
+      name = sfind(node, [0])
+
+      args = sfind(node, [:def, 1, :args, [0]])
+      body = sfind(node, [:def, 2])
+
+      [name, args, body]
+    end
+
+  end
+end

data/lib/macros/expander.rb

@@ -0,0 +1,39 @@
+module Macros
+
+  class Expander
+    include Sexp
+
+    def initialize(macros)
+      @macros = macros
+    end
+
+    def macroexpand(sexp)
+      treemap(sexp, &method(:macroexpand_1))
+    end
+
+    def macroexpand_1(node)
+      return node unless macro_block?(node)
+      macro = seval @macros[sfind(node, [:block, 0, :send, 1])]
+      body = sfind(node, [:block, 2])
+      macro.call(body)
+    end
+
+    # foo(1,2) { some_more_code }
+    #
+    # >>   (block
+    # >>     (send nil :foo
+    # >>       (int 1)
+    # >>       (int 2))
+    # >>     (args)
+    # >>     (send nil :some_more_code)))
+    def macro_block?(node)
+      # send with block
+      node.type == :block &&
+        # target is implicit self
+        sfind(node, [:block, 0, :send, 0]).nil? &&
+        # known macro
+        @macros.key?(sfind(node, [:block, 0, :send, 1]))
+    end
+  end
+
+end

data/lib/macros/loader.rb

@@ -0,0 +1,31 @@
+module Macros
+  class Loader
+    include Macros::Sexp
+
+    def initialize
+      @compiler = Macros::Compiler.new
+      @macros   = {}
+      @expander = Macros::Expander.new(@macros)
+    end
+
+    def require(name)
+      $LOAD_PATH.each do |p|
+        rb_file = (Pathname(p) + "#{name}.rb")
+
+        if rb_file.file?
+          unless $".include? rb_file.to_s
+            load(rb_file)
+            $" << rb_file.to_s
+          end
+        end
+      end
+    end
+
+    def load(pathname)
+      ast = Macros.parse pathname.read
+      @macros.merge! @compiler.collect_defmacros(ast)
+      rest_ast = @compiler.reject_defmacros(ast)
+      MAIN.instance_eval Unparser.unparse @expander.macroexpand(rest_ast)
+    end
+  end
+end

data/lib/macros/sexp.rb

@@ -0,0 +1,59 @@
+module Macros
+
+  module Sexp
+    extend self
+
+    def s(type, *children)
+      Parser::AST::Node.new(type, children)
+    end
+
+    # Traverse into sexp by type and child position
+    def sfind(sexp, specs)
+      specs.inject(sexp) do |node, spec|
+        return NotFound if node.nil?
+
+        if spec.is_a?(Symbol) && node.type == spec
+          node
+        elsif spec.is_a?(Integer) && node.children.length > spec
+          node.children[spec]
+        elsif spec.is_a?(Array)
+          node.children.grep(AST::Node)
+            .flat_map { |child| sfind(child, spec) }
+            .reject { |child| child == NotFound }
+        else
+          return NotFound
+        end
+      end
+    end
+
+    def treemap(node, &block)
+      block.call(s(node.type, *node.children.map do |child|
+          next child unless child.is_a? AST::Node
+          block.call(treemap(child, &block))
+        end))
+    end
+
+    def treefilter(node, &block)
+      acc = []
+      acc << node if block.call(node)
+      treemap(node) { |n| acc << n if block.call(n) ; n}
+      acc.freeze
+    end
+
+    def smatch?(node, pattern)
+      return false unless node.type == pattern.type
+      pattern.children.zip(node.children).all? do |a, b|
+        a == b || node?(a) && smatch?(b, a)
+      end
+    end
+
+    def node?(node)
+      node.is_a?(AST::Node)
+    end
+
+    def seval(ast)
+      eval(Unparser.unparse(ast))
+    end
+  end
+
+end

data/macros.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'macros'
+  gem.version     = '0.1'
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Macros for Ruby'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/macros'
+  gem.license     = 'MPL'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split $/
+  gem.test_files       = gem.files.grep(/^spec/)
+  gem.extra_rdoc_files = %w[README.md]
+
+  gem.add_runtime_dependency 'parser', '> 0'
+  gem.add_runtime_dependency 'unparser', '> 0'
+
+  gem.add_development_dependency 'rspec', '~> 3.0'
+end

data/scratch.rb

@@ -0,0 +1,38 @@
+require '/home/arne/projects/macros/lib/macros'
+
+code = %q{
+Macros do
+  def foo(param1_ast, param2_ast, &block_ast)
+    inside_macro_1(param1_ast, param2_ast, block_ast)
+    inside_macro_2(param1_ast, param2_ast, block_ast)
+  end
+
+  def bar(a,b)
+    inside_macro_1(param1_ast, param2_ast, block_ast)
+    inside_macro_2(param1_ast, param2_ast, block_ast)
+  end
+end
+
+foo(1, 2) do |x|
+  some_more_code
+end
+
+}
+
+include Macros::Sexp
+
+tree = Parser::CurrentRuby.parse(code)
+
+dm = tree.children.first # !> assigned but unused variable - dm
+#p sfind(dm, [:block, 0, :send, 2, 1])
+
+#puts Macros::Compiler.new.collect_defmacros(Parser::CurrentRuby.parse(code))
+
+p Parser::CurrentRuby.parse(code).children.last
+# >> (block
+# >>   (send nil :foo
+# >>     (int 1)
+# >>     (int 2))
+# >>   (args
+# >>     (arg :x))
+# >>   (send nil :some_more_code))

data/spec/macros/compiler_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../../lib/macros'
+
+RSpec.describe Macros::Compiler do
+  include Macros::Sexp
+
+  let(:code) {
+    %q{
+      Macros do
+        def foo(param1_ast, param2_ast, &block_ast)
+          inside_macro_1(param1_ast, param2_ast, block_ast)
+          inside_macro_2(param1_ast, param2_ast, block_ast)
+        end
+
+        def bar(a,b)
+          inside_macro_1(param1_ast, param2_ast, block_ast)
+          inside_macro_2(param1_ast, param2_ast, block_ast)
+        end
+      end
+    }
+  }
+
+  let(:ast) { Macros.parse(code) }
+
+  describe '#collect_defmacros' do
+    specify do
+      expect(subject.collect_defmacros(ast)).to eql(
+        foo: s(:block,
+                s(:send, nil, :lambda),
+                s(:args,
+                  s(:arg, :param1_ast),
+                  s(:arg, :param2_ast),
+                  s(:arg, :block_ast)),
+                s(:begin,
+                  s(:send, nil, :inside_macro_1,
+                    s(:lvar, :param1_ast),
+                    s(:lvar, :param2_ast),
+                    s(:lvar, :block_ast)),
+                  s(:send, nil, :inside_macro_2,
+                    s(:lvar, :param1_ast),
+                    s(:lvar, :param2_ast),
+                    s(:lvar, :block_ast)))),
+         bar: s(:block,
+                s(:send, nil, :lambda),
+                s(:args,
+                  s(:arg, :a),
+                  s(:arg, :b)),
+                s(:begin,
+                  s(:send, nil, :inside_macro_1,
+                    s(:send, nil, :param1_ast),
+                    s(:send, nil, :param2_ast),
+                    s(:send, nil, :block_ast)),
+                  s(:send, nil, :inside_macro_2,
+                    s(:send, nil, :param1_ast),
+                    s(:send, nil, :param2_ast),
+                    s(:send, nil, :block_ast)))))
+    end
+  end
+
+  describe '#macros_node?' do
+    it 'will match "Macros" blocks' do
+      expect(subject.macros_node? Macros.parse('Macros { foo }')).to be true
+    end
+  end
+
+  describe ''
+end

data/spec/macros/expander_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../../lib/macros'
+
+RSpec.describe Macros::Expander do
+  include Macros::Sexp
+
+  let(:macro) { Macros.parse("
+-> ast {
+  S = Macros::Sexp
+  S.treemap(ast) do |node|
+    if S.smatch? node, s(:send, nil, :output)
+      s(:send, nil, :puts, *node.children.drop(2))
+    else
+      node
+    end
+  end
+}")}
+
+
+  subject { described_class.new(foo: macro) }
+
+  describe '#macro_block?' do
+    specify do
+      expect(subject.macro_block?(Macros.parse("foo { bar }"))).to be true
+    end
+  end
+
+  describe '#macroexpand_1' do
+    specify do
+      expect(subject.macroexpand_1(Macros.parse("foo { output 'x' ; output 'y' }")))
+        .to eql s(:begin,
+                  s(:send, nil, :puts,
+                    s(:str, "x")),
+                  s(:send, nil, :puts,
+                    s(:str, "y")))
+    end
+  end
+end

data/spec/macros/sexp_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../../lib/macros'
+
+RSpec.describe Macros::Sexp do
+  include described_class
+
+  let(:block_node) {
+    s(:block,
+      s(:send, nil, :foo,
+        s(:int, 1),
+        s(:int, 2)),
+      s(:args,
+        s(:arg, :x)),
+      s(:send, nil, :some_more_code))
+  }
+
+  describe '#smatch?' do
+    specify do
+      expect(smatch?(s(:send, nil, :foo), s(:send))).to be true
+    end
+
+    specify do
+      expect(
+        smatch?(
+          s(:send, nil, :foo),
+          s(:send, nil, :bar))).to be false
+    end
+
+    specify do
+      expect(
+        smatch?(
+          block_node,
+          s(:block, s(:send, nil, :foo))
+        )
+      ).to be true
+    end
+  end
+
+  describe '#treefilter' do
+    specify do
+      expect(treefilter(block_node) { |n| smatch?(n, s(:send))})
+        .to eql [
+              s(:send, nil, :foo, s(:int, 1), s(:int, 2)),
+              s(:send, nil, :some_more_code)]
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: macros
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Arne Brasseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Macros for Ruby
+email:
+- arne@arnebrasseur.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- example/main.rb
+- example/my_macros.rb
+- example/the_code.rb
+- lib/macros.rb
+- lib/macros/compiler.rb
+- lib/macros/expander.rb
+- lib/macros/loader.rb
+- lib/macros/sexp.rb
+- macros.gemspec
+- scratch.rb
+- spec/macros/compiler_spec.rb
+- spec/macros/expander_spec.rb
+- spec/macros/sexp_spec.rb
+homepage: https://github.com/plexus/macros
+licenses:
+- MPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.3
+signing_key: 
+specification_version: 4
+summary: Macros for Ruby
+test_files:
+- spec/macros/compiler_spec.rb
+- spec/macros/expander_spec.rb
+- spec/macros/sexp_spec.rb
+has_rdoc: