coolstrap-generator 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@coolstrap-generator

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in coolstrap-generator.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r coolstrap-generator.rb"
+end

data/bin/coolstrap

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'coolstrap-generator'
+
+Coolstrap::Generator::CLI.start

data/coolstrap-generator.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "coolstrap-generator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "coolstrap-generator"
+  s.version     = Coolstrap::Generator::VERSION
+  s.authors     = ["Miguel Michelson"]
+  s.email       = ["miguelmichelson@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{App Generator for coolstrap mobile framework }
+  s.description = %q{App Generator for coolstrap mobile framework}
+
+  s.rubyforge_project = "coolstrap-generator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  
+  s.add_runtime_dependency(%q<coffee-script>,       ["~> 2.2.0"])
+
+  s.add_runtime_dependency(%q<colored>,             ["~> 1.2"])
+  s.add_runtime_dependency(%q<rake>,                ["~> 0.9.2"])
+  s.add_runtime_dependency(%q<nokogiri>,            ["~> 1.4.4"])
+  s.add_runtime_dependency(%q<erubis>,              ["~> 2.7.0"])
+  s.add_runtime_dependency(%q<rocco>,               ["~> 0.7"])
+  s.add_runtime_dependency(%q<thor>,                ["~> 0.14.6"])
+  s.add_runtime_dependency(%q<compass>,             ["~> 0.7"])
+  s.add_runtime_dependency(%q<session>,             ["~> 3.1"])
+  s.add_runtime_dependency(%q<middleman>,           ["~> 2.0"])
+  s.add_runtime_dependency(%q<actionpack>           )
+
+  # s.add_development_dependency(%q<bundler>,         ["~> 1.0.14"])
+  s.add_development_dependency(%q<bundler>,         ["~> 1.1.pre.10"])
+  s.add_development_dependency(%q<rspec>,           ["~> 2.6.0"])
+  
+end

data/lib/coolstrap-generator.rb

@@ -0,0 +1,39 @@
+
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'pathname'
+require 'fileutils'
+require 'rbconfig'
+require 'colored'
+require 'rocco'
+require 'thor'
+require 'erubis'
+require 'nokogiri'
+
+module Coolstrap
+  module Generator
+    
+    ROOT_PATH = Pathname(__FILE__).dirname.expand_path
+
+    autoload  :VERSION,       'coolstrap-generator/version.rb'
+    autoload  :CLI,           'coolstrap-generator/cli.rb'
+    autoload  :Logger,        "coolstrap-generator/logger.rb"
+    autoload  :Utils,         "coolstrap-generator/utils.rb"
+    
+    #module Builder
+    #  autoload :Middleman,     'coolstrap-generator/builder/middleman.rb'
+    #end
+
+    module Generate
+      autoload  :Project,     "coolstrap-generator/generate/project.rb"
+      autoload  :Model,       "coolstrap-generator/generate/model.rb"
+      autoload  :View,        "coolstrap-generator/generate/view.rb"
+      autoload  :Controller,  "coolstrap-generator/generate/controller.rb"
+    end
+
+    def self.root
+      @root ||= Pathname(__FILE__).dirname.expand_path
+    end
+  end
+end

data/lib/coolstrap-generator/cli.rb

@@ -0,0 +1,71 @@
+module Coolstrap::Generator
+  class CLI < Thor
+    include Utils
+
+    STATUS_TYPES = {:success          => 0,
+                    :general_error    => 1,
+                    :not_supported    => 3,
+                    :not_found        => 4,
+                    :incorrect_usage  => 64,
+                    }
+
+    no_tasks {
+      def cli_error(message, exit_status=nil)
+        $stderr.puts message
+        exit_status = STATUS_TYPES[exit_status] if exit_status.is_a?(Symbol)
+        exit(exit_status || 1)
+      end
+    }
+
+    ### TODO: When these commands list grows big, we need to move them into a seperate commands.rb file
+    map %w(--version -v) => 'info'
+    desc "info", "information about Coolstrap::Generator."
+    def info
+      say "Version #{::Coolstrap::Generator::VERSION}"
+    end
+
+    map %(n) => 'new'
+    desc "new <name> ", "generates a new Coolstrap project."
+    long_desc "Generates a new Coolstrap project. See 'coolstrap help new' for more information.
+              \n\nExample:
+              \n\ncoolstrap new demo ==> Creates a new project skeleton."
+    def new(name, device_id='org.mycompany.demo', platform='iphone')
+      ::Coolstrap::Generator::Generate::Project.create(name, device_id, platform)
+    end
+    
+    map %w(s) => 'scaffold'
+    desc "scaffold <list/complexlist/tabbar/toolbar> <domain> <name>", "generate a scaffold for Coolstrap elements."
+    def scaffold(cs_type, domain, name)
+      ::Coolstrap::Generator::Generate::View.create(name, { 
+        :domain   => domain, 
+        :cs_type  => cs_type, 
+        :name     => name })
+    end
+
+    map %w(g) => 'generate'
+    #TODO: models, bridges
+    desc "generate <view> <name>", "generate a view"
+    def generate(type, name)
+      case 
+      when type =~ /view/i
+        ::Coolstrap::Generator::Generate::View.create(name)
+      end
+    end
+
+    map %w(r) => 'server'
+    desc "server ", "run middleman app"
+    def server
+      system "echo == :::COOLSTRAP STARTING::: =="
+      system "bundle exec middleman server"
+    end
+
+    map %w(b) => 'build'
+    system "pwd"
+    desc "build ", "builds middleman app"
+    def build
+      system "echo ::== COOLSTRAP BUILD =="
+      system "middleman build"
+    end
+
+  end
+end

data/lib/coolstrap-generator/generate/project.rb

@@ -0,0 +1,96 @@
+require 'session'
+module Coolstrap
+  module Generator
+    module Generate
+      class Project
+        class << self
+          attr_accessor :project_name, :device_platform, :app_id
+          include ::Coolstrap::Generator::Utils
+
+          # Coolstrap::Generator::Generate::Project.create('demo', 'org.codewranglers.demo', 'ipad')
+          def create(name, id, platform='iphone')
+            @project_name    = name
+            @device_platform = platform
+            @app_id          = id
+          
+            begin
+              create_directories('tmp')
+              copy_defaults
+              remove_old_files
+              generate_files
+              log "Your Coolstrap project is ready for you to get coding!"
+            rescue => e
+              error "There was an error generating your Coolstrap project. #{e} #{e.backtrace}"
+            end
+          end
+
+
+          def copy_defaults
+            #FileUtils.cp(location.join("Resources/KS_nav_ui.png"),    "/tmp/")
+            #FileUtils.cp(location.join("Resources/KS_nav_views.png"), "/tmp/")
+          end
+
+
+          def generate_files
+            create_project_directory
+            full_app_hash = {:app_name => @project_name, :app_name_underscore => underscore(@project_name), :platform => @device_platform}
+            create_with_template('.gitignore', 'defaults/gitignore', full_app_hash)
+            create_with_template('Gemfile', 'defaults/Gemfile', full_app_hash)
+            create_with_template('LICENSE', 'defaults/LICENSE', full_app_hash)
+            
+            create_with_template('config.rb', 'defaults/config', full_app_hash)
+            default_templates = ['Readme.mkd']
+            default_templates.each do |tempfile|
+              create_with_template(tempfile, "defaults/#{tempfile}", full_app_hash)
+            end
+            
+            FileUtils.cp_r(templates("app/views/shared/."), location.join("source/views/shared") )
+            FileUtils.cp_r(templates("app/assets/."), location.join("source/assets") )
+            
+            create_with_template('source/index.html.haml', 'app/index.html.haml', full_app_hash)
+            create_with_template('source/layout.haml', 'app/layout.haml', full_app_hash)
+            create_with_template('source/views/_home.haml', 'app/views/_home.haml', full_app_hash)
+            
+          end
+
+
+          def create_project_directory
+            create_directories('docs', 'spec',
+                               "source/assets",
+                               "source/assets/images",
+                               "source/assets/fonts",
+                               "source/assets/stylesheets",
+                               "source/assets/javascripts",
+                               "source/views",
+                               "source/models") 
+          end
+
+          def remove_old_files
+            #remove_files('README')          
+            #remove_directories('Resources')
+          end
+
+          def location
+            base_location.join(@project_name)
+          end
+
+          #TODO: generate ios bridge here
+          def generate_titanium_project
+            
+            platform = ::Config::CONFIG['host_os']
+            if platform =~ /linux/i || platform =~ /darwin/i
+              cmd = "titanium create --name=#{@project_name} --platform=#{@device_platform} --id=#{@app_id}"
+              # We need to use the session gem so that we can access the user's aliases
+              bash = Session::Bash::new 'program' => 'bash --login -i'
+              bash.execute(cmd) { |out, err| puts out }
+            else
+               error("Currently, your OS (#{::Config::CONFIG['host_os']}) is not supported.")
+               exit(0)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/coolstrap-generator/generate/view.rb

@@ -0,0 +1,54 @@
+module Coolstrap::Generator
+  module Generate
+    class View
+      class << self
+        include ::Coolstrap::Generator::Utils
+
+        def create(name, context={})
+          create_view_template(name, context)
+        end
+        
+
+        def create_view_template(name, context)
+          log "Creating #{name} view using a template."      
+          view_directory = "source/views"
+          context.merge!(:name => name)
+          #log "#{context.inspect}"
+          case context[:cs_type]
+          when  'list'
+            log("HINT! to use lists you should call them with href '##{name}' & data-target = 'section', and add the partial in index.html.haml ")
+            template  = templates("app/components/listview/_simplelist.html.haml.erb")
+          when  'complexlist'
+            log("HINT! to use lists you should call them with href '##{name}' & data-target = 'section', and add the partial in index.html.haml ")
+            template  = templates("app/components/listview/_complexlistavatar.html.haml.erb")
+          when  'tabbar'
+            view_directory = "source/views/tabbars"
+            log("HINT! tabbar partial generated, you could put partial in some header or footer element' ")
+            template  = templates("app/components/tabbar.html.haml.erb")
+          when  'toolbar'
+            view_directory = "source/views/toolbars"
+            log("HINT! toolbar partial generated!, you could put partial in some header or footer element' ")
+            template  = templates("app/components/toolbar.html.haml.erb")
+          else
+            log("HINT! to use lists you should call them with href '##{name}' & data-target = 'section', and add the partial in index.html.haml ")
+            template  = templates("app/components/listview/_complexlistavatar.html.haml.erb")
+          end
+          
+          payload   = Pathname.new("#{view_directory}/#{(context[:domain] || '').downcase}")
+          contents  = Erubis::Eruby.new(File.read(template)).result(context) if template
+          
+          create_directories(payload)         unless File.directory?(payload)
+          create_directories("spec/views")    unless File.directory?("spec/views")
+          
+          filename = payload.join("_#{name.downcase}.haml")
+          File.open(location.join(filename), 'w') { |f| f.write(contents) }
+
+          #create_new_file("spec/views/#{name}_spec.coffee", templates("specs/app_spec.coffee"))
+          #create_new_file("app/#{underscore(app_name)}/stylesheets/_#{(context[:domain] || '').downcase}.sass", templates("app/stylesheets/sample.sass"))
+          #append_to_router(context[:domain].capitalize, 'views')
+        end
+
+      end
+    end
+  end
+end

data/lib/coolstrap-generator/logger.rb

@@ -0,0 +1,13 @@
+module Coolstrap::Generator
+  class Logger
+
+    def self.report(msg)
+      $stdout.puts(msg.green.bold)
+    end
+
+    def self.error(msg)
+      $stderr.puts(msg.red.bold)
+    end
+
+  end
+end

data/lib/coolstrap-generator/middleman/helpers.rb

@@ -0,0 +1,176 @@
+require "middleman"
+require 'action_view'
+
+module Middleman::Features::Helpers
+  
+  class << self
+    def registered(app)
+      app.helpers HelperMethods
+    end
+    alias :included :registered
+  end
+
+  module HelperMethods
+    
+    #TODO separate elements in specific classes:
+    # views, asides, articles, header, tabbar, toolbar etc... 
+    
+    def footer(opts={}, &block)
+       content_tag :footer , opts do 
+          capture(&block)
+       end 
+    end
+    
+    def article(opts={}, &block)
+       content_tag :article , opts do 
+          capture(&block)
+       end 
+    end
+    
+    def section(opts={}, &block)
+       content_tag :section , opts do 
+          capture(&block)
+       end 
+    end
+    
+    def header(opts={}, &block)
+       content_tag :header , opts do 
+          capture(&block)
+       end 
+    end
+    
+    def hgroup(opts={}, &block)
+      if block_given?
+        content_tag :hgroup, options do 
+           capture(&block)
+        end
+      else
+        content_tag :hgroup do
+          content_tag( :h1 , opts[:title]).concat(
+          content_tag( :h2 , opts[:subtitle])
+          )
+        end
+      end
+    end
+    
+    def list_view(opts={}, &block)
+      options = {:class=>opts[:class]}.merge({"data-type" => "listview"})
+      content_tag :ul, options do 
+         capture(&block)
+      end
+    end
+    
+    def list_item(opts={}, &block)
+      options = {:class=>opts[:class]}
+      options = options.merge({ :class=>  "#{options[:class]} list-divider"}) if opts[:divider] == true
+      arrow = content_tag :div , :class=>"aside" do
+                content_tag( :i, "",{:class=>"icon-chevron-#{opts[:arrow]}"})
+              end if opts[:arrow].present? 
+      
+      if block_given?
+        content_tag :li, options do
+          capture(&block) << (arrow || "")
+        end
+      else
+        content_tag :li, options do 
+          content_tag :h1 do
+            opts[:content]
+          end
+        end
+      end
+    end
+    
+    def divider(opts={}, &block)
+      if block_given?
+        list_item({:divider=>true}.merge(opts)) do
+          capture(&block)
+        end
+      else
+        list_item({:divider=>true}.merge(opts))
+      end
+    end
+    
+    def nav(opts={}, &block)
+      if block_given?
+        content_tag(:nav, opts) do
+          capture(&block)
+        end
+      else
+      end
+    end
+    
+    def tabbar(opts={}, &block)
+      opts = opts.merge({"data-type" => "tabbar"})
+      nav(opts, &block)
+    end
+    
+    def toolbar(opts={}, &block)
+      opts = opts.merge({"data-type" => "toolbar"})
+      if opts[:control]
+        auto = opts[:auto] ? "autoWidth" : ""
+        nav(opts.reject!{ |k| k == :control || k == :auto }) do
+          content_tag(:div, :class=>"control-group #{auto}") do
+            capture(&block)
+          end
+        end
+      else
+        nav(opts, &block)
+      end
+    end
+    
+    def icon(type, opts={}, &block)
+      if block_given?
+        capture(&block) <<
+        content_tag( :i, "",{:class=>"icon-#{type}"})
+      else
+        name = opts[:text].present? ? content_tag( :span, opts[:text]) : ""
+        name <<
+        content_tag( :i, "",{:class=>"icon-#{type}"})
+      end
+    end
+    
+    def render_tabbar(tabbar)
+      partial("views/tabbars/#{tabbar}")
+    end
+    
+    def render_toolbar(tabbar)
+      partial("views/toolbars/#{tabbar}")
+    end
+    
+    # dont use action view helpers, middleman already use padrino helpers :)
+    # https://github.com/middleman/middleman/blob/master/middleman-more/lib/middleman-more/core_extensions/default_helpers.rb
+=begin    
+    include ActionView::Helpers::DateHelper
+    include ActionView::Helpers::TagHelper
+    #include ActionView::Helpers::NumberHelper
+    include ActionView::Helpers::UrlHelper
+
+    module ActionView::Helpers::UrlHelper
+      # Returns the URL for the set of +options+ provided. See the valid options in link:classes/ActionController/Base.html#M000021
+      def url_for(options = {}, *parameters_for_method_reference)
+        if Hash === options then options = { :only_path => true }.merge(options) end
+          puts options
+          puts *parameters_for_method_reference
+      end
+    end
+
+    def time_ago_in_words(num)
+      #puts ActionView::Helpers::DateHelper.instance_methods 
+      #ActionView::Helpers::DateHelper.send( "distance_of_time_in_words", Time.now)
+    end
+=end
+    
+=begin    
+    def link_to(*args, &block)
+            if block_given?
+              options = args.first || {}
+              html_options = args.second
+              link_to(capture(&block), options, html_options)
+            else
+              name = args[0]
+              options = args[1] || {}
+              html_options = args[2]
+=end
+    
+  end
+end