furnace 0.3.0.beta1 → 0.3.0.beta2

data/lib/furnace.rb

@@ -1,13 +1,11 @@
 module Furnace
-end
+  require "furnace/version"
 
-require "furnace/version"
+  require "furnace/ast"
+  require "furnace/cfg"
 
-require "furnace/ast"
-require "furnace/cfg"
-require "furnace/code"
+  require "furnace/transform/pipeline"
+  require "furnace/transform/iterative_process"
 
-require "furnace/transform/pipeline"
-require "furnace/transform/iterative_process"
-
-require "furnace/graphviz"
+  require "furnace/graphviz"
+end

data/test/ast_test.rb

@@ -0,0 +1,166 @@
+require_relative 'test_helper'
+
+describe AST::Node do
+  class MetaNode < AST::Node
+    attr_reader :meta
+  end
+
+  before do
+    @node = AST::Node.new(:node, [ 0, 1 ])
+    @metanode = MetaNode.new(:node, [ 0, 1 ], meta: 'value')
+  end
+
+  it 'should have accessors for type and children' do
+    @node.type.should.equal :node
+    @node.children.should.equal [0, 1]
+  end
+
+  it 'should set metadata' do
+    @metanode.meta.should.equal 'value'
+  end
+
+  it 'should be frozen' do
+    @node.frozen?.should.be.true
+    @node.children.frozen?.should.be.true
+  end
+
+  it 'should not allow duping' do
+    -> { @node.dup }.should.raise NoMethodError
+  end
+
+  it 'should return an updated node, but only if needed' do
+    @node.updated().should.be.identical_to @node
+    @node.updated(:node).should.be.identical_to @node
+    @node.updated(nil, [0, 1]).should.be.identical_to @node
+
+    updated = @node.updated(:other_node)
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal :other_node
+    updated.children.should.equal @node.children
+
+    updated.frozen?.should.be.true
+
+    updated = @node.updated(nil, [1, 1])
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal @node.type
+    updated.children.should.equal [1, 1]
+
+    updated = @metanode.updated(nil, nil, meta: 'other_value')
+    updated.meta.should.equal 'other_value'
+  end
+
+  it 'should use fancy type in to_s' do
+    node = AST::Node.new(:ast_node)
+    node.to_s.should.equal '(ast-node ...)'
+  end
+
+  it 'should format to_sexp correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_sexp.should.equal '(a :sym [1, 2])'
+    AST::Node.new(:a, [ :sym, @node ]).to_sexp.should.equal "(a :sym\n  (node 0 1))"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_sexp.should.equal "(a :sym\n  (b\n    (node 0 1)\n    (node 0 1)))"
+  end
+
+  it 'should return self in to_ast' do
+    @node.to_ast.should.be.identical_to @node
+  end
+
+  it 'should only use type and children in comparisons' do
+    @node.should.equal @node
+    @node.should.equal @metanode
+    @node.should.not.equal :foo
+
+    mock_node = Object.new.tap do |obj|
+      def obj.to_ast
+        self
+      end
+
+      def obj.type
+        :node
+      end
+
+      def obj.children
+        [ 0, 1 ]
+      end
+    end
+    @node.should.equal mock_node
+  end
+end
+
+describe AST::Processor do
+  def have_sexp(text)
+    text = text.lines.map { |line| line.sub /^ +\|(.+)/, '\1' }.join.rstrip
+    lambda { |ast| ast.to_sexp == text }
+  end
+
+  class MockProcessor
+    include AST::Processor
+
+    attr_reader :counts
+
+    def initialize
+      @counts = Hash.new(0)
+    end
+
+    def on_root(node)
+      count_node(node)
+      node.updated(nil, process_all(node.children))
+    end
+    alias on_body on_root
+
+    def on_def(node)
+      count_node(node)
+      name, arglist, body = node.children
+      node.updated(:def, [ name, process(arglist), process(body) ])
+    end
+
+    def handler_missing(node)
+      count_node(node)
+    end
+
+    def count_node(node)
+      @counts[node.type] += 1; nil
+    end
+  end
+
+  before do
+    @ast = AST::Node.new(:root, [
+      AST::Node.new(:def, [ :func,
+        AST::Node.new(:arglist, [ :foo, :bar ]),
+        AST::Node.new(:body, [
+          AST::Node.new(:invoke, [ :puts, "Hello world" ])
+        ])
+      ]),
+      AST::Node.new(:invoke, [ :func ])
+    ])
+
+    @processor = MockProcessor.new
+  end
+
+  it 'should visit every node' do
+    @processor.process(@ast).should.equal @ast
+    @processor.counts.should.equal({
+      root:    1,
+      def:     1,
+      arglist: 1,
+      body:    1,
+      invoke:  2
+    })
+  end
+
+  it 'should be able to replace inner nodes' do
+    def @processor.on_arglist(node)
+      node.updated(:new_fancy_arglist)
+    end
+
+    @processor.process(@ast).should have_sexp(<<-SEXP)
+    |(root
+    |  (def :func
+    |    (new-fancy-arglist :foo :bar)
+    |    (body
+    |      (invoke :puts "Hello world")))
+    |  (invoke :func))
+    SEXP
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'furnace'
+include Furnace
+
+module Bacon
+  module ColoredOutput
+    def handle_specification(name)
+      puts spaces + name
+      yield
+      puts if Counter[:context_depth] == 1
+    end
+
+    def handle_requirement(description)
+      print spaces
+
+      error = yield
+
+      print error.empty? ? "\e[32m" : "\e[1;31m"
+      print "  - #{description}"
+      puts error.empty? ? "\e[0m" : " [#{error}]\e[0m"
+    end
+
+    def handle_summary
+      print ErrorLog  if Backtraces
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+
+    def spaces
+      "  " * (Counter[:context_depth] - 1)
+    end
+  end
+
+  extend ColoredOutput
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: furnace
 version: !ruby/object:Gem::Version
-  version: 0.3.0.beta1
+  version: 0.3.0.beta2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,8 +9,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-31 00:00:00.000000000 Z
-dependencies: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: Furnace is a static code analysis framework for dynamic languages, aimed
   at efficient type and behavior inference.
 email:
@@ -20,32 +52,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .yardopts
 - Gemfile
 - LICENSE
 - Rakefile
 - furnace.gemspec
 - lib/furnace.rb
 - lib/furnace/ast.rb
-- lib/furnace/ast/matcher.rb
-- lib/furnace/ast/matcher/dsl.rb
-- lib/furnace/ast/matcher/special.rb
 - lib/furnace/ast/node.rb
-- lib/furnace/ast/strict_visitor.rb
-- lib/furnace/ast/visitor.rb
+- lib/furnace/ast/processor.rb
 - lib/furnace/cfg.rb
+- lib/furnace/cfg/algorithms.rb
 - lib/furnace/cfg/graph.rb
 - lib/furnace/cfg/node.rb
-- lib/furnace/code.rb
-- lib/furnace/code/newline_token.rb
-- lib/furnace/code/nonterminal_token.rb
-- lib/furnace/code/separated_token.rb
-- lib/furnace/code/surrounded_token.rb
-- lib/furnace/code/terminal_token.rb
-- lib/furnace/code/token.rb
 - lib/furnace/graphviz.rb
 - lib/furnace/transform/iterative_process.rb
 - lib/furnace/transform/pipeline.rb
 - lib/furnace/version.rb
+- test/ast_test.rb
+- test/test_helper.rb
 homepage: http://github.com/whitequark/furnace
 licenses: []
 post_install_message: 
@@ -58,6 +83,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1541160448532291935
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/furnace/ast/matcher/dsl.rb

@@ -1,50 +0,0 @@
-module Furnace::AST
-  class MatcherDSL
-    SpecialAny         = MatcherSpecial.new(:any)
-    SpecialSkip        = MatcherSpecial.new(:skip)
-    SpecialEach        = MatcherSpecial.define(:each)
-    SpecialEither      = MatcherSpecial.define(:either)
-    SpecialEitherMulti = MatcherSpecial.define(:either_multi)
-    SpecialMaybe       = MatcherSpecial.define(:maybe)
-
-    def any
-      SpecialAny
-    end
-
-    def skip
-      SpecialSkip
-    end
-
-    def each
-      SpecialEach
-    end
-
-    def either
-      SpecialEither
-    end
-
-    def either_multi
-      SpecialEitherMulti
-    end
-
-    def maybe
-      SpecialMaybe
-    end
-
-    def map(name)
-      ->(hash) { MatcherSpecial.new(:map, [name, hash]) }
-    end
-
-    def capture(name)
-      MatcherSpecial.new(:capture, name)
-    end
-
-    def capture_rest(name)
-      MatcherSpecial.new(:capture_rest, name)
-    end
-
-    def backref(name)
-      MatcherSpecial.new(:backref, name)
-    end
-  end
-end

data/lib/furnace/ast/matcher/special.rb

@@ -1,20 +0,0 @@
-module Furnace::AST
-  class MatcherSpecial
-    attr_reader :type, :param
-
-    def initialize(type, param=nil)
-      @type, @param = type, param
-    end
-
-    class << self
-      def define(type)
-        lambda { |*args| new(type, args) }
-      end
-
-      def kind(type)
-        @kind_lambdas       ||= {}
-        @kind_lambdas[type] ||= lambda { |m| m.is_a?(MatcherSpecial) && m.type == type }
-      end
-    end
-  end
-end

data/lib/furnace/ast/matcher.rb

@@ -1,198 +0,0 @@
-module Furnace::AST
-  class MatcherError < StandardError; end
-
-  class Matcher
-    def initialize(&block)
-      @pattern = MatcherDSL.new.instance_exec(&block)
-    end
-
-    def match(object, captures={})
-      if genmatch(object.to_astlet, @pattern, captures)
-        captures
-      else
-        nil
-      end
-    end
-
-    def find_one(collection, initial_captures={})
-      collection.find do |elem|
-        result = match elem, initial_captures.dup
-
-        if block_given? && result
-          yield elem, result
-        else
-          result
-        end
-      end
-    end
-
-    def find_one!(collection, initial_captures={})
-      found = nil
-
-      collection.each do |elem|
-        result = match elem, initial_captures.dup
-
-        if result
-          raise MatcherError, "already matched" if found
-
-          found = elem
-          yield elem, result if block_given?
-        end
-      end
-
-      raise MatcherError, "no match found" unless found
-
-      found
-    end
-
-    def find_all(collection, initial_captures={})
-      collection.select do |elem|
-        result = match elem, initial_captures.dup
-        yield elem, result if block_given? && result
-        result
-      end
-    end
-
-    protected
-
-    def submatch(array, pattern, captures)
-      matches = true
-      nested_captures = captures.dup
-      index   = 0
-
-      pattern.each_with_index do |nested_pattern|
-        return nil if index > array.length
-
-        case nested_pattern
-        when Array
-          matches &&= genmatch(array[index], nested_pattern, nested_captures)
-          index += 1
-        when MatcherDSL::SpecialAny
-          # it matches
-          index += 1
-        when MatcherDSL::SpecialSkip
-          # it matches all remaining elements
-          index = array.length
-        when MatcherSpecial.kind(:capture)
-          # it matches and captures
-          nested_captures[nested_pattern.param] = array[index]
-          index += 1
-        when MatcherSpecial.kind(:capture_rest)
-          # it matches and captures all remaining
-          nested_captures[nested_pattern.param] = array[index..-1]
-          index = array.length
-        when MatcherSpecial.kind(:backref)
-          matches &&= (nested_captures[nested_pattern.param] == array[index])
-          index += 1
-        when MatcherSpecial.kind(:maybe)
-          if advance = submatch(array[index..-1], nested_pattern.param, nested_captures)
-            index += advance
-          end
-        when MatcherSpecial.kind(:each)
-          all_submatches = true
-
-          workset = Set.new array[index..-1]
-
-          nested_pattern.param.each do |subset_pattern|
-            sub_matches  = false
-
-            workset.each do |subset_elem|
-              sub_matches ||= genmatch(subset_elem, subset_pattern, nested_captures)
-
-              if sub_matches
-                workset.delete subset_elem
-                break
-              end
-            end
-
-            all_submatches &&= sub_matches
-            break unless all_submatches
-          end
-
-          index += 1
-          matches &&= all_submatches
-        when MatcherSpecial.kind(:either)
-          sub_found = false
-
-          nested_pattern.param.each do |subset_pattern|
-            if genmatch(array[index], subset_pattern, nested_captures)
-              sub_found = true
-              index += 1
-              break
-            end
-          end
-
-          matches &&= sub_found
-        when MatcherSpecial.kind(:either_multi)
-          sub_found = false
-
-          nested_pattern.param.each do |subset_pattern|
-            if matched = genmatch(array[index..-1], subset_pattern, nested_captures)
-              sub_found = true
-              index += matched
-              break
-            end
-          end
-
-          matches &&= sub_found
-        when MatcherSpecial.kind(:map)
-          captures_key, patterns = nested_pattern.param
-          nested_captures[captures_key] = []
-
-          while index < array.length
-            sub_found = false
-
-            patterns.each do |subset_key, subset_pattern|
-              subset_captures = captures.dup
-
-              if matched = submatch(array[index..-1], subset_pattern, subset_captures)
-                if subset_key
-                  nested_captures[captures_key].push [subset_key, subset_captures]
-                end
-
-                sub_found = true
-                index += matched
-
-                break
-              end
-            end
-
-            matches &&= sub_found
-            break unless matches
-          end
-        else
-          matches &&= (nested_pattern === array[index])
-          index += 1
-        end
-
-        break unless matches
-      end
-
-      captures.replace(nested_captures) if matches
-
-      index if matches
-    end
-
-    def genmatch(astlet, pattern, captures)
-      if $DEBUG
-        if astlet.respond_to? :to_sexp
-          puts "match #{astlet.to_sexp} of #{pattern}"
-        else
-          puts "match #{astlet} of #{pattern}"
-        end
-      end
-
-      if pattern === astlet
-        true
-      elsif pattern.is_a? MatcherSpecial
-        submatch([astlet], [pattern], captures)
-      elsif astlet.is_a? Node
-        submatch([astlet.type].concat(astlet.children), pattern, captures)
-      elsif astlet.is_a? Array
-        submatch(astlet, pattern, captures)
-      else
-        false
-      end
-    end
-  end
-end

data/lib/furnace/ast/visitor.rb

@@ -1,50 +0,0 @@
-module Furnace::AST
-  module Visitor
-    def visit(node)
-      replacements = {}
-
-      node.children.each_with_index do |child, index|
-        if child.is_a? Node
-          visit child
-
-          if child.type == :expand
-            replacements[index] = child.children
-          end
-        end
-      end
-
-      if replacements.any?
-        new_children = []
-
-        node.children.each_with_index do |child, index|
-          if replacements[index]
-            new_children.concat replacements[index]
-          else
-            new_children.push child
-          end
-        end
-
-        node.children.replace new_children
-      end
-
-      node.children.delete_if do |child|
-        if child.is_a? Node
-          child.type == :remove
-        end
-      end
-
-      # Invoke a specific handler
-      on_handler = :"on_#{node.type}"
-      if respond_to? on_handler
-        send on_handler, node
-      end
-
-      # Invoke a generic handler
-      if respond_to? :on_any
-        send :on_any, node
-      end
-
-      node
-    end
-  end
-end

data/lib/furnace/code/newline_token.rb

@@ -1,9 +0,0 @@
-module Furnace
-  module Code
-    class NewlineToken < TerminalToken
-      def to_text
-        "\n"
-      end
-    end
-  end
-end

data/lib/furnace/code/nonterminal_token.rb

@@ -1,16 +0,0 @@
-module Furnace
-  module Code
-    class NonterminalToken < Token
-      attr_reader :children
-
-      def initialize(origin, children, options={})
-        super(origin, options)
-        @children = children.compact
-      end
-
-      def to_text
-        children.map(&:to_text).join
-      end
-    end
-  end
-end

data/lib/furnace/code/separated_token.rb

@@ -1,17 +0,0 @@
-module Furnace
-  module Code
-    class SeparatedToken < SurroundedToken
-      def text_between
-        ""
-      end
-
-      def to_text
-        "#{text_before}#{children.map(&:to_text).join(text_between)}#{text_after}"
-      end
-
-      def to_structure(options={})
-        structurize "#{text_before} #{([text_between] * 3).join(" ")} #{text_after}", options
-      end
-    end
-  end
-end

data/lib/furnace/code/surrounded_token.rb

@@ -1,21 +0,0 @@
-module Furnace
-  module Code
-    class SurroundedToken < NonterminalToken
-      def text_before
-        ""
-      end
-
-      def text_after
-        ""
-      end
-
-      def to_text
-        "#{text_before}#{children.map(&:to_text).join}#{text_after}"
-      end
-
-      def to_structure(options={})
-        structurize "#{text_before} ... #{text_after}", options
-      end
-    end
-  end
-end