take 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2637d99ba8ea1bef3aece18d26f31ed73e8585d5
-  data.tar.gz: 82017635983468566a4e66f433e70e5d8dec765f
+  metadata.gz: 451dc9d6ef5b89807d396e55d0320fa2432991a1
+  data.tar.gz: 32ee53bde93419d3cc52adc9a41b6fbbda8a4aa9
 SHA512:
-  metadata.gz: 52a5a3ffb71977e50388eed3e02344d0fe0caa2bdbcb117affc54409f344b4cb89e9f88d27933d4623ebdfd4f82f293c3a00e6682ebd779fab7fc37f8472ac16
-  data.tar.gz: f25c40d35046001fed6393a98425dbb86cd7ec9c5c49bdf531d208bafaf2fb0a74319ba8ccee686b7c1779704222c4043ab88c6125c6fe43e59e350740518d71
+  metadata.gz: 8d8fddbd0da58bdc641c81190139ed31aeeab39d1d879bd4403997f7ac95e2378bac1007c87d4fa8d0385dad291f5a631ed7d6725d61d5cfab64535888fe7591
+  data.tar.gz: 32faa1c8b86163b1d3181efde2c9ac9a5992f605aeef4fbab9653d07fe0e1ea65c9b727c55911267327d1ca580a63ab53c514acf4d74c1b684273a9adc8a3db8

data/.gitignore

@@ -12,3 +12,6 @@
 *.o
 *.a
 mkmf.log
+.project
+.project.rb
+test.*

data/lib/take/unit/ast/after.rb

@@ -0,0 +1,12 @@
+module Take
+  class Unit
+    module AST
+      class After < Node
+
+        def after?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/before.rb

@@ -0,0 +1,12 @@
+module Take
+  class Unit
+    module AST
+      class Before < Node
+
+        def before?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/block.rb

@@ -0,0 +1,13 @@
+module Take
+  class Unit
+    module AST
+      class Block < Node
+        attribute :body, String
+
+        def block?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/group.rb

@@ -0,0 +1,12 @@
+module Take
+  class Unit
+    module AST
+      class Group < Node
+
+        def group?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/node.rb

@@ -0,0 +1,20 @@
+require "virtus"
+
+module Take
+  class Unit
+    module AST
+      class Node
+
+        include Virtus.model
+
+        attribute :children, Array[Node], default: proc { [] }
+        attribute :name, String
+        attribute :source, Source
+
+        [:block?, :group?, :parent?, :test?, :before?, :after?, :prefix?].each do |m|
+          define_method(m) { false }
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/parent.rb

@@ -0,0 +1,12 @@
+module Take
+  class Unit
+    module AST
+      class Parent < Node
+
+        def parent?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/prefix.rb

@@ -0,0 +1,12 @@
+module Take
+  class Unit
+    module AST
+      class Prefix < Node
+
+        def prefix?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/take/unit/ast/source.rb

@@ -0,0 +1,15 @@
+require "virtus"
+
+module Take
+  class Unit
+    module AST
+      class Source
+        include Virtus.model
+
+        attribute :file, String
+        attribute :line, Integer
+        attribute :column, Integer
+      end
+    end
+  end
+end

data/lib/take/unit/ast.rb

@@ -0,0 +1,17 @@
+require "take/unit/ast/source"
+require "take/unit/ast/node"
+require "take/unit/ast/group"
+require "take/unit/ast/test"
+require "take/unit/ast/block"
+require "take/unit/ast/parent"
+require "take/unit/ast/after"
+require "take/unit/ast/before"
+require "take/unit/ast/prefix"
+
+module Take
+  class Unit
+    module AST
+
+    end
+  end
+end

data/lib/take/unit/compiler.rb

@@ -0,0 +1,119 @@
+module Take
+  class Unit
+    class Compiler
+
+      include PredictMatch
+
+      attr_reader :parent
+
+      def initialize(file, tokens)
+        @file   = file
+        @tokens = tokens
+        @enum   = tokens.each
+        @parent = nil
+      end
+
+      def compile
+        @parent ||= begin
+          @parent = AST::Parent.new(name: @file.
+            gsub(/\..*\z/, "").gsub(/[\W]/, "_"))
+          while peek do
+            @parent.children << compile_group
+          end
+
+          @parent.source = sourcify([0, 0])
+          @parent
+        end
+      end
+
+      def compile_group
+        group = match(:group)
+        node = AST::Group.new(name: group[1], source: sourcify(group))
+
+        until peek == :group_end
+          part = compile_part
+          node.children << part if part
+        end
+
+        match(:group_end)
+
+        node
+      end
+
+      def compile_part
+        predict :group  => :group,
+                :test   => :test,
+                :before => :before,
+                :after  => :after,
+                :prefix => :prefix,
+                :macro  => :macro
+      end
+
+      def compile_test
+        test = match(:test)
+        body = match(:block)
+        AST::Test.new(name: test[1],
+                      children: [AST::Block.new({
+                        body: body[1],
+                        source: sourcify(body)
+                      })],
+                      source: sourcify(test))
+      end
+
+      def compile_before
+        before = match(:before)
+        body = match(:block)
+
+        AST::Before.new(name: before[1],
+                        children: [AST::Block.new({
+                          body: body[1],
+                          source: sourcify(body)
+                          })],
+                        source: sourcify(before))
+      end
+
+      def compile_after
+        after = match(:after)
+        body = match(:block)
+
+        AST::After.new(name: after[1],
+                       children: [AST::Block.new({
+                         body: body[1],
+                         source: sourcify(body)
+                         })],
+                       source: sourcify(after))
+      end
+
+      def compile_prefix
+        prefix = match(:prefix)
+        body = match(:block)
+
+        @parent.children << AST::Prefix.new(
+          name: prefix[1],
+          children: [AST::Block.new({
+            body: body[1],
+            source: sourcify(body)
+          })],
+          source: sourcify(prefix))
+
+        nil
+      end
+
+      def compile_macro
+
+      end
+
+      private
+
+      def input
+        @enum
+      end
+
+      def sourcify(token)
+        hash = Hash[[:line, :column].zip(token[-2..-1])]
+        hash.merge(file: @file)
+      end
+
+    end
+  end
+end

data/lib/take/unit/generator.rb

@@ -0,0 +1,136 @@
+module Take
+  class Unit
+    class Generator
+
+      def initialize(parent, options)
+        @parent  = parent
+        @groups  = [@parent]
+        @options = options
+      end
+
+      def generate
+        @output ||= begin
+          @output = ""
+          walk(@parent)
+          @output
+        end
+      end
+
+      def write_file
+        File.open("#{@parent.name}.c", "w") do |f|
+          f.write generate
+        end
+      end
+
+      def walk(node, *opts)
+        case
+        when node.group?
+          walk_group(node, *opts)
+        when node.test?
+          walk_test(node, *opts)
+        when node.block?
+          walk_block(node, *opts)
+        when node.parent?
+          walk_parent(node, *opts)
+        when node.before?
+          walk_before(node, *opts)
+        when node.after?
+          walk_after(node, *opts)
+        when node.prefix?
+          walk_prefix(node, *opts)
+        else
+          raise ArgumentError, "Invalid argument given: #{node.class} (#{node})"
+        end
+      end
+
+      def walk_group(node)
+        @groups << node
+        group.children.select(&:test?).
+          each { |child| walk(child) }
+
+        @output << "// group #{group_name}\n"
+        @output << "void group_#{group_name}()\n{\n"
+        befores.each { |child| walk(child) }
+        @output << group.children.select(&:test?).
+          map { |child| "  test_#{group_name(child)}();" }.
+          join("\n")
+        @output << "\n"
+        afters.each { |child| walk(child) }
+        @output << "}\n\n"
+        @groups.pop
+      end
+
+      def walk_test(node)
+        @output << "void test_#{group_name(node)}()\n{\n"
+        node.children.select(&:block?).each { |child| walk(child) }
+        @output << "}\n\n"
+      end
+
+      def walk_block(node, indent = 2)
+        @output << "#line \"#{node.source.file}\" #{node.source.line + 2}"
+        lines = node.body.each_line
+        deindent = if scan = node.body.scan(/^[ \t]*(?=\S)/).min
+          scan.size
+        else
+          0
+        end
+
+        body = lines.map { |l| l.gsub(/^[ \t]{#{deindent}}/, "") }.
+          map { |l| (" " * indent) << l }.join("").rstrip.gsub(/^[ \t]+$/, "")
+
+        @output << body << "\n"
+        reset
+      end
+
+      def walk_parent(node)
+        node.children.select(&:prefix?).each { |child| walk(child) }
+        node.children.reject(&:prefix?).each { |child| walk(child) }
+      end
+
+      def walk_node(node)
+        if node.name
+          @output << "// #{node.class.name.gsub(/\A.*::/, "").downcase} #{node.name}\n"
+        end
+
+        node.children.each { |child| walk(child) }
+        @output << "\n"
+      end
+
+      def walk_prefix(node)
+        @output << "// prefix #{node.name}\n"
+        node.children.select(&:block?).each { |child| walk(child, 0) }
+        @output << "\n"
+      end
+
+      alias_method :walk_before, :walk_node
+      alias_method :walk_after, :walk_node
+
+      private
+
+      def group
+        @groups.last
+      end
+
+      def line
+        @output.count("\n") + 2
+      end
+
+      def reset
+        @output << "#line \"#{@parent.name}.c\" #{line}\n"
+      end
+
+      def befores
+        @groups.map(&:children).flatten.select(&:before?)
+      end
+
+      def afters
+        @groups.map(&:children).flatten.select(&:after?)
+      end
+
+      def group_name(test = nil)
+        [*@groups[1..-1], test].compact.map(&:name).
+          map { |n| n.gsub(/[\W]/, "_") }.join("_")
+      end
+    end
+  end
+end

data/lib/take/unit/predict_match.rb

@@ -0,0 +1,51 @@
+module Take
+  class Unit
+    module PredictMatch
+
+      # Makes a prediction based on a set of actions.  If the peek token
+      # doesn't have an action, it will try the special action `:_`, and
+      # then give up.  If it finds a corresponding action either time, it
+      # will run the action.
+      #
+      # @param actions [Hash<Symbol => Symbol>]
+      # @return [Object] the result of the compiliation.
+      def predict(*params, actions)
+
+        action = actions.fetch(peek) do
+          actions.fetch(:_)
+        end
+
+        if action.respond_to?(:call)
+          action.call(*params)
+        else
+          send(:"compile_#{action}", *params)
+        end
+      end
+
+      # Matches the next token of the input.  If it is not of the
+      # expected type, it raises a SyntaxError.  Otherwise, it returns
+      # the token.
+      #
+      # @param name [Symbol] the token to match.
+      # @return [Array] the token.
+      # @raise SyntaxError if the peeked token is invalid.
+      def match(name)
+        if name == peek
+          input.next
+        else
+          raise SyntaxError, "Unexpected token #{peek}"
+        end
+      end
+
+      # Returns the type of the next token.
+      #
+      # @return [Symbol] the type of the next token.
+      def peek
+        input.peek[0]
+      rescue StopIteration
+        nil
+      end
+
+    end
+  end
+end

data/lib/take/unit/scanner.rb

@@ -0,0 +1,149 @@
+require "strscan"
+
+module Take
+  class Unit
+    class Scanner
+
+      attr_reader :tokens
+
+      def initialize(input)
+        @input = "\n" << input
+        @scanner = StringScanner.new(input)
+      end
+
+      def scan
+        @tokens ||= begin
+          @tokens = []
+          until @scanner.eos?
+            scan_group_body { error! }
+          end
+          @tokens
+        end
+      end
+
+      def scan_group_body
+        pre_scan
+        scan_nested or
+        scan_group or
+        scan_body or
+        scan_whitespace or
+        yield
+      end
+
+      def scan_nested
+        if scan_group(/group/)
+          scan_whitespace
+          @scanner.scan(/\{/) or error!
+          loop do
+            scan_group_body do
+              if @scanner.scan(/\}/)
+                pre_scan
+                return emit(:group_end)
+              else
+                error!
+              end
+            end
+          end
+        end
+      end
+
+      def scan_group(scan = /macro|test|before|after|prefix/)
+        if @scanner.scan(scan)
+          group_type = @scanner[0]
+          @scanner.scan(/ ([A-Za-z0-9_.-]+)\(/) or error!
+          group_name = @scanner[1]
+
+          @scanner.scan(/\s*\;/)
+
+          emit group_type.intern,
+               group_name,
+               _scan_arguments(/\s*\)/, /,\s+/)
+        end
+      end
+
+      def scan_body
+        if @scanner.check(/\s*\{/)
+          emit :block, _scan_block
+        end
+      end
+
+      def scan_whitespace(newlines = true)
+        if newlines
+          @scanner.scan(/\s+/)
+        else
+          @scanner.scan(/[ \t]+/)
+        end
+      end
+
+      private
+
+      def pre_scan
+        @pos = @scanner.pos
+      end
+
+      def line
+        @input[0..@pos].count("\n")
+      end
+
+      def column
+        last_newline = @input[0..@pos].rindex("\n") || 0
+        @pos - last_newline
+      end
+
+      def emit(*args)
+        @tokens << args.concat([line, column])
+        true
+      end
+
+      def _scan_block
+        brack = 1
+        body = @scanner.scan(/\s*\{/)
+        scan_for = %r{
+          (
+            (?: " ( \\\\ | \\" | [^"] )* "? )
+          | (?: ' ( \\\\ | \\' | [^'] )* '? )
+          | (?: // .*? \n )
+          | (?: \# .*? \n )
+          | (?: /\* [\s\S]+? \*/ )
+          | (?: \} )
+          | (?: \{ )
+          )
+        }x
+
+        until brack.zero?
+          if part = @scanner.scan_until(scan_for)
+            body << part
+
+
+            if @scanner[1] == "}"
+              brack -= 1
+            elsif @scanner[1] == "{"
+              brack += 1
+            end
+          else
+            @scanner.scan(/(.+)/m)
+            error!
+          end
+        end
+
+        body.gsub(/\A\n*/, "").gsub(/\A\s*\{([\s\S]*)\}\z/, "\\1")
+      end
+
+      def _scan_arguments(ending, seperator)
+        arguments = []
+        until @scanner.scan(ending)
+          @scanner.scan(/(&?[A-Za-z0-9_-]+)/)
+          arguments << @scanner[1]
+          @scanner.scan(seperator) or @scanner.check(ending) or error!
+        end
+
+        arguments
+      end
+
+      def error!
+        p @tokens
+        raise SyntaxError, "Unexpected `#{@scanner.check(/./)}' on line #{line} (column #{column})"
+      end
+    end
+  end
+end

data/lib/take/unit.rb

@@ -0,0 +1,20 @@
+require "take/unit/predict_match"
+require "take/unit/ast"
+require "take/unit/compiler"
+require "take/unit/scanner"
+require "take/unit/generator"
+
+module Take
+
+  # A unit test.  This is used to generate c files for tests.
+  class Unit
+
+    def create(file)
+      file = File.open(file, "r")
+      scanner = Scanner.new(file.read)
+      compiler = Compiler.new(file.path, scanner.scan)
+      generator = Generator.new(compiler.compile).generate
+    end
+
+  end
+end

data/lib/take/version.rb

@@ -1,3 +1,3 @@
 module Take
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

data/lib/take.rb

@@ -1,4 +1,6 @@
 require "take/version"
+require "take/unit"
+require "take/project"
 
 module Take
   # Your code goes here...

data/take.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "virtus", "~> 1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: take
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2014-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Manage your C projects better.
 email:
 - redjazz96@gmail.com
@@ -51,8 +65,20 @@ files:
 - README.md
 - Rakefile
 - lib/take.rb
-- lib/take/project.rb
-- lib/take/project/builder.rb
+- lib/take/unit.rb
+- lib/take/unit/ast.rb
+- lib/take/unit/ast/after.rb
+- lib/take/unit/ast/before.rb
+- lib/take/unit/ast/block.rb
+- lib/take/unit/ast/group.rb
+- lib/take/unit/ast/node.rb
+- lib/take/unit/ast/parent.rb
+- lib/take/unit/ast/prefix.rb
+- lib/take/unit/ast/source.rb
+- lib/take/unit/compiler.rb
+- lib/take/unit/generator.rb
+- lib/take/unit/predict_match.rb
+- lib/take/unit/scanner.rb
 - lib/take/version.rb
 - take.gemspec
 homepage: ''

data/lib/take/project.rb

@@ -1,22 +0,0 @@
-
-module Take
-
-  # Handles project information for a specific project.  Tends to represent
-  # an entire directory.
-  class Project
-
-    # The name of the project.  This is normally guessed from the directory
-    # name.
-    #
-    # @return [String]
-    attr_accessor :name
-
-    # Initialize the project.
-    def initialize(name = nil, &block)
-      raise ArgumentError, "Projects require blocks" unless block_given?
-      @block = block
-      @name  = name
-    end
-
-  end
-end