mobiusloop 0.1.2

data/lib/cucumber/step_match_search.rb

@@ -0,0 +1,67 @@
+module Cucumber
+  module StepMatchSearch
+    def self.new(search, configuration)
+      CachesStepMatch.new(
+        AssertUnambiguousMatch.new(
+          configuration.guess? ? AttemptToGuessAmbiguousMatch.new(search) : search,
+          configuration
+        )
+      )
+    end
+
+    class AssertUnambiguousMatch
+      def initialize(search, configuration)
+        @search, @configuration = search, configuration
+      end
+
+      def call(step_name)
+        result = @search.call(step_name)
+        raise Cucumber::Ambiguous.new(step_name, result, @configuration.guess?) if result.length > 1
+        result
+      end
+    end
+
+    class AttemptToGuessAmbiguousMatch
+      def initialize(search)
+        @search = search
+      end
+
+      def call(step_name)
+        best_matches(step_name, @search.call(step_name))
+      end
+
+      private
+
+      def best_matches(step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+        if no_groups.any?
+          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
+          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+        elsif top_groups.any?
+          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
+          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
+        else
+          top_groups
+        end
+      end
+
+    end
+
+    require 'delegate'
+    class CachesStepMatch < SimpleDelegator
+      def call(step_name) #:nodoc:
+        @match_cache ||= {}
+
+        matches = @match_cache[step_name]
+        return matches if matches
+
+        @match_cache[step_name] = super(step_name)
+      end
+    end
+
+  end
+end
+

data/lib/cucumber/term/ansicolor.rb

@@ -0,0 +1,110 @@
+module Cucumber
+  module Term
+    # The ANSIColor module can be used for namespacing and mixed into your own
+    # classes.
+    module ANSIColor
+      # :stopdoc:
+      ATTRIBUTES = [
+        [ :clear        ,   0 ],
+        [ :reset        ,   0 ],     # synonym for :clear
+        [ :bold         ,   1 ],
+        [ :dark         ,   2 ],
+        [ :italic       ,   3 ],     # not widely implemented
+        [ :underline    ,   4 ],
+        [ :underscore   ,   4 ],     # synonym for :underline
+        [ :blink        ,   5 ],
+        [ :rapid_blink  ,   6 ],     # not widely implemented
+        [ :negative     ,   7 ],     # no reverse because of String#reverse
+        [ :concealed    ,   8 ],
+        [ :strikethrough,   9 ],     # not widely implemented
+        [ :black        ,  30 ],
+        [ :red          ,  31 ],
+        [ :green        ,  32 ],
+        [ :yellow       ,  33 ],
+        [ :blue         ,  34 ],
+        [ :magenta      ,  35 ],
+        [ :cyan         ,  36 ],
+        [ :white        ,  37 ],
+        [ :on_black     ,  40 ],
+        [ :on_red       ,  41 ],
+        [ :on_green     ,  42 ],
+        [ :on_yellow    ,  43 ],
+        [ :on_blue      ,  44 ],
+        [ :on_magenta   ,  45 ],
+        [ :on_cyan      ,  46 ],
+        [ :on_white     ,  47 ],
+      ]
+
+      ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+      # :startdoc:
+
+      # Returns true, if the coloring function of this module
+      # is switched on, false otherwise.
+      def self.coloring?
+        @coloring
+      end
+
+      # Turns the coloring on or off globally, so you can easily do
+      # this for example:
+      #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
+      def self.coloring=(val)
+        @coloring = val
+      end
+      self.coloring = true
+
+      ATTRIBUTES.each do |c, v|
+        eval %Q{
+            def #{c}(string = nil)
+              result = ''
+              result << "\e[#{v}m" if Cucumber::Term::ANSIColor.coloring?
+              if block_given?
+                result << yield
+              elsif string
+                result << string
+              elsif respond_to?(:to_str)
+                result << to_str
+              else
+                return result #only switch on
+              end
+              result << "\e[0m" if Cucumber::Term::ANSIColor.coloring?
+              result
+            end
+        }
+      end
+
+      # Regular expression that is used to scan for ANSI-sequences while
+      # uncoloring strings.
+      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+
+      def self.included(klass)
+        if klass == String
+          ATTRIBUTES.delete(:clear)
+          ATTRIBUTE_NAMES.delete(:clear)
+        end
+      end
+
+      # Returns an uncolored version of the string, that is all
+      # ANSI-sequences are stripped from the string.
+      def uncolored(string = nil) # :yields:
+        if block_given?
+          yield.gsub(COLORED_REGEXP, '')
+        elsif string
+          string.gsub(COLORED_REGEXP, '')
+        elsif respond_to?(:to_str)
+          to_str.gsub(COLORED_REGEXP, '')
+        else
+          ''
+        end
+      end
+
+      module_function
+
+      # Returns an array of all Cucumber::Term::ANSIColor attributes as symbols.
+      def attributes
+        ATTRIBUTE_NAMES
+      end
+      extend self
+    end
+  end
+end

data/lib/cucumber/unit.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  class Unit
+    def initialize(step_collection)
+      @step_collection = step_collection
+    end
+
+    def step_count
+      @step_collection.length
+    end
+  end
+end

data/lib/cucumber/version

@@ -0,0 +1 @@
+2.3.3

data/lib/mobiusloop/measure.rb

@@ -0,0 +1,19 @@
+# Records a measurement of a specific value at a specific time
+# Once created, measures are immutable
+
+class Measure
+
+  attr_reader :value
+  attr_reader :time
+
+  # constructor that records a value and a time that defaults to Time.now unless overridden)
+  # constructor that records value at a defined time (instance of Time).
+  # Only number values allowed.
+  def initialize(value, time = Time.now)
+    raise "Error! Only numbers are allowed for Measure values" unless value.is_a? Numeric
+    raise "Error! Only Time is allowed for Measure time" unless time.is_a? Time
+    @value = value
+    @time = time
+  end
+
+end

data/lib/mobiusloop/mobius_steps.rb

@@ -0,0 +1,36 @@
+require 'mobiusloop/outcome'
+require 'mobiusloop/scale'
+
+@name = nil
+@outcome = nil
+@target = nil
+@target_date = nil
+@baseline = nil
+@baseline_date = nil
+
+
+Given(/^a baseline of (\d+) "([^"]*)" on "([^"]*)"$/) do |arg1, arg2, arg3|
+  @name = arg2
+  @baseline = arg1
+  @baseline_date = arg3
+end
+
+Given(/^a target of (\d+) "([^"]*)" by "([^"]*)"$/) do |arg1, arg2, arg3|
+  @name = arg2
+  @target = arg1
+  @target_date = arg3
+end
+
+When(/^we measure progress with "([^"]*)"$/) do |arg1|
+  scale_class = arg1.gsub(/\s+/, "") # turns 'My Custom Scale' into MyCustomScale
+  @outcome = Outcome.new(@name, Object::const_get(scale_class).new())
+  @outcome.baseline = @baseline.to_i
+  @outcome.baseline_date = @baseline_date
+  @outcome.target = @target.to_i
+  @outcome.target_date = @target_date
+  puts @outcome.measure
+end
+
+Then(/^report progress towards targets$/) do
+  puts @outcome.report
+end

data/lib/mobiusloop/objective.rb

@@ -0,0 +1,10 @@
+
+class Objective
+
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+end

data/lib/mobiusloop/outcome.rb

@@ -0,0 +1,99 @@
+# Represents a specific outcome or key result to be achieved
+
+class Outcome
+
+  attr_reader   :name
+  attr_accessor :baseline
+  attr_accessor :baseline_date
+  attr_accessor :target
+  attr_accessor :target_date
+  attr_reader   :scale
+
+  # register a name (String) and scale (Scale) of measurement at creation time
+  def initialize(name, scale)
+    raise "name must not be nil" if name == nil
+    raise "scale must be of type Scale" unless scale.is_a? Scale
+    @name = name
+    @scale = scale
+  end
+
+  # perform the measurement using the provide scale
+  # delegate the details to any class extending Scale
+  def measure
+    begin
+      start_time = Time.now
+      @scale.record_measurement
+      elapsed_time = (Time.now - start_time)
+      return "Success! found " + format_number(@scale.measurements.last) + " " + @name + " in #{elapsed_time.round(1)} seconds!"
+    rescue Exception => e
+      return "Error! Measurement failed with message: " + e.message
+    end
+  end
+
+  # used to report progress towards goals
+  def report
+    report = ""
+    report << status
+    report << report_progress
+    report << report_remaining
+    report
+  end
+
+  private
+
+  # report the status. Very simplistic now, need to validate if there is need
+  # for this or we should just drop and let others determine status
+  def status
+    status = percent_progress - percent_schedule
+
+    # this value of 10 is temporary. TODO: need to make this more flexible and explainable
+    if status.abs < 10
+      "Hooray! You are on track!\n"
+    else
+      "Sorry, you are not on track\n"
+    end
+  end
+
+  # report percentage progress towards the target
+  def report_progress
+    "#{percent_progress.round(0)}% progress to target using #{percent_schedule.round(0)}% of the time (" + progress_days.to_s + " days)\n"
+  end
+
+  # report remaining progress towards the target
+  def report_remaining
+    "#{percent_remaining.round(0)}% remaining to target in #{remaining_days} days\n"
+  end
+
+  # percentage progress towards target as of now
+  def percent_progress
+    ((@scale.measurements.last.value.to_i - @baseline.to_i).to_f /
+        (@target.to_i - @baseline.to_i).to_f * 100)
+  end
+
+  # percentage schedule used as of o now
+  def percent_schedule
+    ((DateTime.now - DateTime.parse(@baseline_date)).to_i /
+        (DateTime.parse(@target_date) - DateTime.parse(@baseline_date)).to_f * 100)
+  end
+
+  # percent remaining
+  def percent_remaining
+    100 - percent_progress
+  end
+
+  # days from baseline date until now
+  def progress_days
+    (DateTime.now - DateTime.parse(baseline_date)).to_i
+  end
+
+  # days remaining until target date
+  def remaining_days
+    (DateTime.parse(target_date) - DateTime.now).to_i
+  end
+
+  # format number for display (1000000 => 1,000,000)
+  def format_number(measure)
+    measure.value.to_s.gsub(/(\d{3})(?=\d)/, '\\1,') unless measure == nil
+  end
+
+end

data/lib/mobiusloop/scale.rb

@@ -0,0 +1,32 @@
+# Superclass for all scales of measure
+# Designed to be extended with the measure method implemented
+# by the specific
+
+class Scale
+
+  attr_reader :measurements
+
+  # creates internal array to store measurements
+  # if sub-classes need their own initialize logic
+  # call super first
+  def initialize
+    @measurements = Array.new
+  end
+
+  # performs measurement and adds to internal array
+  def record_measurement()
+    new_measure = measure
+    add(new_measure)
+  end
+
+  # method to perform a measurement, should return an instance of Measure
+  def measure()
+    raise "Someone forgot to override Scale.measure with their unique logic"
+  end
+
+  # adds a new measure to end of array
+  def add(measure)
+    @measurements.push(measure)
+  end
+
+end

data/lib/simplecov_setup.rb

@@ -0,0 +1,18 @@
+if ENV['SIMPLECOV']
+  begin
+    # Suppress warnings in order not to pollute stdout which tests expectations rely on
+    $VERBOSE = nil if defined?(JRUBY_VERSION)
+
+    require 'simplecov'
+
+    SimpleCov.root(File.expand_path(File.dirname(__FILE__) + '/..'))
+    SimpleCov.start do
+      add_filter 'iso-8859-1_steps.rb'
+      add_filter '.-ruby-core/'
+      add_filter '/spec/'
+      add_filter '/features/'
+    end
+  rescue LoadError
+    warn("Unable to load simplecov")
+  end
+end

data/major_changes_to_cucumber.md

@@ -0,0 +1,45 @@
+# Major changes since forking from Cucumber
+
+### Update Gem Spec
+cp cucumber.gemspec to mobiusloop.gemspec
+Edit mobiusloop.gemspec. Hard-code version.
+cp bin/cucumber bin/mobiusloop
+rm bin/cucumber
+
+### Build and Install New Gem
+gem build mobiusloop.gemspec
+gem install mobiusloop.version
+
+run /usr/local/Cellar/ruby/2.2.3/bin/mobiusloop
+TODO: add sym-link to /usr/local/bin as part of gem install
+
+cd /usr/local/bin
+ln -s /usr/local/Cellar/ruby/2.2.3/bin/mobiusloop mobiusloop
+
+### Modify Cucumber
+/lib/cucumber/cli/main.rb
+/lib/cucumber/configuration.rb
+/lib/cucumber/project_initializer.rb
+ - copy gherkin-languages.json to gherkin gem
+
+run /usr/local/Cellar/ruby/2.2.3/bin/mobiusloop --init
+
+
+Verify: Should initialize new /goals directory
+
+### Add MobiusLoop Keywords to Gherkin (english only to start)
+modify gherkin-languages.json to add keywords: Objective, Problem, Outcome, Key Result
+
+
+### Add MobiusLoop Domain objects
+/lib/mobiusloop/Outcome.rb
+/lib/mobiusloop/Scale.rb
+/lib/mobiusloop/Measure.rb
+
+
+### Add RSpec tests
+/spec/mobiusloop/*.rb
+
+### Add Examples
+cp sample scale(s) and .goal files that run
+