ora-dev-tools 1.2.1

data/lib/jira_diff/globals.rb

@@ -0,0 +1,4 @@
+module JIRADiff
+  PROGRAM_NAME = "JIRADiff"
+  VERSION      = "0.2.3"
+end

data/lib/jira_diff/options.rb

@@ -0,0 +1,68 @@
+require "devtools"
+
+module JIRADiff
+  class OptParse
+
+    def self.default_options
+      {
+        debug:     false,
+        directory: ".",
+        dryrun:    false,
+        master:    "master",
+        source:    [],
+        verbose:   true
+      }
+    end
+
+    def self.parse(argv_opts = [], unit_testing = false)
+      opt_parse = DevTools::OptParse.new({ name:     PROGRAM_NAME,
+                                           version:  VERSION,
+                                           testing:  unit_testing,
+                                           defaults: default_options })
+
+      parser = opt_parse.parser
+
+      parser.banner = "Usage: #{DevTools::PROGRAM} [OPTIONS]"
+
+      parser.separator ""
+      parser.separator "[OPTIONS]"
+
+      parser.separator ""
+      parser.separator "Specific Options:"
+
+      parser.on("-d", "--directory DIR", "Use DIR as our source directory") do |dir|
+        dir = File.expand_path(dir.strip)
+        if Dir.exist?(dir)
+          Options.directory = dir
+        else
+          raise ArgumentError, "ENOEXIST: Directory does not exist -> #{dir}"
+        end
+      end
+
+      parser.on("-m", "--master BRANCH", "Specify a master branch (default: master)") { |m| Options.master = m }
+      parser.on("-s", "--source BRANCH",
+                "Use BRANCH as the source to compare against (may be used more than once)") do |branch|
+        Options.source << branch unless Options.source.include?(branch)
+      end
+
+      parser.separator ""
+      parser.separator "Common Options:"
+
+      parser.parse!(argv_opts)
+
+      validate_options(Options)
+    end
+
+    def self.validate_options(opts)
+      if opts.source.include?(opts.master)
+        raise RuntimeError, "Source branches cannot include the master branch"
+      end
+
+      opts.source = ["develop"] if opts.source.empty?
+      opts.master = "master" if opts.master.nil? || opts.master.strip == ""
+
+      opts
+    end
+
+  end
+end

data/lib/jira_diff/stories.rb

@@ -0,0 +1,122 @@
+require 'jira_diff/story'
+require 'jira_diff/git'
+
+module JIRADiff
+  class Stories
+
+    def initialize(opts = Options.defaults)
+      @branches = _get_branches(opts[:master], opts[:source])
+      @directory = opts[:directory] || '.'
+      @includes = _get_includes(opts.includes)
+      @options = opts
+      @stories = opts[:stories] || {}
+
+      _get_stories if @stories == {}
+    end
+
+    attr_accessor :branches, :directory
+    attr_reader :stories, :includes
+
+    alias dir directory
+
+    def each
+      @stories.values.each do |stories|
+        stories.each { |story| yield story }
+      end
+    end
+
+    def source
+      @branches[1, @branches.size]
+    end
+
+    def add_include(story)
+      @includes << story
+    end
+
+    def includes=(file)
+      @includes = _get_includes(file)
+    end
+
+    def master
+      @branches[0]
+    end
+
+    def master=(new_master)
+      @stories[master] = []
+      @branches[0] = new_master
+      _get_stories(new_master)
+    end
+
+    def shas
+      source.map do |branch|
+        stories[branch].map { |s| s.sha }
+      end.flatten.reverse
+    end
+
+    def source_stories
+      story_index = {}
+
+      source.each do |branch|
+        stories[branch].each { |s| story_index[s.sha] = s }
+      end
+
+      story_index.values
+    end
+
+    def add_story(branch, story)
+      (@stories[branch] ||= []).push story
+    end
+
+    def find(branch, sha)
+      raise ArgumentError, "Invalid environment #{branch}" unless @branches.include?(branch)
+
+      @stories[branch].each { |story| return true if story.sha == sha }
+
+      false
+    end
+
+    def diff
+      stories = []
+      opts = @options
+
+      source_stories.each do |story|
+        stories << story unless find(master, story.sha)
+      end
+
+      opts.source = ['diff']
+      opts.stories = {'diff' => stories.flatten}
+      Stories.new opts
+    end
+
+    private
+
+    def _get_branches(master, sources)
+      branches = [] << (master.nil? ? 'master' : master)
+      branches << (sources.empty? ? ['develop'] : sources)
+      branches.flatten
+    end
+
+    def _get_includes(includes_file)
+      lines = []
+      if includes_file && File.exist?(includes_file)
+        File.open(includes_file, 'r') do |f|
+          f.each_line { |line| lines << $1 if line =~ /(\w+\-\d+)/ }
+        end
+      end
+      lines
+    end
+
+    def _get_stories(branches = @branches)
+      git = Git.new(@directory)
+
+      branches.to_a.each do |branch|
+        puts "checking #{branch}" if @options.debug
+        git.log(branch).each do |line|
+          add_story branch, Story.new(line)
+        end
+      end
+    end
+
+  end
+end
+

data/lib/jira_diff/story.rb

@@ -0,0 +1,53 @@
+module JIRADiff
+
+  class Story
+    def initialize( story )
+      unless story =~ /\S+|\S+/
+        raise ArgumentError, "story must follow 'SHA|description' format"
+      end
+
+      @sha, @description = story.split('|')
+
+      raise ArgumentError if @sha.nil? || @description.nil?
+    end
+    attr_reader :sha
+
+    def split_story( description = @description )
+      raise RuntimeError 'description cannot be blank' unless description
+
+      stories = []
+      story_pattern = /\[?(((SRMPRT|OSMCLOUD)\-\d+)|NO-JIRA)\]?[,:\-\s]+\s*(.*)$/
+      line = description.match(story_pattern)
+
+      if line.nil? # did not find a JIRA ticket pattern
+        stories.push 'NO-JIRA'
+        desc = description.strip
+      else
+        stories.push line.captures[0]
+        desc = line.captures[3].strip
+      end
+
+      # Perform recursion if there are multiple tickets in the description
+      if desc =~ story_pattern
+        new_story, new_desc = split_story desc
+        stories.push new_story
+        desc = new_desc
+      end
+
+      [stories.flatten, desc]
+    end
+
+    def tickets
+      (split_story)[0]
+    end
+
+    def desc
+      (split_story)[1]
+    end
+
+    def to_s
+      '[%07.07s] %s - %s' % [sha, tickets.join(', '), desc]
+    end
+
+  end
+end

data/lib/pr_list.rb

@@ -0,0 +1,4 @@
+require "devtools"
+require "pr_list/globals"
+require "pr_list/options"
+require "pr_list/pull_requests"

data/lib/pr_list/globals.rb

@@ -0,0 +1,6 @@
+module DevTools
+  module PRlist
+    IDENT   = "PRlist"
+    VERSION = "0.1.0"
+  end
+end

data/lib/pr_list/options.rb

@@ -0,0 +1,55 @@
+
+module DevTools
+  module PRlist
+    class OptParse
+
+      def self.default_options
+        {
+          markdown: false,
+          queue:    false
+        }
+      end
+
+      def self.validate_options
+        raise RuntimeError, "Missing configuration file" if Options.nil?
+        raise RuntimeError, "Missing authentication token" if Options.token.nil?
+        raise RuntimeError, "No repositories provided" if Options.repos.empty?
+      end
+
+      def self.parse(argv_opts = [], unit_testing = false)
+        opt_parse = DevTools::OptParse.new({ name:     IDENT,
+                                             version:  VERSION,
+                                             defaults: default_options,
+                                             testing:  unit_testing })
+
+        parser = opt_parse.parser
+
+        parser.banner = "Usage: #{DevTools::PROGRAM} [OPTIONS]"
+
+        parser.separator ""
+        parser.separator "[OPTIONS]"
+
+        parser.on "-m", "--markdown", "Outputs in markdown friendly format" do
+          Options.markdown = true
+        end
+
+        parser.on "--[no-]queue", "filters PRs into a queue list for QA (default)" do |opt|
+          Options.queue = opt
+        end
+
+        parser.separator ""
+        parser.separator "Common Options:"
+
+        parser.parse!(argv_opts)
+
+        validate_options unless unit_testing
+
+        Options
+      end
+
+      def self.label_values
+        Options.labels.keys.map { |k| Options.labels[k] }.flatten.compact
+      end
+    end
+  end
+end

data/lib/pr_list/pull_requests.rb

@@ -0,0 +1,87 @@
+require "octokit"
+
+module DevTools
+  module PRlist
+    class PullRequest
+      attr_reader :issue
+
+      def method_missing(method_sym, *arguments, &block)
+        @issue.respond_to?(method_sym) ? @issue.send(method_sym, *arguments, &block) : super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @issue.respond_to?(method_name.to_sym) || super
+      end
+
+      def initialize(issue)
+        @issue ||= issue
+      end
+
+      def date
+        @issue.created_at
+      end
+
+      def has_label?(filter_by)
+        labels.any? { |label| [filter_by].flatten.map{ |l| l.downcase.strip }.include?(label.downcase.strip) }
+      end
+
+      def labels
+        @issue.labels.map { |l| l.name }
+      end
+
+      def repo(opt = {})
+        opt[:short] = false unless opt.has_key?(:short)
+
+        /repos\/(\w*\/?(.*))$/.match(@issue.repository_url)[opt[:short] ? 2 : 1]
+      end
+    end
+
+    class PullRequests
+      attr_reader :pulls
+
+      def initialize(token = nil, repos = [])
+        @pulls  ||= []
+        @github ||= __authenticate token
+
+        repos.each { |repo| load!(repo) } if authorized?
+      end
+
+      def authorized?
+        return !@github.nil?
+      end
+
+      def auth!(token)
+        @github = __authenticate token
+      end
+
+      def load!(repo)
+        raise NoAuthError, "You must authorized with github using #auth first" unless authorized?
+
+        @github.issues(repo).each do |issue|
+          __load_issue issue if issue.pull_request?
+        end
+      end
+
+      def by_date
+        sorted_pulls = @pulls.sort_by { |pr| pr.date }
+
+        block_given? ? sorted_pulls.each { |pr| yield pr } : sorted_pulls
+      end
+
+      def repos
+        @pulls.collect { |pr| pr.repo }.uniq
+      end
+
+      private
+
+      def __load_issue(issue)
+        @pulls.push PullRequest.new issue
+      end
+
+      def __authenticate(token)
+        token ? Octokit::Client.new(access_token: token) : nil
+      end
+
+    end
+  end
+end

data/lib/runtest.rb

@@ -0,0 +1,3 @@
+require "devtools"
+require "runtest/globals"
+require "runtest/options"

data/lib/runtest/globals.rb

@@ -0,0 +1,4 @@
+module RunTest
+  PROGRAM_NAME = "RunTest"
+  VERSION      = "1.2.2"
+end

data/lib/runtest/options.rb

@@ -0,0 +1,100 @@
+module RunTest
+  class OptParse
+    def self.default_options
+      {
+        basedir:  "src/js",
+        changed:  false,
+        commands: Config::Options.new,
+        jest:     true,
+        mocha:    true,
+        verbose:  0
+      }
+    end
+
+    #
+    # Return a structure describing the Options.
+    #
+    def self.parse(args, unit_testing=false)
+      # The Options specified on the command line will be collected in *Options*.
+      # We set default values here.
+      opt_parse = DevTools::OptParse.new({ name:     PROGRAM_NAME,
+                                           version:  VERSION,
+                                           defaults: default_options,
+                                           testing:  unit_testing })
+
+      opt_parse.default_options(Options.commands, {
+        diff:       "git diff --name-only develop src/js | egrep \".js$\"",
+        jest:       "$(npm bin)/jest",
+        jest_full:  "npm run test:jest",
+        mocha:      "$(npm bin)/mocha --require src/js/util/test-dom.js --compilers js:babel-core/register",
+        mocha_full: "npm run test:mocha"
+      })
+
+      parser = opt_parse.parser
+
+      parser.banner = "Usage: #{DevTools::PROGRAM} [OPTIONS] [PATTERN]"
+      parser.banner += "\n\nWhere [PATTERN] is any full or partial filename."
+      parser.banner += " All tests matching this filename pattern will be run."
+
+      parser.separator ""
+      parser.separator "[OPTIONS]"
+
+      parser.separator ""
+      parser.separator "Specific Options:"
+
+      # Base directory
+      parser.on("-b", "--basedir DIR", "Specify the base directory to search for tests (DEFAULT: '#{Options.basedir}')") do |dir|
+        Options.basedir = dir
+      end
+
+      # Changed switch
+      parser.on("-c", "--changed", "Run specs for any files that have recently been modified") do
+        Options.changed = true
+      end
+
+      parser.separator ""
+      parser.separator "Test Runners:"
+
+      parser.on("-j", "--[no-]jest", "Only/Don't run Jest tests") do |jest|
+        Options.jest = true; Options.mocha = false
+        (Options.jest = false; Options.mocha = true) unless jest
+      end
+
+      parser.on("-m", "--[no-]mocha", "Only/Don't run Mocha tests") do |mocha|
+        Options.jest = false; Options.mocha = true
+        (Options.jest = true; Options.mocha = false) unless mocha
+      end
+
+      parser.separator ""
+      parser.separator "Test Commands:"
+
+      parser.on("--diff-cmd CMD", "Overwrite git diff command: '#{Options.commands.diff}'") do |cmd|
+        Options.commands.diff = cmd
+      end
+
+      parser.on("--jest-cmd CMD", "Overwrite Jest command: '#{Options.commands.jest}'") do |cmd|
+        Options.commands.jest = cmd
+      end
+
+      parser.on("--jest-full-cmd CMD", "Overwrite Jest full-suite command: '#{Options.commands.jest_full}'") do |cmd|
+        Options.commands.jest_full = cmd
+      end
+
+      parser.on("--mocha-cmd CMD", "Overwrite Mocha command: '#{Options.commands.mocha}'") do |cmd|
+        Options.commands.mocha = cmd
+      end
+
+      parser.on("--mocha-full-cmd CMD", "Overwrite Mocha command: '#{Options.commands.mocha_full}'") do |cmd|
+        Options.commands.mocha_full = cmd
+      end
+
+      parser.separator ""
+      parser.separator "Common Options:"
+
+      parser.parse!(args)
+
+      return Options
+    end
+  end # class OptParse
+end # module RunTest
+