taski 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 260795a6ff4d622bd95b3bfb2668ba6123f17339650ea9371ea54d2210691d98
+  data.tar.gz: 60d7f97a6c736ed91e50bd2e8e9f48c163f76024e7407c0da96c9d77f4394514
+SHA512:
+  metadata.gz: 71ccbe4131ac8409636071355af2de6cfda0862e21fb012e70b2f2fe60cb3bbc7023d640f9d3dc889f6759e8885a5dba5a1c0d543a6aa05e9299aa9ff401df54
+  data.tar.gz: a0a291d6fdd8d9ec1a122dbca9d115aa5c36f8008e7812120b0356e218ea895f46b292eab4404404c611c1f1b69e6dc9e4247f18d2cfc7a079b7d1f0ec2716d6

data/README.md

@@ -0,0 +1,65 @@
+# Taski
+
+**Taski** is a Ruby-based task runner designed for small, composable processing steps.
+With Taski, you define tasks and the outputs they depend on. Taski then statically resolves task dependencies and determines the correct execution order.
+
+Tasks are executed in a topologically sorted order, ensuring that all dependencies are resolved before a task is run. Reverse execution is also supported, making it easy to clean up intermediate files after a build process.
+
+> **🚧 Development Status:** Taski is currently under active development and the API may change.
+
+> **⚠️ Limitation:** Circular dependencies are **not** supported at this time.
+
+### Features
+
+- Simple and declarative task definitions
+- Static dependency resolution
+- Topological execution order
+- Reverse execution for teardown or cleanup
+- Built entirely in Ruby
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add taski
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install taski
+```
+
+## Usage
+
+```ruby
+class TaskA < Taski::Task
+  definition :task_a, -> { "Task A" }
+
+  def build
+    task_a
+  end
+end
+
+class TaskB < Taski::Task
+  definition :simple_task, -> { "Task result is #{TaskA.task_a}" }
+
+  def build
+    puts simple_task
+  end
+end
+
+TaskB.build
+# => Task result is Task A
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/taski.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+end
+
+task default: %i[test]

data/lib/taski/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Taski
+  VERSION = "0.1.0"
+end

data/lib/taski.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "taski/version"
+
+module Taski
+  class Reference
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def deref
+      Object.const_get(@klass)
+    end
+
+    def inspect
+      "&#{@klass}"
+    end
+  end
+
+  class Task
+    def self.__resolve__
+      @__resolve__ ||= {}
+    end
+
+    def self.ref(klass)
+      ref = Reference.new(klass)
+      throw :unresolve, ref
+    end
+
+    def self.definition(name, block, **options)
+      @dependencies ||= []
+      @definitions ||= {}
+
+      self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def self.#{name}
+          __resolve__[__callee__] ||= false
+          if __resolve__[__callee__]
+            # already resolved
+          else
+            __resolve__[__callee__] = true
+            throw :unresolve, [self, __callee__]
+          end
+        end
+      RUBY
+
+      classes = []
+      loop do
+        klass, task = catch(:unresolve) do
+          block.call
+          nil
+        end
+
+        if klass.nil?
+          classes.each do |task_class|
+            task_class[:klass].class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              __resolve__ = {}
+            RUBY
+          end
+
+          break
+        else
+          classes << { klass:, task: }
+        end
+      end
+
+      @dependencies += classes
+      @definitions[name] = {block:, options:, classes:}
+    end
+
+    def self.build
+      resolve_dependences.reverse.each do |task_class|
+        task_class.new.build
+      end
+    end
+
+    def self.clean
+      resolve_dependences.each do |task_class|
+        task_class.new.clean
+      end
+    end
+
+    def exec_command(command, info = nil, ret = false)
+      puts "exec: #{info}" if info
+      puts command
+
+      if ret
+        ret = `#{command}`.chomp
+        if $?.exited?
+          ret
+        else
+          raise "Failed to execute command: #{command}"
+        end
+      else
+        system command, exception: true
+      end
+    end
+
+    def self.refresh
+      # TODO
+    end
+
+    private
+
+    def self.resolve(queue, resolved)
+      @dependencies.each do |task|
+        if task[:klass].is_a?(Reference)
+          task_class = task[:klass].deref
+        end
+
+        # increase priority
+        if resolved.include?(task[:klass])
+          resolved.delete(task[:klass])
+        end
+        queue << task[:klass]
+      end
+
+      # override
+      self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def self.ref(klass)
+          Object.const_get(klass)
+        end
+      RUBY
+
+      @definitions.each do |name, (block, options)|
+        # override
+        self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def self.#{name}
+            @__#{name} ||= @definitions[:#{name}][:block].call
+          end
+        RUBY
+
+        self.define_method(name) do
+          unless instance_variable_defined?("@__#{name}")
+            instance_variable_set("@__#{name}", self.class.send(name))
+          end
+          instance_variable_get("@__#{name}")
+        end
+      end
+
+      self
+    end
+
+    def self.resolve_dependences
+      queue = [self]
+      resolved = []
+
+      while queue.any?
+        resolved << task_class = queue.shift
+        task_class.resolve(queue, resolved)
+      end
+
+      resolved
+    end
+  end
+end

data/sig/taski.rbs

@@ -0,0 +1,4 @@
+module Taski
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: taski
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ahogappa
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Taski is a Ruby-based task runner currently under development. It allows
+  you to define small, composable tasks along with the outputs they depend on. Taski
+  statically resolves dependencies and executes tasks in the correct topological order,
+  from the most dependent tasks first. It also supports reverse execution, useful
+  for cleaning up temporary files after a build. **Note:** Taski does not yet support
+  circular dependencies and may change as development progresses.
+email:
+- ahogappa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/taski.rb
+- lib/taski/version.rb
+- sig/taski.rbs
+homepage: https://github.com/ahogappa/taski
+licenses: []
+metadata:
+  homepage_uri: https://github.com/ahogappa/taski
+  source_code_uri: https://github.com/ahogappa/taski
+  changelog_uri: https://github.com/ahogappa/taski
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A simple yet powerful Ruby task runner with static dependency resolution
+  (in development).
+test_files: []