furnace 0.2.6 → 0.3.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: furnace
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,72 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-30 00:00:00.000000000 Z
-dependencies: []
+date: 2012-12-02 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'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: redcarpet
+  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'
 description: Furnace is a static code analysis framework for dynamic languages, aimed
   at efficient type and behavior inference.
 email:
@@ -20,32 +84,26 @@ 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/ast/sexp.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,15 +116,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2809790994543949274
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2809790994543949274
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A static code analysis framework

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/strict_visitor.rb

@@ -1,20 +0,0 @@
-module Furnace::AST
-  module StrictVisitor
-    def visit(node)
-      # Invoke a specific handler
-      on_handler = :"on_#{node.type}"
-      if respond_to? on_handler
-        new_node = send on_handler, node
-        node = new_node if new_node
-      end
-
-      node
-    end
-
-    def visit_all(nodes)
-      nodes.map do |node|
-        visit node
-      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

data/lib/furnace/code/terminal_token.rb

@@ -1,9 +0,0 @@
-module Furnace
-  module Code
-    class TerminalToken < Token
-      def to_structure(options={})
-        structurize to_text, options
-      end
-    end
-  end
-end

data/lib/furnace/code/token.rb

@@ -1,73 +0,0 @@
-module Furnace
-  module Code
-    class Token
-      attr_reader :origin
-
-      def initialize(origin, options={})
-        @origin, @options = origin, options
-        @waiters = []
-      end
-
-      def self.type
-        @type ||= name.sub(/^.*::/, '').sub(/Token$/, '').to_sym
-      end
-
-      def type
-        self.class.type
-      end
-
-      def subscribe(proc)
-        @waiters << proc
-      end
-
-      def unsubscribe(proc)
-        @waiters.delete proc
-      end
-
-      def to_text
-        raise "Reimplement Token#to_text in a subclass"
-      end
-
-      def to_structure(options={})
-        structurize nil, options
-      end
-
-      protected
-
-      def indent(code, options=@options)
-        unless code.empty?
-          code.to_s.gsub(/^/, (options[:indent_with] || '  ') * (options[:level] || 1))
-        else
-          ""
-        end
-      end
-
-      def structurize(comment, options)
-        options = { level: 0 }.merge(options)
-
-        structure = indent(type, options)
-
-        if comment
-          structure = structure.ljust(options[:describe_at] || 50)
-
-          if comment =~ /^\s+$/
-            structure += "   <whitespace>"
-          else
-            structure += " ; #{comment.gsub(%r{\/\*.*?\*\/}, '').
-                  gsub(/[ \t]+/, ' ').gsub("\n", '')}"
-          end
-        end
-
-        structure += "\n"
-
-        if @children
-          structure += @children.map do |child|
-            child.to_structure(options.merge(:level => options[:level] + 1))
-          end.join
-        end
-
-        structure
-      end
-    end
-  end
-end

data/lib/furnace/code.rb

@@ -1,10 +0,0 @@
-require "set"
-
-require "furnace"
-
-require "furnace/code/token"
-require "furnace/code/terminal_token"
-require "furnace/code/nonterminal_token"
-require "furnace/code/surrounded_token"
-require "furnace/code/separated_token"
-require "furnace/code/newline_token"