cucumber_fm-core 0.1

data/lib/grit/lib/grit/ruby1.9.rb

@@ -0,0 +1,7 @@
+class String
+  if ((defined? RUBY_VERSION) && (RUBY_VERSION[0..2] == "1.9"))
+    def getord(offset); self[offset].ord; end
+  else
+    alias :getord :[]
+  end
+end

data/lib/grit/lib/grit/status.rb

@@ -0,0 +1,151 @@
+module Grit
+
+  class Status
+    include Enumerable
+
+    @base = nil
+    @files = nil
+
+    def initialize(base)
+      @base = base
+      construct_status
+    end
+
+    def changed
+      @files.select { |k, f| f.type == 'M' }
+    end
+
+    def added
+      @files.select { |k, f| f.type == 'A' }
+    end
+
+    def deleted
+      @files.select { |k, f| f.type == 'D' }
+    end
+
+    def untracked
+      @files.select { |k, f| f.untracked }
+    end
+
+    def pretty
+      out = ''
+      self.each do |file|
+        out << file.path
+        out << "\n\tsha(r) " + file.sha_repo.to_s + ' ' + file.mode_repo.to_s
+        out << "\n\tsha(i) " + file.sha_index.to_s + ' ' + file.mode_index.to_s
+        out << "\n\ttype   " + file.type.to_s
+        out << "\n\tstage  " + file.stage.to_s
+        out << "\n\tuntrac " + file.untracked.to_s
+        out << "\n"
+      end
+      out << "\n"
+      out
+    end
+
+    # enumerable method
+
+    def [](file)
+      @files[file]
+    end
+
+    def each
+      @files.each do |k, file|
+        yield file
+      end
+    end
+
+    class StatusFile
+      attr_accessor :path, :type, :stage, :untracked
+      attr_accessor :mode_index, :mode_repo
+      attr_accessor :sha_index, :sha_repo
+
+      @base = nil
+
+      def initialize(base, hash)
+        @base = base
+        @path = hash[:path]
+        @type = hash[:type]
+        @stage = hash[:stage]
+        @mode_index = hash[:mode_index]
+        @mode_repo = hash[:mode_repo]
+        @sha_index = hash[:sha_index]
+        @sha_repo = hash[:sha_repo]
+        @untracked = hash[:untracked]
+      end
+
+      def blob(type = :index)
+        if type == :repo
+          @base.object(@sha_repo)
+        else
+          @base.object(@sha_index) rescue @base.object(@sha_repo)
+        end
+      end
+
+    end
+
+    private
+
+      def construct_status
+        @files = ls_files
+
+        Dir.chdir(@base.working_dir) do
+          # find untracked in working dir
+          Dir.glob('**/*') do |file|
+            if !@files[file]
+              @files[file] = {:path => file, :untracked => true} if !File.directory?(file)
+            end
+          end
+
+          # find modified in tree
+         diff_files.each do |path, data|
+            @files[path] ? @files[path].merge!(data) : @files[path] = data
+          end
+
+          # find added but not committed - new files
+          diff_index('HEAD').each do |path, data|
+            @files[path] ? @files[path].merge!(data) : @files[path] = data
+          end
+
+          @files.each do |k, file_hash|
+            @files[k] = StatusFile.new(@base, file_hash)
+          end
+        end
+      end
+
+      # compares the index and the working directory
+      def diff_files
+        hsh = {}
+        @base.git.diff_files.split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+          hsh[file] = {:path => file, :mode_file => mode_src.to_s[1, 7], :mode_index => mode_dest,
+                        :sha_file => sha_src, :sha_index => sha_dest, :type => type}
+        end
+        hsh
+      end
+
+      # compares the index and the repository
+      def diff_index(treeish)
+        hsh = {}
+        @base.git.diff_index({}, treeish).split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+          hsh[file] = {:path => file, :mode_repo => mode_src.to_s[1, 7], :mode_index => mode_dest,
+                        :sha_repo => sha_src, :sha_index => sha_dest, :type => type}
+        end
+        hsh
+      end
+
+      def ls_files
+        hsh = {}
+        lines = @base.git.ls_files({:stage => true})
+        lines.split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode, sha, stage) = info.split
+          hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
+        end
+        hsh
+      end
+  end
+
+end

data/lib/grit/lib/grit/submodule.rb

@@ -0,0 +1,88 @@
+module Grit
+
+  class Submodule
+    attr_reader :id
+    attr_reader :mode
+    attr_reader :name
+
+    # Create a Submodule containing just the specified attributes
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Submodule (unbaked)
+    def self.create(repo, atts)
+      self.allocate.create_initialize(repo, atts)
+    end
+
+    # Initializer for Submodule.create
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Submodule
+    def create_initialize(repo, atts)
+      @repo = repo
+      atts.each do |k, v|
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+      self
+    end
+
+    # The url of this submodule
+    #   +ref+ is the committish that should be used to look up the url
+    #
+    # Returns String
+    def url(ref)
+      config = self.class.config(@repo, ref)
+
+      lookup = config.keys.inject({}) do |acc, key|
+        id = config[key]['id']
+        acc[id] = config[key]['url']
+        acc
+      end
+
+      lookup[@id]
+    end
+
+    # The configuration information for the given +repo+
+    #   +repo+ is the Repo
+    #   +ref+ is the committish (defaults to 'master')
+    #
+    # Returns a Hash of { <path:String> => { 'url' => <url:String>, 'id' => <id:String> } }
+    # Returns {} if no .gitmodules file was found
+    def self.config(repo, ref = "master")
+      commit = repo.commit(ref)
+      blob = commit.tree/'.gitmodules'
+      return {} unless blob
+
+      lines = blob.data.gsub(/\r\n?/, "\n" ).split("\n")
+
+      config = {}
+      current = nil
+
+      lines.each do |line|
+        if line =~ /^\[submodule "(.+)"\]$/
+          current = $1
+          config[current] = {}
+          config[current]['id'] = (commit.tree/current).id
+        elsif line =~ /^\t(\w+) = (.+)$/
+          config[current][$1] = $2
+          config[current]['id'] = (commit.tree/$2).id if $1 == 'path'
+        else
+          # ignore
+        end
+      end
+
+      config
+    end
+
+    def basename
+      File.basename(name)
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Submodule "#{@id}">}
+    end
+  end # Submodule
+
+end # Grit

data/lib/grit/lib/grit/tag.rb

@@ -0,0 +1,16 @@
+module Grit
+
+  class Tag < Ref
+    def self.find_all(repo, options = {})
+      refs = repo.git.refs(options, prefix)
+      refs.split("\n").map do |ref|
+        name, id = *ref.split(' ')
+        cid = repo.git.commit_from_sha(id)
+        raise "Unknown object type." if cid == ''
+        commit = Commit.create(repo, :id => cid)
+        self.new(name, commit)
+      end
+    end
+  end
+
+end

data/lib/grit/lib/grit/tree.rb

@@ -0,0 +1,123 @@
+module Grit
+
+  class Tree
+    lazy_reader :contents
+    attr_reader :id
+    attr_reader :mode
+    attr_reader :name
+
+    # Construct the contents of the tree
+    #   +repo+ is the Repo
+    #   +treeish+ is the reference
+    #   +paths+ is an optional Array of directory paths to restrict the tree
+    #
+    # Returns Grit::Tree (baked)
+    def self.construct(repo, treeish, paths = [])
+      output = repo.git.ls_tree({}, treeish, *paths)
+      self.allocate.construct_initialize(repo, treeish, output)
+    end
+
+    def construct_initialize(repo, id, text)
+      @repo = repo
+      @id = id
+      @contents = []
+
+      text.split("\n").each do |line|
+        @contents << content_from_string(repo, line)
+      end
+      @contents.compact!
+
+      self
+    end
+
+    def lazy_source
+      Tree.construct(@repo, @id, [])
+    end
+
+    # Create an unbaked Tree containing just the specified attributes
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Tree (unbaked)
+    def self.create(repo, atts)
+      self.allocate.create_initialize(repo, atts)
+    end
+
+    # Initializer for Tree.create
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Tree (unbaked)
+    def create_initialize(repo, atts)
+      @repo = repo
+
+      atts.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+      self
+    end
+
+    # Parse a content item and create the appropriate object
+    #   +repo+ is the Repo
+    #   +text+ is the single line containing the items data in `git ls-tree` format
+    #
+    # Returns Grit::Blob or Grit::Tree
+    def content_from_string(repo, text)
+      mode, type, id, name = text.split(" ", 4)
+      case type
+        when "tree"
+          Tree.create(repo, :id => id, :mode => mode, :name => name)
+        when "blob"
+          Blob.create(repo, :id => id, :mode => mode, :name => name)
+        when "link"
+          Blob.create(repo, :id => id, :mode => mode, :name => name)
+        when "commit"
+          Submodule.create(repo, :id => id, :mode => mode, :name => name)
+        else
+          raise "Invalid type: #{type}"
+      end
+    end
+
+    # Find the named object in this tree's contents
+    #
+    # Examples
+    #   Repo.new('/path/to/grit').tree/'lib'
+    #   # => #<Grit::Tree "6cc23ee138be09ff8c28b07162720018b244e95e">
+    #   Repo.new('/path/to/grit').tree/'README.txt'
+    #   # => #<Grit::Blob "8b1e02c0fb554eed2ce2ef737a68bb369d7527df">
+    #
+    # Returns Grit::Blob or Grit::Tree or nil if not found
+    def /(file)
+      if file =~ /\//
+        file.split("/").inject(self) { |acc, x| acc/x } rescue nil
+      else
+        self.contents.find { |c| c.name == file }
+      end
+    end
+
+    def basename
+      File.basename(name)
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Tree "#{@id}">}
+    end
+
+    # Find only Tree objects from contents
+    def trees
+      contents.select {|v| v.kind_of? Tree}
+    end
+
+    # Find only Blob objects from contents
+    def blobs
+      contents.select {|v| v.kind_of? Blob}
+    end
+
+    # Compares trees by name
+    def <=>(other)
+      name <=> other.name
+    end
+  end # Tree
+
+end # Grit

data/lib/grit/lib/open3_detach.rb

@@ -0,0 +1,46 @@
+module Open3
+  extend self
+
+  def popen3(*cmd)
+    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
+    pr = IO::pipe
+    pe = IO::pipe
+
+    pid = fork{
+      # child
+      fork{
+        # grandchild
+        pw[1].close
+        STDIN.reopen(pw[0])
+        pw[0].close
+
+        pr[0].close
+        STDOUT.reopen(pr[1])
+        pr[1].close
+
+        pe[0].close
+        STDERR.reopen(pe[1])
+        pe[1].close
+
+        exec(*cmd)
+      }
+      exit!(0)
+    }
+
+    pw[0].close
+    pr[1].close
+    pe[1].close
+    Process.waitpid(pid)
+    pi = [pw[1], pr[0], pe[0]]
+    pw[1].sync = true
+    if defined? yield
+      begin
+        return yield(*pi)
+      ensure
+        Process.detach(pid) if pid
+        pi.each { |p| p.close unless p.closed? }
+      end
+    end
+    pi
+  end
+end

data/spec/cucumber_f_m/aggregator_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+# TODO understand why subject { Klass.new(a,b) } doesn't work in rspec as it should
+
+describe CucumberFM::Aggregator do
+  before(:each) do
+    @f1 = mock('feature1')
+    @f2 = mock('feature2')
+    @s11 = mock('scenario1', :feature => @f1, :tags => ['@m1', '@mc', '@i1'],
+                :tags_without_technical => ['@m1', '@mc', '@i1'], :estimation => 1.5)
+    @s12 = mock('scenario2', :feature => @f1, :tags => ['@m2', '@ak', '@i1'],
+                :tags_without_technical => ['@m2', '@ak', '@i1'], :estimation => 1.75)
+    @s13 = mock('scenario5', :feature => @f1, :tags => ['@m2', '@ak', '@i1'],
+                :tags_without_technical => ['@m2', '@ak', '@i1'], :estimation => 1)
+    @s21 = mock('scenario3', :feature => @f2, :tags => ['@m3', '@mc', '@i1'],
+                :tags_without_technical => ['@m3', '@mc', '@i1'], :estimation => 2)
+    @s22 = mock('scenario4', :feature => @f2, :tags => ['@m2', '@tb', '@i2'],
+                :tags_without_technical => ['@m2', '@tb', '@i2'], :estimation => 1)
+    @cfm = mock('cfm', :scenarios => [@s11, @s12, @s13, @s21, @s22])
+    @aggregator1 = CucumberFM::FeatureElement::Component::Tags::PATTERN[:milestone]
+    @aggregator2 = CucumberFM::FeatureElement::Component::Tags::PATTERN[:iteration]
+  end
+
+  it "should return estimation value for scenarios array" do
+    @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator1])
+    @aggregator.collection['@m2'][@f1].estimation.should == 2.75
+  end
+
+  context "totals values should be correct" do
+    before(:each) do
+      @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator1])
+      @collection = @aggregator.collection
+    end
+    it "for features" do
+      @collection.should have(2).features
+    end
+    it "for scenarios" do
+      @collection.should have(5).scenarios
+    end
+    it "for estimation" do
+      @collection.estimation.should == 7.25
+    end
+  end
+
+  context "single dimension" do
+    before(:each) do
+      @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator1])
+      @collection = @aggregator.collection
+    end
+
+    it "should aggregate correctly" do
+      @collection.should ==
+              {
+                      '@m1' => {
+                              @f1 => [@s11]
+                      },
+                      '@m2' => {
+                              @f1 => [@s12, @s13],
+                              @f2 => [@s22]
+                      },
+                      '@m3' => {
+                              @f2 => [@s21]
+                      }
+              }
+    end
+
+    {'@m1' =>[1, 1, 1.5], '@m2' => [2, 3, 3.75], '@m3' => [1, 1, 2]}.each_pair do |key, value|
+      context "should correct count" do
+        context key do
+          it "features" do
+            @collection[key].should have(value[0]).features
+          end
+          it "scenarios" do
+            @collection[key].should have(value[1]).scenarios
+          end
+          it "estimation" do
+            @collection[key].estimation.should == value[2]
+          end
+        end
+      end
+    end
+  end
+
+  context "double dimension" do
+    before(:each) do
+      @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator1, @aggregator2])
+      @collection = @aggregator.collection
+    end
+    it "should aggregate correctly" do
+      @collection.should ==
+              {
+                      '@m1' => {
+                              '@i1' => { @f1 => [@s11] }
+                      },
+                      '@m2' => {
+                              '@i1' => { @f1 => [@s12, @s13]},
+                              '@i2' => { @f2 => [@s22]}
+                      },
+                      '@m3' => {
+                              '@i1' => { @f2 => [@s21]}
+                      }
+              }
+    end
+
+    {'@m1' =>[1, 1, 1.5], '@m2' => [2, 3, 3.75], '@m3' => [1, 1, 2]}.each_pair do |key, value|
+      context "should count correctly at first level" do
+        context key do
+          it "features " do
+            @collection[key].should have(value[0]).features
+          end
+          it "scenarios" do
+            @collection[key].should have(value[1]).scenarios
+          end
+          it "estimation" do
+            @collection[key].estimation.should == value[2]
+          end
+        end
+      end
+    end
+
+    {['@m2', '@i1'] =>[1, 2, 2.75], ['@m2', '@i2'] =>[1, 1, 1], ['@m3', '@i1'] => [1, 1, 2]}.each_pair do |key, value|
+      context "should count correctly at second level" do
+        context key do
+          it "features " do
+            @collection[key.first][key.last].should have(value[0]).features
+          end
+          it "scenarios" do
+            @collection[key.first][key.last].should have(value[1]).scenarios
+          end
+          it "estimation" do
+            @collection[key.first][key.last].estimation.should == value[2]
+          end
+        end
+      end
+    end
+
+  end
+
+  context "when tag for pattern not found is should be labelled as 'undefined' " do
+    before(:each) do
+      @s22 = mock('scenario4', :feature => @f2, :tags => ['@tb'], :tags_without_technical => ['@tb'],
+                  :estimation => 1)
+      @cfm = mock('cfm', :scenarios => [@s11, @s12, @s13, @s21, @s22])
+      @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator1])
+      @collection = @aggregator.collection
+    end
+
+    it "should aggregate correctly" do
+      @collection.should ==
+              {
+                      '@m1' => {
+                              @f1 => [@s11]
+                      },
+                      '@m2' => {
+                              @f1 => [@s12, @s13]
+                      },
+                      '_undefined_' => {
+                              @f2 => [@s22]
+                      },
+                      '@m3' => {
+                              @f2 => [@s21]
+                      }
+              }
+    end
+  end
+
+  context "multiple tags (one scenario can be aggregated many times" do
+    before(:each) do
+      @s22 = mock('scenario4', :feature => @f2, :tags => ['@mc', '@tb'],
+                  :tags_without_technical => ['@mc', '@tb'], :estimation => 1)
+      @cfm = mock('cfm', :scenarios => [@s11, @s12, @s13, @s21, @s22])
+      @aggregator = CucumberFM::Aggregator.new(@cfm, nil, ['@mc', '@tb', '@ak'])
+      @collection = @aggregator.collection
+    end
+
+       it "should aggregate correctly" do
+      @collection.should ==
+              {
+                      '@mc' => [@s11, @s21, @s22],
+                      '@tb' => [@s22],
+                      '@ak' => [@s12, @s13]
+              }
+    end
+
+  end
+
+  context "results should not be aggregated by technical tags on second level" do
+    before(:each) do
+      @aggregator_component = CucumberFM::FeatureElement::Component::Tags::PATTERN[:component]
+      @aggregator_developer = CucumberFM::FeatureElement::Component::Tags::PATTERN[:developer]
+      @s22 = mock('scenario4', :feature => @f2, :tags => ['@selenium', '@aggregator', '@ao'],
+                  :tags_without_technical => ['@aggregator','@ao'], :estimation => 1)
+      @cfm = mock('cfm', :scenarios => [@s22])
+      @aggregator = CucumberFM::Aggregator.new(@cfm, [@aggregator_developer, @aggregator_component])
+      @collection = @aggregator.collection
+    end
+
+       it "should aggregate correctly" do
+      @collection.should ==
+              {
+                      '@ao' => {
+                          '@aggregator' => {
+                              @f2 => [@s22]
+                          }
+                      }
+              }
+    end
+
+  end
+end