xmvc 0.1.2 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/bin/xmvc

@@ -18,3 +18,5 @@ rescue Xmvc::Error => e
   Xmvc.ui.error(e.message)
   exit e.status_code
 end
+
+  

data/lib/xmvc/builder.rb

@@ -10,8 +10,7 @@ module Xmvc
           setup(options)
         else
           begin
-            @jammit = jammit(options)
-            @jammit.invoke(:build, [name])
+            Xmvc.asset_mgr(options).invoke(:build, [name])
           rescue Jammit::Error => e
             raise Xmvc::BuilderError.new(e.message)
           end
@@ -36,7 +35,7 @@ module Xmvc
             javascripts.update(vendor["name"] => vendor_assets("javascripts", vendor))
           end
           
-          jammit = Jammit::CLI.new([], options)
+          jammit = Xmvc.asset_mgr(options)
           jammit.invoke(:init)
           jammit.invoke(:config, ["set", "javascripts",  javascripts])
           jammit.invoke(:build)
@@ -53,10 +52,6 @@ module Xmvc
       def application_assets(type, assets)
         assets.map {|f| File.join(f)}
       end
-      
-      def jammit(options={})
-        Jammit::CLI.new([], options)
-      end
     end
   end
 end

data/lib/xmvc/cli.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'thor/group'
 
 require 'jammit-core'
 require 'jammit-core/cli'
@@ -14,9 +15,10 @@ module Xmvc
     end
     
     desc "generate", "Generate model, controller, view or app"
-    def generate(which, *params)
+    def generate(*params)
+      which = params.shift
       Xmvc.ensure_in_app unless which == 'app'
-      Xmvc::Generator.dispatch(which, *params)  
+      Xmvc::Generator.dispatch(which, options, *params)  
     end
     
     desc "build", "Build stuff"
@@ -34,7 +36,7 @@ module Xmvc
     desc "stats", "View code statistics"
     def stats
       Xmvc.ensure_in_app
-      #Xmvc::Stats.new('Frak')
+      Xmvc::Stats.dispatch
     end
     
     desc "namespace", "Change the application's namespace"
@@ -46,14 +48,14 @@ module Xmvc
     def initialize(args=ARGV, config={}, options={})
       
       # Boot UI
-      Xmvc.ui = UI::Shell.new(shell)
+      Xmvc.ui = shell
       
       unless options[:host]
         raise Xmvc::NoFramework.new("Xmvc is meant to be supplied with a framework extension, eg extjs-mvc, via Xmvc::CLI.start(ARGV, {:framework => Your::Framework})")
       end
       
       # Boot environment
-      Xmvc.environment = Xmvc::Environment.new(:development)
+      Xmvc.environment = Xmvc::Environment.load(:development)
       
       # Set the framework.
       Xmvc.host = options[:host]

data/lib/xmvc/environment.rb

@@ -1,8 +1,92 @@
 module Xmvc
-  class Environment
-    def initialize(environment)
-      @environment = environment
-      Xmvc.ui.info("(loaded #{@environment.to_s} environement)")
+  module Environment
+    
+    DEFAULT_ENVIRONMENT = File.join(Xmvc::CONFIG_PATH, "environment")
+    ENVIRONMENT_PATH    = File.join(Xmvc::CONFIG_PATH, "environments")
+    
+    class FileNotFound < Xmvc::Error; status_code(10) ; end
+    
+    class << self
+      
+      ##
+      # TODO implement development/production environments
+      #
+      def load(environment)
+        @environment  = environment
+        @config       = load_environment(environment)
+        self
+      end
+      
+      def get(key)
+        config[key]
+      end
+      
+      def set(key, value)
+        config[key] = value
+        save
+      end
+      
+      ##
+      # write a newly generated controller, model or view to environment.json
+      # Unfortunately, we cannot JSON.parse the entire config/environment.json, since it contains comments
+      # and such.  Have to RegExp, pick-out the requested key, and JSON.parse the returned chunk.
+      # Is this Regexp satisfactory??  Could probably be made better.
+      #
+      def add (key, item)
+        key = key.to_s
+        config[key] = [] unless config[key] && config[key].kind_of?(Array)
+        
+        unless key == "views"
+          config[key] << item
+        else
+          if controller = config[key].find {|i| i[item[:package]]}
+            controller[item[:package]] << item[:filename]
+          else
+            config[key] << {
+              item[:package] => [
+                item[:filename]
+              ]
+            }
+          end
+        end
+        save
+      end
+      
+      def render
+        File.open("#{DEFAULT_ENVIRONMENT}.json", "w") {|file|
+          file << config.to_json
+        }
+      end
+      
+      private
+      
+      ##
+      # TODO: load and merge! specific environemnt.
+      #
+      def load_environment(environment)
+        # When generating a new app, there is no environment yet
+        #
+        #unless File.exists?("#{DEFAULT_ENVIRONMENT}.yml")
+        #  raise FileNotFound.new("Failed to load environment #{DEFAULT_ENVIRONMENT}.yml")
+        #end  
+        if File.exists? "#{DEFAULT_ENVIRONMENT}.yml"
+          YAML.load_file("#{DEFAULT_ENVIRONMENT}.yml") 
+        end
+      end
+      
+      def config
+        @config ||= load_environment(:development)
+      end
+      
+      def save
+        File.open("#{DEFAULT_ENVIRONMENT}.yml", "w") {|file|
+          file << config.to_yaml
+        }
+        File.open("#{DEFAULT_ENVIRONMENT}.json", "w") {|file|
+          file << config.to_json
+        }
+      end
     end
   end
-end
+end
+

data/lib/xmvc/generator.rb

@@ -1,44 +1,54 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require 'hpricot'
-require 'generators/base'
-require 'generators/app'
-require 'generators/model'
-require 'generators/view'
-require 'generators/controller'
-require 'generators/scaffold'
-
 module Xmvc
   module Generator
-  
-    @@generators = %w(app model controller scaffold view namespace)
-    def self.dispatch(generator, *params)
+    autoload :Layout,     'generators/layout'
+    autoload :App,        'generators/app'
+    autoload :Model,      'generators/model'
+    autoload :View,       'generators/view'
+    autoload :Controller, 'generators/controller'
+    autoload :Scaffold,   'generators/scaffold'
+    autoload :Boot,       'generators/boot'
+    
+    GENERATORS = %w(app model controller scaffold view namespace)
+    
+    def self.dispatch(generator, options, *params)
       
-      unless @@generators.include?(generator)
-        raise MVC::ArgumentError.new("Must use one of the following: " + @@generators.join(", ").downcase)
+      unless GENERATORS.include?(generator)
+        raise MVC::ArgumentError.new("Must use one of the following: " + GENERATORS.join(", ").downcase)
       end
       
-      name = params.shift
-      
       case generator
         when "app"
-          App.new(name).generate!
+          App.start(params, options.dup)
+          boot = Boot.new([], options.dup)
+          boot.invoke("generate")
+          
         when "model"
-          fields = params.select {|arg| arg != "--force"}.collect {|f| f.split(":")}
-          Model.new(name, fields).generate!
+          model = Model.new([], options.dup)
+          model.invoke("generate", [params.shift, *params])
         when "controller"
-          actions = params.select {|arg| arg != "--force"}
-          Controller.new(name, actions).generate!
+          name = params.shift
+          controller = Controller.new([], options.dup)
+          controller.invoke("generate", [name])
+          if params.length
+            params.each do |v|
+              view = View.new([], options.dup) # why have to create new instance for each??
+              view.invoke("generate", [name, v])
+            end
+          end
         when "scaffold"
-          fields = params.select {|arg| arg != "--force"}.collect {|f| f.split(":")}
-          Scaffold.new(name, fields).generate!
-        when "view"
-          package = name
           name = params.shift
-          View.new(package, name).generate!
+          Xmvc.ui.warn("scaffold generation is not yet implemented")
+          scaffold = Scaffold.new([], options.dup)
+          scaffold.invoke("generate", [name, params])
+        when "view"
+          package = params.shift
+          name    = params.shift
+          view    = View.new([], options.dup)
+          view.invoke("generate", [package, name])
         when "namespace"
-          self.namespace(name)
-          
+          #self.namespace(name)
       end
     end
     
@@ -61,8 +71,6 @@ module Xmvc
       }
     end
     
-    
-    
     private
     
     def self.write_namespace(f, current, namespace)

data/lib/xmvc/generators/app.rb

@@ -1,6 +1,8 @@
 module Xmvc
   module Generator
-    class App < Base
+    class App < Thor::Group
+      
+      include Thor::Actions
       
       FRAMEWORK_ASSETS = [
         'app/App.js',
@@ -13,122 +15,86 @@ module Xmvc
         'app/views/*/**.js'
       ]
       
-      def initialize(name, namespace=nil)
-        @file_re ||= Regexp.new("^\.?\/(.*)")
-        @name = name
-        @namespace = namespace || Extlib::Inflection.camelize(name)
-        @template = "#{TEMPLATE_PATH}/app"
+      def self.source_root 
+        File.join(Xmvc::TEMPLATE_PATH, "app", "public")
       end
-
-      def generate!    
-        if File.exists?(@name)
-          raise Xmvc::AppAlreadyExists.new("An app named #{@name} already exists")
-        end
-        FileUtils.mkdir(@name)
-        FileUtils.chdir(@name)
-        
-        # Save a ref to app root, need for Jammit config.
-        app_root = File.expand_path(".")
-        
-        # Create the root directory
-        create_root
-        
-        # Now walk into the created public folder to write the javascript framework
-        FileUtils.chdir("public")
-        create_app
-        create_config
-        create_lib
-        create_public
-        create_spec
-        create_vendor
-        install_host
-                
-        # Build assets.
-        Xmvc::BuilderManager.dispatch(:setup, {
-          :asset_root => File.expand_path('.'),
-          :app_root => app_root,
-          :vendors => [
-            Xmvc.host.config
-          ],
-          :application => FRAMEWORK_ASSETS
-        })
-                  
-      end
-
-      private
+      
+      argument :name, :type => :string, :desc => "Name of application to generate"
+      desc "Generates a new Xmvc application"
       
       def create_root
-        FileUtils.mkdir(%w(public))
-        
-        # Write config/settings.yml, call-out to Xmvc::Environment isntead.
-        #FileUtils.cp("#{@template}/config/environment.yml", "config")
-        copy_file("config", ".")
-        
+        empty_directory(name)
+        self.destination_root = name
       end
       
       def create_app
-        FileUtils.mkdir(%w(app app/models app/views app/controllers))
-        copy_file("public/app", ".")
-        show_files("app")        
+        empty_directory("app")
+        inside("app", {}) do
+          copy_file("App.js", "#{destination_root}/App.js")
+          directory("models", "models")
+          directory("views", "views")
+          directory("controllers", "controllers")
+        end
       end
       
       def create_config
-        FileUtils.mkdir(%w(config config/environments))
-        copy_file("public/config", ".")
-        show_files("config")
+        directory("config", "config")
       end
       
       def create_lib
-        FileUtils.mkdir(%w(lib))
-        show_files("lib")
+        directory("lib", "lib")
       end
       
       def create_public
-        FileUtils.mkdir(%w(public public/stylesheets public/images public/javascripts))
-        copy_file("public/public", ".")
-        show_files("public")
+        empty_directory("public")
+        inside("public", {}) do
+          copy_file("index.html", "index.html")
+          directory("images", "images")
+          directory("stylesheets", "stylesheets")
+          directory("javascripts", "javascripts")
+        end
+
       end
       
       def create_spec
-        FileUtils.mkdir(%w(spec spec/controllers spec/models))
-        copy_file("public/spec", ".")
-        show_files("spec")
+        directory("spec", "spec", :recursive => false)
+        inside("spec", {}) do
+          directory("models", "models")
+          directory("controllers", "controllers")
+        end
       end
       
       def create_vendor
-        FileUtils.mkdir(%w(vendor vendor/plugins))
-        copy_file("public/vendor", ".")
-        show_files("vendor", false)
+        directory("vendor", "vendor")
+        inside("vendor", {}) do 
+          empty_directory("plugins")
+        end
       end
       
       def install_host
-        begin
-          Xmvc.host.install("vendor")
-          Xmvc.ui.confirm(" install vendor/#{Xmvc.host.config['name']}")
-        rescue StandardError => e
-          Xmvc.ui.error('An error occured while installing the host framework')
-          raise Xmvc::HostError.new(e.message)
+        inside("vendor", {}) do
+          directory(Xmvc.host::VENDOR_PATH, Xmvc.host.config["name"])
         end
-          
-      end
-      
-      
-      def notify(f)
-        m = f.match(@file_re)
-        Xmvc.ui.confirm(" create #{(m) ? m[1] : f}")
       end
       
-      def copy_file(src, dest)
-        FileUtils.cp_r("#{@template}/#{src}", dest)
+      def install_plugins
+        inside("vendor/plugins", {}) do
+          # install vendor/plugins here
+        end
       end
       
-      def show_files(dir, recursive=true)
-        pattern = (recursive) ? "./#{dir}/**/*.*" : "./#{dir}/*"
-        notify(dir)
-        Dir[pattern].each do |f|
-          notify(f)
-        end
+      def build_assets
+        # Build assets.
+        Xmvc::BuilderManager.dispatch(:setup, {
+          :asset_root => destination_root,
+          :vendors => [
+            Xmvc.host.config
+          ],
+          :application => FRAMEWORK_ASSETS
+        })
+        FileUtils.chdir(destination_root)
+        Xmvc.environment.render
       end
     end
   end
-end
+end

data/lib/xmvc/generators/boot.rb

@@ -0,0 +1,43 @@
+module Xmvc
+  module Generator
+    class Boot < Thor
+      include Thor::Actions
+      
+      def self.source_root 
+        File.join(Xmvc::TEMPLATE_PATH)
+      end
+      
+      desc "generate", "Generate the config/boot.js file"
+      def generate
+        
+        host = Xmvc.host.config["name"]
+        
+        @development = [
+          'http://extjs.cachefly.net/ext-3.1.1/adapter/ext/ext-base.js',
+          'http://extjs.cachefly.net/ext-3.1.1/ext-all-debug.js'
+        ]
+        @development << url_for(host, "js", Jammit::DEBUG_SUFFIX)
+        
+        @production = [
+          'http://extjs.cachefly.net/ext-3.1.1/adapter/ext/ext-base.js',
+          'http://extjs.cachefly.net/ext-3.1.1/ext-all.js'
+        ]
+        @production << url_for(host, "js", Jammit::SUFFIX)
+        
+        @test = @development.dup
+        @test << url_for(host, "js", Jammit::DEBUG_SUFFIX)
+        @test << File.join("/", Xmvc::PUBLIC_PATH, "vendor", "jspec", "lib", "jspec.js")
+        @test << File.join("/", Xmvc::PUBLIC_PATH, "vendor", "spec", "TestHelper.js")
+        
+        template("boot.js", "config/boot.js")
+      end
+      
+      private
+      
+      def url_for(name, ext, suffix)
+        File.join("/", Xmvc::PUBLIC_PATH, name, Jammit.filename(name, ext, suffix))
+      end
+      
+    end
+  end
+end

data/lib/xmvc/generators/controller.rb

@@ -1,41 +1,26 @@
 module Xmvc
   module Generator
-    class Controller < Base
-      def initialize(name, actions = [])
-        super
-
-        @name    = name
-        @actions = actions
-        @package = name.downcase
-
-        @gsubs.merge!({
-          'controller_name' => Extlib::Inflection.underscore(name),
-          'short_name'      => @package,
-          'actions'         => generate_actions
-        })
+    class Controller < Thor
+      include Thor::Actions
       
-        @controller_filename = "app/controllers/#{@gsubs['controller_name']}_controller.js"
+      def self.source_root 
+        File.join(Xmvc::TEMPLATE_PATH)
       end
-
-      def generate!
-        ensure_no_overwrite!        @controller_filename
-        ensure_directories_present! "app", "app/controllers"
-
-        template "Controller.js", @controller_filename
-        
-        Xmvc::Settings.add(:controllers, @gsubs["controller_name"])
+      
+      desc "generate", "Generate a new Controller"
+      def generate(name, *actions)
+        @name             = name
+        @actions          = actions
+        @package          = name.downcase
+        @controller_name  = Extlib::Inflection.underscore(name)
+        @filename         = "app/controllers/#{@controller_name}_controller.js"
         
-        generate_views!
-      end
-
-      private
-      def generate_actions
-        @actions.collect {|act| render_template("_Action.js", {'action_name' => act})}.join("")
-      end
-
-      def generate_views!
-        @actions.each {|a| View.new(@package, a).generate!}
+        unless File.exists? @filename
+          Xmvc.environment.add(:controllers, @controller_name)
+        end
+                      
+        template "Controller.js", @filename
       end
     end
   end
-end
+end

data/lib/xmvc/generators/layout.rb

@@ -0,0 +1,25 @@
+module Xmvc
+  module Generator
+    
+    def self.script_tag(file)
+      '<script type="text/javascript" src="' + file + '"></script>'
+    end
+    
+    class Layout < Thor::Group
+      include Thor::Actions
+            
+      def self.source_root
+        puts "source_root"
+        "."
+      end
+      
+      desc "Generates a new application"
+      argument :name, :type => :string, :desc => "The name of your new Xmvc application"
+      def build
+        @javascripts = Jammit.packager.individual_urls("application", :js).map {|file| Generator.script_tag(file) }.join("\n")
+        
+        template("#{Generator::TEMPLATE_PATH}/layout.html.erb", 'layout.html')
+      end
+    end
+  end
+end

data/lib/xmvc/generators/model.rb

@@ -1,42 +1,33 @@
 module Xmvc
   module Generator
-    class Model < Base
-      def initialize(name, fields = [])
-        super
-
-        @fields = fields
-        @gsubs['inst_name']   = name.downcase
-        @gsubs['class_name']  = Extlib::Inflection.camelize(name)
-        @gsubs['file_name']   = Extlib::Inflection.underscore(name)
-        @gsubs['fields']      = fields.collect {|f| field_template(f[0], f[1])}.join(",\n")
-
-        @model_filename = "app/models/#{@gsubs['file_name']}.js"
-        @spec_filename  = "spec/models/#{@gsubs['file_name']}.spec.js"
+    class Model < Thor
+      include Thor::Actions
+      
+      def self.source_root 
+        File.join(Xmvc::TEMPLATE_PATH)
       end
-
-      def generate!
-        ensure_no_overwrite! @model_filename, @spec_filename
-
-        ensure_directories_present! "app",  "app/models"
-        ensure_directories_present! "spec", "spec/models"
+      
+      desc "generate", "Generates a new Model"
+      def generate(name, *fields)      
+        filename    = Extlib::Inflection.underscore(name)
         
-        template "Model.js",     @model_filename
-        template "ModelSpec.js", @spec_filename
+        @var_name   = filename
+        @class_name = Extlib::Inflection.camelize(name)
+        @fields     = fields.map {|f|
+          field = f.split(':')
+          {:name => field.shift, :type => field.shift}
+        }
+
+        model_filename = "app/models/#{filename}.js"
+        spec_filename  = "spec/models/#{filename}.spec.js"
         
-        #to_environment(:models, @gsubs["file_name"])
-        Xmvc::Settings.add(:models, @gsubs["file_name"])
+        unless File.exists?(model_filename)
+          Xmvc.environment.add(:models, filename)
+        end
         
-      end
-
-      private
-      def field_template(name, type)
-        padding = longest_field_length - name.length
-        "    {name: '#{name}', #{" " * padding}type: '#{type}'}"
-      end
-
-      def longest_field_length
-        @fields.collect {|f| f[0].length}.max
+        template("Model.js", model_filename)
+        template("ModelSpec.js", spec_filename)
       end
     end
   end
-end
+end