houston-core 0.7.0.beta3 → 0.7.0.beta4

data/houston-core.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
 
   # For Houston as a Web Application
-  spec.add_dependency "rails", "~> 4.2.5.1"
+  spec.add_dependency "rails", "~> 4.2.5"
   spec.add_dependency "pg", "~> 0.18.3"
   # --------------------------------
   spec.add_dependency "activerecord-import"

data/lib/houston/boot/actions.rb

@@ -0,0 +1,105 @@
+require "thread_safe"
+
+module Houston
+  class Actions
+
+    def initialize
+      @actions = ThreadSafe::Hash.new
+    end
+
+
+    def names
+      actions.keys
+    end
+
+    def count
+      actions.count
+    end
+
+    def exists?(name)
+      actions.key?(name)
+    end
+
+    def [](name)
+      actions[name]
+    end
+
+    def to_a
+      actions.values
+    end
+
+    def define(name, required_params=[], &block)
+      raise ArgumentError, "#{name.inspect} is already defined" if exists?(name)
+      redefine(name, required_params, &block)
+    end
+
+    def redefine(name, required_params=[], &block)
+      raise ArgumentError, "A block is required to define an action" unless block_given?
+      actions[name] = Action.new(name, required_params, block)
+    end
+
+    def undefine(name)
+      raise ArgumentError, "#{name.inspect} is not defined" unless exists?(name)
+      actions.delete name
+    end
+
+
+    def run(name, params={}, options={})
+      raise ArgumentError, "#{name.inspect} is not defined" unless exists?(name)
+      action = actions.fetch(name)
+
+      unless params.is_a?(Hash)
+        raise ArgumentError, "params must be a Hash" unless params.respond_to?(:to_h)
+        params = params.to_h
+      end
+
+      assert_required_params! action, params
+      assert_serializable! params
+
+      Houston.async(options.fetch(:async, true)) do
+        action.send :run!, params, options
+      end
+    end
+
+
+  private
+    attr_reader :actions
+
+
+    def assert_required_params!(action, params)
+      action.assert_required_params! params.keys.map(&:to_s)
+    end
+
+    def assert_serializable!(params)
+      Houston::Serializer.new.assert_serializable!(params)
+    end
+
+
+    class Action < Struct.new(:name, :required_params, :block)
+      def initialize(name, required_params, block)
+        super name, required_params.map(&:to_s), block
+      end
+
+      def assert_required_params!(params)
+        missing_params = required_params - params
+        if missing_params.any?
+          raise Houston::Observer::MissingParamError, "#{missing_params.first.inspect} is a required param of the action #{name.inspect}"
+        end
+      end
+
+    private
+
+      def run!(params, options={})
+        params = ReadonlyHash.new(params)
+        trigger = options.fetch(:trigger, "manual")
+
+        ::Action.record name, params, trigger do
+          Rails.logger.info "\e[34m[#{trigger} => #{name}] Running job\e[0m"
+          params.instance_eval(&block)
+        end
+      end
+    end
+
+
+  end
+end

data/lib/houston/boot/active_record_serializer.rb

@@ -0,0 +1,24 @@
+module Houston
+  class ActiveRecordSerializer
+
+    def applies_to?(object)
+      object.is_a?(ActiveRecord::Base)
+    end
+
+    def pack(record)
+      model = record.class
+      normal_attributes = record.attributes.each_with_object({}) do |(attribute, value), attributes|
+        attributes[attribute] = model.column_for_attribute(attribute).type_cast_for_database(value)
+      end
+      { "class" => model.name, "attributes" => normal_attributes }
+    end
+
+    def unpack(object)
+      klass, attributes = object.values_at("class", "attributes")
+      klass.constantize.instantiate(attributes)
+    end
+
+  end
+end
+
+Houston.add_serializer Houston::ActiveRecordSerializer.new

data/lib/houston/boot/configuration.rb

@@ -2,14 +2,25 @@ root = File.expand_path(File.join(File.dirname(__FILE__), "../../.."))
 require File.join(root, "lib/core_ext/hash")
 require File.join(root, "lib/core_ext/kernel")
 require File.join(root, "lib/core_ext/exception")
+require File.join(root, "lib/houston/boot/triggers")
 require File.join(root, "lib/houston/boot/observer")
+require File.join(root, "lib/houston/boot/actions")
+require File.join(root, "lib/houston/boot/timer")
 
 $:.unshift File.expand_path(File.join(root, "app/adapters"))
 require "houston/adapters"
 
 module Houston
+module_function
+  def deprecation_notice(message, stack_offset=1)
+    message = message.gsub /<b>(.*)<\/b>/, "\e[1m\\1\e[0;34m"
+    puts "\e[34mDEPRECATION: #{message}\e[0;90m\n#{caller[stack_offset]}\e[0m\n\n"
+  end
+
+
+
   class Configuration
-    attr_reader :timers
+    attr_reader :observer, :actions, :timer
 
     def initialize
       @root = Rails.root
@@ -21,9 +32,27 @@ module Houston
       @ticket_tracker_configuration = {}
       @ci_server_configuration = {}
       @error_tracker_configuration = {}
-      @timers = []
     end
 
+    def triggers
+      return @triggers if defined?(@triggers)
+      @triggers = Houston::Triggers.new(self)
+    end
+
+    def observer
+      return @observer if defined?(@observer)
+      @observer = Houston::Observer.new
+    end
+
+    def actions
+      return @actions if defined?(@actions)
+      @actions = Houston::Actions.new
+    end
+
+    def timer
+      return @timer if defined?(@timer)
+      @timer = Houston::Timer.new
+    end
 
 
 
@@ -342,18 +371,86 @@ module Houston
 
 
 
-    # Events
+    # Actions and Triggers
 
-    def on(event, &block)
-      Houston.observer.on(event, &block)
+    def action(name, required_params=[], &block)
+      actions.define(name, required_params, &block)
     end
 
-    def at(time, name, options={}, &block)
-      @timers.push [:cron, time, name, options, block]
+    def on(*args, &block)
+      event_name, action_name = extract_trigger_and_action!(args)
+      event = Houston.get_registered_event(event_name)
+      action = assert_action! action_name, event.params, &block
+      action.assert_required_params! event.params
+
+      triggers.on event_name, action_name
+      action
     end
 
-    def every(interval, name, options={}, &block)
-      @timers.push [:every, interval, name, options, block]
+    def at(*args, &block)
+      time, action_name = extract_trigger_and_action!(args)
+      action = assert_action! action_name, &block
+      action.assert_required_params! []
+
+      # Passing options to Houston.config.at is deprecated
+      # -------------------------------------------------------------- #
+      if args.first.is_a?(Hash)
+        options = args.first
+        if days_of_the_week = options.delete(:every)
+          Houston.deprecation_notice "Instead of passing every: #{days_of_the_week.inspect} to Houston.config.at, use Houston.config.at [#{days_of_the_week.inspect}, #{time}], ..."
+          time = [days_of_the_week, time]
+        end
+        options.keys.each do |key|
+          Houston.deprecation_notice "#{key.inspect} is an unknown option for Houston.config.at. In the next version of houston-core, Houston.config.at will no longer accept options"
+        end
+      end
+      # -------------------------------------------------------------- #
+
+      triggers.at time, action_name
+      action
+    end
+
+    def every(*args, &block)
+      interval, action_name = extract_trigger_and_action!(args)
+      action = assert_action! action_name, &block
+      action.assert_required_params! []
+
+      # Passing options to Houston.config.every is deprecated
+      # -------------------------------------------------------------- #
+      if args.first.is_a?(Hash)
+        options = args.first
+        options.keys.each do |key|
+          Houston.deprecation_notice "#{key.inspect} is an unknown option for Houston.config.at. In the next version of houston-core, Houston.config.at will no longer accept options"
+        end
+      end
+      # -------------------------------------------------------------- #
+
+      triggers.every interval, action_name
+      action
+    end
+
+    private def extract_trigger_and_action!(args)
+      if args.first.is_a?(Hash)
+        return args.shift.to_a[0] if args.first.one?
+        raise ArgumentError, "Unrecognized trigger: #{args.inspect}"
+      end
+      return args.shift(2) if args.length >= 2
+      if args.length == 1
+        method_name = caller[0][/in `(.*)'/, 1]
+        Houston.deprecation_notice "<b>Houston.config.#{method_name}(#{args[0].inspect})</b> does not specify an action name\nIn a future version of Houston <b>Houston.config.#{method_name}(#{args[0]} => \"do-something\")</b> will be required", 2
+        return [args[0], "#{args[0]}:#{SecureRandom.hex}"]
+      end
+      raise NotImplementedError, "I haven't been programmed to extract trigger and action_name from #{args.inspect}"
+    end
+
+    private def assert_action!(name, required_params=[], &block)
+      if block_given?
+        action name, required_params, &block
+      elsif action = actions[name]
+        action
+      else
+        raise ArgumentError, "An action named #{name.inspect} is not defined"
+      end
     end
 
 
@@ -490,40 +587,6 @@ module Houston
 
 
 
-
-
-  class Jobs
-
-    def run(job)
-      trigger = "manual"
-      job, trigger = [job.tags.first, job.original] if job.is_a? Rufus::Scheduler::Job
-      block = find_timer_block!(job)
-      Houston.async do
-        run! job, trigger, block
-      end
-    end
-
-  private
-
-    def find_timer_block!(job_name)
-      timer = Houston.config.timers.detect { |(_, _, name, _, _)| name == job_name }
-      raise ArgumentError, "#{job_name} is not a job" unless timer
-      timer.last
-    end
-
-    def run!(job_name, trigger, block)
-      Job.record job_name do
-        Rails.logger.info "\e[34m[#{job_name}/#{trigger}] Running job\e[0m"
-        block.call
-      end
-    rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
-      Houston.report_exception($!, parameters: {job_name: job_name})
-    end
-
-  end
-
-
-
   class NotConfigured < RuntimeError
     def initialize(message = "Houston has not been configured. Please load config/config.rb before calling Houston.config")
       super
@@ -544,18 +607,24 @@ module_function
     @configuration
   end
 
+  def triggers
+    config.triggers
+  end
 
-  def self.root
-    config.root
+  def observer
+    config.observer
   end
 
+  def actions
+    config.actions
+  end
 
-  def observer
-    @observer ||= Observer.new
+  def timer
+    config.timer
   end
 
-  def jobs
-    @jobs ||= Jobs.new
+  def root
+    config.root
   end
 
   def github

data/lib/houston/boot/events.rb

@@ -0,0 +1,46 @@
+Houston.register_events {{
+
+  "antecedent:{type}:released"      => params("antecedent").desc("A ticket or commit with an antecedent of {type} was released"),
+  "antecedent:{type}:resolved"      => params("antecedent").desc("A ticket with an antecedent of {type} was resolved"),
+  "antecedent:{type}:closed"        => params("antecedent").desc("A ticket with an antecedent of {type} was closed"),
+
+  "commit:create"                   => params("commit").desc("A new commit was created"),
+
+  "daemon:{type}:start"             => desc("Daemon {type} has started"),
+  "daemon:{type}:restart"           => desc("Daemon {type} has restarted"),
+  "daemon:{type}:stop"              => desc("Daemon {type} has stopped"),
+
+  "deploy:completed"                => params("deploy").desc("A deploy just finished"),
+  "deploy:succeeded"                => params("deploy").desc("A deploy succeeded"),
+  "deploy:failed"                   => params("deploy").desc("A deploy failed"),
+
+  "github:comment:create"           => params("comment").desc("A comment was added to a commit, diff, or issue on GitHub"),
+  "github:comment:{type}:create"    => params("comment").desc("A comment was added to a {type} on GitHub"),
+  "github:comment:update"           => params("comment").desc("A comment on a commit, diff, or issue was updated on GitHub"),
+  "github:comment:{type}:update"    => params("comment").desc("A comment on a {type} was updated on GitHub"),
+  "github:comment:delete"           => params("comment").desc("A comment on a commit, diff, or issue was deleted on GitHub"),
+  "github:comment:{type}:delete"    => params("comment").desc("A comment on a {type} was deleted on GitHub"),
+
+  "github:pull:opened"              => params("pull_request").desc("A pull request was opened"),
+  "github:pull:updated"             => params("pull_request", "changes").desc("A pull request was updated"),
+  "github:pull:closed"              => params("pull_request").desc("A pull request was closed"),
+  "github:pull:reopened"            => params("pull_request").desc("A pull request was reopened"),
+  "github:pull:synchronize"         => params("pull_request").desc("Commits where pushed to a pull request"),
+
+  "hooks:{type}"                    => params("params").desc("/hooks/{type} was invoked"),
+  "hooks:project:{type}"            => params("project", "params").desc("/hooks/project/:slug/{type} was invoked"),
+
+  "release:create"                  => params("release").desc("A new release was created"),
+
+  "task:released"                   => params("task").desc("A commit mentioning this task was released"),
+  "task:committed"                  => params("task").desc("A commit mentioning this task was created"),
+  "task:completed"                  => params("task").desc("A task was completed"),
+  "task:reopened"                   => params("task").desc("A task was reopened"),
+
+  "test_run:start"                  => params("test_run").desc("A test run was started on the CI server"),
+  "test_run:complete"               => params("test_run").desc("A test run was completed on the CI server"),
+  "test_run:compared"               => params("test_run").desc("The test results for a commit were compared to the results for its parent"),
+
+  "ticket:release"                  => params("ticket", "release").desc("A ticket was released")
+
+}}

data/lib/houston/boot/extensions.rb

@@ -1,5 +1,9 @@
+require "houston/boot/serializer"
+
+
 module Houston
   module Extensions
+    attr_reader :events, :serializers
 
 
 
@@ -13,6 +17,29 @@ module Houston
 
 
 
+
+    def available_project_features
+      @available_project_features.keys
+    end
+
+    def get_project_feature(slug)
+      @available_project_features[slug]
+    end
+
+    def add_project_feature(slug, &block)
+      dsl = ProjectFeatureDsl.new
+      dsl.instance_eval(&block)
+      feature = dsl.feature
+      feature.slug = slug
+      raise ArgumentError, "Project Feature must supply name, but #{slug.inspect} doesn't" unless feature.name
+      raise ArgumentError, "Project Feature must supply icon, but #{slug.inspect} doesn't" unless feature.icon
+      raise ArgumentError, "Project Feature must supply path lambda, but #{slug.inspect} doesn't" unless feature.path_block
+
+      @available_project_features[slug] = feature
+    end
+
+
+
     def add_user_option(slug, &block)
       dsl = FormBuilderDsl.new
       dsl.instance_eval(&block)
@@ -28,24 +55,50 @@ module Houston
 
 
 
-    def available_project_features
-      @available_project_features.keys
+    def add_project_option(slug, &block)
+      dsl = FormBuilderDsl.new
+      dsl.instance_eval(&block)
+      form = dsl.form
+      form.slug = slug
+
+      @project_options[slug] = form
     end
 
-    def get_project_feature(slug)
-      @available_project_features[slug]
+    def project_options
+      @project_options.values
     end
 
-    def add_project_feature(slug, &block)
-      dsl = ProjectFeatureDsl.new
-      dsl.instance_eval(&block)
-      feature = dsl.feature
-      feature.slug = slug
-      raise ArgumentError, "Project Feature must supply name, but #{slug.inspect} doesn't" unless feature.name
-      raise ArgumentError, "Project Feature must supply icon, but #{slug.inspect} doesn't" unless feature.icon
-      raise ArgumentError, "Project Feature must supply path lambda, but #{slug.inspect} doesn't" unless feature.path_block
 
-      @available_project_features[slug] = feature
+
+    def registered_event?(event_name)
+      events.any? { |event| event.matches? event_name }
+    end
+
+    def get_registered_event(event_name)
+      events.find { |event| event.matches? event_name }
+    end
+
+    def register_event(name, description)
+      events.push Event.new(name, description)
+    end
+
+    def register_events(&block)
+      dsl = RegisterEventsDsl.new
+      hash = dsl.instance_eval(&block)
+      hash.each do |name, description|
+        register_event(name, description.to_h)
+      end
+    end
+
+
+
+    def add_serializer(serializer)
+      [:applies_to?, :pack].each do |method|
+        next if serializer.respond_to?(method)
+        raise ArgumentError, "`serializer` must respond to `#{method}`"
+      end
+
+      @serializers.push serializer
     end
 
 
@@ -125,12 +178,63 @@ module Houston
       end
     end
 
+    class RegisterEventsDsl
+      def params(*params)
+        RegisterEventDsl.new.params(*params)
+      end
+
+      def description(value)
+        RegisterEventDsl.new.description(value)
+      end
+      alias :desc :description
+    end
+
+    class RegisterEventDsl
+      def initialize
+        @hash = {}
+      end
+
+      def params(*params)
+        @hash[:params] = params
+        self
+      end
+
+      def description(value)
+        @hash[:description] = value
+        self
+      end
+      alias :desc :description
+
+      def to_h
+        @hash
+      end
+    end
+
+    class Event
+      attr_reader :name, :description, :params
+
+      def initialize(name, options)
+        @name = name
+        @description = options.fetch(:description)
+        @params = options.fetch(:params, [])
+        @matcher = Regexp.new("\\A#{name.gsub /\{([^:}]+)\}/, "(?<\\1>[^:]+)"}\\z")
+      end
+
+      def matches?(event_name)
+        @matcher === event_name
+      end
+    end
+
   end
 
 
 
   @navigation_renderers = {}
-  @user_options = {}
   @available_project_features = {}
+  @user_options = {}
+  @project_options = {}
+  @events = []
+  @event_matchers = []
+  @serializers = []
   extend Houston::Extensions
 end