hippo-fw 0.9.1

data/lib/hippo/command/generate_model.usage

@@ -0,0 +1,45 @@
+Stubs out a new model. Pass the model name, either CamelCased or
+under_scored, and an optional list of attribute pairs as arguments.
+
+Attribute pairs are field:type arguments specifying the
+model's attributes. Timestamps are added by default, so you don't have to
+specify them by hand as 'created_at:datetime updated_at:datetime'.
+
+You don't have to think up every attribute up front, but it helps to
+sketch out a few so you can start working with the model immediately.
+
+
+Available field types:
+
+Are the same as ActiveRecord, to wit:
+     integer
+     primary_key
+     decimal
+     float
+     boolean
+     binary
+     string
+     text
+     date
+     time
+     datetime
+     references
+
+Example:
+
+ When executed inside a project called "Blog":
+
+ `hippo generate model comments user:references subject:string{60} body:text`
+
+ Hippo will create:
+
+         Migration:     db/migrate/XXX_create_comments.rb
+         Model:         lib/blog/comment.rb
+         Model Spec:    spec/comment_spec.rb
+         Fixtures:      spec/fixtures/comments.yml
+         Client Model:  client/data/Comment.coffee
+         Client Spec:   spec/client/data/CommentSpec.coffee
+
+  The Ruby model will contain a `belongs_to` association to the User model,
+  and the Javascript model definition will also have an association defined.
+

data/lib/hippo/command/generate_screen.rb

@@ -0,0 +1,40 @@
+require_relative 'model_attribute'
+
+module Hippo
+    module Command
+
+        class GenerateScreen < NamedCommand
+            OPTIONS = {
+                title:       '',
+                description: '',
+                icon:        '',
+                group_id:    'system',
+                model_class: '',
+                namespace: nil
+            }
+            class_options( OPTIONS )
+
+            attr_reader :screen_id, :screen_class
+
+            def set_variables
+                super
+                options[:title] = name.titleize if options[:title].blank?
+                @screen_id = class_name.underscore.dasherize
+                @screen_class = class_name
+            end
+
+            def create_screen
+                template "client/screens/screen.jsx", "#{client_dir}/screens/#{screen_id}.jsx"
+                template "spec/client/screen.spec.jsx", "spec/client/screens/#{screen_id}.spec.jsx"
+            end
+
+            def add_definition
+                insert_into_file "config/screens.rb", :after => /Hippo::Screen.for_extension.*?\n/ do
+                    source = File.expand_path(find_in_source_paths("config/screen.rb"))
+                    ERB.new(::File.binread(source), nil, "-","@output_buffer").result(binding)
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/command/generate_screen.usage

@@ -0,0 +1,8 @@
+Create the bare-bones definition of a screen
+
+Screens are a special type of component that supports
+dynamic loading
+
+Initially only the definition for the screen is available,
+and the css and javascript for the it is loaded
+when the screen is first displayed.

data/lib/hippo/command/guard.rb

@@ -0,0 +1,18 @@
+require 'guard/cli'
+
+require_relative '../extension'
+require_relative './jest'
+
+module Hippo
+    module Command
+
+        class Guard < Thor::Group
+            include Thor::Actions
+
+            def start
+                say 'Starting Guard', :green
+                ::Guard.start
+            end
+        end
+    end
+end

data/lib/hippo/command/jest.rb

@@ -0,0 +1,40 @@
+require_relative './client_config'
+require_relative '../extension'
+require_relative '../command'
+
+module Hippo
+    module Command
+
+        class Jest < Thor::Group
+            include Thor::Actions
+
+            attr_reader :config
+
+            class_option :watch, :type => :boolean, default: false,
+                         desc: "Whether to keep running and watch for file changes"
+
+            class_option :debug, :type => :boolean, default: false
+
+
+            def configure
+                @config = ClientConfig.new
+                @config.invoke_all
+                self
+            end
+
+            def config_file
+                config.directory.join('jest.config.json')
+            end
+
+            def start
+                say 'Starting Jest', :green
+                say Dir.pwd, :yellow
+                cmd = "$(npm bin)/jest --config #{config_file}"
+                options.each do |key, value|
+                    cmd << " --#{key}" if value
+                end
+                exec(cmd)
+            end
+        end
+    end
+end

data/lib/hippo/command/migration_support.rb

@@ -0,0 +1,29 @@
+require_relative 'model_attribute'
+
+module Hippo
+    module Command
+        module MigrationSupport
+            def create_migration
+                migration = existing_migration ||
+                  migration_timestamp + "_create_#{table_name}.rb"
+                self.fields = fields.map{ |field| ModelAttribute.parse(field) }
+                template "db/create_table_migration.rb", "db/migrate/#{migration}"
+            end
+
+          private
+
+            def existing_migration
+                migrations = Pathname.glob("#{destination_root}/db/migrate/[0-9]*_create_#{table_name}.rb")
+                migrations.any? ? migrations.first.basename.to_s : nil
+            end
+
+            def migration_timestamp
+                ENV['MIGRATION_TIMESTAMP'] || Time.now.utc.strftime("%Y%m%d%H%M%S")
+            end
+
+            def fields_with_index
+                fields.select { |a| !a.reference? && a.has_index? }
+            end
+        end
+    end
+end

data/lib/hippo/command/model_attribute.rb

@@ -0,0 +1,193 @@
+require 'active_support/time'
+
+# This is a straight-up copy of railties/lib/rails/generators/generated_attribute.rb
+
+module Hippo
+  module Command
+    class ModelAttribute # :nodoc:
+      INDEX_OPTIONS = %w(index uniq)
+      UNIQ_INDEX_OPTIONS = %w(uniq)
+
+      attr_accessor :name, :type
+      attr_reader   :attr_options
+      attr_writer   :index_name
+
+      class << self
+          def parse(column_definition)
+
+          name, type, has_index = column_definition.split(':')
+
+          # if user provided "name:index" instead of "name:string:index"
+          # type should be set blank so GeneratedAttribute's constructor
+          # could set it to :string
+          has_index, type = type, nil if INDEX_OPTIONS.include?(type)
+
+          type, attr_options = *parse_type_and_options(type)
+          type = type.to_sym if type
+
+          if type && reference?(type)
+            references_index = UNIQ_INDEX_OPTIONS.include?(has_index) ? { unique: true } : true
+            attr_options[:index] = references_index
+          end
+
+          new(name, type, has_index, attr_options)
+        end
+
+        def reference?(type)
+          [:references, :belongs_to].include? type
+        end
+
+        private
+
+        # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
+        # when declaring options curly brackets should be used
+        def parse_type_and_options(type)
+          case type
+          when /(string|text|binary|integer)\{(\d+)\}/
+            return $1, limit: $2.to_i
+          when /decimal\{(\d+)[,.-](\d+)\}/
+            return :decimal, precision: $1.to_i, scale: $2.to_i
+          when /(references|belongs_to)\{(.+)\}/
+            type = $1
+            provided_options = $2.split(/[,.-]/)
+            options = Hash[provided_options.map { |opt| [opt.to_sym, true] }]
+            return type, options
+          else
+            return type, {}
+          end
+        end
+      end
+
+      def initialize(name, type=nil, index_type=false, attr_options={})
+        @name           = name
+        @type           = type || :string
+        @has_index      = INDEX_OPTIONS.include?(index_type)
+        @has_uniq_index = UNIQ_INDEX_OPTIONS.include?(index_type)
+        @attr_options   = attr_options
+      end
+
+      def decorator
+          name == 'id' ? 'identifier' : 'field'
+      end
+
+      def field_type
+        @field_type ||= case type
+          when :integer              then :number_field
+          when :float, :decimal      then :text_field
+          when :time                 then :time_select
+          when :datetime, :timestamp then :datetime_select
+          when :date                 then :date_select
+          when :text                 then :text_area
+          when :boolean              then :check_box
+          else
+            :text_field
+        end
+      end
+
+      def default
+        @default ||= case type
+          when :integer                     then 1
+          when :float                       then 1.5
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then Time.now.to_s(:db)
+          when :date                        then Date.today.to_s(:db)
+          when :string                      then name == "type" ? "" : "MyString"
+          when :text                        then "MyText"
+          when :boolean                     then false
+          when :references, :belongs_to     then nil
+          else
+            ""
+        end
+      end
+
+      def plural_name
+        name.sub(/_id$/, '').pluralize
+      end
+
+      def singular_name
+        name.sub(/_id$/, '').singularize
+      end
+
+      def human_name
+        name.humanize
+      end
+
+      def index_name
+        @index_name ||= if polymorphic?
+          %w(id type).map { |t| "#{name}_#{t}" }
+        else
+          column_name
+        end
+      end
+
+      def column_name
+        @column_name ||= reference? ? "#{name}_id" : name
+      end
+
+      def foreign_key?
+        !!(name =~ /_id$/)
+      end
+
+      def reference?
+        self.class.reference?(type)
+      end
+
+      def polymorphic?
+        self.attr_options[:polymorphic]
+      end
+
+      def required?
+        self.attr_options[:required]
+      end
+
+      def has_index?
+        @has_index
+      end
+
+      def has_uniq_index?
+        @has_uniq_index
+      end
+
+      def password_digest?
+        name == 'password' && type == :digest
+      end
+
+      def inject_options
+        "".tap { |s| options_for_migration.each { |k,v| s << ", #{k}: #{v.inspect}" } }
+      end
+
+      def inject_index_options
+        has_uniq_index? ? ", unique: true" : ""
+      end
+
+      def options_for_migration
+        @attr_options.dup.tap do |options|
+          if required?
+            options.delete(:required)
+            options[:null] = false
+          end
+        end
+      end
+
+      def client_type
+          @client_type ||= case type
+            when :datetime then 'date'
+            when :integer  then 'integer'
+            when :float    then 'number'
+            when :text     then 'string'
+            when :string   then 'string'
+            when :boolean  then 'boolean'
+            when :decimal  then 'bigdec'
+            when :hstore   then 'object'
+            when :references, :belongs_to then 'integer'
+            else 'any'
+            end
+      end
+
+      def belongs_to?
+          :belongs_to == type
+      end
+
+    end
+  end
+end

data/lib/hippo/command/named_command.rb

@@ -0,0 +1,33 @@
+module Hippo
+    module Command
+
+        class NamedCommand < Thor::Group
+            include Thor::Actions
+
+            argument :name
+
+            attr_reader :namespace, :class_name, :client_dir, :spec_dir, :identifier
+
+            def self.source_root
+                Pathname.new(__FILE__).dirname.join("..","..","..","templates")
+            end
+
+            def load_namespace
+                @identifier = extension.identifier
+                @namespace  = options[:namespace] || @identifier.underscore.camelize
+            end
+
+            def set_variables
+                @class_name = name.underscore.camelize
+                @spec_dir   = "spec/client"
+                @client_dir = "client/#{identifier}"
+            end
+
+            protected
+
+            def extension
+                @extension ||= Command.load_current_extension(raise_on_fail:true)
+            end
+        end
+    end
+end

data/lib/hippo/command/puma.rb

@@ -0,0 +1,56 @@
+require_relative '../extension'
+require_relative '../command'
+
+require 'irb'
+
+module Hippo
+    module Command
+
+        class Puma < Thor::Group
+            include Thor::Actions
+
+            class_option :wait, :type => :boolean, default: true,
+                         desc: "Whether to keep running and wait for exit"
+
+            def start
+                say "Starting Puma", :green
+                @proc = ::ChildProcess.build('puma')
+                @output, w = IO.pipe
+                @proc.io.stdout = @proc.io.stderr = w
+                @proc.start
+                w.close
+                @listener = listen_for_status_updates
+                sleep 1
+                unless @proc.alive?
+                    raise "NOT LIVING"
+                    puts @output.read
+                end
+                self
+            end
+
+            def maybe_wait
+                @proc.wait if options[:wait]
+            end
+
+            def stop
+                say "Stopping Puma", :green
+                @listener.kill
+                @proc.stop
+                @prop = nil
+            end
+
+            private
+
+
+            def listen_for_status_updates
+                Thread.new do
+                    @output.each_line do | l |
+                        Hippo.logger.info(l.chomp)
+                    end
+                end
+            end
+
+
+        end
+    end
+end