hippo-fw 0.9.1

data/lib/hippo/job/failure_logger.rb

@@ -0,0 +1,33 @@
+require "resque"
+require "resque/failure/multiple"
+require "resque/failure/redis"
+require "resque/failure/multiple"
+
+module Hippo
+    class Job
+        class FailureLogger < ::Resque::Failure::Base
+
+            def self.configure
+                Resque::Failure::Multiple.configure do |multi|
+                    # Always stores failure in Redis and writes to log
+                    multi.classes = Resque::Failure::Redis, self
+                end
+            end
+
+            def save
+                Hippo.logger.error detailed
+            end
+
+            def detailed
+                <<-EOF
+#{worker} failed processing #{queue}:
+Payload:
+#{payload.inspect.split("\n").map { |l| "  " + l }.join("\n")}
+Exception:
+#{exception}
+#{exception.backtrace.map { |l| "  " + l }.join("\n")}
+EOF
+            end
+        end
+    end
+end

data/lib/hippo/logger.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+require 'logger'
+
+module Hippo
+
+    class MultiDestinationLogger
+        def initialize
+            @targets = [STDOUT]
+            @targets.push(
+                File.open("log/#{Hippo.config.environment}.log", "a")
+            ) if File.writable?("log")
+        end
+
+        def write(*args)
+            @targets.each {|t| t.write(*args)}
+        end
+
+        def close
+            @targets.each(&:close)
+        end
+
+    end
+
+    class << self
+        def logger
+            @logger ||= _create_logger
+        end
+
+        def logger=( logger )
+            @logger = logger
+        end
+
+        def silence_logs( &block )
+            old_logger = Hippo.logger
+            begin
+                Hippo.logger=Logger.new( StringIO.new )
+                yield
+            ensure
+                Hippo.logger=old_logger
+            end
+        end
+
+        def logger_debug( output )
+            logger.debug '⚡ '*40
+            logger.debug '⚡ ' + output
+            logger.debug '⚡ '*40
+        end
+
+        private
+
+        def _create_logger
+            logger = ::Logger.new MultiDestinationLogger.new
+            logger.formatter = proc do |severity, datetime, progname, msg|
+                sprintf "%5.5s %s\n", severity, msg
+            end
+            if ENV['LOG']
+                logger.level = ::Logger.const_get(ENV['LOG'].upcase)
+            else
+                logger.level = ::Logger::INFO
+            end
+            logger
+        end
+    end
+end

data/lib/hippo/mailer.rb

@@ -0,0 +1,28 @@
+require 'mail'
+
+module Hippo
+
+    module Mailer
+
+        def self.create(args = {})
+            config = SystemSettings.for_ext(:hippo)['smtp'] || {}
+            delivery = delivery_method_config(config)
+            Mail::Message.new(args) do
+                from "\"#{config['from_name']}\" <#{config['from_email']}>"
+                delivery_method delivery
+            end
+        end
+
+        def self.delivery_method_config(config)
+            return :test unless Hippo.env.production?
+            {
+                smtp: {
+                    address: config['server'],
+                    user_name: config['login'],
+                    password: config['password']
+                }
+            }
+        end
+
+    end
+end

data/lib/hippo/model.rb

@@ -0,0 +1,24 @@
+require_relative 'concerns/all'
+
+module Hippo
+
+    class Model < ::ActiveRecord::Base
+        self.abstract_class = true
+
+        include Concerns::PubSub
+        include Concerns::ApiAttributeAccess
+        include Concerns::ExportMethods
+        include Concerns::ExportScope
+        include Concerns::ExportAssociations
+        include Concerns::ExportJoinTables
+        include Concerns::AssociationExtensions
+        include Concerns::ApiPath
+        include Concerns::CodeIdentifier
+        include Concerns::SanitizeFields
+        include Concerns::Queries
+        include Concerns::SortingExpressions
+        include Concerns::RandomIdentifer
+
+    end
+
+end

data/lib/hippo/multi_server_boot.rb

@@ -0,0 +1,26 @@
+module Hippo
+    module MultiServiceBoot
+        def self.perform
+            require 'hippo/api'
+            Hippo::Configuration.apply
+
+            config = Hippo::Command::ClientConfig.new
+            config.invoke_all
+
+            API.webpack = Hippo::Command::Webpack.new([], wait: false)
+            API.webpack.config = config
+
+            API.webpack.invoke_all# startup
+
+            Hippo::GuardTasks.client_config = config
+
+            sleep(1) # give webpack a bit of time to fail if it's going to
+            unless API.webpack.process.alive?
+                puts API.webpack.messages
+                exit 1
+            end
+            Guard.start # will block until complete
+            API.webpack.process.stop # stop webpack after guard completes
+        end
+    end
+end

data/lib/hippo/numbers.rb

@@ -0,0 +1,72 @@
+# * Utility methods that manipulate Numbers
+
+module Hippo
+    module Numbers
+        # Document the responsibility of the class
+        #
+        # == Heading
+        #
+        # Use headings to break up descriptions
+        #
+        # == Formatting
+        #
+        # Embody +parameters+ or +options+ in Teletype Text tags. You can also use
+        # *bold* or *italics* but must use HTML tags for <b>multiple words</b>,
+        # <i>like this</i> and <tt>like this</tt>.
+        # - See more at: http://blog.firsthand.ca/2010/09/ruby-rdoc-example.html#sthash.q9Jkcjrl.dpuf
+
+
+        # ### PercNum
+        #
+        #
+        # A "percnum" is a Stockor invention *(or abomination, depending on your POV)*.
+        # It's a string that contains a number and an optional percent sign.
+        # If the percent sign is present, the number is treated as a percentage.
+        # If desired the user may also input negative numbers which will invert the sense of the method.
+        #
+        # It's intended to be a user-friendly method to provide one input box for "discount" or "surcharge",
+        # and allow the user to input either a flat amount such as 4.50, or a percentage like 20%
+        #
+        class PercNum
+            # @param perc_or_num [BigDecimal,String, Integer] any value that BigDecimal will accept
+            def initialize( perc_or_num )
+                @is_perc    = !! perc_or_num.to_s.match( /\%\s*$/ )
+                @right_side = BigDecimal.new( perc_or_num, 5 )
+                if is_percentage?
+                    @right_side *= 0.01
+                end
+            end
+
+            # Adds the PercNum to the specified amount.
+            # @param amount[BigDecimal] the amount that should be added to the PercNum
+            # @return [BigDecimal] The result of either adding (non percent) or multiplying by (percent) the amount
+            # @example
+            #     PercNum.new( '23.42' ).credit_to(  33 ).to_s  #=> '56.42'
+            #     PercNum.new( '25%'   ).credit_to( 100 ).to_s  #=> '125.0'
+            def credit_to( amount )
+                is_percentage? ? ( 1 + @right_side ) * amount : amount += @right_side
+            end
+
+            # Subtracts the PercNum to the specified amount.
+            # @param amount[BigDecimal] the amount that should be added to the PercNum
+            # @return [BigDecimal] The result of either adding (non percent) or multiplying by (percent) the amount
+            # @example
+            #     PercNum.new( '23.42' ).debit_from( 42.42 ).to_s  #=> '19.00'
+            #     PercNum.new( '25%'   ).debit_from( 100   ).to_s  #=> '75.0'
+            def debit_from( amount )
+                is_percentage? ? ( 1 - @right_side ) * amount : amount -= @right_side
+            end
+
+            ## If PercNum was initialized with a blank string
+            def present?
+                ! @right_side.zero?
+            end
+
+            # Is the PercNum percentage based or absolute
+            def is_percentage?
+                @is_perc
+            end
+        end
+
+    end
+end

data/lib/hippo/rails_engine.rb

@@ -0,0 +1,5 @@
+module Hippo::Core
+    class RailsEngine < Rails::Engine
+        config.autoload_paths += Dir["#{config.root}/lib/**/"]
+    end
+end

data/lib/hippo/rake_tasks.rb

@@ -0,0 +1,69 @@
+require 'resque/tasks'
+require_relative '../hippo'
+require_relative 'command/jest'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+      t.pattern = Dir.glob('spec/server/**/*_spec.rb')
+  end
+rescue LoadError
+end
+
+desc "Open an irb session configured with the Hippo environment"
+task :console do
+    require 'irb'
+    require 'irb/completion'
+    require 'pp'
+    include Hippo
+    DB.establish_connection
+    ActiveRecord::Base.logger = Logger.new STDOUT
+    ARGV.clear
+    IRB.start
+end
+
+task :env do
+    Hippo::DB.configure_rake_environment
+    Hippo::Configuration.apply
+end
+
+# ## quite a bit of this is cribbed from Sinatra ActiveRecord
+load 'active_record/railties/databases.rake'
+
+task :routes do
+    require 'hippo/api'
+    Hippo::API::Root.routes.each do |verb,handlers|
+        puts "\n#{verb}:\n"
+        handlers.each do |handler|
+            puts handler[0].source.to_s.gsub("\\A",'').gsub("\\z",'')
+        end
+    end
+end
+
+namespace :db do
+    task :environment do
+        Hippo::DB.configure_rake_environment
+    end
+    task :load_hippo_config do
+        Hippo::DB.configure_rake_environment
+    end
+    task(:load_config).clear.enhance([:load_hippo_config])
+end
+
+namespace :assets do
+    task :precompile do
+        require 'hippo/command/webpack'
+        wp = Hippo::Command::Webpack.new([], compile: true)
+        wp.invoke_all
+    end
+end
+
+task :test => [:spec] do
+    ::Hippo::Command::Jest.new.configure.single_run
+end
+
+task :ci => ['db:migrate', 'db:seed'] do
+    sh %{node node_modules/eslint/bin/eslint.js client spec/client/}
+    sh %{bundle exec hippo jest}
+    sh %{bundle exec rspec}
+end

data/lib/hippo/redis.rb

@@ -0,0 +1,13 @@
+require 'redis'
+
+module Hippo
+
+    # returns a persistent connection to the Redis instance
+    def self.redis_connection(cache: true)
+        if cache
+            @@REDIS ||= ::Redis.new(Hippo.config.redis)
+        else
+            ::Redis.new(Hippo.config.redis)
+        end
+    end
+end

data/lib/hippo/reloadable_sinatra.rb

@@ -0,0 +1,24 @@
+require 'guard/compat/plugin'
+require_relative 'command/puma'
+
+module ::Guard
+
+    class ReloadableSinatra < ::Guard::Plugin
+        def start
+            Hippo.logger.info "RELOADING WebServer"
+            @puma = ::Hippo::Command::Puma.new
+            @puma.start
+        end
+
+        def run_on_modifications(paths)
+            @puma.stop
+            @puma.start
+        end
+
+        def stop
+            @puma.stop
+        end
+
+    end
+
+end

data/lib/hippo/reloadable_view.rb

@@ -0,0 +1,13 @@
+require 'guard/compat/plugin'
+require_relative './command/webpack_view'
+
+module ::Guard
+    class ReloadableView < ::Guard::Plugin
+        def run_on_modifications(paths)
+            paths.each do |view|
+                ::Hippo::Command::WebpackView.new(view).write
+                Hippo.logger.info "Re-compiled #{view}"
+            end
+        end
+    end
+end

data/lib/hippo/screen.rb

@@ -0,0 +1,152 @@
+require 'yaml'
+require 'oj'
+require 'pry'
+
+module Hippo
+
+    module Screen
+
+        GROUPS=Hash.new{|h,k| g=Group.new; g.identifier=k; h[k]=g }
+        DEFINITIONS=Hash.new
+
+        mattr_accessor :enabled_group_ids
+
+        class DefinitionList
+            def initialize(extension_id)
+                @extension_id = extension_id
+            end
+
+            def define(id)
+                definition = (DEFINITIONS[id] ||= Definition.new(id, @extension_id))
+                yield definition
+            end
+        end
+
+        class << self
+
+            include Enumerable
+
+            def [](config)
+                if DEFINITIONS.key?(config)
+                    DEFINITIONS[config]
+                else
+                    nil
+                end
+            end
+
+            def for_extension(id)
+                yield DefinitionList.new(id)
+            end
+
+            def define_group(id)
+                group = GROUPS[id]
+                yield group
+            end
+
+            def each
+                Extensions.load_screens
+                DEFINITIONS.values.each{ | definition | yield definition }
+            end
+
+            def each_group
+                Extensions.load_screens
+                GROUPS.values.each{ | group | yield group }
+            end
+
+            def config_file
+                Hippo::Extensions.controlling.root_path.join("config", "screens.rb")
+            end
+
+        end
+
+
+        class Group
+            include Concerns::AttrAccessorWithDefault
+
+            attr_accessor_with_default :identifier
+            attr_accessor_with_default :title
+            attr_accessor_with_default :description
+            attr_accessor_with_default :icon
+            attr_accessor_with_default :order
+
+            def to_json
+                Oj.dump({
+                    id: identifier,
+                    title: title,
+                    description: description,
+                    icon: icon
+                }, mode: :compat)
+            end
+        end
+
+        class Definition
+            include Concerns::AttrAccessorWithDefault
+
+            attr_accessor_with_default :identifier
+            attr_accessor_with_default :title
+            attr_accessor_with_default :description
+            attr_accessor_with_default :icon
+            attr_accessor_with_default :group_id
+            attr_accessor_with_default :extension
+            attr_accessor_with_default :view_class
+            attr_accessor_with_default :model_class
+            attr_accessor_with_default :model_access, 'read'
+            attr_accessor_with_default :asset
+
+            def initialize(id, extension_id)
+                self.identifier = id
+                @extension_id = extension_id
+                @extension    = extension_id.underscore.camelize
+            end
+
+            def group
+                GROUPS[@group_id]
+            end
+
+            def has_file_matching?(pattern)
+                Pathname.glob(root_path.join(pattern)).any?
+            end
+
+            def root_path
+                ext = Hippo::Extensions.for_identifier(@extension_id)
+                raise "Unable to find extension '#{@extension_id}' for screen group" unless ext
+                ext.root_path.join('client', url_prefix, identifier)
+            end
+
+            def model
+                return nil if @model_class.blank?
+                ext = Hippo::Extensions.for_identifier(@extension_id)
+                (@extension_id.camelize + '::' + @model_class).constantize
+            end
+
+            def viewable_by?(user)
+                model.nil? || user.can_read?(self)
+            end
+
+            def asset_path
+                (asset && asset =~ /\//) ? asset : "#{@extension_id}/screens/#{asset || identifier}"
+            end
+
+            def as_json
+                {
+                    id:    identifier,
+                    title: title,
+                    icon:  icon,
+                    model: model_class,
+                    view:  view_class,
+                    access: model_access,
+                    group_id: group_id,
+                    extension: extension,
+                    description: description,
+                    asset: asset_path
+                }
+            end
+
+            def to_json
+                Oj.dump(as_json, mode: :compat)
+            end
+        end
+
+    end
+
+end