lanes 0.0.3 → 0.0.5

data/lib/lanes/command/generate_model.rb

@@ -0,0 +1,105 @@
+require_relative 'model_attribute'
+
+module Lanes
+    module Command
+
+        class GenerateModel < NamedCommand
+            RESERVED_YAML_KEYWORDS = %w(y yes n no true false on off null)
+            OPTIONS ||= {
+                timestamps: true,
+                parent:    "Lanes::Model",
+                client_collection_parent: "Lanes.Data.Collection"
+            }
+
+            class_options OPTIONS
+
+            argument :fields, type: :array, default: []
+
+            attr_reader :file_name, :table_name
+
+            def set_variables
+                super
+                if name=~/::/
+                    (@namespace,@name) = name.split("::")
+                else
+                    @namespace = computed_namespace
+                end
+                @file_name  = name.underscore
+                @table_name = namespace + "_" + name.tableize
+            end
+
+            def create_migration
+                migration = exising_migration || Time.now.utc.strftime("%Y%m%d%H%M%S") + "_create_#{table_name}.rb"
+                self.fields = fields.map{ |field| ModelAttribute.parse(field) }
+                template "db/create_table_migration.rb", "db/migrate/#{migration}"
+            end
+
+            def create_model
+                template "lib/namespace/model.rb", "lib/#{namespace}/#{file_name}.rb"
+                template "spec/namespace/model_spec.rb", "spec/#{namespace}/#{file_name}.rb"
+                template "spec/fixtures/namespace/model.yml", "spec/fixtures/#{namespace}/#{file_name}.yml"
+            end
+
+            def create_client
+                template "client/data/Model.coffee", \
+                         "#{client_dir}/data/#{class_name}.coffee"
+                template "spec/client/data/ModelSpec.coffee", \
+                         "spec/client/data/#{class_name}Spec.coffee"
+            end
+
+            def add_route
+                insert_into_file "config/routes.rb", before: "end" do
+                    "    resources #{namespace.camelize}::#{class_name}\n"
+                end
+            end
+
+          private
+
+            def fields_with_index
+                fields.select { |a| !a.reference? && a.has_index? }
+            end
+
+            def exising_migration
+                migrations = Pathname.glob("#{destination_root}/db/migrate/[0-9]*_create_#{table_name}.rb")
+                migrations.any? ? migrations.first.basename.to_s : nil
+            end
+
+            def computed_namespace
+                # find a file and directory with the same basename
+                entries = Dir.glob(self.destination_root + "/lib/*")
+                name = entries.detect{ |directory|
+                    FileTest.directory?(directory) && entries.detect{ |file|
+                        file == directory+".rb"
+                    }
+                }
+                name ? File.basename(name).to_s : nil
+            end
+
+            def yaml_key_value(key, value)
+                if RESERVED_YAML_KEYWORDS.include?(key.downcase)
+                    "'#{key}': #{value}"
+                else
+                    "#{key}: #{value}"
+                end
+            end
+
+            def client_parent
+                if options[:parent] == 'Lanes::Model'
+                    "Lanes.Data.Model"
+                else
+                    "Lanes.#{namespace.camelize}.#{options[:parent]}"
+                end
+            end
+
+            def max_field_length
+                @max_field_length ||= fields.map{|field|
+                    field.name.length + ( field.reference? ? 3 : 0 )
+                }.max
+            end
+
+            def reference_fields
+                fields.select { |a| a.reference? }
+            end
+        end
+    end
+end

data/lib/lanes/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":
+
+ `lanes generate model comments user:references subject:string{60} body:text`
+
+ Lanes 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/lanes/command/generate_screen.rb

@@ -0,0 +1,31 @@
+require_relative 'model_attribute'
+
+module Lanes
+    module Command
+
+        class GenerateScreen < NamedCommand
+            OPTIONS = {
+                title:       '',
+                description: '',
+                icon:        '',
+                group_id:    '',
+                model_class: '',
+                namespace: nil
+            }
+            class_options( OPTIONS )
+
+            def set_defaults
+                options[:title] = name.titleize if options[:title].blank?
+            end
+
+            def create_screen
+                template "lib/namespace/screen.rb",      "lib/#{namespace}/#{name}_screen.rb"
+                template "client/screens/index.js",      "#{client_dir}/screens/#{name}/index.js"
+                template "client/screens/styles.scss",   "#{client_dir}/screens/#{name}/index.scss"
+                template "client/screens/Screen.coffee", "#{client_dir}/screens/#{name}/#{name.classify}.coffee"
+                template "client/screens/layout.html",   "#{client_dir}/screens/#{name}/layout.html"
+            end
+
+        end
+    end
+end

data/lib/lanes/command/generate_screen.usage

@@ -0,0 +1,11 @@
+Create the bare-bones definition of a screen
+
+Screens are a special type of view that have a few extra attributes.
+Namely, they have a "title" attribute and can be hidden and shown.  
+
+They are dynamically loaded.  Initially only the definition for the view
+is available, and the css and javascript for the view is only loaded
+when the view is first displayed.
+
+If the "model-class" option is provided, the screen will only be
+available to users who have read or write access to the given model.

data/lib/lanes/command/generate_view.rb

@@ -0,0 +1,22 @@
+require_relative 'model_attribute'
+
+module Lanes
+    module Command
+
+        class GenerateView < NamedCommand
+            OPTIONS ||= {
+                namespace: nil
+            }
+            class_options( OPTIONS )
+
+            def create_screen
+                template "client/views/View.coffee",   "#{client_dir}/views/#{name.classify}.coffee"
+                template "client/views/template.html", "#{client_dir}/views/#{name.dasherize}.html"
+                template "spec/client/views/ViewSpec.coffee", \
+                         "spec/client/views/#{class_name}Spec.coffee"
+            end
+
+        end
+
+    end
+end

data/lib/lanes/command/generate_view.usage

@@ -0,0 +1,13 @@
+Stubs out a new View. Pass the view name, either CamelCased or
+under_scored
+
+ When executed inside a project called "Blog":
+
+ `lanes generate view comment`
+
+ Lanes will create:
+
+         Client View: client/view/Comment.coffee
+         Template:    client/view/comment.html
+         Spec:        spec/client/view/CommentSpec.coffee
+

data/lib/lanes/command/model_attribute.rb

@@ -0,0 +1,188 @@
+require 'active_support/time'
+
+# This is a straight-up copy of railties/lib/rails/generators/generated_attribute.rb
+
+module Lanes
+  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 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/lanes/command/named_command.rb

@@ -0,0 +1,27 @@
+module Lanes
+    module Command
+
+        class NamedCommand < Thor::Group
+            include Thor::Actions
+
+            argument :name
+
+            attr_reader :namespace, :class_name, :client_dir
+
+            def self.source_root
+                Pathname.new(__FILE__).dirname.join("templates")
+            end
+
+            def load_namespace
+                @namespace  = options[:namespace] || Command.load_current_extension.identifier
+                raise Thor::Error("Unable to locate Lanes environment") unless @namespace
+            end
+
+            def set_variables
+                @class_name = name.classify
+                @client_dir = "client/#{namespace}"
+            end
+
+        end
+    end
+end

data/lib/lanes/command/server.rb

@@ -0,0 +1,19 @@
+require 'guard'
+
+module Lanes
+    module Command
+
+        class Server < Thor::Group
+            include Thor::Actions
+
+            class_option  :port, type: :numeric
+
+            def launch
+                say "Launching testing server at http://localhost:8888/", :green
+                Guard.start
+            end
+        end
+
+    end
+
+end

data/lib/lanes/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/lanes/command/templates/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem "guard-jasmine",      github: "guard/guard-jasmine",   branch: 'master'
+gem "lanes",              github: "argosity/lanes",        branch: 'master'
+
+# Uncomment to enable access control and user administration
+# gem "lanes-access",       github: "argosity/lanes-access", branch: 'master'
+
+gem "rake"
+gem 'puma'

data/lib/lanes/command/templates/Rakefile

@@ -0,0 +1,2 @@
+require_relative 'lib/<%= namespace %>'
+require 'lanes/rake_tasks'

data/lib/lanes/command/templates/client/Extension.coffee

@@ -0,0 +1,5 @@
+class Lanes.<%= namespace.underscore.camelize %>.Extension extends Lanes.Extensions.Base
+
+    identifier: "<%= namespace %>"
+
+    setBootstrapData: (data)->

data/lib/lanes/command/templates/client/components/Component.coffee

@@ -0,0 +1 @@
+class Lanes.<%= namespace.camelize %>.Component.<%= class_name %> extends Lanes.Component.Base

data/lib/lanes/command/templates/client/data/Model.coffee

@@ -0,0 +1,24 @@
+class <%= namespace.camelize %>.Data.<%= class_name %> extends <%= client_parent %>
+
+    api_path: '<%= name.downcase.pluralize.underscore.dasherize %>'
+    namespace: NAMESPACE
+
+    props:
+<% fields.each do |field| -%>
+<% if field.reference? -%>
+        <%= sprintf("%-#{max_field_length}s",field.name+'_id') %>: "<%= field.client_type %>"
+<% else -%>
+        <%= sprintf("%-#{max_field_length}s",field.name) %>: "<%= field.client_type %>"
+<% end -%>
+<% end %>
+<% if reference_fields.any? -%>
+
+    associations:
+<% reference_fields.each do |field| -%>
+        <%= sprintf("%-#{max_field_length}s ",field.name) %>: { <%= field.belongs_to? ? 'model' : 'collection' -%>: "Lanes.<%= namespace.camelize %>.<%= field.name.camelize %>" }
+<% end -%>
+<% end -%>
+
+class Lanes.<%= namespace.camelize %>.Data.<%= class_name %>Collection extends <%= options[:client_collection_parent] %>
+
+    model: Lanes.<%= namespace.camelize %>.Data.<%= class_name %>

data/lib/lanes/command/templates/client/namespace-extension.js

@@ -0,0 +1,17 @@
+//=require_tree ./data
+//=require_tree ./views
+//=require_tree ./components
+//=require ./Extension
+
+/*
+ Files located in the above directories are part of the default
+ Javascript build and are downloaded to the client on the initial
+ request.
+
+ Accordingly, only essential files should be included here. Code that
+ relates to a screen should be placed in the "screens" directory,
+ where it will be loaded dynamically when the screen is displayed.
+
+ Alternatively, feel free to modify the require statements above to
+ only include the paths you need.
+ */

data/lib/lanes/command/templates/client/screens/Screen.coffee

@@ -0,0 +1,9 @@
+class <%= namespace.camelize %>.Screens.<%= class_name %> extends Lanes.Screens.Base
+
+    namespace: NAMESPACE
+
+    # List subviews <TODO: add link to docs>
+    subviews: {}
+
+    # List events  <TODO: add link to docs>
+    events: {}

data/lib/lanes/command/templates/client/screens/index.js

@@ -0,0 +1,5 @@
+//= require_tree .
+
+/*
+ Add additional requirement statements for other files that the screen uses
+*/

data/lib/lanes/command/templates/client/screens/layout.html

@@ -0,0 +1,3 @@
+<div>
+  <h1><%= options[:title] %></h1>
+</div>

data/lib/lanes/command/templates/client/screens/styles.scss

@@ -0,0 +1,9 @@
+/*
+ If your screen does not use any custom styles
+
+ You should remove this file and it's reference from:
+ lib/<%= namespace %>/<%= name %>_screen.rb
+
+ Otherwise Lanes will continue to fetch an empty file whenever
+ the screen is displayed
+*/

data/lib/lanes/command/templates/client/styles/styles.scss

@@ -0,0 +1 @@
+/* Enter styles for your application in scss format here */

data/lib/lanes/command/templates/client/views/View.coffee

@@ -0,0 +1,9 @@
+class <%= namespace.classify %>.Views.<%= class_name %> extends Lanes.Views.Base
+
+    namespace: NAMESPACE
+
+    # List subviews <TODO: add link to docs>
+    subviews: {}
+
+    # List events  <TODO: add link to docs>
+    events: {}

data/lib/lanes/command/templates/client/views/template.html

@@ -0,0 +1,3 @@
+<div>
+  <!-- Template for <%= class_name %>-->
+</div>

data/lib/lanes/command/templates/config/lanes.rb

@@ -0,0 +1,7 @@
+# This file will be loaded if the current extension is the
+# one controlling Lanes.
+#
+# It will not be evaluated if another extension is loading this one
+Lanes.configure do | config |
+    config.root_view = "<%= class_name %>.Screens.<%= class_name %>"
+end

data/lib/lanes/command/templates/config/routes.rb

@@ -0,0 +1,2 @@
+Lanes::API.routes.draw do
+end

data/lib/lanes/{generators/app → command/templates}/config.ru

@@ -1,4 +1,5 @@
 require 'bundler'
 Bundler.require
+require_relative 'lib/<%= namespace %>'
 require 'lanes/api'
 run Lanes::API::Root

data/lib/lanes/command/templates/db/create_table_migration.rb

@@ -0,0 +1,19 @@
+class Create<%= namespace.camelize %><%= class_name.pluralize %> < ActiveRecord::Migration
+    def change
+        create_table :<%= table_name %> do |t|
+<% fields.each do |attribute| -%>
+<% if attribute.password_digest? -%>
+            t.string :password_digest<%= attribute.inject_options %>
+<% else -%>
+            t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% end -%>
+<% if options[:timestamps] %>
+            t.timestamps null: false
+<% end -%>
+        end
+<% fields_with_index.each do |attribute| -%>
+        add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+    end
+end

data/lib/lanes/command/templates/gitignore

@@ -0,0 +1 @@
+tmp/cache

data/lib/lanes/command/templates/lib/namespace/extension.rb

@@ -0,0 +1,13 @@
+require_relative '../<%= name %>'
+
+module <%= namespace.camelize %>
+
+    class Extension < Lanes::Extensions::Definition
+
+        identifier "<%= name %>"
+
+        root_path Pathname.new(__FILE__).dirname.join("..","..").expand_path
+
+    end
+
+end