houston-core 0.8.4 → 0.9.0.rc1

data/lib/houston/boot/extensions/navigation.rb

@@ -0,0 +1,42 @@
+require "concurrent/array"
+require "delegate"
+require "houston/boot/extensions/dsl"
+
+module Houston
+  module Extensions
+    class Navigation
+      attr_reader :links
+
+      def initialize
+        @links = Concurrent::Array.new
+      end
+
+      def add_link(content, &path_block)
+        if content.is_a?(Symbol)
+          slug = content
+          content = slug.to_s.titleize
+        else
+          slug = content.underscore.to_sym
+        end
+        Chain(AbilityBlock, AcceptsName, Link.new(slug, content).tap do |link|
+          link.instance_variable_set :@path_block, path_block
+          @links.push link
+        end)
+      end
+      alias :add :add_link
+      alias :<< :add_link
+
+      def slugs
+        links.map(&:slug)
+      end
+
+      def [](slug)
+        links.find { |link| link.slug == slug }
+      end
+    end
+
+    Link = Struct.new(:slug, :name) do
+      include Permitted, LinkTo
+    end
+  end
+end

data/lib/houston/boot/extensions/oauth.rb

@@ -0,0 +1,62 @@
+require "concurrent/array"
+
+module Houston
+  module Extensions
+    class Oauth
+      class ProviderNotFound < ArgumentError; end
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @providers = Concurrent::Hash.new
+      end
+
+      def providers
+        @providers.keys
+      end
+
+      def add_provider(name, &block)
+        provider = Houston::Provider.new(name.to_sym)
+        ProviderDsl.new(provider).instance_eval(&block)
+
+        raise ArgumentError, "Provider must define a site" if provider.site.blank?
+        raise ArgumentError, "Provider must define a authorize_path" if provider.authorize_path.blank?
+        raise ArgumentError, "Provider must define a token_path" if provider.token_path.blank?
+
+        @providers[provider.name] = provider
+      end
+
+      def get_provider(name)
+        name = name.to_sym
+        @providers.fetch(name)
+      rescue KeyError
+        puts "registered providers: #{providers.inspect}"
+        raise ProviderNotFound, "An Oauth Provider named #{name.inspect} has not been registered"
+      end
+
+
+      class ProviderDsl
+        attr_reader :provider
+
+        def initialize(provider)
+          @provider = provider
+        end
+
+        def site(value)
+          provider.site = value
+        end
+
+        def authorize_path(value)
+          provider.authorize_path = value
+        end
+
+        def token_path(value)
+          provider.token_path = value
+        end
+      end
+
+    end
+  end
+end

data/lib/houston/boot/extensions/serializers.rb

@@ -0,0 +1,29 @@
+require "concurrent/array"
+
+module Houston
+  module Extensions
+    class Serializers
+      include Enumerable
+
+      def initialize
+        @serializers = Concurrent::Array.new
+      end
+
+      def each(&block)
+        @serializers.each(&block)
+      end
+
+      def add(serializer)
+        serializer = serializer.new if serializer.is_a?(Class)
+
+        [:applies_to?, :pack].each do |method|
+          next if serializer.respond_to?(method)
+          raise ArgumentError, "`serializer` must respond to `#{method}`"
+        end
+
+        @serializers.push serializer
+      end
+      alias :<< :add
+    end
+  end
+end

data/lib/houston/boot/extensions/view.rb

@@ -0,0 +1,34 @@
+require "concurrent/hash"
+require "houston/boot/extensions/dsl"
+
+module Houston
+  module Extensions
+    class Views
+      def initialize
+        @views = Concurrent::Hash.new do |hash, key|
+          hash[key] = Houston::Extensions::View.new
+        end
+      end
+
+      def [](view)
+        @views[view]
+      end
+
+      def reset!
+        @views.values.each(&:reset!)
+      end
+    end
+
+
+    class View
+      def has(*constants)
+        constants.each do |constant|
+          extend Houston::Extensions.const_get(:"Has#{constant}")
+        end
+        self
+      end
+
+      def reset!; end
+    end
+  end
+end

data/lib/houston/boot/observer.rb

@@ -23,7 +23,12 @@ module Houston
       nil
     end
 
-    def off(callback)
+    def off(callback, &block)
+      if block_given?
+        event = callback
+        callback = observers_of(event).detect { |callback| callback.block == block }
+        return nil unless callback
+      end
       observers_of(callback.event).delete callback
       nil
     end
@@ -67,12 +72,12 @@ module Houston
 
     def assert_registered!(event_name)
       return if event_name == :*
-      return if Houston.registered_event?(event_name)
+      return if Houston.events.registered?(event_name)
       raise UnregisteredEventError, "#{event_name.inspect} is not a registered event"
     end
 
     def assert_registered_params!(event_name, params)
-      event = Houston.get_registered_event(event_name)
+      event = Houston.events[event_name]
 
       missing_params = event.params - params.keys.map(&:to_s)
       unregistered_params = params.keys.map(&:to_s) - event.params
@@ -91,7 +96,7 @@ module Houston
 
 
     class Callback
-      attr_reader :observer, :event
+      attr_reader :observer, :event, :block
 
       def initialize(observer, event, options, block)
         @observer = observer
@@ -113,7 +118,7 @@ module Houston
       def call(*args)
         Houston.async(invoke_async?) do
           begin
-            @block.call(*args)
+            block.call(*args)
 
           rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
             raise if raise_exceptions?

data/{app/models/oauth → lib/houston/boot}/provider.rb

@@ -1,8 +1,10 @@
-module Oauth
-  class Provider < ActiveRecord::Base
-    self.table_name = "oauth_providers"
+module Houston
+  class Provider
+    attr_accessor :name, :site, :authorize_path, :token_path, :client_id, :client_secret
 
-    validates :name, :site, :authorize_path, :token_path, :client_id, :client_secret, presence: true
+    def initialize(name)
+      @name = name
+    end
 
     def authorize_url(params={})
       client.auth_code.authorize_url params.merge(redirect_uri: oauth2_callback_url)
@@ -28,7 +30,7 @@ module Oauth
     end
 
     def oauth2_callback_url
-      "http://#{Houston.host}/oauth2/callback"
+      "#{Houston.root_url}/oauth2/callback"
     end
 
   end

data/lib/houston/boot/running_as.rb

@@ -8,11 +8,6 @@ module Houston
     RUBY
   end
 
-  def self.server?
-    Houston.deprecation_notice "Houston.server? is deprecated; use Houston.running_as_web_server?"
-    running_as_web_server?
-  end
-
   def self.running_as
     @__process_type ||= discover_process_type
   end

data/lib/houston/boot/serializer.rb

@@ -7,6 +7,10 @@ module Houston
   class Serializer
     class UnserializableError < ArgumentError; end
 
+    def initialize(serializers=Houston.serializers)
+      @serializers = serializers
+    end
+
     def load(string)
       begin
         object = Oj.load(string, nilnil: true, auto_define: false)
@@ -25,15 +29,15 @@ module Houston
     end
 
   private
+    attr_reader :serializers
 
     def unpack(object)
       if object.is_a?(Array)
         object.map { |item| unpack(item) }
       elsif object.is_a?(Hash)
         object = object.each_with_object({}) { |(key, value), new_object| new_object[key] = unpack(value) }
-        if serializer = object["^S"]
-          object = serializer.constantize.new.unpack(object)
-        end
+        serializer = object["^S"]
+        object = serializer.constantize.new.unpack(object) if serializer
         object
       else
         object
@@ -55,13 +59,15 @@ module Houston
         pack object.to_h
       when ActiveSupport::TimeWithZone
         object.to_datetime
+      when ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array::Data
+        pack object.values
       when *SERIALIZABLE_TYPES
         object
       else
-        Houston.serializers.each do |serializer|
+        serializers.each do |serializer|
           next unless serializer.applies_to?(object)
           packed_object = serializer.pack(object)
-          packed_object.merge!("^S" => serializer.class.name) if serializer.respond_to?(:unpack)
+          packed_object["^S"] = serializer.class.name if serializer.respond_to?(:unpack)
           return pack(packed_object)
         end
 
@@ -77,8 +83,8 @@ module Houston
       Date,
       DateTime,
       FalseClass,
-      Fixnum,
       Float,
+      Integer,
       NilClass,
       String,
       Symbol,

data/lib/houston/boot/{active_record_serializer.rb → serializers/active_record_serializer.rb}

@@ -21,5 +21,3 @@ module Houston
 
   end
 end
-
-Houston.add_serializer Houston::ActiveRecordSerializer.new

data/lib/houston/boot/{readonly_hash_serializer.rb → serializers/readonly_hash_serializer.rb}

@@ -11,5 +11,3 @@ module Houston
 
   end
 end
-
-Houston.add_serializer Houston::ReadonlyHashSerializer.new

data/lib/houston/boot/timer.rb

@@ -48,6 +48,16 @@ module Houston
       $scheduler.public_send method_name, argument, &block
     end
 
+    def stop(interval, block)
+      return queued_timers.delete [:every, interval, block] unless $scheduler
+
+      # Look up the job by its handler
+      # Note: this doesn't check `interval`. Conceivably, two jobs could be
+      # set up at different intervals that both invoke the same block.
+      job = $scheduler.jobs.detect { |job| job.handler == block }
+      job.unschedule
+    end
+
   private
 
     attr_reader :queued_timers

data/lib/houston/boot/triggers.rb

@@ -23,8 +23,8 @@ module Houston
       push build(:on, event, action, params)
     end
 
-    def build(method_name, value, action, params)
-      Trigger.new(self, method_name, value, action, params)
+    def build(method_name, value, action, params, persistent_trigger_id: nil)
+      Trigger.new(self, method_name, value, action, params, persistent_trigger_id)
     end
 
     def push(trigger)
@@ -34,27 +34,46 @@ module Houston
       trigger
     end
 
+    def delete(trigger)
+      i = find_index(trigger)
+      return unless i
+      trigger = self[i]
+      trigger.unregister!
+      delete_at i
+    end
+
   end
 
 
-  class Trigger < Struct.new(:method_name, :value, :action, :params)
+  class Trigger < Struct.new(:method_name, :value, :action, :params, :persistent_trigger_id)
 
     def initialize(triggers, *args)
       @triggers = triggers
+      @callback = method(:call).to_proc
       super *args
     end
 
     def register!
       case method_name
-      when :every then config.timer.every(value, &method(:call))
-      when :on then config.observer.on(value, &method(:call))
+      when :every then config.timer.every(value, &callback)
+      when :on then config.observer.on(value, &callback)
+      else raise NotImplementedError, "Unrecognized method name: #{method_name.inspect}"
+      end
+    end
+
+    def unregister!
+      case method_name
+      when :every then config.timer.stop(value, callback)
+      when :on then config.observer.off(value, &callback)
       else raise NotImplementedError, "Unrecognized method name: #{method_name.inspect}"
       end
     end
 
     def call(params={})
-      options = { trigger: to_s, async: triggers.async }
-      config.actions.run action, self.params.merge(params.to_h), options
+      Rails.logger.info "\e[34m[#{to_s} => #{action}]\e[0m"
+      config.actions.run action, self.params.merge(params.to_h),
+        trigger: to_s,
+        async: triggers.async
     end
 
     def to_s
@@ -62,7 +81,7 @@ module Houston
     end
 
   private
-    attr_reader :triggers
+    attr_reader :triggers, :callback
 
     def config
       triggers.config

data/lib/houston/version.rb

@@ -1,3 +1,3 @@
 module Houston
-  VERSION = "0.8.4"
+  VERSION = "0.9.0.rc1"
 end

data/templates/new-instance/.gitignore

@@ -7,10 +7,6 @@
 # Ignore bundler config.
 /.bundle
 
-# Ignore sensitive passwords and things.
-config/keypair.pem
-
 # Ignore all logfiles and tempfiles.
 /log/*.log
 /tmp
-

data/templates/new-instance/config/main.rb

@@ -22,22 +22,20 @@ Houston.config do
   # This is the host where Houston will be running
   host "houston.my-company.com"
 
+  # Your secret key is used for verifying the integrity of signed cookies.
+  # If you change this key, all old signed cookies will become invalid!
+  #
+  # Make sure the secret is at least 30 characters and all random,
+  # no regular words or you'll be exposed to dictionary attacks.
+  # You can use `rake secret` to generate a secure secret key.
+  secret_key_base ENV["HOUSTON_SECRET_KEY_BASE"]
+
   # This is the email address for emails send from Houston
   mailer_sender "houston@my-company.com"
 
   # Range for password length. Default is 8..128.
   # password_length 8..128
 
-  # This is the passphrase you used when generating config/keypair.pem
-  # Houston will use the keypair to encrypt and decrypt sensitive data
-  # To generate a new keypair.pem, execute these commands:
-  #
-  #   openssl genrsa -des3 -out config/private.pem 2048
-  #   openssl rsa -in config/private.pem -out config/public.pem -outform PEM -pubout
-  #   cat config/private.pem config/public.pem >> config/keypair.pem
-  #
-  passphrase ENV["HOUSTON_PASSPHRASE"]
-
   # Enter your Google Analytics Tracking ID to add Google's
   # Universal Analytics script to every page.
   google_analytics do