hippo-fw 0.9.1

data/lib/hippo/db/migrations.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+module Hippo
+    module DB
+        module Migrations
+            # The `paths` array is an extension point for other
+            mattr_accessor :paths
+            self.paths = [
+              Pathname.new(__FILE__).dirname.join("../../../db/migrate").realpath
+            ]
+
+            # Migration table definition helpers methods
+            module TableDefinitionHelpers
+                # track user modifications
+                def track_modifications(create_only: false, null: false)
+                    column(:created_at, :datetime,   null: null)
+                    column(:created_by_id, :integer, null: null)
+                    return if create_only
+
+                    column(:updated_at, :datetime,   null: null)
+                    column(:updated_by_id, :integer, null: null)
+                end
+            end
+        end
+    end
+end
+
+
+
+ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods.class_eval do
+    include ::Hippo::DB::Migrations::TableDefinitionHelpers
+end

data/lib/hippo/environment.rb

@@ -0,0 +1,22 @@
+module Hippo
+
+    class Environment
+        def test?
+            Hippo.config.environment == :test
+        end
+        def development?
+            Hippo.config.environment == :development
+        end
+        def production?
+            Hippo.config.environment == :production
+        end
+        def to_s
+            Hippo.config.environment.to_s
+        end
+    end
+
+    # @return [Environment]
+    def self.env
+        @environment ||= Environment.new
+    end
+end

data/lib/hippo/extension.rb

@@ -0,0 +1,112 @@
+module Hippo
+
+    module Extensions
+        mattr_accessor :controlling_locked
+
+        ALL=Array.new
+
+        class << self
+            include Enumerable
+
+            def load_screens
+                each do | ext |
+                    screens_config = ext.root_path.join('config','screens.rb')
+                    if screens_config.exist?
+                        require screens_config
+                    end
+                end
+            end
+
+            # lock the current controlling extension so that it can't
+            # be changed by other extensions that are loaded later
+            def lock_controlling!
+                self.controlling_locked=true
+            end
+
+            def add(klass)
+                @cached_instances = nil
+                if Extensions.controlling_locked
+                    ALL.unshift(klass)
+                else
+                    ALL << klass
+                end
+            end
+
+            def all
+                ALL
+            end
+
+            def for_identifier(identifier)
+                each{|ext| return ext if ext.identifier == identifier }
+                nil
+            end
+
+            def sorted
+                unmapped = all
+                mapped   = []
+                while unmapped.any?
+                    mapped_count = mapped.length
+                    unmapped.each do | ext |
+                        if !ext.before && !ext.after
+                            mapped.push(ext)
+                        end
+                        if ext.before && (position = mapped.find_index(ext.before))
+                            mapped.insert(position, ext)
+                        end
+                        if ext.after && (position = mapped.find_index(ext.after))
+                            mapped.insert(position+1, ext)
+                        end
+                    end
+                    if mapped_count == mapped.length # we failed to add any extensions
+                        Hippo.logger.info "Conflicting load directives.  Some extensions will not be available"
+                    end
+                    unmapped -= mapped
+                end
+                mapped
+            end
+
+            def each(reversed: false)
+                @cached_instances ||= sorted.map{ |klass| klass.new }
+                (reversed ? @cached_instances.reverse : @cached_instances).each do |ext|
+                    yield ext
+                end
+            end
+
+            def controlling
+                last = ALL.last
+                each{|ext| return ext if ext.is_a?(last) }
+                Hippo.logger.error "Unable to find controlling extension. #{sorted} are loaded"
+            end
+
+            def client_bootstrap_data
+                data = {
+                  api_path: Hippo.config.api_path,
+                  root_path: Hippo.config.mounted_at,
+                  root_view: Hippo.config.root_view,
+                  environment: Hippo.config.environment,
+                  assets_path_prefix: Hippo.config.assets_path_prefix,
+                  controlling_extension: controlling.identifier,
+                  initial_workspace_screen_id: Hippo.config.initial_workspace_screen_id
+                }
+                each do | ext |
+                    ext_data  = ext.client_bootstrap_data
+                    data[ext.identifier] = ext_data unless ext_data.nil?
+                end
+                return data
+            end
+
+            def load_controlling_config
+                config_file = self.controlling.root_path.join('config','initialize.rb')
+                if config_file.exist?
+                    require config_file
+                end
+            end
+
+        end
+
+    end
+
+
+end
+
+require_relative 'extension/definition'

data/lib/hippo/extension/definition.rb

@@ -0,0 +1,90 @@
+module Hippo
+    module Extensions
+
+        class Definition
+            include ::Hippo::Concerns::AttrAccessorWithDefault
+
+            def self.inherited(klass)
+                Extensions.add(klass)
+            end
+
+            attr_reader :context
+
+            attr_accessor_with_default :client_js_aliases, lambda{ Hash.new }
+
+            attr_accessor_with_default :title, ''
+
+            attr_accessor_with_default :load_phase, :late
+
+            attr_accessor_with_default :identifier
+
+            # Array of Pathname's to add to sprockets
+            attr_accessor_with_default :root_path
+
+            attr_accessor_with_default :db_table_prefix
+
+            # Load extension before/after the named extensions
+            class_attribute :before
+            class_attribute :after
+
+            def initialize
+                self.add_to_load_path
+            end
+
+            def load_after(extension)
+                self.after = extension
+            end
+
+            def load_before(extension)
+                self.before = extension
+            end
+
+            def client_bootstrap_data
+                {}
+            end
+
+            def view_templates
+                ['index.html']
+            end
+
+            def on_dev_console
+            end
+
+            def route(route_set)
+                routes_config = root_path.join('config','routes.rb')
+                if routes_config.exist?
+                    require routes_config
+                end
+            end
+
+            def add_to_load_path
+                @in_load_path_set ||= (
+                    lib = root_path.join('lib').to_s
+                    $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+                )
+            end
+
+            def apply_configuration
+                 config_file = root_path.join('config', 'hippo.rb')
+                 if config_file.exist?
+                     require config_file
+                 end
+            end
+
+            def client_extension_path
+                "#{identifier}/extension"
+            end
+        end
+
+        class Base < Definition
+            identifier "hippo"
+            title "Hippo Application"
+            root_path Pathname.new(__FILE__).dirname.join("..","..","..").expand_path
+
+            def client_extension_path
+                "hippo/extensions/hippo"
+            end
+        end
+
+    end
+end

data/lib/hippo/guard_tasks.rb

@@ -0,0 +1,62 @@
+require_relative '../hippo'
+require_relative 'command/jest'
+require_relative 'reloadable_sinatra.rb'
+require_relative 'reloadable_view.rb'
+require 'guard/jest'
+require 'guard/rspec'
+
+module Hippo
+    module GuardTasks
+        mattr_accessor :client_config
+
+        class CustomMatchers
+            attr_reader :client_matches, :server_matches
+
+            def client(&block)
+                @client_matches = block
+            end
+            def server(&block)
+                @server_matches = block
+            end
+        end
+
+
+        def self.run(dsl, options, &block)
+            matchers = CustomMatchers.new
+            yield matchers
+            identifier = ::Hippo::Extensions.controlling.identifier
+            config = client_config || ::Hippo::Command::Jest.new.configure.config
+
+            jest_options = options.merge(
+                logger: Hippo.logger,
+                silent: false,
+                jest_cmd: './node_modules/.bin/jest',
+                config_file: config.directory.join('jest.config.json')
+            )
+            dsl.guard :jest, jest_options
+
+            rspec_options = {
+                all_on_start: false,
+                cmd: 'bundle exec rspec'
+            }
+            dsl.guard :rspec, rspec_options do
+                dsl.watch(%r{^spec/server/spec_helper\.rb}) { 'spec' }
+                dsl.watch(%r{^spec/server/.*_spec\.rb})
+                dsl.watch(%r{^spec/fixtures/#{identifier}(.+)s\.yml})   { |m| "spec/server/#{m[1]}_spec.rb" }
+                dsl.watch(%r{^lib/#{identifier}/(.+)\.rb})              { |m| "spec/server/#{m[1]}_spec.rb" }
+                matchers.server_matches.call if matchers.server_matches
+            end
+
+            dsl.guard :reloadable_sinatra do
+                dsl.watch(%r{^lib/.*\.rb})
+                dsl.watch(%r{^config/.*\.rb})
+            end
+
+            dsl.guard :reloadable_view do
+                dsl.watch(%r{^views/(.*\.html)}) { |m| m[1] }
+            end
+
+        end
+
+    end
+end

data/lib/hippo/hippo_guard_plugin.rb

@@ -0,0 +1,80 @@
+require 'guard/compat/plugin'
+require_relative 'api'
+
+module ::Guard
+
+    class HippoGuardPlugin
+        ROOT = Pathname.new(__FILE__).dirname.join('..','..')
+
+        attr_reader :threads, :jest, :webpack
+
+        def initialize(options = {})
+
+            super
+
+        end
+
+        def stop
+            webpack.stop
+            jest.stop
+            threads.each do |thread|
+                thread.exit
+            end
+
+        end
+
+        def start
+            @threads = Array.new()
+
+            @webpack = WebpackDriver::DevServer.new(
+                '--port', '8889', '--config',
+                ROOT.join('lib','js','webpack.config.js').expand_path.to_s
+            )
+            Hippo::API.webpack = @webpack
+
+            roots = Hippo::Extensions.map{|ext| ext.root_path.join('client').to_s }
+
+            @jest = ::ChildProcess.build(
+                ROOT.join('node_modules/jest-cli/bin/jest.js').to_s, '--watch',
+                '--config', ROOT.join('lib', 'js', 'jest.config.js').to_s
+            )
+
+            @jest_output, w = IO.pipe
+            jest.io.stdout = jest.io.stderr = w
+            # jest.io.stdin = STDIN
+            jest.start
+            Thread.new do
+                @jest_output.each_line do | l |
+                    puts l
+                end
+            end
+
+            threads << Thread.new {
+                Hippo::API::Root.run!
+            }
+            threads << Thread.new {
+                until API::Root.running?
+                    sleep 1
+                end
+                # needed to remove the Sinatra's handler
+                trap("INT") { exit }
+            }
+
+
+            webpack.environment.merge!(
+                HIPPO_EXT_ROOTS: roots.join(',')
+            )
+
+            webpack.start
+
+            sleep(1)
+
+            unless webpack.alive?
+                puts webpack.messages
+            end
+
+        end
+
+    end
+
+end

data/lib/hippo/job.rb

@@ -0,0 +1,82 @@
+require 'jobba'
+require_relative 'api/pub_sub'
+
+
+module Jobba
+    module RecordStatus
+
+        def self.included(klass)
+            klass.send(:attr_reader, :job_status)
+            klass.around_enqueue do |job, block|
+                @job_status = Jobba.find!(job.job_id)
+                @job_status.set_job_name(self.class.to_s)
+                @job_status.unqueued!
+                block.call
+                @job_status.queued!
+            end
+            klass.around_perform do |job, block|
+                # we use find! so it will create a record of the job even if
+                # it's created using perform_now.  In that case the enqueue step's skipped
+                @job_status = Jobba.find!(job.job_id)
+                @job_status.started!
+                block.call
+                @job_status.succeeded!
+            end
+        end
+
+    end
+end
+
+module Hippo
+
+    # A job in hippo is identical to a ActiveJob::Base job, except it records it's
+    # status using the Jobba::Status mixin module
+    class Job < ::ActiveJob::Base
+
+        after_perform{ |job|
+            job.deliver_progress_to_clients
+        }
+
+        def deliver_progress_to_clients
+            ::Hippo::API::PubSub.publish(
+                "/hippo/job-statuses/#{job_id}",
+                update: Job.status_for_id(job_id)
+            )
+        end
+
+        def save_progress(output, progress=1.0)
+            job_status.set_progress(progress)
+            job_status.save(output: output)
+            deliver_progress_to_clients
+        end
+
+        def self.status_for_id(id)
+            status = Jobba.find(id)
+            return nil unless status
+            {
+                id:          status.id,
+                job_name:    status.job_name,
+                progress:    status.progress,
+                attempt:     status.attempt,
+                state:       status.state.name,
+                recorded_at: status.recorded_at,
+                queued_at:   status.queued_at,
+                errors:      status.errors,
+                data:        status.data
+            }
+        end
+
+        def self.api_status_message(job, message="Job started")
+            return {
+                success: true, message: message, data: {
+                    job: Hippo::Job.status_for_id(job.job_id)
+                }
+            }
+        end
+
+        include Jobba::RecordStatus
+    end
+
+
+
+end