tasking 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3d84bc5f691b364727b241743fb800bf6d571ac3885461124081e959fc6ac78
+  data.tar.gz: cd7411408417cd0942ba17e66ce38c3f707b4d76ca4f7171027b07bc670ce2cc
+SHA512:
+  metadata.gz: d4efa63e1c58b9dac0997f1ff46ba067bcb724c052bbba2f221fde224f12e4f83983e3b56fab1e1a4c91759cfd76d5fc64f431fb0d45c671878f01ef5b3d7404
+  data.tar.gz: 7f25bef3273737f3655809b5af02268c88dc57bbbf1f70e67deca30cf21669584ed6161e02634839f6f0b8b23cbd59975da455fca0126341cd29e144b21ce143

data/README.rdoc

@@ -0,0 +1,94 @@
+=== Running tasks from the command line
+tasking <task_name>
+
+=== The DSL
+The DSL has the following commands:
+  * namespace
+  * task
+  * options
+  * before
+  * after
+  * execute
+
+==== Namespaces
+Namespaces are used to organize tasks into logical units and isolate options
+from each other. Namespaces can be nested. To reference a nested namespace you
+can use the format "outer_name::inner_name". To reference a namespace with it's
+absolute name, prefix the name with a "::", e.g. "::outer::inner".
+
+Namespaces can be re-opened. In that case their content will be merged with the
+original content.
+
+==== Tasks
+Tasks contain commands to be executed. The execution of a task can be modified
+by supplying before- and after-task chains (see the before/after sections
+below).
+
+Note that each task _must_ be contained in a namespace. Top-Level tasks will
+raise an error.
+
+Opening a task with a name that already exists within the same namespace will
+overwrite the original task.
+
+==== Before/After
+The before and after commands modify the execution chain of a task, by giving a
+list of other tasks that should be executed before and after the main task is
+executed. Note that these filters will be run each time the main task is run.
+
+Also, while the main task name can be given relative to the current namespace,
+the tasks in the chain are always interpreted in an absolute fashion.
+
+Referencing a task that does not exist will raise an error. 
+
+Also note that the before and after commands can only be given within the scope
+of a namespace, not within a task.
+
+==== Execute
+aka run, invoke. Used to execute another task from within a task. The only
+command that may be supplied within a task (and only from within a task). 
+
+The supplied task name will first be looked up in a fashion relative to the
+current tasks parent namespace. If no task is found there, an absolute lookup
+is performed. Will raise an error if a non-existant task is referenced.
+
+==== Options
+Supplies a hash of options that can accessed from within a task. Supplying
+options within nested namespaces will result in the inner namespace merging its
+set of options with the outer namespaces options.
+
+Note that the namespace, task and execute commands can also supply an explicit
+hash of options.
+
+At the time being, explicitly invoking a task from another task does not 
+automatically supply the invoking tasks options to the invoked task.
+
+Options that have a value that responds to #call (procs, lambdas, methods) will
+be resolved to the return value of that #call invocation right before a task
+is executed. During the resolving of the options, the original set of 
+(unresolved) options is passed as an argument.
+
+Option resolution happens every time a task is executed, and the results are
+not persisted or memoized. The resolution happens independently for before
+and after hook tasks from the main task being executed.
+
+For example:
+
+    namespace "outer", :foo => :bar do
+      options :bar => :baz
+      namespace "inner", :baz => :quux do
+        options :quux => :narf
+        task "some task" do
+          execute "my task", :bla => :blubb
+        end
+
+        task "my task", :narf => :bla do |options|
+          # options now has the contents: { :foo => :bar,
+                                            :bar => :baz,
+                                            :baz => :quux,
+                                            :quux => :narf,
+                                            :narf => :bla,
+                                            :bla  => :blubb }
+        end
+      end
+    end
+

data/bin/tasking

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'lib/tasking'
+
+include Tasking
+task_name = ARGV[0]
+
+load 'Taskfile'
+
+execute task_name
+
+

data/lib/tasking/namespace.rb

@@ -0,0 +1,76 @@
+module Tasking
+  class Namespace
+    attr_reader :name, :options
+
+    def self.namespaces
+      @namespaces ||= {}
+    end
+    private_class_method :namespaces
+
+    def self.all
+      namespaces.values
+    end
+
+    def self.add_namespace( ns )
+      namespaces[ns.name] = ns
+    end
+
+    def self.find_namespace( name )
+      namespaces[name]
+    end
+
+    def self.find_task_in_namespace( ns_name, task_name )
+      ns = find_namespace( ns_name )
+      ns&.find_task( task_name )
+    end
+
+    def self.find_task( full_name )
+      namespace_name, _, task_name = full_name.rpartition( '::' )
+
+      self.find_task_in_namespace( namespace_name, task_name )
+    end
+
+    def self.find_or_create( name, options = {} )
+      find_namespace( name ) || new( name, options )
+    end
+
+    def initialize( name, options = {} )
+      @tasks = {}
+      @name = name
+      @options = options
+      
+      self.class.add_namespace( self )
+    end
+
+    def tasks
+      @tasks.values
+    end
+
+    def parent_namespace
+      parent_name, _, _ = @name.rpartition( '::' )
+
+      parent_name.empty? ? nil : self.class.find_namespace( parent_name )
+    end
+
+    def execute( options = {}, &block )
+      @options.merge!( options )
+      block.call if block
+    end
+
+    def merge_options( options )
+      @options.merge!( options )
+    end
+
+    def register_task( task )
+      @tasks[task.name] = task
+    end
+
+    def unregister_task( task )
+      @tasks.delete( task.name )
+    end
+
+    def find_task( name )
+      @tasks[name]
+    end
+  end
+end

data/lib/tasking/task.rb

@@ -0,0 +1,49 @@
+module Tasking
+  class Task
+    attr_reader :name, :options, :block, :before_filters, :after_filters,
+                :parent_namespace
+
+    def initialize( name, parent_namespace, options = {}, &block )
+      @name             = name
+      @parent_namespace = parent_namespace
+      @options          = options
+      @block            = block
+      @before_filters   = []
+      @after_filters    = []
+    end
+
+    def add_before_filters( *filters )
+      @before_filters.concat( filters.flatten )
+    end
+
+    def add_after_filters( *filters )
+      @after_filters.concat( filters.flatten )
+    end
+
+    def execute( options = {} )
+      total_options = @options.merge( options )
+      execute_task_chain( before_filters, total_options, "Unknown before task '%s' for task '#{@name}'" )
+      @block.call( resolve_options( total_options ) ) if @block
+      execute_task_chain( after_filters, total_options, "Unknown after task '%s' for task '#{@name}'" )
+    end
+
+    private
+
+    def resolve_options(options)
+      options.transform_values { |v| v.respond_to?(:call) ? v.call(options) : v }
+    end
+
+    def execute_task_chain( tasks, options, fail_message )
+      tasks.each do |t|
+        task = task_lookup( t )
+        abort( fail_message % t ) unless task
+        task.execute(options)
+      end
+    end
+
+    def task_lookup( name )
+      name.slice!( 0, 2 ) if name.start_with?( '::' ) 
+      Tasking::Namespace.find_task( name )
+    end
+  end
+end

data/lib/tasking.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+module Tasking
+  def task( name, options = {}, &block )
+    abort( "Tasks with empty names are not allowed" ) if name.to_s.empty?
+
+    full_name = fully_qualified_name( name )
+    namespace_name, task_name = split_task_from_namespace( full_name )
+
+    abort( "Task '#{name}' is not in a namespace" ) if namespace_name.empty?
+
+    build_namespace_hierarchy( namespace_name )
+
+    parent_namespace = Tasking::Namespace.find_namespace( namespace_name )
+    task = Tasking::Task.new( task_name, parent_namespace, options, &block )
+    parent_namespace.register_task( task )
+  end
+
+  def namespace( name, options = {}, &block ) 
+    abort( "Namespaces with empty names are not allowed" ) if name.to_s.empty?
+    @__parent_namespace ||= []
+
+    full_name = fully_qualified_name( name )
+    parent_namespace_names, _ = split_task_from_namespace( full_name )
+    build_namespace_hierarchy( parent_namespace_names )
+
+    next_namespace = Tasking::Namespace.find_or_create( full_name, options )
+    @__parent_namespace.push( next_namespace )
+    next_namespace.execute( options, &block )
+    @__parent_namespace.pop
+  end
+
+  def options( options ) 
+    @__parent_namespace.last.merge_options( options )
+  end
+
+  def late_before( task_name, parent_namespace_name, *before_task_names )
+    task = Tasking::Namespace.find_task_in_namespace( parent_namespace_name, task_name ) ||
+           Tasking::Namespace.find_task( task_name ) 
+    abort( "Unknown task '#{task_name}' in before filter" ) unless task
+
+    task.add_before_filters( *before_task_names )
+  end
+
+  def late_after( task_name, parent_namespace_name, *after_task_names )
+    task = Tasking::Namespace.find_task_in_namespace( parent_namespace_name, task_name ) ||
+           Tasking::Namespace.find_task( task_name ) 
+    abort( "Unknown task '#{task_name}' in after filter" ) unless task
+
+    task.add_after_filters( *after_task_names )
+  end
+
+  def before( task_name, *before_task_names )
+    @__late_evaluations ||= {}
+    @__late_evaluations[:before] ||= []
+    parent_namespace_name = @__parent_namespace.last&.name.to_s
+    @__late_evaluations[:before] << [ task_name, parent_namespace_name, before_task_names.flatten ]
+  end
+
+  def after( task_name, *after_task_names )
+    @__late_evaluations ||= {}
+    @__late_evaluations[:after] ||= []
+    parent_namespace_name = @__parent_namespace.last&.name.to_s
+    @__late_evaluations[:after] << [ task_name, parent_namespace_name, after_task_names.flatten ]
+  end
+
+  def late_evaluations
+    return unless @__late_evaluations
+    @__late_evaluations.each_pair do |type, task_parameters|
+      task_parameters.each do |( task_name, parent_namespace_name, args )|
+        self.send( :"late_#{type}", task_name, parent_namespace_name, *args )
+      end
+    end
+  end
+
+  def execute( name, options = {} )
+    if !@__subsequent_executions
+      @__subsequent_executions = true
+      late_evaluations
+    end
+    task = task_lookup( name )
+  
+    if !task
+      msg = "Unknown task '#{name}'"
+      msg << " or #{fully_qualified_name( name )}" if @__parent_namespace.size > 0
+      abort( msg )
+    end
+
+    namespace_hierarchy_options = gather_options_for( name, task )
+    namespace_hierarchy_options.merge!( options )
+    @__parent_namespace.push( task.parent_namespace )
+    task.execute( namespace_hierarchy_options )
+    @__parent_namespace.pop
+  end
+  alias_method :invoke, :execute
+  alias_method :run, :execute
+
+  private
+  def task_lookup( name )
+    @__parent_namespace ||= []
+    task = nil
+
+    if name.start_with?( '::' ) 
+      name.slice!( 0, 2 )
+      return Tasking::Namespace.find_task( name )
+    end
+
+    if @__parent_namespace.last 
+      full_name = "#{@__parent_namespace.last.name}::#{name}"
+      task = Tasking::Namespace.find_task( full_name )
+    end
+
+    task || Tasking::Namespace.find_task( name )
+  end
+
+  def walk_namespace_tree_to( namespace_name, type = :namespace, &block )
+    ns_segments = namespace_name.split( '::' )
+    ns_segments.pop if type != :namespace
+
+    current_ns_hierarchy_level = nil
+    ns_segments.each do |segment|
+      if current_ns_hierarchy_level == nil
+        current_ns_hierarchy_level = segment
+      else
+        current_ns_hierarchy_level += "::#{segment}"
+      end 
+
+      block.call( current_ns_hierarchy_level )
+    end
+  end
+
+  def gather_options_for( full_task_name, task )
+    final_options = {}
+
+    walk_namespace_tree_to( full_task_name, :task ) do |ns_name|
+      namespace = Tasking::Namespace.find_namespace( ns_name )
+      final_options.merge!( namespace.options )
+    end
+
+    final_options.merge!( task.options )
+  end
+
+  def fully_qualified_name( name )
+    @__parent_namespace&.last ? 
+      "#{@__parent_namespace.last.name}::#{name}" : 
+      name
+  end
+
+  def build_namespace_hierarchy( full_name ) 
+    walk_namespace_tree_to( full_name ) do |ns_name|
+      Tasking::Namespace.find_or_create( ns_name ) 
+    end
+  end
+
+  def split_task_from_namespace( full_name )
+    namespace_name, _, task_name = full_name.rpartition( '::' )
+
+    [ namespace_name, task_name ]
+  end
+end
+
+require_relative 'tasking/namespace'
+require_relative 'tasking/task'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: tasking
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Sven Riedel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A lightweight DSL for task definition and execution
+email: sr@gimp.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.rdoc
+- bin/tasking
+- lib/tasking.rb
+- lib/tasking/namespace.rb
+- lib/tasking/task.rb
+homepage: https://github.com/sriedel/tasking
+licenses:
+- GPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A lightweight task runner DSL
+test_files: []