appjam 0.1.0.pre6 → 0.1.0.pre9

data/README.rdoc

@@ -10,7 +10,7 @@ run command below in your favorite shell, appjam will generate your iphone app s
 
 $ gem install appjam --pre
 
-$ appjam User # Model name(like User)
+$ appjam project contact 
 
 == Contributing to appjam
  

data/bin/appjam

@@ -7,11 +7,6 @@ unless $LOAD_PATH.include?(lib_dir)
 end
 
 require 'appjam'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/appjam/generators/project')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/appjam/generators/cli')
 
-begin
-  Appjam::Generators::Project.start(ARGV)
-rescue => e
-  STDERR.puts "Error: #{e}"
-  exit -1
-end
+Appjam::Generators::Cli.start(ARGV)

data/lib/appjam.rb

@@ -40,6 +40,14 @@ module Appjam
       def add_generator(name, klass)
         mappings[name] = klass
       end
+      
+      ##
+      # Load Global Actions and Component Actions then all files in +load_path+.
+      #
+      def load_components!
+        require 'appjam/generators/actions'
+        load_paths.flatten.each { |file| require file  }
+      end      
     end
   end # Generators
 end # IphoneMvc
@@ -47,4 +55,4 @@ end # IphoneMvc
 ##
 # We add our generators to Appjam::Genererator
 #
-Appjam::Generators.load_paths << Dir[File.dirname(__FILE__) + '/appjam/generators/project.rb']
+Appjam::Generators.load_paths << Dir[File.dirname(__FILE__) + '/appjam/generators/{project,model}.rb']

data/lib/appjam/command.rb

@@ -0,0 +1,27 @@
+require 'rbconfig'
+
+module Appjam
+  ##
+  # This method return the correct location of appjam bin or
+  # exec it using Kernel#system with the given args
+  #
+  def self.bin(*args)
+    @_appjam_bin ||= [self.ruby_command, File.expand_path("../../../bin/appjam", __FILE__)]
+    args.empty? ? @_appjam_bin : system(args.unshift(@_appjam_bin).join(" "))
+  end
+
+  ##
+  # Return the path to the ruby interpreter taking into account multiple
+  # installations and windows extensions.
+  #
+  def self.ruby_command
+    @ruby_command ||= begin
+      ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      ruby << Config::CONFIG['EXEEXT']
+
+      # escape string in case path to ruby executable contain spaces.
+      ruby.sub!(/.*\s.*/m, '"\&"')
+      ruby
+    end
+  end
+end # Appjam

data/lib/appjam/generators/actions.rb

@@ -0,0 +1,170 @@
+module Appjam
+  module Generators
+    class  AppRootNotFound < RuntimeError; end
+
+    module Actions
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Performs the necessary generator for a given component choice
+      # execute_component_setup(:mock, 'rr')
+      def execute_component_setup(component, choice)
+        return true && say("Skipping generator for #{component} component...", :yellow) if choice.to_s == 'none'
+        say "Applying '#{choice}' (#{component})...", :yellow
+        apply_component_for(choice, component)
+        send("setup_#{component}") if respond_to?("setup_#{component}")
+      end
+
+      # Returns the related module for a given component and option
+      # generator_module_for('rr', :mock)
+      def apply_component_for(choice, component)
+        # I need to override Thor#apply because for unknow reason :verobse => false break tasks.
+        path = File.expand_path(File.dirname(__FILE__) + "/components/#{component.to_s.pluralize}/#{choice}.rb")
+        say_status :apply, "#{component.to_s.pluralize}/#{choice}"
+        shell.padding += 1
+        instance_eval(open(path).read)
+        shell.padding -= 1
+      end
+
+      # Returns the component choice stored within the .component file of an application
+      # fetch_component_choice(:mock)
+      def fetch_component_choice(component)
+        retrieve_component_config(destination_root('.components'))[component]
+      end
+
+      # Set the component choice and store it in the .component file of the application
+      # store_component_choice(:renderer, :haml)
+      def store_component_choice(key, value)
+        path        = destination_root('.components')
+        config      = retrieve_component_config(path)
+        config[key] = value
+        create_file(path, :force => true) { config.to_yaml }
+        value
+      end
+
+      # Loads the component config back into a hash
+      # i.e retrieve_component_config(...) => { :mock => 'rr', :test => 'riot', ... }
+      def retrieve_component_config(target)
+        YAML.load_file(target)
+      end
+
+      # Prompts the user if necessary until a valid choice is returned for the component
+      # resolve_valid_choice(:mock) => 'rr'
+      def resolve_valid_choice(component)
+        available_string = self.class.available_choices_for(component).join(", ")
+        choice = options[component]
+        until valid_choice?(component, choice)
+          say("Option for --#{component} '#{choice}' is not available.", :red)
+          choice = ask("Please enter a valid option for #{component} (#{available_string}):")
+        end
+        choice
+      end
+
+      # Returns true if the option passed is a valid choice for component
+      # valid_option?(:mock, 'rr')
+      def valid_choice?(component, choice)
+        choice.present? && self.class.available_choices_for(component).include?(choice.to_sym)
+      end
+
+      # Creates a component_config file at the destination containing all component options
+      # Content is a yamlized version of a hash containing component name mapping to chosen value
+      def store_component_config(destination)
+        components = @_components || options
+        create_file(destination) do
+          self.class.component_types.inject({}) { |result, comp|
+            result[comp] = components[comp].to_s; result
+          }.to_yaml
+        end
+      end
+
+      # Returns the root for this thor class (also aliased as destination root).
+      def destination_root(*paths)
+        File.expand_path(File.join(@destination_stack.last, paths))
+      end
+
+      # Returns true if inside a Appjam application
+      def in_app_root?
+        File.exist?(destination_root('Classes'))
+      end
+
+      # Returns the field with an unacceptable name(for symbol) else returns nil
+      def invalid_fields(fields)
+        results = fields.select { |field| field.split(":").first =~ /\W/ }
+        results.empty? ? nil : results
+      end
+
+      # Returns the app_name for the application at root
+      def fetch_app_name(app='app')
+        app_path = destination_root(app, 'app.rb')
+        @app_name ||= File.read(app_path).scan(/class\s(.*?)\s</).flatten[0]
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      #
+      #   ask("What is your app name?")
+      def ask(statement, default=nil, color=nil)
+        default_text = default ? " (leave blank for #{default}):" : nil
+        say("#{statement}#{default_text} ", color)
+        result = $stdin.gets.strip
+        result.blank? ? default : result
+      end
+
+      # Raise SystemExit if the app is inexistent
+      def check_app_existence(app)
+        unless File.exist?(destination_root(app))
+          say
+          say "================================================================="
+          say "We didn't found #{app.underscore.downcase}!                      "
+          say "================================================================="
+          say
+          # raise SystemExit
+        end
+      end
+
+      # Ensure that project name is valid, else raise an NameError
+      def valid_constant?(name)
+        if name =~ /^\d/
+          raise ::NameError, "Project name #{name} cannot start with numbers"
+        elsif name =~ /^\W/
+          raise ::NameError, "Project name #{name} cannot start with non-word character"
+        end
+      end
+
+      module ClassMethods
+        # Defines a class option to allow a component to be chosen and add to component type list
+        # Also builds the available_choices hash of which component choices are supported
+        # component_option :test, "Testing framework", :aliases => '-t', :choices => [:bacon, :shoulda]
+        def component_option(name, caption, options = {})
+          (@component_types   ||= []) << name # TODO use ordered hash and combine with choices below
+          (@available_choices ||= Hash.new)[name] = options[:choices]
+          description = "The #{caption} component (#{options[:choices].join(', ')}, none)"
+          class_option name, :default => options[:default] || options[:choices].first, :aliases => options[:aliases], :desc => description
+        end
+
+        # Tell to Appjam that for this Thor::Group is necessary a task to run
+        def require_arguments!
+          @require_arguments = true
+        end
+
+        # Return true if we need an arguments for our Thor::Group
+        def require_arguments?
+          @require_arguments
+        end
+
+        # Returns the compiled list of component types which can be specified
+        def component_types
+          @component_types
+        end
+
+        # Returns the list of available choices for the given component (including none)
+        def available_choices_for(component)
+          @available_choices[component] + [:none]
+        end
+      end
+    end # Actions
+  end # Generators
+end # Appjam

data/lib/appjam/generators/cli.rb

@@ -0,0 +1,42 @@
+require 'thor/group'
+
+module Appjam
+  module Generators
+    ##
+    # This class bootstrap +config/boot+ and perform +Appjam::Generators.load_components!+ for handle
+    # 3rd party generators
+    #
+    class Cli < Thor::Group
+
+      # Include related modules
+      include Thor::Actions
+
+      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+
+      # We need to TRY to load boot because some of our app dependencies maybe have
+      # custom generators, so is necessary know who are.
+      def load_boot
+        begin
+          ENV['BUNDLE_GEMFILE'] = File.join(options[:root], "Gemfile") if options[:root]
+        rescue Exception => e
+          puts "=> Problem loading #{boot}"
+          puts ["=> #{e.message}", *e.backtrace].join("\n  ")
+        end
+      end
+
+      def setup
+        Appjam::Generators.load_components!
+
+        generator_kind  = ARGV.delete_at(0).to_s.downcase.to_sym if ARGV[0].present?
+        generator_class = Appjam::Generators.mappings[generator_kind]
+
+        if generator_class
+          args = ARGV.empty? && generator_class.require_arguments? ? ["-h"] : ARGV
+          generator_class.start(args)
+        else
+          puts "Please specify generator to use (#{Appjam::Generators.mappings.keys.join(", ")})"
+        end
+      end
+    end # Cli
+  end # Generators
+end # Appjam

data/lib/appjam/generators/model.rb

@@ -0,0 +1,51 @@
+require 'thor'
+require 'thor/group'
+require 'thor/actions'
+require 'active_support/core_ext/string'
+
+module Appjam
+  module Generators
+    class Model < Thor::Group
+
+      # Add this generator to our appjam
+      Appjam::Generators.add_generator(:model, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      def self.banner; "appjam model [name]"; end
+
+      # Include related modules
+      include Thor::Actions
+
+      desc "Description:\n\n\tappjam will generates an new PureMvc Model for iphone"
+
+      argument :name, :desc => "The name of your puremvc model"
+
+      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+      class_option :destroy, :aliases => '-d', :default => false,   :type    => :boolean
+
+      # Show help if no argv given
+      #require_arguments!
+    
+      def in_app_root?
+        File.exist?('Classes')
+      end     
+
+      def create_app
+        self.destination_root = options[:root]
+        @project_name = name.gsub(/\W/, "_").downcase
+        @class_name = name.gsub(/\W/, "_").capitalize 
+        app = options[:model]
+        self.behavior = :revoke if options[:destroy]
+
+        say (<<-TEXT).gsub(/ {10}/,'')
+      
+      =================================================================
+      Your #{@class_name} Model app has been generated.
+      =================================================================
+      
+      TEXT
+      end
+    end # Model
+  end # Generators
+end # Appjam

data/lib/appjam/generators/project.rb

@@ -2,13 +2,14 @@ require 'thor'
 require 'thor/group'
 require 'thor/actions'
 require 'active_support/core_ext/string'
+require File.dirname(__FILE__) + '/actions'
 
 module Appjam
   module Generators
     class Project < Thor::Group
 
       # Add this generator to our appjam
-      Appjam::Generators.add_generator(:app, self)
+      Appjam::Generators.add_generator(:project, self)
 
       # Define the source template root
       def self.source_root; File.expand_path(File.dirname(__FILE__)); end
@@ -16,6 +17,7 @@ module Appjam
 
       # Include related modules
       include Thor::Actions
+      include Appjam::Generators::Actions      
 
       desc "Description:\n\n\tappjam will generates an new PureMvc application for iphone"
 
@@ -32,10 +34,11 @@ module Appjam
       end     
 
       def create_app
-        self.destination_root = options[:root]
-        @project_name = name.gsub(/\W/, "_").downcase
+        valid_constant?(options[:project] || name)
+        @project_name = (options[:app] || name).gsub(/\W/, "_").downcase
         @class_name = name.gsub(/\W/, "_").capitalize 
-        app = options[:app]
+        self.destination_root = options[:root]
+        project = options[:project]
         self.behavior = :revoke if options[:destroy]
         
         empty_directory "#{@project_name}"
@@ -63,6 +66,6 @@ module Appjam
       
       TEXT
       end
-    end # App
+    end # Project
   end # Generators
-end # IphoneMvc
+end # Appjam