abid 0.3.0.pre.alpha.3 → 0.3.0.pre.alpha.4

data/lib/abid/play_core.rb

@@ -1,53 +0,0 @@
-module Abid
-  module PlayCore
-    def set(name, value = nil, &block)
-      var = :"@#{name}"
-
-      define_method(name) do
-        unless instance_variable_defined?(var)
-          if !value.nil?
-            instance_variable_set(var, value)
-          elsif block_given?
-            instance_variable_set(var, instance_eval(&block))
-          end
-        end
-        instance_variable_get(var)
-      end
-    end
-
-    def params_spec
-      @params_spec ||= {}
-    end
-
-    def param(name, **param_spec)
-      define_method(name) { task.params[name] }
-      params_spec[name] = { significant: true }.merge(param_spec)
-    end
-
-    def undef_param(name)
-      params_spec.delete(name)
-      undef_method(name) if method_defined?(name)
-    end
-
-    def include(*mod)
-      ms = mod.map do |m|
-        if m.is_a? Module
-          m
-        else
-          mixin_task = task.application[m, task.scope]
-
-          fail "#{m} is not a mixin" unless mixin_task.is_a? MixinTask
-
-          mixin_task.mixin.tap do |mixin|
-            # inherit params_spec
-            mixin.params_spec.each do |k, v|
-              params_spec[k] ||= v
-            end
-          end
-        end
-      end
-
-      super(*ms)
-    end
-  end
-end

data/lib/abid/rake_extensions/task.rb

@@ -1,41 +0,0 @@
-module Abid
-  module RakeExtensions
-    module Task
-      def volatile?
-        true
-      end
-
-      def worker
-        :default
-      end
-
-      def job
-        Job[name, defined?(params) ? params : {}]
-      end
-
-      def params
-        {}
-      end
-
-      def name_with_params
-        name
-      end
-
-      def concerned?
-        true
-      end
-
-      def top_level?
-        application.top_level_tasks.any? { |t| application[t] == self }
-      end
-
-      def hooks
-        @hooks ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      def call_hooks(tag, *args)
-        hooks[tag].each { |h| h.call(*args) }
-      end
-    end
-  end
-end

data/lib/abid/state_manager/database.rb

@@ -1,40 +0,0 @@
-require 'sequel/plugins/serialization'
-require 'abid/state_manager/state'
-require 'abid/state_manager/state_proxy'
-
-module Abid
-  module StateManager
-    class Database
-      Sequel.extension :migration
-
-      MIGRATIONS_PATH = File.expand_path('../../../../migrations', __FILE__)
-
-      # Creates a new database object and checks schema version.
-      #
-      # @return [Sequel::Database] database object
-      # @see Sequel.connect
-      def self.connect(*args)
-        db = Sequel.connect(*args)
-        Sequel::Migrator.check_current(db, MIGRATIONS_PATH)
-        db
-      rescue Sequel::Migrator::NotCurrentError
-        raise Error, 'current schema is out of date'
-      end
-
-      def initialize(env)
-        @env = env
-        @mon = Monitor.new
-      end
-
-      def connection
-        @connection ||= self.class.connect(@env.config.database)
-      end
-
-      def states
-        @mon.synchronize do
-          @states ||= Class.new(State.Model(connection[:states]))
-        end
-      end
-    end
-  end
-end

data/lib/abid/state_manager/state_proxy.rb

@@ -1,65 +0,0 @@
-require 'forwardable'
-
-module Abid
-  module StateManager
-    # StateProxy provides accessor methods to State for Job#state.
-    #
-    # StateProxy holds a reference to the job, and find corresponding state
-    # every time when needed.
-    #
-    # Use StateProxy#find if you have to access the undergrounding State object
-    # many times.
-    class StateProxy
-      def initialize(job)
-        @job = job
-        @states = job.env.db.states
-      end
-
-      # Find underlying State object
-      #
-      # @return [State] state corresponding the job.
-      def find
-        if @job.volatile?
-          @states.init_by_job(@job).tap(&:freeze)
-        else
-          @states.find_or_init_by_job(@job).tap(&:freeze)
-        end
-      end
-      alias instance find
-
-      # Update the state to started unless volatile.
-      # @see State.start
-      def start
-        return if @job.dryrun? || @job.volatile?
-        @states.start(@job)
-      end
-
-      # Try to update the state to started unless volatile.
-      # @see State.start
-      # @return [Boolean] false if already running
-      def try_start
-        start
-        true
-      rescue AlreadyRunningError
-        false
-      end
-
-      # Update the state to SUCCESSED / FAILED unless volatile.
-      # @see State.finish
-      def finish(error = nil)
-        return if @job.dryrun? || @job.volatile?
-        @states.finish(@job, error)
-      end
-
-      def assume(force: false)
-        @states.assume(@job, force: force)
-      end
-
-      # for testing
-      def mock_fail(error)
-        start
-        finish(error)
-      end
-    end
-  end
-end

data/lib/abid/task.rb

@@ -1,123 +0,0 @@
-module Abid
-  class Task < Rake::Task
-    extend Forwardable
-
-    attr_accessor :play_class_definition, :extends
-    attr_reader :play, :params
-
-    def_delegators :play, :worker, :volatile?
-
-    def initialize(task_name, app)
-      super(task_name, app)
-      @siblings = {}
-    end
-
-    def play_class
-      return @play_class if @play_class
-
-      task = self
-      klass = application.lookup_play_class(extends, scope)
-      @play_class = Class.new(klass) do |c|
-        c.task = task
-        c.class_eval(&task.play_class_definition)
-      end
-    end
-
-    def bound?
-      !@play.nil?
-    end
-
-    def bind(**params)
-      fail 'already bound' if bound?
-
-      parsed_params = ParamsParser.parse(params, play_class.params_spec)
-      return @siblings[parsed_params] if @siblings.include?(parsed_params)
-
-      sorted_params = parsed_params.sort.to_h
-      sorted_params.freeze
-
-      @siblings[sorted_params] = dup.tap do |t|
-        t.instance_eval do
-          @prerequisites = []
-          @params = sorted_params
-          @play = play_class.new(t)
-          call_play_hooks(:setup)
-          bind_play_hooks(:before, :before_execute)
-          bind_play_hooks(:after, :after_invoke)
-        end
-      end
-    end
-
-    def prerequisite_tasks
-      fail 'no play is bound yet' unless bound?
-
-      prerequisites.map do |pre, params|
-        application[pre, @scope, **self.params.merge(params)]
-      end
-    end
-
-    # Name of task with argument list description.
-    def name_with_args # :nodoc:
-      if params_description
-        "#{super} #{params_description}"
-      else
-        super
-      end
-    end
-
-    # Name of task with params
-    def name_with_params # :nodoc:
-      if params_description
-        "#{name} #{params_description}"
-      else
-        super
-      end
-    end
-
-    def params_description
-      sig_params = play_class.params_spec.select do |_, spec|
-        spec[:significant]
-      end
-      return if sig_params.empty?
-
-      if bound? # unbound
-        p = sig_params.map { |name, _| "#{name}=#{params[name]}" }
-      else
-        p = sig_params.map { |name, spec| "#{name}:#{spec[:type]}" }
-      end
-
-      p.join(' ')
-    end
-
-    # Execute the play associated with this task.
-    def execute(_args = nil)
-      fail 'no play is bound yet' unless bound?
-
-      if application.options.dryrun
-        application.trace "** Execute (dry run) #{name_with_params}"
-        return
-      end
-      if application.options.trace
-        application.trace "** Execute #{name_with_params}"
-      end
-
-      play.run
-    end
-
-    def bind_play_hooks(tag, to = nil)
-      to ||= tag
-      hooks[to] = [proc { |*args| call_play_hooks(tag, *args) }]
-    end
-
-    def call_play_hooks(tag, *args)
-      return unless bound?
-      play_class.hooks[tag].each { |blk| play.instance_exec(*args, &blk) }
-    end
-
-    class <<self
-      def define_play(*args, &block) # :nodoc:
-        Abid.application.define_play(self, *args, &block)
-      end
-    end
-  end
-end

data/lib/abid/task_manager.rb

@@ -1,61 +0,0 @@
-module Abid
-  module TaskManager
-    def initialize
-      super
-    end
-
-    def define_play(task_class, play_name, extends: nil, &block)
-      define_task(task_class, play_name).tap do |task|
-        task.extends = extends
-        task.play_class_definition = block
-      end
-    end
-
-    def define_mixin(task_class, mixin_name, &block)
-      define_task(task_class, mixin_name).tap do |task|
-        task.mixin_definition = block
-      end
-    end
-
-    def [](task_name, scopes = nil, **params)
-      task = super(task_name, scopes)
-
-      if task.respond_to? :bind
-        task.bind(**params)
-      else
-        task
-      end
-    end
-
-    def play_base(&block)
-      if block_given?
-        @play_base = Class.new(Abid::Play, &block)
-      else
-        @play_base ||= Abid::Play
-      end
-    end
-
-    def lookup_play_class(task_name, scope = nil)
-      if task_name.nil?
-        play_base
-      elsif task_name.is_a? Class
-        task_name
-      else
-        t = lookup(task_name.to_s, scope)
-        if t.respond_to? :play_class
-          t.play_class
-        elsif t.nil?
-          fail "play #{task_name} not found"
-        else
-          fail "task #{task_name} has no play class"
-        end
-      end
-    end
-
-    class << self
-      def record_task_metadata # :nodoc:
-        Rake::TaskManager.record_task_metadata
-      end
-    end
-  end
-end