hippo-fw 0.9.1

data/lib/hippo/concerns/queries.rb

@@ -0,0 +1,24 @@
+module Hippo
+    module Concerns
+
+        # A collection of handly utility methods to generate queries
+        module Queries
+
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+
+                def compose_query_using_detail_view( view: nil, join_to: nil )
+                    join_to ||= self.name.demodulize.tableize.singularize + '_' + primary_key
+                    q = joins("join #{view} as details on details.#{join_to} = #{table_name}.#{primary_key}")
+                          .select("details.*")
+                    if current_scope.nil? || current_scope.select_values.exclude?("#{table_name}.*")
+                        q = q.select("#{table_name}.*")
+                    end
+                    q
+                end
+
+            end
+        end
+    end
+end

data/lib/hippo/concerns/random_identifier.rb

@@ -0,0 +1,37 @@
+module Hippo::Concerns
+
+    # @see ClassMethods
+    module RandomIdentifer
+
+        extend ActiveSupport::Concern
+
+        # ### Random Identifier Concern
+        # This adds the {#has_random_hash_code} class method
+        module ClassMethods
+
+            # A random string that identifies an model
+            # The code is generated by {Hippo::Strings.random} for new records
+            # It's useful for generating links for anonymous access to an entity that cannot be guessed.
+            # @param field_name [Symbol] which field should the hash_code be stored in
+            # @param length [Integer] how long the hash_code should be
+
+            def has_random_identifier(field_name: :identifier, length: 12)
+
+                validates field_name,
+                          presence: {
+                              message: "random identifier is not set (should be automatically chosen)"
+                          }
+
+                before_validation(on: :create) do
+                    5.times do
+                        if self[field_name].blank?
+                            code = Hippo::Strings.random(length)
+                            self[field_name] = code if self.class.where("#{field_name}" => code).none?
+                        end
+                        break if self[field_name].present?
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/hippo/concerns/sanitize_fields.rb

@@ -0,0 +1,32 @@
+require 'sanitize'
+
+module Hippo
+    module Concerns
+
+        # @see ClassMethods
+        module SanitizeFields
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+                # Remove invalid HTML from fields before save
+                # by using the "sanitize" gem's Sanitize.fragment method.
+                #
+                # Defaults to removing all HTML, but a valid Sanitize::Config
+                # hash can be specified as well.
+                def sanitize_fields(*fields)
+                    options = fields.extract_options!
+                    using = options[:using] || {}
+                    before_save do
+                        fields.each do |field|
+                            value = read_attribute(field)
+                            unless value.blank?
+                                write_attribute(field, Sanitize.fragment(sanitized,using))
+                            end
+                        end
+                    end
+                end
+
+            end
+        end
+    end
+end

data/lib/hippo/concerns/set_attribute_data.rb

@@ -0,0 +1,125 @@
+module Hippo::Concerns
+
+    module ApiAttributeAccess
+
+        DEFAULT_BLACKLISTED = {}
+
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :blacklisted_attributes
+            class_attribute :whitelisted_attributes
+            include AccessChecks
+        end
+
+        module AccessChecks
+            # Can the API read data from the model?
+            def can_read_attributes?(params, user)
+                return user.can_read?(self, params)
+            end
+
+            # Can the API write data to the model?
+            # This check is performed before we bother checking each attribute individually
+            def can_write_attributes?(params, user)
+                return user.can_write?(self, params)
+            end
+
+            # Can the API delete the model?
+            # This check is performed before we bother checking each attribute individually
+            def can_delete_attributes?(params, user)
+                return user.can_delete?(self, params)
+            end
+        end
+
+        module ClassMethods
+
+            # @param attributes [Array of symbols] attributes that are safe for the API to set
+            def whitelist_attributes( *attributes )
+                options = attributes.extract_options!
+                self.whitelisted_attributes ||= {}
+                attributes.each{|attr| self.whitelisted_attributes[ attr.to_sym ] = options }
+            end
+
+            # @param attributes [Array of symbols] attributes that are not safe for the API to set
+            def blacklist_attributes( *attributes )
+                options = attributes.extract_options!
+                self.blacklisted_attributes ||= DEFAULT_BLACKLISTED.clone
+                attributes.each{|attr| self.blacklisted_attributes[ attr.to_sym ] = options }
+            end
+
+            def from_attribute_data(data,user)
+                record = self.new
+                record.set_attribute_data(data, user)
+                record
+            end
+
+            include AccessChecks
+        end
+
+
+        # An attribute is allowed if it's white listed
+        # or it's a valid attribute and not black listed
+        # @param name [Symbol]
+        # @param user [User] who is performing request
+        def setting_attribute_is_allowed?(name, user)
+            return false unless user.can_write?(self, name)
+            (self.whitelisted_attributes && self.whitelisted_attributes.has_key?( name.to_sym)) ||
+            (
+              self.attribute_names.include?( name.to_s ) &&
+              ( self.blacklisted_attributes.nil? ||
+                ! self.blacklisted_attributes.has_key?( name.to_sym )  )
+            )
+        end
+
+        # Takes in a hash containing attribute name/value pairs, as well as sub hashes/arrays.
+        # Sets all the attributes that are allowed and recursively sets sub-associations as well
+        # @param data [Hash]
+        # @param user [User] who is performing request
+        # @returns
+        def set_attribute_data(data, user)
+            return {} unless self.can_write_attributes?(data, user)
+            data.each_with_object(Hash.new) do | (key, value), result |
+                # First we set all the attributes that are allowed
+
+                if self.setting_attribute_is_allowed?(key.to_sym, user)
+                    result[key] = value
+                    public_send("#{key}=", value)
+                elsif value.present?
+                    # allow nested params to be specified using Rails _attributes
+                    name = key.to_s.gsub(/_attributes$/,'').to_sym
+
+                    next unless self.class.has_exported_nested_attribute?(name, user)
+
+                    association = self.association(name)
+                    if value.is_a?(Hash) && [:belongs_to,:has_one].include?(association.reflection.macro)
+                        target = send(name) || association.build
+                        result[name] = target.set_attribute_data(value, user)
+                    elsif value.is_a?(Array) && :has_many == association.reflection.macro
+                        result[name] = _set_attribute_data_from_collection(association, name, value, user)
+                    end
+                end
+            end
+        end
+
+        def _set_attribute_data_from_collection(association, name, record_data, user)
+            records = public_send(name)
+            record_data.map do | association_data |
+
+                record = if association_data['id'].blank?
+                             association.build
+                         else
+                             records.detect{ |r| r.id.to_s == association_data['id'].to_s }
+                         end
+                next unless record
+
+                if association_data['_delete'] == true
+                    record.mark_for_destruction
+                else
+                    record.set_attribute_data(association_data, user)
+                end
+            end
+        end
+
+    end
+
+end

data/lib/hippo/concerns/sorting_expressions.rb

@@ -0,0 +1,34 @@
+module Hippo::Concerns
+
+    # @see ClassMethods
+    module SortingExpressions
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+            # Add a proc that will be called to add a sort expression to a query.
+            # The proc should accept an arel query object and a single direction parameter,
+            # which will be a symbol value of :asc or :desc
+            # It must return a arel query with the sort applied
+            # @param name [String] The name of the expression
+            def export_sort( name, &block )
+                @sorting_expressions ||= {}
+                @sorting_expressions[name.to_s] = block
+            end
+
+            def has_sorting_expression?(name)
+                @sorting_expressions && @sorting_expressions[name]
+            end
+
+            def append_sort_to_query(query, field, dir)
+                dir = :asc unless dir == :desc
+                if @sorting_expressions && (block = @sorting_expressions[field])
+                    block.call(query, dir)
+                else
+                    query.order(field.gsub(/[^\w|^\.]/,'') + ' ' +
+                                  ( ( :asc == dir ) ? 'ASC' : 'DESC' ) )
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/configuration.rb

@@ -0,0 +1,143 @@
+require_relative "concerns/attr_accessor_with_default"
+require 'securerandom'
+require 'pathname'
+require 'shrine'
+require 'active_job'
+require 'jobba'
+require 'webpack_driver'
+require 'yaml'
+require 'hashie/mash'
+require 'shrine/storage/file_system'
+
+module Hippo
+
+    class Configuration
+        include Concerns::AttrAccessorWithDefault
+        cattr_reader :secrets
+
+        # Since changing a config value inadvertently
+        # can have pretty drastic consequences that might not be
+        # discovered immediately, we log each time a value is changed
+        def self.config_option( name, default, options={} )
+            define_method( "#{name}=" ) do | value |
+                old_value = self.send( name )
+                if value != old_value && !options[:silent]
+                    Hippo.logger.info "Config option #{name} changed from '#{old_value.inspect}' to '#{value.inspect}'"
+                end
+                instance_variable_set("@#{name}", value)
+                if @observers.has_key?(name)
+                    @observers[name].each{ |cb| cb.call(value, old_value) }
+                end
+            end
+            attr_reader_with_default(name, default)
+        end
+
+        def initialize
+            @observers=Hash.new{ |hash,key| hash[key] = Array.new }
+        end
+
+        def on_change(config, &block)
+            @observers[config.to_sym] << block
+        end
+
+        def get(config, &block)
+            value = self.send(config.to_sym)
+            if block
+                on_change(config,&block)
+                block.call( value, value )
+            end
+            value
+        end
+
+        def self.apply
+            controlling_ext = Hippo::Extensions.controlling
+            secrets = controlling_ext.root_path.join('config', 'secrets.yml')
+            @@secrets = Hashie::Mash.new(
+                secrets.exist? ? YAML.load(ERB.new(secrets.read).result) : {}
+            )
+
+            ActiveJob::Base.queue_adapter = Hippo.env.test? ? :test : :resque
+            Hippo::Job::FailureLogger.configure
+
+            DB.establish_connection
+
+            Jobba.configure do |config|
+                config.redis_options = Hippo.config.redis
+                config.namespace = "#{controlling_ext.identifier}::jobba"
+            end
+
+            Resque.redis.namespace = "#{controlling_ext.identifier}::resque"
+            Resque.redis = Hippo.config.redis
+
+            Hippo::SystemSettings.for_ext('hippo').apply!
+            Extensions.each{|ext| ext.apply_configuration }
+
+            if Kernel.const_defined?(:Guard) && ::Guard.const_defined?(:Jest)
+                ::Guard::Jest.logger = Hippo.logger
+            end
+
+            ::Hippo::Concerns::AssetUploader.storages = {
+                cache: Shrine::Storage::FileSystem.new(controlling_ext.root_path,
+                                                       prefix: "tmp/cache"),
+                store: Shrine::Storage::FileSystem.new(controlling_ext.root_path,
+                                                       prefix: "public/files")
+            }
+        end
+
+    end
+
+    class DefaultConfiguration < Configuration
+
+        # Since the Configuration class is essentially a singleton,
+        # we don't care about AttrReaderWithDefault sharing values between instances
+        # Therefore all the values are given directly and not enclosed in Procs/lambdas.
+
+        # The configuration environment to use, test, development, production
+        config_option :environment, (ENV['HIPPO_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development').to_sym
+
+        # The secret key to use for session cookies.
+        config_option :session_secret_key_base,  '1234', silent: true
+
+        # Configuration for Redis
+        config_option :redis, ENV.has_key?('REDIS_URL') ?
+           {url: ENV["REDIS_URL"]} : {path: "/tmp/redis.sock"}
+
+        # url prefix to use for assets
+        config_option :assets_path_prefix, "/assets"
+
+        # url prefix to use for generated pdf's
+        config_option :print_path_prefix, "/print"
+
+        # prefix to use for all urls
+        config_option :mounted_at, '/'
+
+        # The initial id of the screen that should be displayed
+        config_option :root_view, 'workspace-layout'
+
+        # Screen to display on load (if workspace extension is used)
+        config_option :initial_workspace_screen_id, ''
+
+        # types of assets to include into compiled package
+        config_option :static_asset_types, ['images','fonts']
+
+        # Configuration for action cable
+        config_option :cable, { 'adapter' => 'redis' }
+
+        def api_path
+            mounted_at + 'api'
+        end
+
+    end
+
+    class << self
+        @@config = DefaultConfiguration.new
+        def config
+            @@config
+        end
+
+        def configure
+            yield(@@config)
+        end
+    end
+
+end

data/lib/hippo/db.rb

@@ -0,0 +1,57 @@
+module Hippo
+
+    module DB
+        extend self
+
+        attr_accessor(:config_file)
+
+        def establish_connection(env=Hippo.config.environment)
+            if ENV['DATABASE_URL']
+                ::ActiveRecord::Base.establish_connection(ENV['DATABASE_URL'])
+            else
+                file = config_file || Extensions.controlling.root_path.join("config","database.yml")
+                config = YAML::load( IO.read(file) )
+                ::ActiveRecord::Base.configurations = config
+                ::ActiveRecord::Base.establish_connection(::ActiveRecord::Base.configurations[env.to_s])
+            end
+        end
+
+        def load_seed
+            path = Pathname.new("./db/seed.rb")
+            load path if path.exist?
+        end
+
+        def configure_rake_environment
+            ActiveRecord::Tasks::DatabaseTasks.seed_loader = Hippo::DB
+            default_schema = Extensions.controlling.root_path.join("db","schema.sql")
+            ENV['SCHEMA']          ||= default_schema.to_s
+            ENV['DB_STRUCTURE']    ||= default_schema.to_s
+            ActiveRecord::Base.schema_format = :sql
+            ActiveRecord::Base.dump_schema_after_migration = !Hippo.env.production?
+            Hippo::DB.establish_connection
+            ActiveRecord::Tasks::DatabaseTasks.database_configuration = ActiveRecord::Base.configurations
+            env=Hippo.config.environment.to_s
+            ActiveRecord::Tasks::DatabaseTasks.env = env
+            ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'db/migrate'
+            ActiveRecord::Tasks::DatabaseTasks.current_config(
+                config: ActiveRecord::Base.configurations[env]
+            )
+        end
+
+        private
+
+        def migrations_dir
+            ::ActiveRecord::Migrator.migrations_paths.first
+        end
+
+        def silence_activerecord
+            old_logger = ::ActiveRecord::Base.logger
+            ::ActiveRecord::Base.logger = nil
+            yield if block_given?
+            ::ActiveRecord::Base.logger = old_logger
+        end
+    end
+
+    ActiveRecord::Base.logger = Hippo.logger
+
+end