puer 0.0.4 → 0.0.6

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.6

data/bin/puer

@@ -15,60 +15,8 @@ unless $LOAD_PATH.include?(lib_dir)
 end
 
 require 'puer'
-require 'optparse'
-  
-OptionParser.new do |opts|
-  opts.banner  =<<END
-  Usage: puer [options] [filename]
-  Usage: puer all  # convert all xib files to js under current directory
-END
 
-  opts.on("-w", "--[no-]warnings", "Show warnings") do |w|
-    @show_warnings = w
-  end
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puer/generators/cli')
 
-  opts.on("-o", "--output-file name", "Specify output file") do |o|
-    @output_file = o
-  end
-  
-  opts.on("-c", "--config-file name", "Specify config file") do |o|
-    @config_file = o
-  end
-  
-end.parse!
+Puer::Generators::Cli.start(ARGV)  
 
-if ARGV.size == 1
-  
-  case ARGV[0]
-  when "all"
-    Dir.glob(File.join('**','*.xib')).each do |s| 
-        puts "#{s} is converted to #{File.basename(s, '.*')}.js "
-        system "puer #{s} -o #{File.basename(s, '.*')}.js" 
-        exit   
-    end 
-  else
-    input_file = ARGV.first
-  
-    session = Session.new @config_file || File.join("#{File.dirname(__FILE__)}/../lib/puer", 'config.rb')
-    session.parse_file input_file
-    if session.has_errors?
-      puts "Aborted!"
-      puts session.full_log [:error]
-    else  
-      severities = []
-      severities.unshift :warning if @show_warnings
-      log = session.full_log severities
-      script = js_comments_for(log) + js_for(session.out)
-      if @output_file
-        File.open(@output_file, 'w') do |file|
-          file.write script
-        end
-        puts log
-      else
-        puts script
-      end
-    end
-  end
-else
-  puts "For help, type: puer -h"
-end

data/lib/puer.rb

@@ -4,3 +4,67 @@ unless $LOAD_PATH.include?(lib_dir)
 end
 
 require 'xibtoti'
+
+require 'thread'
+require 'puer/version'
+require 'puer/tasks'
+require 'active_support' 
+
+module Puer
+  ##
+  # This method return the correct location of mvc-gen bin or
+  # exec it using Kernel#system with the given args
+  #
+  def self.bin_gen(*args)
+    @_mvc_gen_bin ||= [IphoneMvc.ruby_command, File.expand_path("../bin/puer", __FILE__)]
+    args.empty? ? @_mvc_gen_bin : system(args.unshift(@_mvc_gen_bin).join(" "))
+  end
+
+  ##
+  # This module it's used for register generators
+  #
+  module Generators
+
+    DEV_PATH = File.expand_path("../../", File.dirname(__FILE__))
+
+    class << self
+
+      ##
+      # Here we store our generators paths
+      #
+      def load_paths
+        @_files ||= []
+      end
+
+      ##
+      # Return a ordered list of task with their class
+      #
+      def mappings
+        @_mappings ||= ActiveSupport::OrderedHash.new
+      end
+
+      ##
+      # Gloabl add a new generator class
+      #
+      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 'puer/generators/actions'
+        load_paths.flatten.each { |file| require file  }
+      end      
+    end
+  end # Generators
+end # Puer
+
+##
+# We add our generators to Puer::Genererator
+#
+Puer::Generators.load_paths << Dir[File.dirname(__FILE__) + '/puer/generators/{controller,model,xib,lib,gist,search,help}.rb']
+
+
+

data/lib/puer/command.rb

@@ -0,0 +1,27 @@
+require 'rbconfig'
+
+module Puer
+  ##
+  # This method return the correct location of puer bin or
+  # exec it using Kernel#system with the given args
+  #
+  def self.bin(*args)
+    @_puer_bin ||= [self.ruby_command, File.expand_path("../../../bin/puer", __FILE__)]
+    args.empty? ? @_puer_bin : system(args.unshift(@_puer_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 # Puer

data/lib/puer/config.rb

@@ -1,10 +1,15 @@
-ignore_properties 'contentStretch', 'simulatedStatusBarMetrics', 'simulatedOrientationMetrics'
-ignore_classes 'IBProxyObject'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'session'
+
+$config = Session.new
+
+$config.ignore_properties 'contentStretch', 'simulatedStatusBarMetrics', 'simulatedOrientationMetrics'
+$config.ignore_classes 'IBProxyObject'
 
 # To get another creation call than standard
 # Ti.UI.create#{name}
 # give a array as value: 'IBUIWindow' => ['Window', 'myWindowCall']
-classes 'IBUIWindow' => 'Window',
+$config.classes 'IBUIWindow' => 'Window',
         'IBUIView' => 'View',
         'IBUILabel' => 'Label',  
         'IBUIButton' => 'Button',
@@ -23,8 +28,8 @@ classes 'IBUIWindow' => 'Window',
 # font(:output)
 # vextor(:x, :y) # Where '{1, 2}' => {:x => 1, :y => 2}
 # properties 'backgroundColor' => color(:backgroundColor),
-properties 'font' => font(:font),
-           'frameOrigin' => vector(:top, :bottom),
-           'frameSize' => vector(:height, :width),
-           'text' => val(:text)
+$config.properties 'font' => $config.font(:font),
+           'frameOrigin' => $config.vector(:top, :bottom),
+           'frameSize' => $config.vector(:height, :width),
+           'text' => $config.val(:text)
            #'textColor' => color(:color)

data/lib/puer/generators/actions.rb

@@ -0,0 +1,183 @@
+module Puer
+  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 Puer application
+      def in_app_root?
+        #File.exist?(destination_root('Classes'))
+        Dir.glob("tiapp.xml").count >= 1
+      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 iexistent
+      def check_app_existence(app)
+        unless File.exist?(destination_root(app))
+          say
+          say "================================================================="
+          say "We didn't found #{app.underscore.camelize}!                      "
+          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
+      
+      ## Detect command and dump it's path 
+      def which cmd
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = "#{path}/#{cmd}#{ext}"
+            return exe if File.executable? exe
+          }
+        end
+        return nil
+      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 Puer 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 # Puer

data/lib/puer/generators/cli.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'thor/group'
+require 'cli-colorize'
+require 'hirb'
+require File.dirname(__FILE__) + '/../view'
+
+module Puer
+  module Generators
+    ##
+    # This class bootstrap +config/boot+ and perform +Puer::Generators.load_components!+ for handle
+    # 3rd party generators
+    #
+    class Cli < Thor::Group
+      include CLIColorize
+      
+      CLIColorize.default_color = :red
+      
+      RENDER_OPTIONS = { :fields => [:category,:command,:description] }   
+      # Include related modules
+      include Thor::Actions
+      desc "Puer Version:\t#{Puer::Version::STRING}"
+      class_option :help, :desc => "Help screen", :aliases => '-h', :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
+        Puer::Generators.load_components!
+
+        generator_kind  = ARGV.delete_at(0).to_s.downcase.to_sym if ARGV[0].present?
+        generator_class = Puer::Generators.mappings[generator_kind]
+        if generator_class
+          args = ARGV.empty? && generator_class.require_arguments? ? ["-h"] : ARGV  
+          generator_class.start(args)            
+        else                 
+          puts colorize( "Puer Version: #{Puer::Version::STRING}", { :foreground => :red, :background => :white, :config => :underline } )
+          puts
+          require 'yaml'
+          gistfile = File.expand_path("~") + '/.puer/gist.yml'
+          Gist::update_gist unless File.exist?(gistfile)          
+          begin 
+            g = YAML.load_file(gistfile)  
+          rescue ArgumentError => e
+            g = YAML.load_file(File.expand_path(File.dirname(__FILE__) + '/gist.yml'))
+          end
+          puts "notice: a new version '#{g['info']}' released" if g['info'] and g['info'].strip != "#{Puer::Version::STRING}"
+          puts          
+          puts "Puer is a Titanium Starter Project Generate Tool"
+          puts          
+          puts colorize("For more information")
+          puts
+          puts "puer help"
+          puts
+          puts colorize("Update latest repository info")
+          puts
+          puts "puer gist update"
+          puts          
+        end
+      end
+    end # Cli
+  end # Generators
+end # Puer