ripe 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2961c4cc93b7823c51c6ef1dc6d717b41de56d58
-  data.tar.gz: 5f80f681106b6b747f88fd9a3797ae661db7557f
+  metadata.gz: 28ae834d0a84d2072400169910c39825c1c37aa3
+  data.tar.gz: 2b1be6510c88ad3679dc69e4b198eea81d050734
 SHA512:
-  metadata.gz: 8b7edf637ca227eb6ac31ec0dd32bf7efbae0a54fda49e474f313850c554d45c55f03c767b315101f872cf11164c7a500f50b440fd9228f4afb2da42c34fa578
-  data.tar.gz: d8829b666f606a54c56c29e5a21a68ca04a177ce4a859fc83a8c9a0758c9d0f86d42e0ba671b31b996ac8313671e8bd849d731f2b8c420693cf0cc9096830534
+  metadata.gz: cac0941044a07fe4b97a8fda9f68e52881bc6be0943efafb6d104e0fa6e0c45e4f219ad25431b6099aa30e6fac3847fa79cc28d472b13f3cce59f852fe52fb60
+  data.tar.gz: c43fcd8a697350737a8b02fef384d40bcc6666954f0ce2e8204efb1a88f9a4661099c4c2598cbe654d1ca86dcc9e89d8c28ab456b1ea34c4a4dd5b59e8780603

data/.travis.yml

@@ -1,10 +1,5 @@
 language: ruby
 cache: bundler
-rvm:
-  - 2.1.5
 script: bundle exec rake spec
-branches:
-  only:
-    - develop
 notifications:
   email: false

data/Guardfile

@@ -1,6 +1,4 @@
 guard :rspec, cmd: 'rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/ripe/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb') { "spec" }
-  watch('spec/testpack.rb') { "spec" }
+  watch(%r{^spec/.+\.rb$}) { 'spec' }
+  watch(%r{^lib/ripe/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
 end

data/README.md

@@ -1,4 +1,5 @@
 # Ripe
+[![Gem Version](https://badge.fury.io/rb/ripe.svg)](http://badge.fury.io/rb/ripe)
 [![Build Status](https://travis-ci.org/ndejay/ripe.svg)](https://travis-ci.org/ndejay/ripe)
 [![Code Climate](https://codeclimate.com/github/ndejay/ripe/badges/gpa.svg)](https://codeclimate.com/github/ndejay/ripe)
 [![Test Coverage](https://codeclimate.com/github/ndejay/ripe/badges/coverage.svg)](https://codeclimate.com/github/ndejay/ripe)

data/bin/ripe

@@ -1,63 +1,5 @@
 #!/usr/bin/env ruby
 
 require_relative '../lib/ripe'
-require_relative '../lib/ripe/dsl'
-require 'ripl' # REPL
-require 'hirb' # Pretty output for +ActiveRecord+ objects
-require 'thor'
 
-include Ripe
-include Ripe::DSL
-
-class CLI < Thor
-  desc 'console', 'Enter ripe console'
-  def console
-    repo = Repo.new
-    repo.attach
-
-    # Do not send arguments to the REPL
-    ARGV.clear
-
-    Ripl.config[:prompt] = proc do
-      # This is the only place I could think of placing +Hirb#enable+.
-      Hirb.enable unless Hirb::View.enabled?
-      'ripe> '
-    end
-
-    # Launch the REPL session in the context of +WorkerController+.
-    Ripl.start :binding => repo.controller.instance_eval { binding }
-  end
-
-  desc 'prepare SAMPLES', 'Prepare jobs from template workflow'
-  option :workflow, :aliases => '-w', :type => :string, :required => true,
-    :desc => 'Workflow to be applied'
-  option :options, :aliases => '-o', :type => :string, :required => false,
-    :desc => 'Options', :default => ''
-  def prepare(*samples)
-    abort "No samples specified." if (samples.length == 0)
-
-    additional_vars = options[:options].split(/,/).map do |pair|
-      key, value = pair.split(/=/)
-      { key.to_sym => value }
-    end
-    additional_vars = additional_vars.inject(&:merge) || {}
-
-    repo = Repo.new
-
-    filename = repo.library.find_workflow(options[:workflow])
-    abort "Could not find workflow #{@handle}." if filename == nil
-    require_relative filename # Imports +$workflow+ from the workflow component
-
-    repo.attach_or_create # Create .ripe if it doesn't exist
-    repo.controller.prepare(samples,
-                            $workflow.callback,
-                            $workflow.params.merge(additional_vars))
-  end
-
-  desc 'version', 'Retrieve ripe version'
-  def version
-    puts "ripe version #{Ripe::VERSION}"
-  end
-end
-
-CLI.start(ARGV)
+Ripe::CLI.start(ARGV)

data/lib/ripe.rb

@@ -1,5 +1,12 @@
-require_relative 'ripe/version'
+require_relative 'ripe/blocks'
+require_relative 'ripe/db'
+require_relative 'ripe/dsl'
+require_relative 'ripe/library'
 require_relative 'ripe/repo'
+require_relative 'ripe/worker_controller'
+
+require_relative 'ripe/cli'
+require_relative 'ripe/version'
 
 module Ripe
   PATH = File.expand_path('..', File.dirname(__FILE__))

data/lib/ripe/blocks.rb

@@ -0,0 +1,13 @@
+module Ripe
+  module Blocks
+    # Forward declaration to prevent cyclic dependencies
+    class Block; end
+  end
+end
+
+require_relative 'blocks/multi_block'
+require_relative 'blocks/block'
+require_relative 'blocks/parallel_block'
+require_relative 'blocks/serial_block'
+require_relative 'blocks/working_block'
+require_relative 'blocks/liquid_block'

data/lib/ripe/blocks/block.rb

@@ -0,0 +1,142 @@
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents the fundamental building block of ripe.
+    #
+    # @abstract
+    #
+    # @attr_reader id [String] a mandatory, but optionally unique identifier
+    #   for the block
+    # @attr_reader blocks [Array<Block>] list of children blocks
+    # @attr vars [Hash<Symbol, String>] key-value pairs
+    #
+    # @see Ripe::WorkerController::Preparer
+
+    class Block
+
+      attr_reader :id, :blocks
+
+      attr_accessor :vars
+
+      ##
+      # @param id [String] a mandatory, but optionally unique identifier
+      #   for the block
+      # @param blocks [Array<Block>] list of children blocks
+      # @param vars [Hash<Symbol, String>] key-value pairs
+
+      def initialize(id, blocks = [], vars = {})
+        @id, @blocks, @vars = id, blocks, vars
+      end
+
+      ##
+      # Return the string command of the subtree starting at the current block.
+      #
+      # @return [String] subtree command
+
+      def command
+        ''
+      end
+
+      ##
+      # Prune the subtree starting at the current block.
+      #
+      # @param protect [Boolean] if the current block (and recursively, its
+      #   children) should be protected from pruning -- setting this parameter
+      #   to +true+ guarantees that the block will not be pruned
+      # @param depend [Boolean] if the current block is unprotected because
+      #   its parent (serially) needs to be executed
+      # @return [Block, nil] a +Block+ representing the subtree that has not
+      #   been pruned, and +nil+ otherwise
+
+      def prune(protect, depend)
+        self
+      end
+
+      ##
+      # Test whether all targets for the current block exist.
+      #
+      # @return [Boolean] whether all targets exist
+
+      def targets_exist?
+        # {Block} is an abstract class.  By default, assume that no targets
+        # exist.
+        false
+      end
+
+      ##
+      # Return the topology of the subtree starting at the current block in a
+      # nested list format.  The first element of any nested list is the
+      # identifier of the corresponding block in the subtree, and the
+      # subsequent elements are each a subtree corresponding to the children
+      # blocks of the current subtree.
+      #
+      # @return [Array<Symbol, Array>] topology nested list
+
+      def topology
+        []
+      end
+
+      ##
+      # Compose a new parallel block from two blocks.  This method provides
+      # syntactic sugar in the form:
+      #
+      #   Block1 | Block2 | Block3
+      #
+      # @param block [Block] a block
+      # @return [Block] parallel block composition of the current block with
+      #   the block passed in the argument list
+
+      def |(block)
+        ParallelBlock.new(self, block)
+      end
+
+      ##
+      # Compose a new serial block from two blocks.  This method provides
+      # syntactic sugar in the form:
+      #
+      #   Block1 + Block2 + Block3
+      #
+      # @param (see #|)
+      # @return [Block] serial block composition of the current block with
+      #   the block passed in the argument list
+
+      def +(block)
+        SerialBlock.new(self, block)
+      end
+
+    end
+
+  end
+
+end
+
+##
+# +NilClass+ is monkey-patched+ to provide syntactic sugar for +Block#|+ and
+# +Block#\++ by treating +nil+ like an empty block.
+#
+# @see Ripe::Blocks::Block
+
+class NilClass
+
+  ##
+  # If attempting to compose a new block with a +nil+ element, ignore the +nil+
+  # element.
+  #
+  # @param (see Ripe::Blocks::Block#|)
+  # @return [Block] the +block+ parameter
+
+  def |(block)
+    raise NoMethodError unless Ripe::Blocks::Block > block.class
+    block
+  end
+
+  ##
+  # (see #|)
+
+  def +(block)
+    self.|(block)
+  end
+
+end

data/lib/ripe/blocks/liquid_block.rb

@@ -0,0 +1,48 @@
+require 'liquid'
+
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents a working block that should be processed using the
+    # Liquid templating engine, rather than the simple +bash+ engine defined in
+    # {WorkingBlock}.
+    #
+    # @see Ripe::Blocks::WorkingBlock
+
+    class LiquidBlock < WorkingBlock
+
+      ##
+      # @param filename [String] filename of the template file
+      # @param vars [Hash<Symbol, String>] key-value pairs
+
+      def initialize(filename, vars = {})
+        super(filename, vars)
+      end
+
+      ##
+      # Return liquid block +parameters+ as a +Hash<Symbol, Object>+.
+      #
+      # @return [Hash<Symbol, Object>] liquid block +parameters+
+
+      def declarations
+        @vars.inject({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+      end
+
+      ##
+      # (see Block#command)
+      #
+      # The resulting string contains the render result of the liquid template
+      # based on the parameters specified in +vars+.
+
+      def command
+        template = Liquid::Template.parse(File.new(@filename).read)
+        template.render(declarations)
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/blocks/multi_block.rb

@@ -0,0 +1,71 @@
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents a block composition, that is, a placeholder block
+    # that joins multiple blocks together.
+    #
+    # This class only exists to provide a superclass for {ParallelBlock} and
+    # {SerialBlock}.
+    #
+    # @abstract
+    #
+    # @see Ripe::Blocks::ParallelBlock
+    # @see Ripe::Blocks::SerialBlock
+
+    class MultiBlock < Block
+
+      ##
+      # @param id [String] a mandatory, but optionally unique identifier
+      #   for the block
+      # @param blocks [Array<Block>] list of children blocks
+
+      def initialize(id, *blocks)
+        # Ignore nil objects
+        super(id, blocks.compact, {})
+      end
+
+      ##
+      # (see Block#prune)
+      #
+      # Unless the block is protected, attempt to prune all children blocks.
+      # If all blocks are pruned, return nothing.  If a single block remains,
+      # return that block.  If more than one block remains, return the current
+      # {MultiBlock}.
+
+      def prune(protect, depend)
+        if !protect
+          @blocks = @blocks.map { |block| block.prune(protect, depend) }.compact
+          case @blocks.length
+          when 0; nil
+          when 1; @blocks.first
+          else;   self
+          end
+        else
+          self
+        end
+      end
+
+      ##
+      # (see Block#targets_exist?)
+      #
+      # A {MultiBlock}'s targets exist if the targets of all its # children
+      # exist.
+
+      def targets_exist?
+        @blocks.map(&:targets_exist?).inject(:&)
+      end
+
+      ##
+      # (see Block#topology)
+
+      def topology
+        [@id] + @blocks.map(&:topology)
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/blocks/parallel_block.rb

@@ -0,0 +1,29 @@
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents a parallel composition of blocks, in that the
+    # children blocks of an instance of this class are to be run in parallel.
+
+    class ParallelBlock < MultiBlock
+
+      ##
+      # @param blocks [Array<Block>] list of children blocks
+
+      def initialize(*blocks)
+        super(:|, *blocks)
+      end
+
+      ##
+      # (see Block#command)
+
+      def command
+        @blocks.map { |block| "(\n%s\n) & " % block.command }.join('') + 'wait'
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/blocks/serial_block.rb

@@ -0,0 +1,61 @@
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents a parallel composition of blocks, in that the
+    # children blocks of an instance of this class are to be run in serial.
+
+    class SerialBlock < MultiBlock
+
+      ##
+      # @param blocks [Array<Block>] list of children blocks
+
+      def initialize(*blocks)
+        super(:+, *blocks)
+      end
+
+      ##
+      # (see Block#command)
+
+      def command
+        @blocks.map { |block| "(\n%s\n)" % block.command }.join(' ; ')
+      end
+
+      alias :super_prune :prune
+
+      ##
+      # (see MultiBlock#prune)
+      #
+      # A {SerialBlock} differs from a {MultiBlock} or {ParallelBlock} in that
+      # there is a linear dependency for its children blocks as they are to be
+      # run in serial.  If a given block must be run, then all subsequent
+      # blocks that depend on it must be run as well.
+
+      def prune(protect, depend)
+        return super_prune(protect, depend) if !depend
+        return self if protect
+
+        @blocks = @blocks.map do |block|
+          new_protect = !block.targets_exist?
+          new_block = block.prune(protect, depend)
+          protect = new_protect
+          new_block
+        end
+        @blocks = @blocks.compact
+
+        case @blocks.length
+        when 0
+          nil
+        when 1
+          @blocks.first
+        else
+          self
+        end
+      end
+
+    end
+
+  end
+
+end