taski 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 260795a6ff4d622bd95b3bfb2668ba6123f17339650ea9371ea54d2210691d98
-  data.tar.gz: 60d7f97a6c736ed91e50bd2e8e9f48c163f76024e7407c0da96c9d77f4394514
+  metadata.gz: d04adfab160e07e101e7d6364796d5607a896010396950ee5d479824bb4c422e
+  data.tar.gz: aeb0ea3476853608c0ef77e80e907c79db7ea62c1aaead8a22d8232d7e4c13aa
 SHA512:
-  metadata.gz: 71ccbe4131ac8409636071355af2de6cfda0862e21fb012e70b2f2fe60cb3bbc7023d640f9d3dc889f6759e8885a5dba5a1c0d543a6aa05e9299aa9ff401df54
-  data.tar.gz: a0a291d6fdd8d9ec1a122dbca9d115aa5c36f8008e7812120b0356e218ea895f46b292eab4404404c611c1f1b69e6dc9e4247f18d2cfc7a079b7d1f0ec2716d6
+  metadata.gz: b3201ee69bc45ae1e58569bf1a98647ff7e38adabf0d04334805fdbac816468d420b1d460113970e1fc9394e6f9e6ca2fe4c700e0c390b9032366a01690c7762
+  data.tar.gz: 81a9796f7234f8f66216b61b7ea676b40614bb8258b8a6d6a0244e5d016319ea1492f7817324e1669a6ede1eeaf3f0ad4d8b71fd210168022838f66047348bff

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ahogappa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,49 +1,37 @@
 # 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.
+In Taski, you define tasks as Ruby classes that expose named values through `define`. Dependencies between tasks are established automatically when one task references the result of another—no need for explicit dependency declarations.
 
-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.
+Tasks are executed in a topologically sorted order, ensuring that tasks are built only after their inputs are available. Reverse execution is also supported, making it easy to clean up intermediate files or revert changes after a build.
 
 > **🚧 Development Status:** Taski is currently under active development and the API may change.
 
 > **⚠️ Limitation:** Circular dependencies are **not** supported at this time.
 
+> **ℹ️ Note:** Taski does **not** infer dependencies from file contents or behavior. Instead, dependencies are implicitly established via references between task definitions.
+
 ### Features
 
-- Simple and declarative task definitions
-- Static dependency resolution
+- Define tasks using Ruby classes
+- Implicit dependencies via reference to other task outputs
 - Topological execution order
-- Reverse execution for teardown or cleanup
+- Reverse execution for 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
+### Example
 
 ```ruby
 class TaskA < Taski::Task
-  definition :task_a, -> { "Task A" }
+  define :task_a_result, -> { "Task A" }
 
   def build
-    task_a
+    puts 'Processing...'
   end
 end
 
 class TaskB < Taski::Task
-  definition :simple_task, -> { "Task result is #{TaskA.task_a}" }
+  define :simple_task, -> { "Task result is #{TaskA.task_a_result}" }
 
   def build
     puts simple_task
@@ -51,9 +39,24 @@ class TaskB < Taski::Task
 end
 
 TaskB.build
+# => Processing...
 # => Task result is Task A
 ```
 
+## 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
+```
+
 ## 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.

data/lib/taski/utils.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Taski
+  class Utils < FileUtils
+    def rm
+
+    end
+
+    def rm_f
+    end
+
+    def rm_rf
+
+    end
+
+    def cp
+
+    end
+
+    def cp_r
+
+    end
+
+    def mkdir
+
+    end
+
+    def mkdir_p
+
+    end
+
+    def mktmpdir
+
+    end
+
+    def cmd(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
+  end
+end

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -18,138 +18,126 @@ module Taski
   end
 
   class Task
-    def self.__resolve__
-      @__resolve__ ||= {}
-    end
+    class << self
+      def ref(klass)
+        ref = Reference.new(klass)
+        throw :unresolved, ref
+      end
 
-    def self.ref(klass)
-      ref = Reference.new(klass)
-      throw :unresolve, ref
-    end
+      def define(name, block, **options)
+        @dependencies ||= []
+        @definitions ||= {}
 
-    def self.definition(name, block, **options)
-      @dependencies ||= []
-      @definitions ||= {}
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def self.#{name}
+            __resolve__[__callee__] ||= false
+            if __resolve__[__callee__]
+              # already resolved
+            else
+              __resolve__[__callee__] = true
+              throw :unresolved, [self, __callee__]
+            end
+          end
+        RUBY
 
-      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__]
+        classes = []
+        loop do
+          klass, task = catch(:unresolved) do
+            block.call
+            nil
           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
 
-        if klass.nil?
-          classes.each do |task_class|
-            task_class[:klass].class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              __resolve__ = {}
-            RUBY
+            break
+          else
+            classes << { klass:, task: }
           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
+        @dependencies += classes
+        @definitions[name] = { block:, options:, classes: }
       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}"
+      def build
+        resolve_dependencies.reverse.each do |task_class|
+          task_class.new.build
         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
+      def clean
+        resolve_dependencies.each do |task_class|
+          task_class.new.clean
         end
+      end
 
-        # increase priority
-        if resolved.include?(task[:klass])
-          resolved.delete(task[:klass])
-        end
-        queue << task[:klass]
+      def refresh
+        # TODO
       end
 
-      # override
-      self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def self.ref(klass)
-          Object.const_get(klass)
+      def resolve(queue, resolved)
+        @dependencies.each do |task|
+          if task[:klass].is_a?(Reference)
+            task[:klass].deref
+          else
+            task[:klass]
+          end => task_class
+
+          # increase priority
+          if resolved.include?(task_class)
+            resolved.delete(task_class)
+          end
+          queue << task_class
         end
-      RUBY
 
-      @definitions.each do |name, (block, options)|
         # override
-        self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.#{name}
-            @__#{name} ||= @definitions[:#{name}][:block].call
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def self.ref(klass)
+            Object.const_get(klass)
           end
         RUBY
 
-        self.define_method(name) do
-          unless instance_variable_defined?("@__#{name}")
-            instance_variable_set("@__#{name}", self.class.send(name))
+        @definitions.each do |name, (_block, _options)|
+          # override
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def self.#{name}
+              @__#{name} ||= @definitions[:#{name}][:block].call
+            end
+          RUBY
+
+          define_method(name) do
+            unless instance_variable_defined?("@__#{name}")
+              instance_variable_set("@__#{name}", self.class.send(name))
+            end
+            instance_variable_get("@__#{name}")
           end
-          instance_variable_get("@__#{name}")
         end
-      end
 
-      self
-    end
+        self
+      end
 
-    def self.resolve_dependences
-      queue = [self]
-      resolved = []
+      private
 
-      while queue.any?
-        resolved << task_class = queue.shift
-        task_class.resolve(queue, resolved)
+      def __resolve__
+        @__resolve__ ||= {}
       end
 
-      resolved
+      def resolve_dependencies
+        queue = [self]
+        resolved = []
+
+        while queue.any?
+          resolved << task_class = queue.shift
+          task_class.resolve(queue, resolved)
+        end
+
+        resolved
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - ahogappa
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-05-18 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
@@ -21,9 +21,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - Rakefile
 - lib/taski.rb
+- lib/taski/utils.rb
 - lib/taski/version.rb
 - sig/taski.rbs
 homepage: https://github.com/ahogappa/taski
@@ -46,7 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A simple yet powerful Ruby task runner with static dependency resolution
   (in development).