marso 0.1.15089 → 0.1.29007

data/lib/marso/messages/errors.rb

@@ -0,0 +1,29 @@
+
+module Marso
+  module Messages
+
+    def self.no_component_found(component_type, rootpath)
+      component_name = proc {
+        case component_type
+        when :feature
+          "features"
+        when :story
+          "stories"
+        when :scenario
+          "scenarios"
+        else
+          raise ArgumentError, ":#{component_type} is not a valid component_type. " +
+          "Valid values are: #{[:feature, :story, :scenario].join(', ')}"
+        end
+      }
+
+      "E0000: No #{component_name.call} were found under path '#{rootpath}'.\n" +
+      "Browse to a different folder, or use the :rootpath option to define an adequate path"
+    end
+
+    def self.no_component_match(component_type, offenders)
+      "E0001: The following selected #{component_type} ids couldn't be found: #{offenders.join(', ')}"
+    end
+
+  end
+end

data/lib/marso/toolbelt/fiberpiping.rb

@@ -0,0 +1,207 @@
+require 'eventmachine'
+
+module Marso
+  class Enumerate
+
+    STOP_MSG = "End of seed"
+    attr_reader :process, :src
+
+    def self.from(collection)
+      _process = lambda {
+        collection.each { |x|
+          Fiber.yield x
+        }
+
+        raise StopIteration, STOP_MSG
+      }
+
+      Enumerate.new(_process)
+    end
+
+    def initialize(process, source={})
+      @src = source
+      @process = process
+
+      @fiber_delegate = Fiber.new do
+        process.call
+      end
+    end
+
+    def resume
+      if @src.is_a?(Marso::Enumerate)
+        @fiber_delegate.resume(@src.resume)
+      else # case where @src is nil
+        @fiber_delegate.resume
+      end
+    end
+
+    def source(other_source)
+      Enumerate.new(@process, other_source)
+    end
+
+    def clone
+      class_name = self.class.to_s
+      if @src.is_a?(Marso::Enumerate)
+        return Object.const_get(class_name).new(@process, @src.clone)
+      else
+        return Object.const_get(class_name).new(@process)
+      end
+    end
+
+    def |(other_source)
+      other_source.source(clone_original_source_to_protect_it)
+    end
+
+    def where(&block)
+      FiberFilter.new(block, clone_original_source_to_protect_it)
+    end
+
+    def select(&block)
+      FiberProjection.new(block, clone_original_source_to_protect_it)
+    end
+
+    def select_many(&block)
+      FiberProjectionMany.new(block, clone_original_source_to_protect_it)
+    end
+
+    def execute(max_iteration=1000000)
+      begin
+        if max_iteration.zero?
+          loop do
+            self.resume
+          end
+        else
+          max_iteration.times { self.resume }
+        end
+      rescue StopIteration => ex
+        raise ex unless ex.message == STOP_MSG
+      rescue Exception => ex
+        raise ex
+      end
+    end
+
+    def to_a
+      a = []
+      begin
+        loop do
+          a << self.resume
+        end
+      rescue StopIteration => ex
+        raise ex unless ex.message == STOP_MSG
+      rescue Exception => ex
+        raise ex
+      end
+
+      return a
+    end
+
+    private
+      def clone_original_source_to_protect_it
+        # prevent the core source to be altered so that we can reuse it
+        # to build other queries. Otherwise, after one usage, there'll be
+        # a dead fiber exception thrown
+        return self.clone
+      end
+  end
+
+  class FiberProjection < Enumerate
+
+    def initialize(process, source={})
+      @src = source
+      @process = process
+
+      @fiber_delegate = Fiber.new do
+        output = nil
+        while input = Fiber.yield(output)
+          output = process.call(input)
+        end
+      end
+
+      @fiber_delegate.resume
+    end
+
+    def source(other_source)
+      FiberProjection.new(@process, other_source)
+    end
+  end
+
+  class FiberProjectionMany < Enumerate
+
+    def initialize(process, source={})
+      @src = source
+      @process = process
+      @is_inside_inner_enumerate = false
+
+      @fiber_delegate = Fiber.new do
+        output = []
+        while input = Fiber.yield(output)
+          output = process.call(input)
+
+          @is_inside_inner_enumerate = true
+
+          output.each { |o|
+            Fiber.yield(o)
+          }
+
+          @is_inside_inner_enumerate = false
+        end
+      end
+
+      @fiber_delegate.resume
+    end
+
+    def resume
+      if @src.is_a?(Marso::Enumerate) && !@is_inside_inner_enumerate
+        output = @fiber_delegate.resume(@src.resume)
+        output = @fiber_delegate.resume(@src.resume)  if output.is_a?(Array) && output.empty?
+        return output
+      else
+        output = @fiber_delegate.resume
+        output = @fiber_delegate.resume(@src.resume) unless @is_inside_inner_enumerate
+        output = @fiber_delegate.resume(@src.resume)  if output.is_a?(Array) && output.empty?
+        return output
+      end
+    end
+
+    def source(other_source)
+      FiberProjectionMany.new(@process, other_source)
+    end
+
+  end
+
+  class FiberFilter < Enumerate
+
+    def initialize(process, source={})
+      @src = source
+      @process = process
+
+      @fiber_delegate = Fiber.new do
+        output = nil
+        while input = Fiber.yield(output)
+          if process.call(input)
+            output = input
+          else
+            output = :invalid_input
+          end
+        end
+      end
+
+      @fiber_delegate.resume
+    end
+
+    def resume
+      v = nil
+      if @src.is_a?(Marso::Enumerate)
+        v = @fiber_delegate.resume(@src.resume)
+        v = self.resume if v == :invalid_input
+      else
+        v = @fiber_delegate.resume
+      end
+      return v
+    end
+
+    def source(other_source)
+      FiberFilter.new(@process, other_source)
+    end
+  end
+end

data/lib/marso/validation/symbol.rb

@@ -0,0 +1,21 @@
+
+class NilClass
+  
+  def ensure_valid_sync_mode
+    raise ArgumentError, "'sync_mode' cannot be nil" if self == null
+  end
+end
+
+class Object
+
+  def ensure_valid_sync_mode
+    raise ArgumentError, "'sync_mode' must be a Symbol" unless self.is_a?(Symbol)
+  end
+end
+
+class Symbol
+
+  def ensure_valid_sync_mode
+    raise ArgumentError, "':#{self}' is an invalid sync_mode value. Valid values are either :sync or :async" unless (self == :sync || self == :async)
+  end
+end

data/lib/marso/version.rb

@@ -1,3 +1,3 @@
 module Marso
-  VERSION ="0.1.15089"
+  VERSION ="0.1.29007"
 end

data/marso.gemspec

@@ -37,4 +37,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.3"
   spec.add_runtime_dependency "colorize", "~> 0.7"
   spec.add_runtime_dependency "watir-webdriver", "~> 0.6"
+  spec.add_runtime_dependency "eventmachine", "~> 1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: marso
 version: !ruby/object:Gem::Version
-  version: 0.1.15089
+  version: 0.1.29007
 platform: ruby
 authors:
 - Nicolas Dao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-07 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Marso is the beginning of a small lightweight BDD project. Currently,
   this is just a very simple code sample that only displays a custom message in green
   or in red depending on the value of a predicate.
@@ -82,10 +96,25 @@ files:
 - README.md
 - Rakefile
 - lib/marso.rb
-- lib/marso/assert.rb
 - lib/marso/config.rb
+- lib/marso/domain/feature/feature.rb
+- lib/marso/domain/feature/feature_load.rb
+- lib/marso/domain/feature/feature_publish.rb
+- lib/marso/domain/scenario/scenario.rb
+- lib/marso/domain/scenario/scenario_publish.rb
+- lib/marso/domain/step/step.rb
+- lib/marso/domain/step/step_publish.rb
+- lib/marso/domain/story/story.rb
+- lib/marso/domain/story/story_load.rb
+- lib/marso/domain/story/story_publish.rb
 - lib/marso/factories.rb
-- lib/marso/scenario.rb
+- lib/marso/helpers/componenthelper.rb
+- lib/marso/helpers/statushelper.rb
+- lib/marso/helpers/texthelper.rb
+- lib/marso/launcher.rb
+- lib/marso/messages/errors.rb
+- lib/marso/toolbelt/fiberpiping.rb
+- lib/marso/validation/symbol.rb
 - lib/marso/version.rb
 - marso.gemspec
 homepage: https://github.com/nicolasdao/marso

data/lib/marso/assert.rb

@@ -1,17 +0,0 @@
-require "colorize"
-
-module Marso
-	module_function
-
-	def assert(message, &block)
-		begin
-			if (block.call)
-				puts "Assert #{message}: PASSED".green
-			else
-				puts "Assert #{message}: FAILED".red
-			end
-		rescue Exception => e
-			puts "Assert #{message} FAILED with exception #{e.message}".red
-		end
-	end
-end

data/lib/marso/scenario.rb

@@ -1,278 +0,0 @@
-require 'colorize'
-require 'securerandom'
-require_relative 'config'
-
-module Marso
-
-  class Scenario
-    ISSUES_LIST = [:error, :failed, :cancelled]
-    @@color_options=nil
-    @@color_options_size=0
-    attr_reader :name, :steps, :id, :status, :color_theme, :cancel_steps_upon_issues,
-    :realtime_step_stdout
-
-    # name: Scenario's name
-    # options:
-    #   :id => hex string (length 8). Default is randomly generated
-    #   :steps => array of Step objects
-    #   :color_theme => color from gem 'colorize'(e.g. :blue). That allows
-    #                   to visually group all steps from the same scenario.
-    #                   Default is randomly choosen from the available set
-    #   :cancel_steps_upon_issues => Boolean. If true, all steps defined after
-    #                                a broken step(i.e. step in status :failed,
-    #                                :error, or :cancelled) will not be
-    #                                executed, and will all be set so their
-    #                                status is :cancelled. If defined, it
-    #                                overrides the Config.cancel_steps_upon_issues
-    #                                setting.
-    def initialize(name, options={})
-
-      if @@color_options.nil?
-        @@color_options = String.colors
-        @@color_options_size = @@color_options.size
-      end
-
-      @name = name
-      @id =
-        options.key?(:id) ?
-        options[:id] :
-        SecureRandom.hex(4)
-
-      @status =
-        options.key?(:status) ?
-        options[:status] :
-        :pending
-
-      @color_theme =
-        options.key?(:color_theme) ?
-        options[:color_theme] :
-        @@color_options[rand(@@color_options_size)]
-
-      @steps =
-        options.key?(:steps) ?
-        options[:steps].map { |s| Step.new(s.text, @id, @color_theme, s.status, &s.block) } :
-        []
-
-      @cancel_steps_upon_issues =
-        options.key?(:cancel_steps_upon_issues) ?
-        options[:cancel_steps_upon_issues] :
-        Marso::Config.get(:cancel_steps_upon_issues)
-
-      @realtime_step_stdout =
-        options.key?(:realtime_step_stdout) ?
-        options[:realtime_step_stdout] :
-        Marso::Config.get(:realtime_step_stdout)
-    end
-
-    def given(assumption_text, *args, &block)
-      return add_step(:given, assumption_text, *args, &block)
-    end
-
-    def and(assumption_text, *args, &block)
-      return add_step(:and, assumption_text, *args, &block)
-    end
-
-    def when(assumption_text, *args, &block)
-      return add_step(:when, assumption_text, *args, &block)
-    end
-
-    def then(assumption_text, *args, &block)
-      return add_step(:then, assumption_text, *args, &block)
-    end
-
-    def but(assumption_text, *args, &block)
-      return add_step(:but, assumption_text, *args, &block)
-    end
-
-    def run
-      previous_step_status = nil
-      scenario_status = :passed
-      no_issues = true
-      puts "Scenario #{@id}".colorize(@color_theme) + ": " + "#{name}".blue if @realtime_step_stdout
-
-      processed_steps = @steps.map { |s|
-        executed_step = execute_step(s, previous_step_status)
-
-        print executed_step.print_context if @realtime_step_stdout
-
-        previous_step_status = executed_step.status
-
-        if no_issues
-          case previous_step_status
-          when :error
-            no_issues = false
-            scenario_status = :error
-          when :failed
-            no_issues = false
-            scenario_status = :failed
-          when :cancelled
-            no_issues = false
-            scenario_status = :failed
-          end
-        end
-
-        executed_step
-      }
-
-      return Scenario.new(@name, {
-        :id => @id,
-        :steps => processed_steps,
-        :status => scenario_status,
-        :color_theme => @color_theme
-      })
-    end
-
-    def context
-      return
-        "Scenario #{@id}: #{name}\n" +
-        (@steps.any? ? @steps.map { |s| s.context }.join("\n") : "")
-    end
-
-    def print_context
-      puts "Scenario #{@id}".colorize(@color_theme) + ": " + "#{name}".blue
-      @steps.map { |s| s.print_context  } if !@steps.nil?
-    end
-
-
-    private
-
-      def add_step(step_type, assumption_text, *args, &block)
-        body_msg = nil
-        status = :pending
-        step_name = step_type.to_s
-
-        begin
-          body_msg = "#{step_name} " + assumption_text % args
-        rescue Exception => e
-          status = :error
-          body_msg =
-            "#{assumption_text}: ERROR\n" +
-            "args: #{args.nil? ? '' : args.join(',')}\n" +
-            "#{e.message}\n" +
-            "#{e.backtrace}"
-        end
-
-        new_step_series = @steps | [Step.new(body_msg, @id, color_theme, status, &block)]
-
-        return Scenario.new(@name, {
-          :id => @id,
-          :steps => new_step_series,
-          :status => @status,
-          :color_theme => @color_theme
-        })
-      end
-
-      def execute_step(step, previous_step_status)
-        if ISSUES_LIST.include?(previous_step_status) && @cancel_steps_upon_issues
-          cancelled_step = Step.new(step.text, @id, @color_theme, :cancelled, &step.block)
-          return cancelled_step.execute
-        else
-          return step.execute
-        end
-      end
-  end
-
-  # A 'Step' is a Scenario's part. It contains
-  # a text that describe what that step does, as well
-  # as a status that indicates whether or not that step
-  # has already been executed. This status can take the
-  # following values:
-  # => :pending
-  # => :passed
-  # => :failed
-  # => :cancelled
-  # => :error
-  class Step
-    attr_reader :text, :status, :color_theme, :scenario_id, :block
-
-    def initialize(text, scenario_id, color_theme, status=:pending, &block)
-      @text=text
-      @status=status
-      @block=block
-      @scenario_id=scenario_id
-      @color_theme = color_theme
-    end
-
-    def execute
-      if @status != :cancelled
-        execute_block
-      else
-        return self
-      end
-    end
-
-    def context
-      scenario_id = "#{@scenario_id}"
-      body = nil
-      case @status
-      when :pending
-        body = "#{@text}: PENDING"
-      when :passed
-          body = "#{@text}: PASSED"
-      when :failed
-        body = "#{@text}: FAILED"
-      when :cancelled
-        body = "#{@text}: CANCELLED"
-      when :error
-        body = "#{@text}"
-      end
-
-      return "#{scenario_id}: #{body}"
-
-    end
-
-    def print_context
-      scenario_id = "#{@scenario_id}".colorize(@color_theme)
-      body = nil
-      case @status
-      when :pending
-        body = "#{@text}: PENDING".light_yellow
-      when :passed
-          body = "#{@text}: PASSED".green
-      when :failed
-        body = "#{@text}: FAILED".red
-      when :cancelled
-        body = "#{@text}: CANCELLED".light_black
-      when :error
-        body = "#{@text}".red
-      end
-
-      puts "#{scenario_id}: #{body}"
-
-    end
-
-    private
-      def execute_block
-        operation = lambda { |x|
-          begin
-            result = @block.call
-            result_type = result.class
-            if result_type == TrueClass || result_type == FalseClass
-              if result
-                return :passed, nil
-              else
-                return :failed, nil
-              end
-            else
-              return :passed, nil
-            end
-          rescue Exception => e
-            return :error, e
-          end
-        }
-
-        status, err = operation.call(nil)
-
-        updated_text = @text
-
-        if status==:error
-          updated_text =
-            "#{text}: ERROR\n" +
-            "#{err.message}\n" +
-            "#{err.backtrace}"
-        end
-
-        return Step.new(updated_text, @scenario_id, @color_theme, status, &@block)
-      end
-  end
-end