hippo-fw 0.9.1

data/lib/hippo/api/root.rb

@@ -0,0 +1,70 @@
+require 'sinatra'
+require 'oj'
+require 'rack/protection'
+require 'rack/cors'
+
+require_relative "../access/authentication_provider"
+
+module Hippo
+    module API
+        class Root < Sinatra::Application
+            CORS_PATHS = {}
+
+            Hippo.config.get(:environment) do | env |
+                set :environment, env
+            end
+            helpers RequestWrapper
+            helpers HelperMethods
+            helpers FormattedReply
+
+            use Rack::Session::Cookie,
+                :key => 'rack.session',
+                :secret => Hippo.config.session_secret_key_base
+            not_found do
+                Oj.dump({ message: "endpoint not found", success: false  })
+            end
+            error ActiveRecord::RecordNotFound do
+                halt 404, error_as_json
+            end
+            error do
+                error_as_json
+            end
+
+            configure do
+                set :show_exceptions, false
+                require_relative 'routing'
+                Hippo::Configuration.apply
+                Extensions.load_controlling_config
+
+                set :views, Extensions.controlling.root_path.join('views')
+
+                require_relative './default_routes'
+                API::Cable.configure
+            end
+
+            configure do
+                cors_resources = []
+                if API::Root::CORS_PATHS.any?
+                    use Rack::Cors, debug: !Hippo.env.production?, logger: Hippo.logger do
+                        API::Root::CORS_PATHS.each do | path, options |
+                            allow do
+                                cors_resources.push  Rack::Cors::Resource.new('', path)
+                                origins options[:origins]
+                                resource path,
+                                         :methods => options[:methods].map(&:to_sym) + [:options],
+                                         :headers => :any
+                            end
+                        end
+
+                    end
+
+                end
+                # use Rack::Protection, allow_if: -> (env) {
+                #     path = env['PATH_INFO']
+                #     cors_resources.any?{|r| r.matches_path?(path) }
+                # }
+
+            end
+        end
+    end
+end

data/lib/hippo/api/routing.rb

@@ -0,0 +1,111 @@
+module Hippo
+    module API
+
+        def self.set_root_view(view)
+            API::Root.get Hippo.config.mounted_at + '?*' do
+                if request.accept? 'text/html'
+                    erb :hippo_root_view
+                else
+                    pass
+                end
+            end
+        end
+
+        class RoutingBlock
+            def initialize(ext_id)
+                Hippo::Extensions.for_identifier(ext_id) ||
+                    raise( "Unable to find extension '#{ext_id}' for screen group")
+                @ext_id = ext_id
+            end
+
+            [:get, :post, :put, :patch, :delete].each do | method_name |
+                define_method(method_name) do | path_suffix, options = {}, &block |
+                    API::Root.send(method_name, make_path(path_suffix), options, &block)
+                end
+            end
+
+            def enable_cors(path_suffix, options = {origins: '*', methods: [:get]})
+                API::Root::CORS_PATHS[make_path(path_suffix)] = options
+            end
+
+            def resources(model, options = {})
+                path = options[:path] || model.api_path
+                controller = options[:controller] || Hippo::API::GenericController
+                format = options[:format] || '.json'
+                if options[:under]
+                    options[:parent_attribute] = options[:under].underscore.singularize+'_id'
+                end
+
+                prefix = options[:parent_attribute] ? options[:parent_attribute] + '/' : ''
+
+                valid_methods = []
+
+                bind = lambda{ |method, route, wrapper_method = method|
+                    valid_methods.push(method)
+                    self.send(method, route + format,
+                              &RequestWrapper.send(wrapper_method, model, controller, options))
+                }
+
+                # show
+                if controller.method_defined?(:show)
+                    bind[:get, "#{prefix}#{path}/?:id?"]
+                end
+
+                # create
+                if controller.method_defined?(:create)
+                    bind[:post, "#{prefix}#{path}"]
+                end
+
+                unless options[:immutable]
+
+                    # update
+                    if controller.method_defined?(:update)
+                        bind[:patch, "#{prefix}#{path}/?:id?", :update]
+                        bind[:put,   "#{prefix}#{path}/?:id?", :update]
+                    end
+
+                    # destroy
+                    if controller.method_defined?(:destroy) and not options[:indestructible]
+                        bind[:delete, "#{prefix}#{path}/?:id?"]
+                    end
+
+                end
+
+                if options[:cors] && valid_methods.any?
+                    cors = options[:cors].is_a?(Hash) ? otions[:cors] : {origins: options[:cors]}
+                    enable_cors "#{prefix}#{path}/?:id?#{format}",
+                                cors.merge(methods: valid_methods)
+                end
+
+            end
+
+            private
+
+            def make_path(path)
+                path = Hippo.config.api_path + '/' + @ext_id + '/' + path
+                Hippo.logger.debug("[route]: #{path}")
+                path
+            end
+        end
+
+        class RouteSet
+            def initialize(root)
+                @root = root
+            end
+
+            def draw(&block)
+                @root.instance_eval(&block)
+            end
+
+            def for_extension(ext_id, &block)
+                routes = RoutingBlock.new(ext_id)
+                routes.instance_eval(&block)
+            end
+        end
+
+        def self.routes(&block)
+            @routes ||= RouteSet.new(API::Root)
+        end
+
+    end
+end

data/lib/hippo/api/sprockets_extension.rb

@@ -0,0 +1,105 @@
+# require 'sprockets'
+# require 'sass'
+# require 'sinatra/sprockets-helpers'
+# require 'compass/import-once/activate'
+# require 'sprockets-helpers'
+# require 'tilt/erb'
+# require 'compass/import-once/activate'
+
+# module Hippo
+#     module API
+#         module SprocketsExtension
+#             class << self
+
+#                 def compile!
+#                     # only require processor if it's needed
+#                     # it requires asset pipeline functionality that requires a JS runtime
+#                     # which may not be available on production
+#                     require_relative 'javascript_processor'
+#                     env = ::Sprockets::Environment.new
+#                     Hippo::API::SprocketsExtension.configure(env, compress:true)
+#                     JsAssetCompiler.register(env)
+#                     manifest = Sprockets::Manifest.new( env.index, "public/assets/manifest.json" )
+#                     manifest.compile('hippo/vendor.js', 'hippo.js', 'hippo.css')
+#                     Extensions.each do |ext|
+#                         ext.each_static_asset do | asset |
+#                             manifest.compile( asset.to_s )
+#                         end
+#                     end
+#                     Screen.each do | screen |
+#                         [:js,:css].each do | type |
+#                             asset = screen.url_path_for(type)
+#                             manifest.compile( asset ) unless asset.blank?
+#                         end
+#                     end
+
+#                 end
+
+#                 def configure(env, compress:false)
+#                     root = Pathname.new(__FILE__).dirname.join("../../..")
+#                     Hippo.config.get(:environment) do
+#                         unless Hippo.env.production?
+#                             env.cache = ::Sprockets::Cache::FileStore.new(Pathname.pwd.join('tmp','cache'))
+#                         end
+#                     end
+
+#                     Hippo::Extensions.each do | ext |
+#                         ext.on_boot
+#                         ext.client_paths.each{ |path|
+#                             env.append_path(path)
+#                         }
+#                     end
+#                     if compress
+#                         env.js_compressor  = :uglifier
+#                         env.css_compressor = :sass
+#                     end
+#                     # assets are pre-compiled on production
+#                     unless Hippo.env.production?
+#                         require_relative 'javascript_processor'
+#                         JsAssetCompiler.register(env)
+#                     end
+#                     env.append_path root.join('client')
+#                 end
+
+#                 def registered(app)
+#                     app.register Sinatra::Sprockets::Helpers
+#                     app.set :sprockets, ::Sprockets::Environment.new
+#                     configure(app.sprockets)
+
+#                     app.configure do
+#                         ::Sprockets::Helpers.configure do |config|
+#                             config.environment = app.sprockets
+#                             config.prefix      = Hippo.config.assets_path_prefix
+
+#                             config.public_path = app.public_folder
+#                             config.debug = !app.production?
+#                             if app.production?
+#                                 config.manifest = Sprockets::Manifest.new(app.sprockets,
+#                                                                           "public/assets/manifest.json")
+#                             end
+#                         end
+#                     end
+
+#                     Root::CORS_PATHS['/assets/*'] = {origins: '*', methods: [:get]}
+
+#                     app.configure :test, :development do
+#                         app.get "#{Hippo.config.assets_path_prefix}/*" do |path|
+#                             env_sprockets = request.env.dup
+#                             env_sprockets['PATH_INFO'] = path.gsub(/\?\d+$/, '')
+#                             settings.sprockets.call env_sprockets
+#                         end
+#                     end
+#                     app.configure :production do
+#                         app.get "#{Hippo.config.assets_path_prefix}/*" do |path|
+#                             if manifest_path = ::Sprockets::Helpers.manifest.assets[path]
+#                                 path = manifest_path
+#                             end
+#                             send_file "public/assets/" + path
+#                         end
+#                     end
+#                 end
+
+#             end
+#         end
+#     end
+# end

data/lib/hippo/api/to_json.rb

@@ -0,0 +1,7 @@
+require 'oj'
+
+module Hippo::API
+    def self.to_json(data)
+        Oj.dump(data, mode: :compat, time_format: :xmlschema)
+    end
+end

data/lib/hippo/api/updates.rb

@@ -0,0 +1,37 @@
+module Hippo
+
+    module API
+
+        module Updates
+            @relaying_messages = false
+
+            def self.user_info_for_change(model)
+                if model.class.reflect_on_aggregation(:updated_by)
+                    model.updated_by.as_json(only:[:id,:name,:email])
+                else
+                    {}
+                end
+            end
+
+            def self.relay!
+                if @relaying_messages
+                    raise "Already relaying messages, calling relay! twice will lead to message duplication"
+                end
+                @relaying_messages = true
+                Hippo::Model.observe(:save) do |model|
+                    if model.changes.any?
+                        path = "/#{model.class.api_path(with_module: true)}/#{model.id}"
+                        Hippo::API::PubSub.publish(path, {
+                            by: self.user_info_for_change(model),
+                            update: model.changes
+                        })
+                    end
+                end
+
+            end
+
+        end
+
+
+    end
+end

data/lib/hippo/asset.rb

@@ -0,0 +1,18 @@
+module Hippo
+
+    class Asset < Hippo::Model
+
+        include Hippo::Concerns::AssetUploader[:file]
+
+        belongs_to :owner, polymorphic: true
+
+        def present?
+            super && file.present?
+        end
+
+        def path(size)
+            Hippo.config.api_path + Hippo.config.assets_path_prefix + '/' + file_data[size]['id']
+        end
+    end
+
+end

data/lib/hippo/capistrano.rb

@@ -0,0 +1,30 @@
+set :linked_files, %w{config/database.yml}
+
+namespace :db do
+
+    desc 'Migrates the database by running: bundle exec hippo db migrate'
+    task :migrate => ["deploy:set_rails_env"] do
+        on roles(:db) do
+            info '[deploy:migrate] Run `hippo db migrate`'
+            within release_path do
+                with rails_env: fetch(:rails_env) do
+                    execute :bundle, "exec hippo db migrate"
+                end
+            end
+        end
+    end
+
+    desc 'Seeds the database by running: bundle exec hippo db seed'
+    task :seed => ["deploy:set_rails_env"] do
+        on roles(:db) do
+            info '[deploy:seed] Run `hippo db seed`'
+            within release_path do
+                with rails_env: fetch(:rails_env) do
+                    execute :bundle, "exec hippo db seed"
+                end
+            end
+        end
+    end
+
+    after 'deploy:updated', 'db:migrate'
+end

data/lib/hippo/cli.rb

@@ -0,0 +1,50 @@
+require 'thor'
+require 'require_all'
+require_relative '../hippo'
+require_relative 'command'
+require_relative 'command/named_command'
+require_rel 'command/*.rb'
+
+module Hippo
+
+    # This is the main interface to Hippo that is called by the command
+    # `bin/hippo`. Do not put any logic in here, create a class and delegate
+    # instead.
+    class CLI < Thor
+
+        register Command::App, 'new', 'new [NAME]', 'Creates a new Hippo based application'
+
+        desc "generate SUBCOMMAND ...ARGS", "Generate a component"
+        subcommand "generate", Command::Generate
+
+        desc "update SUBCOMMAND ...ARGS", "Update a model"
+        subcommand "update", Command::Update
+
+        desc "version", "Display version of hippo"
+        def version
+            puts Hippo::VERSION
+        end
+
+        long_desc Command.usage_from_file("server")
+        register Command::Server,  'serve', 'serve', 'Run the app in development/testing mode'
+
+        long_desc "start the Jest test server"
+        register Command::Jest,  'jest', 'jest', 'Start the Jest test server for client code'
+
+        long_desc "start the webpack dev server"
+        register Command::Webpack, 'webpack', 'webpack', 'Start the Webpack Dev Server'
+
+        long_desc "start the Puma server"
+        register Command::Puma, 'puma', 'puma', 'Start the Puma(Sinata) Server'
+
+        long_desc "start the guard test runner"
+        register Command::Guard,  'guard', 'guard', 'Start the Guard server'
+
+        long_desc Command.usage_from_file("db")
+        register Command::Db,  'db', 'db', 'Database commands'
+
+        register Command::Console, "console",  "console", "Start IRB console"
+
+    end
+
+end

data/lib/hippo/command.rb

@@ -0,0 +1,43 @@
+require 'thor/error'
+
+module Hippo
+    module Command
+        class << self
+
+            # Reads and returns the contents of a usage file.  Used
+            # internally by commands to populate their long_desc
+            # @param [String] basename of file to read usage from
+            def usage_from_file(file)
+                Pathname.new(__FILE__).dirname.join("command","#{file}.usage").read.gsub(/\n/,"\n\x5")
+            end
+
+            # Loads the code for the extension that the user is currently
+            # working inside.  The `hippo` command uses this to detect
+            # what actions should be taken.
+            #
+            # Will silently swallow any exceptions that are raised when the file is required and return nil
+            #
+            # @return [Extension] extension that was loaded, nil if none was found
+            def load_current_extension(raise_on_fail:false)
+                ext = Dir.glob("./lib/*/extension.rb").first
+                if ext
+                    begin
+                        require(ext)
+                    rescue =>e
+                        stack = e.backtrace[0..4].join("\n")
+                        raise Thor::Error.new("Loading ./lib/*/extension.rb failed with: #{e}\n#{stack}")
+                    end
+                    Extensions.controlling
+                else
+                    return _maybe_fail(raise_on_fail)
+                end
+            end
+
+            def _maybe_fail(should_raise)
+                raise Thor::Error.new("Unable to locate Hippo environment.\nDoes ./lib/*/extension.rb exist?") if should_raise
+                return nil
+            end
+
+        end
+    end
+end