take 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30a3eaeb64d8a7145710c1b21b61ef49438c2ce9
-  data.tar.gz: 7b6088a71e656c266783e00ccced336c40a6dbef
+  metadata.gz: d4f683117b5d40dc796e5fef18255f3f16a3f005
+  data.tar.gz: 2107ea1194a5da5ffc14658b1f248b43410b563a
 SHA512:
-  metadata.gz: 0c94995f202f6a12a982ae5eb551382752619111d80545fe0a10a5302eb9c95b934e847cab5ee346dca50b6aa36e6bb7b04d49002b131c2537674bfa864f4fc2
-  data.tar.gz: 12248c0b1533fe39e896152c1e8076652801b825e6a066b92d8d595126f3f999fcad96899c50546d0e36f2c2cdfb5df845ffb754590481db4efdbc710e74fb9b
+  metadata.gz: 51ab66ab98bd63428cd1d8dce72282ee97348189cc18cfbe9cd6bb6e383b440c02bf30941df98196eb08d628b0b35c6ac8b9825132b817b6627d710f57fd8a83
+  data.tar.gz: 086c7c3f47d0863fa575d3822f568c7b90668f13c2971bb7a174f9e25008100df6738ee2c927ef2277d6f5f6342608f19bc4c40a8d2b651c15e449a45163d7e8

data/lib/take.rb

@@ -3,5 +3,5 @@ require "take/unit"
 require "take/project"
 
 module Take
-  # Your code goes here...
+
 end

data/lib/take/compiler.rb

@@ -0,0 +1,5 @@
+module Take
+  module Compiler
+
+  end
+end

data/lib/take/compiler/base.rb

@@ -0,0 +1,22 @@
+module Take
+  module Compiler
+    class Base
+
+      def self.on_platform?
+        false
+      end
+
+      def self.command
+        raise NotImplementedError
+      end
+
+      def initialize
+        @options = { extra: {} }
+      end
+
+      def command
+        self.class.command
+      end
+    end
+  end
+end

data/lib/take/compiler/gcc.rb

@@ -0,0 +1,118 @@
+module Take
+  module Compiler
+    class GCC < Base
+
+      DEBUG_OPTIONS = {
+        default: "0",
+        normal: "1",
+        more: "2",
+        max: "3",
+        debug: "g",
+        fast: "fast",
+        size: "s"
+      }.freeze
+
+      def self.on_platform?
+        @_on_platform ||= begin
+          runner = Command::Runner.new(command, "--version")
+          runner.run.successful?
+        end
+      end
+
+      def self.command
+        "gcc".freeze
+      end
+
+      def initialize
+        super
+        @options[:libraries] = []
+        @options[:directories] = { include: [],
+                                   quote: [],
+                                   library: [] }.freeze
+        @options[:defines] = {}
+        @options[:optimize] = DEBUG_OPTIONS.fetch(:default)
+        @options[:warnings] = ["all", "extra"]
+      end
+
+      def output=(file)
+        @options[:output] = file
+      end
+
+      def language=(lang)
+        @options[:lang] = lang || "none"
+      end
+
+      def standard=(standard)
+        if standard
+          @options[:std] = standard
+        else
+          @options.delete(:std)
+        end
+      end
+
+      def optimize_mode=(mode)
+        mode = :default unless mode
+        @options[:optimize] = DEBUG_OPTIONS.fetch(mode) do
+          DEBUG_OPTIONS.fetch(:default)
+        end
+      end
+
+      def []=(key, value)
+        @options[:extra][key] = value
+      end
+
+      def libraries
+        @options[:libraries]
+      end
+
+      def directories
+        @options[:directories]
+      end
+
+      def defines
+        @options[:defines]
+      end
+
+      def warnings
+        @options[:warnings]
+      end
+
+      def stop_after(stage = nil)
+        case stage
+        when :link
+          @options[:stop] = "c"
+        when :assemble
+          @options[:stop] = "S"
+        when :preprocess
+          @options[:stop] = "E"
+        else
+          @options.delete(:stop)
+        end
+      end
+
+      def object
+        stop_after :link
+        self
+      end
+
+      def run
+
+      end
+
+      private
+
+      def compile_options
+        compiled = ""
+
+        if @options.key?(:std)
+          compiled << "-std=#{@options[:std]} "
+        end
+
+        compiled << "-g#{@options[:optimize]} "
+        compiled << @options[:warnings].map { |w| "-W#{w}" }.join(" ")
+        compiled << "-fPIC "
+        compiled << @options[:directories][:include].map { |i| "-I#{i}"}
+      end
+    end
+  end
+end

data/lib/take/lint.rb

@@ -0,0 +1,8 @@
+require "take/lint/base"
+
+
+module Take
+  module Lint
+
+  end
+end

data/lib/take/lint/base.rb

@@ -0,0 +1,28 @@
+module Take
+  module Lint
+
+    # Manages linting source files when building.  Should be
+    # interesting to see how this pans out.
+    #
+    # @abstract
+    class Base
+
+      # Initializes the base linter.  Requires only one parameter.
+      #
+      # @param file [Path] the file that will be linted.
+      def initialize(file)
+        @file = file
+      end
+
+      # Lints the given file.  Returns an array of lint errors, which
+      # is used to give information about what could be fixed.
+      #
+      # @abstract
+      # @return [Array<Take::Lint::Error>]
+      def lint
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/take/lint/error.rb

@@ -0,0 +1,24 @@
+module Take
+  module Lint
+    class Error
+
+      attr_accessor :type
+      attr_accessor :file
+      attr_accessor :line
+      attr_accessor :column
+      attr_accessor :description
+
+      def initialize(data = {})
+        data.each do |key, value|
+          key = :"#{key}="
+
+          if respond_to? key
+            send key, value
+          else
+            raise ArgumentError, "Bad key given"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/take/project.rb

@@ -0,0 +1,88 @@
+require "pathname"
+require "command/runner"
+require "take/project/file"
+require "take/project/actionable"
+require "take/project/target"
+require "take/project/convert"
+require "take/project/definition"
+require "take/project/requirement"
+
+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
+
+    # Creates a new project with the block, and calls {#call}.
+    # Returns the created project.  A name is not required.
+    #
+    # @param [String?] name the name of the project.  If it is not
+    #   given, it is assumed from the directory name.
+    # @return [Project]
+    # @todo FIX
+    def self.create(name = nil, path = nil, &block)
+      project = new(name, path, &block)
+      project.call
+      project
+    end
+
+    # Initialize the project.
+    def initialize(name = nil, path = nil, &block)
+      @block   = block
+      @name    = name
+      @groups  = {}
+      @files   = {}
+      @targets = []
+      if path
+        @_path = Pathname.new(path)
+      end
+    end
+
+    # Set the project name.
+    def project(name)
+      @name = name
+    end
+
+    # The path to the project.
+    #
+    # @return [Pathname]
+    def path
+      @_path ||= Pathname.new("/home/homer/projects/dash")
+    end
+
+    def call
+      @definition = Definition.new(self)
+      @definition.instance_exec(&@block)
+      p @definition
+      @definition
+    end
+
+    # Creates a Makefile syntax-based string of the project.
+    #
+    # @return [String]
+    def to_makefile
+      out = ""
+      out << @targets.
+        map { |target| target.to_makefile(self) }.join("\n\n")
+      out
+    end
+
+    def file(name)
+      index = File.normalize(name, path)
+      @files[index] ||= File.new(index)
+    end
+
+    def env
+      {
+        cc: "gcc"
+      }
+    end
+
+  end
+end

data/lib/take/project/actionable.rb

@@ -0,0 +1,40 @@
+module Take
+  class Project
+
+    # Handles actions that might be taken from within a build action;
+    # used in {Convert}s and {Target}s.
+    class Actionable
+
+      attr_reader :data
+
+      def initialize(&blk)
+        @data = {}
+        @block = blk
+      end
+
+      def run(command, arguments)
+        runner = Command::Runner.new(command, arguments)
+        runner.pass!
+      end
+
+      def call(project, data = {})
+        @data = data.merge(
+          :curdir => project.path,
+          :env    => project.env)
+        instance_exec(@block)
+      end
+
+      def method_missing(method, *args, &block)
+        if @data.key?(method) && args.size == 0 && !block_given?
+          @data[method]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, _)
+        @data.key?(method)
+      end
+    end
+  end
+end

data/lib/take/project/convert.rb

@@ -0,0 +1,47 @@
+module Take
+  class Project
+
+    # Takes a file with a specific extension, and converts it to
+    # another file with a specific extension.  Woop de do.
+    class Convert
+
+      def initialize(hash, &blk)
+        raise ArgumentError, "Expected a block" unless block_given?
+        handle_arguments(hash)
+        @action = Actionable.new(&blk)
+      end
+
+      def can_convert?(from, to)
+        from_ext, to_ext = [from, to].map do |file|
+          if file.respond_to?(:extname)
+            file.extname
+          else
+            ::File.extname(file)
+          end
+        end
+
+        @from == from_ext && @to == to_ext
+      end
+
+      def convert(project, from, to)
+        raise ArgumentError, "Cannot convert #{from.inspect} to " \
+          "#{to.inspect} with this converter!" \
+          unless can_convert?(from, to)
+
+        @action.call(project, :input => from, :output => to)
+      end
+
+      private
+
+      def handle_arguments(hash)
+        raise ArgumentError, "Expected hash to only have size 1" \
+          unless hash.to_a.size == 1
+
+        pair = hash.to_a[0]
+        @from = pair[0]
+        @to = pair[1]
+      end
+
+    end
+  end
+end

data/lib/take/project/definition.rb

@@ -0,0 +1,31 @@
+module Take
+  class Project
+    class Definition
+
+      def initialize(project)
+        @project = project
+        @targets = {}
+        @converts = []
+        @requirements = []
+      end
+
+      def target(hash, &blk)
+        ntarget = Target.new(hash, @project, &blk)
+        @targets[ntarget.name] = ntarget
+      end
+
+      def targets
+        @targets
+      end
+
+      def to_convert(*opts, &blk)
+        Convert.new(*opts, &blk).tap { |c| @converts << c }
+      end
+
+      def requires(hash, &blk)
+        Requirement.convert(hash, @project, &blk).
+          tap { |r| @requirements.concat(r) }
+      end
+    end
+  end
+end

data/lib/take/project/file.rb

@@ -0,0 +1,47 @@
+require 'forwardable'
+
+module Take
+  class Project
+    class File
+
+      extend Forwardable
+
+      def self.normalize(file, path)
+        expanded = ::File.expand_path(file, path)
+        raise ArgumentError, "The given file cannot be placed in " \
+          "the project: #{file.inspect}" \
+          unless expanded.start_with?(path.to_s)
+        name = Pathname.new(expanded)
+        name.relative_path_from(path)
+      end
+
+      def_delegators :@name, :to_path, :to_s, :extname
+
+      def initialize(name)
+        @name = name
+      end
+
+      def type
+        @_type ||= begin
+          case @name.extname
+          when ".ta"
+            :library
+          when ".to", ".o"
+            :object
+          when ".c"
+            :source
+          when ""
+            :executable
+          else
+            :unknown
+          end
+        end
+      end
+
+
+      def sub_ext(ext)
+        File.new(@name.sub_ext(ext))
+      end
+    end
+  end
+end

data/lib/take/project/requirement.rb

@@ -0,0 +1,44 @@
+require "take/project/requirement/base"
+require "take/project/requirement/library"
+require "take/project/requirement/header"
+require "take/project/requirement/program"
+
+module Take
+  class Project
+    module Requirement
+
+      def self.convert(hash, project, &blk)
+        if hash.size > 1
+          raise ArgumentError, "Cannot use a block for a " \
+            "multi-requirement!" if block_given?
+        end
+
+        requirements = []
+
+        hash.each do |key, value|
+          requirement_class = lookup(key)
+          requirement = requirement_class.new(key, value, project,
+            &blk)
+          requirements << requirement
+        end
+
+        requirements
+      end
+
+      def self.lookup(name)
+        case name
+        when :header
+          Header
+        when :library
+          Library
+        when :program
+          Program
+        when Class
+          name
+        else
+          raise ArgumentError, "Unknown requirement #{name.inspect}!"
+        end
+      end
+    end
+  end
+end

data/lib/take/project/requirement/base.rb

@@ -0,0 +1,39 @@
+module Take
+  class Project
+    module Requirement
+      class Base
+
+        def self.default_action(&blk)
+          if block_given?
+            @_default_action = blk
+          else
+            @_default_action
+          end
+        end
+
+        def initialize(type, data, project, &blk)
+          @type = type
+          @data = data
+          @block = blk
+          @project = project
+
+          raise ArgumentError, "Unexpected block for requirement " \
+            "#{self.class}" unless expected_block?
+        end
+
+        def fills_requirement?
+          block = @block || default_action
+          block.call(@data, @project)
+        end
+
+        def expected_block?
+          true
+        end
+
+        def default_action
+          self.class.default_action
+        end
+      end
+    end
+  end
+end

data/lib/take/project/requirement/header.rb

@@ -0,0 +1,26 @@
+module Take
+  class Project
+    module Requirement
+      class Header < Base
+
+        default_action do |header, project|
+          file = Tempfile.new(['test', '.c'])
+          file.write("#include <#{header}>\n\nint main() " \
+            "{ return 0; }\n")
+          file.flush
+          out = Tempfile.new(['test', ''])
+
+          command = Command::Runner.new(project.env[:cc],
+            "-o {out} {in} -fPIC")
+          success = command.run(in: file.path, out: out.path) do |m|
+            p m
+          end.successful?
+
+          file.close(true)
+          out.close(true)
+          success
+        end
+      end
+    end
+  end
+end

data/lib/take/project/requirement/library.rb

@@ -0,0 +1,26 @@
+module Take
+  class Project
+    module Requirement
+      class Library < Base
+
+        default_action do |library, project|
+          file = Tempfile.new(['test', '.c'])
+          file.write("#include <stdlib.h>\n\nint main() " \
+            "{ return 0; }\n")
+          file.flush
+          out = Tempfile.new(['test', ''])
+
+          command = Command::Runner.new(project.env[:cc],
+            "-o {out} {in} -fPIC -l{library}")
+          success = command.run(in: file.path, library: library,
+            out: out.path).successful?
+
+          file.close(true)
+          out.close(true)
+          success
+        end
+
+      end
+    end
+  end
+end

data/lib/take/project/requirement/program.rb

@@ -0,0 +1,13 @@
+module Take
+  class Project
+    module Requirement
+      class Program < Base
+
+        default_action do |program, project|
+          runner = Command::Runner.new(program, "")
+          runner.run.no_command?
+        end
+      end
+    end
+  end
+end

data/lib/take/project/target.rb

@@ -0,0 +1,102 @@
+module Take
+  class Project
+
+    class Target
+
+      # Initializes the target.
+      #
+      # @param [Project] project the project that this target is
+      #   a part of.
+      # @param [Hash] hash a hash of the options for this target.  If
+      #   the any key is not one of the below, it is assumed to be the
+      #   target key-pair; there may only be one target key-pair (any
+      #   more will cause an ArgumentError).  If the key of the key
+      #   pair is a symbol, it is considered an "invalid" target,
+      #   meaning it _must not_ be a default target.
+      # @option hash [Symbol] :type The type of target it is.  This is
+      #   normally assumed from the extension.
+      # @option hash [Array<String>] :depends, :depends_on Files that
+      #   the target depends on.  This is normally set by the value
+      #   of the target key pair.
+      # @option hash [Symbol, String] :name The name of the target.
+      #   This is normally set by the key of the target key pair.
+      def initialize(hash, project, &block)
+        raise ArgumentError, "Targets require blocks" \
+          unless block_given?
+        @block = block
+        @project = project
+        @dependencies = []
+        handle_arguments(hash)
+        guess_type unless @type
+      end
+
+      def invalid?
+        @target.is_a?(Symbol)
+      end
+
+      def name
+        if invalid?
+          @target
+        else
+          @target.to_path
+        end
+      end
+
+      def sub(what, to)
+        @dependencies.map do |dep|
+          if dep.extname == what
+            dep.sub_ext(to)
+          else
+            dep
+          end
+        end
+      end
+
+      def to_a
+        @dependencies.map(&:to_path)
+      end
+
+      private
+
+      attr_reader :project
+
+      def guess_type
+        if invalid?
+          @type = :invalid
+        else
+          @type = @target.type
+        end
+      end
+
+      def handle_arguments(hash)
+        [:type, :depends, :depends_on, :name]
+        defined_target = false
+        raise ArgumentError, "Expected Hash, got #{hash.class}" \
+          unless hash.is_a?(Hash)
+
+        hash.each do |key, value|
+          case key
+          when :type
+            @type = value
+          when :depends, :depends_on
+            @dependencies.concat(Array(value))
+          when :name
+            @target = value
+          when String, Symbol
+            raise ArgumentError, "Target already defined!  Maybe you" \
+              " misspelled.  Unknown option #{key.inspect}." \
+              if defined_target
+            @target = key
+            defined_target = true
+            @dependencies.concat(Array(value))
+          else
+            raise ArgumentError, "Unknown option #{key.inspect}."
+          end
+        end
+
+        @target = project.file(@target) unless invalid?
+        @dependencies.map! { |dep| project.file(dep) }
+      end
+    end
+  end
+end

data/lib/take/unit/generator.rb

@@ -76,7 +76,7 @@ CODE
 void test_#{group_name(node)}()
 {
   tests++;
-  int test_success = 1;
+  int test_skip = 0, test_success = 1;
   output(TEXT_COLOR_MAGENTA "\\t\\tTEST \\"" TEXT_COLOR_BOLD_MAGENTA
     "#{node.name}" TEXT_COLOR_MAGENTA "\\": ");
 
@@ -86,7 +86,11 @@ CODE
         afters.each { |child| walk(child) }
         @output << <<-CODE
 
-  if(test_success)
+  if(test_skip)
+  {
+    output(TEXT_COLOR_BOLD_YELLOW "PASS\\n");
+  }
+  else if(test_success)
   {
 #ifdef VERBOSE
     output("\\n\\t\\t\\t" TEXT_COLOR_GREEN "OK\\n");

data/lib/take/version.rb

@@ -1,3 +1,3 @@
 module Take
-  VERSION = "0.0.10".freeze
+  VERSION = "0.0.11".freeze
 end

data/take.gemspec

@@ -21,4 +21,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"
+  spec.add_dependency "command-runner"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: take
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
+date: 2014-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: command-runner
+  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'
 description: Manage your C projects better.
 email:
 - redjazz96@gmail.com
@@ -65,6 +79,23 @@ files:
 - README.md
 - Rakefile
 - lib/take.rb
+- lib/take/compiler.rb
+- lib/take/compiler/base.rb
+- lib/take/compiler/gcc.rb
+- lib/take/lint.rb
+- lib/take/lint/base.rb
+- lib/take/lint/error.rb
+- lib/take/project.rb
+- lib/take/project/actionable.rb
+- lib/take/project/convert.rb
+- lib/take/project/definition.rb
+- lib/take/project/file.rb
+- lib/take/project/requirement.rb
+- lib/take/project/requirement/base.rb
+- lib/take/project/requirement/header.rb
+- lib/take/project/requirement/library.rb
+- lib/take/project/requirement/program.rb
+- lib/take/project/target.rb
 - lib/take/unit.rb
 - lib/take/unit/ast.rb
 - lib/take/unit/ast/after.rb
@@ -107,3 +138,4 @@ signing_key:
 specification_version: 4
 summary: Manage your C projects better.
 test_files: []
+has_rdoc: