hippo-fw 0.9.1

data/lib/hippo/command/server.rb

@@ -0,0 +1,19 @@
+require 'guard/cli'
+require_relative '../guard_tasks'
+require_relative '../multi_server_boot'
+
+module Hippo
+    module Command
+
+        class Server < Thor::Group
+
+            include Thor::Actions
+
+            def launch
+                say "Launching testing server at http://localhost:8888/", :green
+                Command.load_current_extension
+                ::Hippo::MultiServiceBoot.perform
+            end
+        end
+    end
+end

data/lib/hippo/command/server.usage

@@ -0,0 +1,3 @@
+Run the webserver and testing tasks.  The server
+will monitor the files for changes and automatically
+run the relevant tests when modifications occur.

data/lib/hippo/command/update.rb

@@ -0,0 +1,13 @@
+module Hippo
+    module Command
+
+        class Update < Thor
+
+            desc 'update model [NAME]', 'Updates a model'
+            long_desc Command.usage_from_file("update_model")
+            register Command::UpdateModel, 'model', 'model [NAME]', 'Updates a client model to match the server definition'
+
+        end
+
+    end
+end

data/lib/hippo/command/update_model.rb

@@ -0,0 +1,127 @@
+require_relative 'model_attribute'
+
+module Hippo
+    module Command
+
+        class UpdateModel < NamedCommand
+
+            attr_reader :namespaced_name
+
+            def set_variables
+                super
+                @file_name  = name.underscore
+            end
+
+            def read_class
+                if name=~/::/
+                    (@namespace,@name) = name.split("::")
+                else
+                    ext = Command.load_current_extension(raise_on_fail:true)
+                    @namespace = ext.identifier
+                end
+
+                namespaced_name = "#{namespace.classify}::#{class_name}"
+                @klass = namespaced_name.safe_constantize
+                if !@klass
+                    raise Thor::Error.new("#{namespaced_name} was not found")
+                end
+                @file = Pathname.new(client_dir).join("models/#{class_name}.coffee")
+                unless @file.exist?
+                    raise Thor::Error.new("Model #{@file} doesn't exist")
+                end
+                Hippo::DB.establish_connection
+            end
+
+            def replace_props
+                columns = columns_for(@klass)
+                return unless columns.any? # could happen I guess?
+                (props,indent) = read_indent('props')
+                maxlen = columns.map{|field| field.name.length }.max
+                contents = props
+                columns.each do | column |
+                    contents << sprintf("#{indent}%-#{maxlen+1}s",column.name+':') + type_specification(column) + "\n"
+                end
+                gsub_file @file, /props\s*:\s*\n.*?\n(?!#{indent})/m, contents
+            end
+
+            def replace_associations
+                associations = associations_for(@klass)
+                return unless associations.any?
+                (section,indent) = read_indent('associations',optional: true)
+                maxlen = associations.map{|field| field.name.length }.max
+                contents = section || (
+                               single_indent = @file.read[/\n(\h+)(\w+):/,1] || '    '
+                               indent = single_indent*2
+                               "\n#{single_indent}associations:\n"
+                             )
+                associations.each do | assoc |
+                    type = assoc.collection? ? 'collection' : 'model'
+                    contents << sprintf("#{indent}%-#{maxlen+2}s",assoc.name.to_s+':') + \
+                                "{ #{type}: \"#{assoc.class_name.demodulize}\" }\n"
+                end
+                if section
+                    gsub_file @file, /associations\s*:\s*\n.*?\n(?!#{indent})/m, contents
+                else
+                    gsub_file @file, /\n\z/m, contents
+                end
+            end
+
+          private
+
+            def read_indent(section, optional: false)
+                  contents = @file.read
+                  match = contents.match(/(#{section}\s*:\s*\n+)(\s+)\w/m)
+                  return match.captures if match
+                  if optional
+                      return [nil,nil]
+                  else
+                      raise Thor::Error.new("Unable to detect #{section} section")
+                  end
+            end
+
+            def type_specification(column)
+                if column.null
+                    '"' + type_for_column(column) + '"'
+                else
+                    type = { type: type_for_column(column), required: true }
+                    if column.default
+                        type[:default] = case column.default
+                                         when 'true' then true
+                                         when 'false' then false
+                                         else column.default
+                                         end
+                    end
+                    type.to_json.gsub(%r{,"}, ', "')
+                end
+            end
+
+            def associations_for(klass)
+                klass.reflect_on_all_associations.reject{|assoc| assoc.name =~ /^(created|updated)_by/ }
+            end
+
+            def columns_for(klass)
+                klass.columns.reject{ |column| column.name =~ /^(created|updated)_/ }
+            end
+
+            def type_for_column(column)
+                if column.array
+                    'array'
+                elsif column.sql_type == 'json'
+                    'object'
+                else
+                    case column.type
+                    when :datetime then 'date'
+                    when :integer  then 'integer'
+                    when :float    then 'number'
+                    when :boolean  then 'boolean'
+                    when :decimal  then 'bigdec'
+                    when :text, :string then 'string'
+                    when :jsonb, :json, :hstore then 'object'
+                    else 'any'
+                    end
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/command/update_model.usage

@@ -0,0 +1,2 @@
+Updates a model's client definition to match the fields
+that are defined on the server.

data/lib/hippo/command/webpack.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+require 'fileutils'
+require 'pathname'
+
+module Hippo
+
+    module Command
+
+        class Webpack < Thor::Group
+            include Thor::Actions
+
+            attr_reader :process
+
+            attr_accessor :config
+
+            attr_reader :wpd_config
+
+            class_option :wait, :type => :boolean, default: true,
+                         desc: "Whether to keep running and wait for exit"
+
+            class_option :compile, :type => :boolean, default: false
+
+            def set_production_env
+                Hippo.config.environment = :production if options[:compile]
+            end
+
+            def make_config
+                return if @config
+                @config = ClientConfig.new
+                config.invoke_all
+            end
+
+            def configure
+                @wpd_config = WebpackDriver::Configuration.new(
+                    config.directory.join('webpack.config.js'),
+                    logger: Hippo.logger,
+                    directory: config.controlling_extension.root_path,
+                    cmd_line_flags: (options[:compile] ? [] : ['--hot', '--inline']),
+                    environment: { NODE_ENV: options[:compile] ? 'production' : 'development' }
+                )
+                self
+            end
+
+            def create_process
+                @process = options[:compile] ? ::WebpackDriver::Compile.new(wpd_config) :
+                               ::WebpackDriver::DevServer.new(wpd_config)
+            end
+
+            def startup
+                process.start
+                process.wait if options[:wait]
+            end
+
+        end
+    end
+
+end

data/lib/hippo/command/webpack_view.rb

@@ -0,0 +1,32 @@
+require 'erb'
+require 'ostruct'
+
+module Hippo::Command
+
+    class WebpackView
+
+        attr_reader :directory, :erb, :view, :ext
+
+        def initialize(view)
+            @ext = Hippo::Extensions.controlling
+            @directory = ext.root_path.join('tmp')
+            @view = view
+            @erb = ERB.new(ext.root_path.join('views', view).read)
+        end
+
+        def write
+            destination.write erb.result(binding)
+        end
+
+        def destination
+            directory.join(view)
+        end
+
+        def include(partial, locals = {})
+            subview = ERB.new(ext.root_path.join('views', partial).read)
+            context = OpenStruct.new(locals).instance_eval { binding }
+            subview.result(context)
+        end
+    end
+
+end

data/lib/hippo/concerns/all.rb

@@ -0,0 +1,15 @@
+require_relative "api_path"
+require_relative "association_extensions"
+require_relative "attr_accessor_with_default"
+require_relative "export_associations"
+require_relative "export_join_tables"
+require_relative "export_methods"
+require_relative "export_scope"
+require_relative "set_attribute_data"
+require_relative "pub_sub"
+require_relative "code_identifier"
+require_relative "queries"
+require_relative "sanitize_fields"
+require_relative "sorting_expressions"
+require_relative "asset_uploader"
+require_relative "random_identifier"

data/lib/hippo/concerns/api_path.rb

@@ -0,0 +1,21 @@
+module Hippo::Concerns
+
+    # @see ClassMethods
+    module ApiPath
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            def api_path(with_module: false)
+                path = with_module ? to_s : to_s.demodulize
+                path.pluralize.underscore.dasherize
+            end
+
+            def from_api_path(path)
+                name = path.underscore.camelize.singularize
+                name.safe_constantize
+            end
+
+        end
+    end
+end

data/lib/hippo/concerns/asset_uploader.rb

@@ -0,0 +1,38 @@
+require 'shrine'
+require 'image_processing/mini_magick'
+
+module Hippo::Concerns
+
+    class AssetUploader < Shrine
+        module LocationHash
+            module InstanceMethods
+                CHAR_CHOICES = [*('a'..'z'),*('0'..'9')]
+                def generate_location(io, context)
+                    basename, _ = super.split("/")
+                    path = Array.new(3){ CHAR_CHOICES.shuffle[0,4].join }
+                    path.push(basename).join('/')
+                end
+            end
+        end
+        ::Shrine::Plugins.register_plugin(:location_hash, LocationHash)
+
+        include ImageProcessing::MiniMagick
+
+        plugin :activerecord
+        plugin :rack_file
+        plugin :processing
+        plugin :store_dimensions
+        plugin :determine_mime_type
+        plugin :versions
+        plugin :location_hash
+
+        process(:store) do |io, context|
+            size_800 = resize_to_limit(io.download, 800, 800)
+            size_500 = resize_to_limit(size_800,    500, 500)
+            size_300 = resize_to_limit(size_500,    300, 300)
+            {original: size_800, medium: size_500, thumbnail: size_300}
+        end
+
+    end
+
+end

data/lib/hippo/concerns/association_extensions.rb

@@ -0,0 +1,94 @@
+module Hippo::Concerns
+
+
+    # Custom implentation of has_many and belongs_to
+    #
+    module AssociationExtensions
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            def has_one(name, scope = nil, options = {})
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            def belongs_to(name, scope = nil, options = {} )
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            def has_many(name, scope=nil,options={}, &extension )
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            private
+
+            def handle_private_options( name, opts )
+                association = reflect_on_association( name.to_sym )
+                setup_listeners( association, opts[:listen] ) if opts[:listen]
+                setup_association_export( association, opts[:export] ) if opts[:export]
+            end
+
+            def extract_private_options( scope, options )
+                if scope.is_a?(Hash)
+                    scope.extract!( :export, :listen )
+                else
+                    options.extract!( :export, :listen )
+                end
+            end
+
+            # This gets complex; We
+            #   First setup proc's for each listener,
+            #   then attempt to load the associations's class
+            #   If that succeds, we're done, otherwise we add it
+            #   to PubSub's pending queue
+            def setup_listeners( association, listeners )
+                targets = {}
+                if listeners.any? && association.options[:inverse_of].nil?
+                    raise ArgumentError.new "Setting listener on #{name}##{association.name} " +
+                        "but the association does not have " +
+                        "an inverse_of specified."
+                end
+                listeners.each do | name, target |
+                    targets[name] = make_association_listener_for(target, association)
+                end
+                begin
+                    klass = association.klass # This will throw if the class hasn't been loaded yet
+                    targets.each{ | name, proc | klass.send :_add_event_listener, name, &proc }
+                rescue NameError
+                    pending = Hippo::Concerns::PubSub::PendingListeners.add(association.class_name)
+                    targets.each do | name, proc |
+                        pending[name] << proc
+                    end
+                end
+            end
+            def make_association_listener_for(target, association)
+                Proc.new{ | record, *args |
+                    associated_record = record.public_send(association.inverse_of.name)
+                    if associated_record
+                        args.unshift(record)
+                        if associated_record.is_a? ActiveRecord::Associations::CollectionProxy
+                            associated_record.each{ |r| r.send(target, *args) }
+                        else
+                            associated_record.send(target, *args)
+                        end
+                    end
+                }
+            end
+            def setup_association_export( association, options )
+                export_associations( association.name, options == true ? {} : options )
+            end
+        end
+
+    end
+
+end

data/lib/hippo/concerns/attr_accessor_with_default.rb

@@ -0,0 +1,68 @@
+module Hippo::Concerns
+
+    # @see ClassMethods
+    module AttrAccessorWithDefault
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            # defines a attr_accessor with a default value
+            # @param name [ Symbol ] name of the attribute
+            # @param default [ Object, lambda, Proc ] if a value is given, be aware that it will be shared between instances
+            # @example
+            #
+            #     Shared = Struct.new(:str)
+            #     class AttrTestClass
+            #         include AttrAccessorWithDefault
+            #         attr_accessor_with_default :non_copying, ->{ Shared.new("a default string") }
+            #         attr_accessor_with_default :shared, Shared.new("a default string")
+            #     end
+            #     a = AttrTestClass.new
+            #     b = AttrTestClass.new
+            #     a.non_copying.str                   #=> "a default string"
+            #     a.non_copying.str  = "new_string"   #=> "new string"
+            #     b.non_copying.str                   #=> "a default string"
+            #
+            #     a.shared.str                   #=> "a default string"
+            #     b.shared.str                   #=> "a default string"
+            #     a.shared.str = "new string"    #=> "new string"
+            #     b.shared.str                   #=> "new string"
+
+            def attr_accessor_with_default( name, default=nil )
+                attr_writer name
+                attr_add_default_setting_method(name)
+                attr_reader_with_default(name, default)
+            end
+
+            def attr_add_default_setting_method(name)
+                module_eval do
+                    define_singleton_method(name) do |value = nil|
+                        attr_reader_with_default(name, value) if value
+                        instance_variable_get("@#{name}".to_sym)
+                    end
+                end
+            end
+
+            def attr_reader_with_default( name, default )
+                instance_var = "@#{name.to_s}".to_sym
+                instance_variable_set(instance_var, default)
+                module_eval do
+                    define_method(name) do
+                        class << self; self; end.class_eval do
+                            attr_reader(name)
+                        end
+                        if instance_variable_defined?(instance_var)
+                            instance_variable_get(instance_var)
+                        else
+                            instance_variable_set(instance_var,
+                                                  default.is_a?(Proc) ?
+                                                      instance_exec(&default) : default )
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+
+end