loki 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+gemspec
+
+gem "rake"

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/loki

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# require "rubygems"
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "loki"))

data/lib/loki.rb

@@ -0,0 +1,33 @@
+require "singleton"
+require "fileutils"
+
+require "loki/time"
+require "loki/logger"
+require "loki/identity"
+require "loki/file_pattern"
+require "loki/file_path"
+require "loki/task/base"
+require "loki/task/proc"
+require "loki/task/task"
+require "loki/task/file"
+require "loki/task/make"
+
+
+module Loki
+
+  def self.task(name = :task, &block)
+    task = Task::Task.new(name)
+    task.instance_eval(&block)
+    # task.list
+    task.work
+  end
+
+
+  private
+
+  def self.block_unique_id(&block)
+    source = block.source_location
+    ::File.expand_path(source[0]) + ":#{source[1]}"
+  end
+
+end # module

data/lib/loki/file_path.rb

@@ -0,0 +1,41 @@
+module Loki
+  class FilePath
+    attr_reader :path
+
+
+    def initialize(path)
+      self.path = path
+    end
+
+
+    def path=(path)
+      @path = ::File.expand_path(path.to_s)
+    end
+
+
+    def relative(from = Dir.pwd)
+      @path.gsub(/^#{from}\//, '')
+    end
+
+
+    def absolute
+      ::File.expand_path(@path)
+    end
+
+
+    def mtime
+      ::File.mtime(@path)
+    end
+
+
+    def exists?
+      ::File.exists?(@path)
+    end
+
+
+    def to_s
+      @path.to_s
+    end
+
+  end # class
+end # module

data/lib/loki/file_pattern.rb

@@ -0,0 +1,79 @@
+module Loki
+  class FilePattern
+    include Enumerable
+    attr_reader :path
+
+
+    def initialize(path)
+      self.path = path
+    end
+
+
+    def path=(new_path)
+      @path = new_path.to_s
+    end
+
+
+    def each(&block)
+      Dir.glob(@path).each do |file|
+        yield FilePath.new(file) if block_given?
+      end
+    end
+    
+    
+    def interpolate_each(result_pattern, &block)
+      each do |source_path|
+        yield source_path, interpolate(source_path, result_pattern) if block_given?
+      end
+    end
+
+
+    def individual?
+      !(@path =~ /[\?\[\]\{\}\*]/)
+    end
+
+
+    def collection?
+      !individual?
+    end
+
+
+    def relative(from = Dir.pwd)
+      @path.gsub(/^#{from}\//, '')
+    end
+
+
+    def absolute
+      ::File.expand_path(@path)
+    end
+
+
+    def to_s
+      @path.to_s
+    end
+    
+    
+    private
+
+    def interpolate(source_path, result_pattern)
+      parts_regex = ""
+      parts = absolute.split("/") # File::SEPARATOR
+      parts.each_with_index do |part, index|
+        if part == "**"
+          parts_regex += "((?:[^\/]+\/)*)"
+        else
+          has_captures = !!(part =~ /[\?\[\]\{\}\*]/)
+          part.gsub!(/\?/, ".")
+          part.gsub!(/([\.\\])/, "\\\\\\1")
+          part.gsub!(/\{([^\}]+)\}/) { "(?:" + $1.split(",").join("|") + ")" }
+          part.gsub!(/\*/, "[^\/]+")
+          parts_regex += has_captures ? "(" + part + ")" : part
+          parts_regex += "/" unless index == parts.size - 1
+        end
+      end
+      parts = source_path.to_s.match(/^#{parts_regex}$/)
+      result_pattern.to_s.gsub(/\*+\/?/).each_with_index { |m, i| parts[i+1] }
+    end
+
+  end # class
+end # module

data/lib/loki/identity.rb

@@ -0,0 +1,21 @@
+module Loki
+
+  IDENTITY_MAP = {}
+
+  module Identity
+    def self.included(other)  
+      other.class_eval %{
+        class << self
+          alias_method :__#{other.to_s.gsub(':','')}_new, :new
+          def new(name, *args, &block)
+            name = self.identify(name) if self.respond_to?(:identify)
+            IDENTITY_MAP.fetch(name) do
+              IDENTITY_MAP[name] = __#{other.to_s.gsub(':','')}_new(name, *args, &block)
+            end
+          end
+        end
+      }
+    end
+  end
+
+end # module

data/lib/loki/logger.rb

@@ -0,0 +1,70 @@
+module Loki
+  class Logger
+    include Singleton
+    
+
+    COLORS = {
+      :red     => 31,
+      :green   => 32,
+      :yellow  => 33,
+      :blue    => 34,
+      :magenta => 35,
+      :cyan    => 36,
+      :white   => 37,
+      :r       => 31,
+      :g       => 32,
+      :y       => 33,
+      :b       => 34,
+      :m       => 35,
+      :c       => 36,
+      :w       => 37
+    }
+
+
+    def initialize
+      @indent = 0
+    end
+
+
+    def push
+      @indent += 1
+    end
+
+
+    def pull
+      @indent -= 1
+    end
+
+
+    def puts(text, mark = ">")
+      $stdout.puts((" " * @indent * 2) + "#{mark} #{parse(text)}")
+    end
+
+
+    def line
+      $stdout.puts("-" * 80) if @indent == 0
+    end
+    
+    
+    public
+    
+    def paint(text, color = :white)
+      "\e[#{COLORS[color]}m#{text}\e[0m"
+    end
+
+
+    def parse(text)
+      colors = COLORS.keys.collect(&:to_s).join('|')
+      text.gsub(/\<(#{colors})\>(.*)\<\/\1\>/) do
+        paint($2, $1.to_sym)
+      end
+    end
+
+  end # class
+
+
+  def self.logger
+    @logger ||= Logger.instance
+  end
+
+end # module

data/lib/loki/task/base.rb

@@ -0,0 +1,74 @@
+module Loki
+  module Task
+    class Base
+      attr_reader :name
+
+
+      def initialize(name)
+        @name = name
+        @parent = nil
+      end
+
+
+      def work(&block)
+        Loki.logger.puts "#{@name}"
+        Loki.logger.push
+        yield if block_given?
+        Loki.logger.pull
+      end
+
+
+      def time
+        Time.now
+      end
+
+
+      def done?
+        false
+      end
+
+
+      def sham?
+        false
+      end
+
+
+      def list(&block)
+        Loki.logger.line
+        Loki.logger.puts "#{self.class}: #{@name}, done: #{done?}, time: #{time}", "-"
+        Loki.logger.push
+        yield if block_given?
+        Loki.logger.pull
+        Loki.logger.line
+      end
+
+
+      protected
+
+      def parent
+        @parent
+      end
+
+
+      def parent=(parent)
+        @parent = parent
+      end
+
+
+      def siblings
+        @parent.children.reject { |task| task == self }
+      end
+
+
+      def evaluate(&block)
+        block_id = Loki.block_unique_id(&block)
+        @evaluated ||= {}
+        unless @evaluated.has_key?(block_id)
+          instance_eval(&block)
+          @evaluated[block_id] = true
+        end
+      end
+
+    end # class
+  end # module
+end # module

data/lib/loki/task/file.rb

@@ -0,0 +1,48 @@
+module Loki
+  module Task
+    class File < Task
+      include Identity
+
+
+      def initialize(path)
+        @path = FilePath.new(path)
+        super(@path.relative)
+      end
+
+
+      def self.identify(name)
+        ::File.expand_path(name.to_s)
+      end
+
+
+      def path
+        @path.path
+      end
+
+
+      def done?
+        exists? and up_to_date? and super
+      end
+
+
+      def exists?
+        @path.exists?
+      end
+
+
+      def up_to_date?
+        @children.none? { |task| task.time > time }
+      end
+
+
+      def time
+        if exists?
+          @path.mtime
+        else
+          Loki::PRIMEVAL
+        end
+      end
+
+    end # class
+  end # module
+end # module

data/lib/loki/task/make.rb

@@ -0,0 +1,41 @@
+module Loki
+  module Task
+    class Make < File
+      include Identity
+
+
+      def initialize(path, sources = nil)
+        @sources = Array(sources).map { |s| File.new(s) }
+        super(path)
+      end
+
+
+      def sources
+        @sources.collect(&:path)
+      end
+
+
+      def source_path
+        @sources.first.path
+      end
+
+
+      def result_path
+        @path.path
+      end
+
+
+      def up_to_date?
+        (@children + @sources).none? { |task| task.time > time }
+      end
+      
+      def test?
+        @children.find_all { |task| task.time > time }.each do |o|
+          ap "#{o.name} #{o.time}"
+        end
+        (@children + @sources).reject(&:sham?).none? { |task| task.time > time }
+      end
+
+    end # class
+  end # module
+end # module

data/lib/loki/task/proc.rb

@@ -0,0 +1,34 @@
+module Loki
+  module Task
+    class Proc < Base
+
+      def initialize(name, &proc)
+        @proc = proc
+        super(name.gsub(/^#{Dir.pwd}\//, ''))
+      end
+
+
+      def work
+        super do
+          @proc.call unless @proc.nil?
+        end
+      end
+
+
+      def time
+        Loki::PRIMEVAL
+      end
+
+
+      def done?
+        siblings.reject(&:sham?).all?(&:done?) and @parent.done?
+      end
+
+
+      def sham?
+        true
+      end
+
+    end # class
+  end # module
+end # module

data/lib/loki/task/task.rb

@@ -0,0 +1,91 @@
+module Loki
+  module Task
+    class Task < Base
+      include Identity
+      attr_reader :children
+
+
+      def initialize(name)
+        @children = []
+        super(name)
+      end
+
+
+      def task(name, &block)
+        add_dependency Task.new(name), &block
+      end
+
+
+      def proc(&block)
+        source = Loki.block_unique_id(&block)
+        add_dependency Proc.new(source, &block)
+      end
+
+
+      def make(result_pattern, source_pattern = nil, &block)
+        if source_pattern.nil?
+          add_dependency Make.new(result_pattern), &block
+        else
+          source_pattern = FilePattern.new(source_pattern)
+          result_pattern = FilePattern.new(result_pattern)
+          if result_pattern.individual?
+            add_dependency Make.new(result_pattern, source_pattern.to_a), &block
+          else
+            source_pattern.interpolate_each(result_pattern) do |source_path, result_path|
+              add_dependency Make.new(result_path, source_path), &block
+            end
+          end
+        end
+      end
+
+
+      def scan(dependencies, &block)
+        dependencies = Dir.glob(dependencies) if dependencies.is_a?(String)
+        dependencies.each do |dependency|
+          add_dependency(File.new(dependency), &block)
+        end
+      end
+
+
+      def work
+        super do
+          @children.each do |task|
+            task.work unless task.done?
+          end
+        end
+      end
+
+
+      def done?
+        @children.reject(&:sham?).all?(&:done?)
+      end
+
+
+      def time
+        @children.collect(&:time).max || super
+      end
+
+
+      def list
+        super do
+          @children.each do |task|
+            task.list
+          end
+        end
+      end
+
+
+      protected
+
+      def add_dependency(task, &block)
+        unless children.include?(task)
+          task.parent = self
+          children << task
+          task.evaluate(&block) if block_given?
+        end
+        task
+      end
+
+    end # class
+  end # module
+end # module

data/lib/loki/time.rb

@@ -0,0 +1,46 @@
+require 'singleton'
+
+
+module Loki
+  class Primeval
+    include Comparable
+    include Singleton
+
+
+    def <=>(other)
+      -1
+    end
+
+
+    def to_s
+      "<Primeval>"
+    end
+
+
+    def strftime(*args)
+      "<Primeval>"
+    end
+  end
+
+
+  PRIMEVAL = Primeval.instance
+end
+
+
+class Time
+
+  alias loki_original_compare :<=>
+  def <=>(other)
+    if Loki::Primeval === other
+      - other.<=>(self)
+    else
+      loki_original_compare(other)
+    end
+  end
+
+
+  def to_s
+    strftime("%m-%d-%Y %H:%M:%S")
+  end
+
+end

data/lib/loki/version.rb

@@ -0,0 +1,3 @@
+module Loki
+  VERSION = "0.0.2"
+end

data/loki.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "loki/version"
+
+Gem::Specification.new do |s|
+  s.name        = "loki"
+  s.version     = Loki::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Patrick Hogan"]
+  s.email       = ["pbhogan@gmail.com"]
+  s.homepage    = "https://github.com/pbhogan/loki"
+  s.summary     = "A highly experimental and simplistic Rake-like DSL."
+  s.description = s.summary
+
+  # s.rubyforge_project = "loki"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: loki
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Patrick Hogan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-24 00:00:00 Z
+dependencies: []
+
+description: A highly experimental and simplistic Rake-like DSL.
+email: 
+- pbhogan@gmail.com
+executables: 
+- loki
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/loki
+- lib/loki.rb
+- lib/loki/file_path.rb
+- lib/loki/file_pattern.rb
+- lib/loki/identity.rb
+- lib/loki/logger.rb
+- lib/loki/task/base.rb
+- lib/loki/task/file.rb
+- lib/loki/task/make.rb
+- lib/loki/task/proc.rb
+- lib/loki/task/task.rb
+- lib/loki/time.rb
+- lib/loki/version.rb
+- loki.gemspec
+homepage: https://github.com/pbhogan/loki
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3930385297513677759
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3930385297513677759
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: A highly experimental and simplistic Rake-like DSL.
+test_files: []
+