calatrava 0.5.0 → 0.6.0

data/CHANGES.markdown

@@ -0,0 +1,40 @@
+## v0.6.0
+
+* Added
+[plugin support](https://github.com/calatrava/calatrava/wiki/Plugins)
+* Added an alert plugin implementation:
+  `web/app/source/alert.web.coffee`,
+  `droid/test/src/com/calatrava/bridge/AlertPlugin.java` and
+  `ios/Pods/calatrava/calatrava-ios/Bridge/AlertPlugin.m`.
+* Substantial re-writing of the build tasks. Should largely not be
+  externally visible, except there are a lot less tasks now.
+  
+Bugs fixed:
+* [Issue #5][i5]: Creates the droid build with default name of the
+  project as 'test' instead of the project name
+* [Issue #12][i12]: Failing AJAX - Typo in calatrava.inbound
+* [Issue #13][i13]: Problem Building on Xcode (4.5.1) - Can't Find
+  Bundler
+* [Issue #14][i14]: Cosmetic: ios/public misplaced during calatrava
+  create
+* [Issue #15][i15]: Uncaught TypeError: Object #<Object> has no
+  method 'success'
+  
+Changes that will affect existing projects:
+* Edited httpd conf template: `config/templates/httpd.conf.erb`
+* Edited the single page Haml template: `web/app/views/index.haml`
+
+## v0.5.0
+
+* First public release
+
+## Contributors:
+* [Giles Alexander](https://github.com/gga)
+* [Vivek Jain](https://github.com/vivekjain10)
+* [Renaud Tircher](https://github.com/rtircher)
+
+[i5]: https://github.com/calatrava/calatrava/issues/5
+[i12]: https://github.com/calatrava/calatrava/issues/12
+[i13]: https://github.com/calatrava/calatrava/issues/13
+[i14]: https://github.com/calatrava/calatrava/issues/14
+[i15]: https://github.com/calatrava/calatrava/issues/15

data/README.md

@@ -4,6 +4,11 @@ It should be as easy to get started with Calatrava as
 possible. However, there are still a small number of dependencies that
 need to be installed beforehand.
 
+*Note*: Currently, Calatrava only supports development on Macs. this
+ will probably always be the case for iOS apps, but there are plans to
+ at least support Linux for Android and Mobile Web. Windows is a
+ little further off. Pull requests welcomed.
+
 1. [rvm](http://rvm.io). Calatrava projects are configured to use
    `rvm` by default. You could use Calatrava without it, but you will
    then need to make sure you have Ruby 1.9.3 installed however you

data/calatrava.gemspec

@@ -26,10 +26,9 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "haml"
   s.add_runtime_dependency "sass"
   s.add_runtime_dependency "mustache"
-  s.add_runtime_dependency "xcoder"
-  s.add_runtime_dependency "xcodeproj"
   s.add_runtime_dependency "cucumber"
-  s.add_runtime_dependency "frank-cucumber"
   s.add_runtime_dependency "watir-webdriver"
+  s.add_runtime_dependency "frank-cucumber"
+  s.add_runtime_dependency "xcodeproj"
   s.add_runtime_dependency "cocoapods"
 end

data/lib/calatrava/apache.rb

@@ -0,0 +1,126 @@
+module Calatrava
+
+  class Apache
+    include Rake::DSL
+
+    Calatrava::Configuration.extra do |c|
+      if `uname -a`.chomp["amzn1"]
+        c.runtime :modules_path, "/usr/lib64/httpd/modules"
+        c.runtime :load_log_module, true
+      elsif `uname`.chomp == "Linux"
+        c.runtime :modules_path, "/usr/lib/apache2/modules"
+        c.runtime :load_log_module, false
+      elsif `uname`.chomp == "Darwin"
+        c.runtime :modules_path, "/usr/libexec/apache2"
+        c.runtime :load_log_module, true
+      else
+        raise "Calatrava does not support running apache on this platform."
+      end
+    end
+    
+    def apache_dir
+      "web/apache"
+    end
+
+    def apache_public_dir
+      "#{apache_dir}/public"
+    end
+
+    def apache_logs_dir
+      "#{apache_dir}/logs"
+    end
+
+    def apache_conf_dir
+      "#{apache_dir}/conf"
+    end
+
+    def httpd(command, opts = {})
+      ensure_httpd
+      cmd = %Q{#{@httpd} -d #{apache_dir} -f conf/httpd.conf -e DEBUG -k #{command} -DNO_DETACH -DFOREGROUND}
+      puts cmd
+      if opts[:background]
+        fork do
+          exec cmd
+        end
+      else
+        exec cmd
+      end
+    end
+
+    def configure_apache
+      cp Calatrava::Project.current.config.path("httpd.conf"), apache_conf_dir
+    end
+
+    def launch_apache(opts = {})
+      if !opts[:background]
+        puts
+        puts "\t\t" + "*"*40
+        puts "\t\t" + "***   STARTING APACHE ON PORT 8888   ***"
+        puts "\t\t" + "*"*40
+        puts
+      end
+
+      httpd :start, opts
+    end
+
+    def stop_apache
+      httpd 'graceful-stop'
+    end
+
+    def reload_apache
+      httpd :restart
+    end
+
+    def ensure_httpd
+      if !@httpd
+        if `uname -a`.chomp["amzn1"]
+          @httpd = "httpd"
+        elsif `uname`.chomp == "Linux"
+          @httpd = "apache2"
+        elsif `uname`.chomp == "Darwin"
+          @httpd = "httpd"
+        else
+          raise "Calatrava does not support running apache on this platform."
+        end
+      end
+    end
+
+    def install_tasks
+      directory apache_logs_dir
+      file apache_public_dir do
+        cd apache_dir do
+          ln_s "../public", "public"
+        end
+      end
+
+      desc "launch a non-daemon apache instance on port 8888 which will serve our local app and also proxy to backend services"
+      task :start => ['web:build', apache_public_dir, apache_logs_dir] do
+        configure_apache
+        launch_apache
+      end
+
+      task :background => ['web:build', apache_public_dir, apache_logs_dir] do
+        configure_apache
+        launch_apache :background => true
+      end
+
+      desc "Reload the apache configuration"
+      task :reload do
+        reload_apache
+      end
+
+      desc "Stop the apache configuration"
+      task :stop do
+        stop_apache
+      end
+
+      desc "Cleans apache config"
+      task :clean do
+        rm_rf apache_logs_dir
+        rm_rf File.join(apache_conf_dir, 'httpd.conf')
+      end
+
+    end
+  end
+
+end

data/lib/calatrava/app.rb

@@ -10,8 +10,8 @@ module Calatrava
       die "template must exist" unless File.exist?(options[:template])
       die "template must be a directory" unless File.directory?(options[:template])
 
-      proj = Project.new(project_name,
-                         :is_dev => options.dev?)
+      proj = ProjectScript.new(project_name,
+                               :is_dev => options.dev?)
       proj.create(Template.new(options[:template]))
     end
 

data/lib/calatrava/app_builder.rb

@@ -0,0 +1,68 @@
+module Calatrava
+
+  class AppBuilder
+    include Rake::DSL
+
+    def initialize(output_dir, manifest)
+      @output_dir, @manifest = output_dir, manifest
+    end
+
+    def build_dir ; @output_dir ; end
+    def build_html_dir ; "#{build_dir}/views" ; end
+    def build_scripts_dir ; "#{build_dir}/scripts" ; end
+    def build_images_dir ; "#{build_dir}/images" ; end
+    def build_styles_dir ; "#{build_dir}/styles" ; end
+
+    def coffee_files
+      @manifest.coffee_files + [Calatrava::Project.current.config.path('env.coffee')]
+    end
+
+    def js_file(cf)
+      "#{build_scripts_dir}/#{File.basename(cf, '.coffee')}.js"
+    end
+
+    def load_instructions
+      build_path = Pathname.new(File.dirname(build_dir))
+      @manifest.kernel_bootstrap.collect do |cf|
+        Pathname.new(js_file(cf)).relative_path_from(build_path).to_s
+      end.join($/)
+    end
+
+    def haml_files
+      @manifest.haml_files
+    end
+
+    def builder_task
+      directory build_html_dir
+      directory build_images_dir
+      directory build_scripts_dir
+
+      app_files = haml_files.collect do |hf|
+        file "#{build_html_dir}/#{File.basename(hf, '.haml')}.html" => [build_html_dir, hf] do
+          HamlSupport::compile_hybrid_page hf, build_html_dir, :platform => 'ios'
+        end
+      end
+
+      app_files += coffee_files.collect do |cf|
+        file js_file(cf) => [build_scripts_dir, cf] do
+          coffee cf, build_scripts_dir
+        end
+      end
+
+      app_files += @manifest.css_tasks(build_styles_dir)
+      app_files << file("#{build_dir}/load_file.txt" => build_dir) do |t|
+        File.open(t.name, "w+") { |f| f.puts load_instructions }
+      end
+
+      task :shared => [build_images_dir, build_scripts_dir] do
+        cp_ne "assets/images/*", build_images_dir
+        cp_ne "assets/lib/*.js", build_scripts_dir
+        cp_ne "ios/res/js/*.js", build_scripts_dir
+      end
+
+      task :app => [:shared] + app_files
+    end
+
+  end
+
+end

data/lib/calatrava/configuration.rb

@@ -0,0 +1,73 @@
+require 'erb'
+
+module Calatrava
+
+  class Configuration
+    include Rake::DSL
+
+    @@extras = []
+    def self.extra(&configurator)
+      @@extras << configurator
+    end
+
+    def initialize
+      @runtime = {}
+    end
+
+    def config_result_dir
+      "config/result"
+    end
+    def config_yaml
+      "config/environments.yml"
+    end
+    def config_template_dir
+      "config/templates"
+    end
+    def templates
+      Rake::FileList["#{config_template_dir}/*.erb"]
+    end
+
+    def config_for(environment)
+      @@extras.each { |e| e.call(self) }
+      @runtime.merge(YAML::load(File.open(config_yaml))[environment])
+    end
+
+    def runtime(key, value)
+      @runtime[key] = value
+    end
+
+    def evaluate_template(template_path, configuration)
+      file_path = File.join(config_result_dir, File.basename(template_path).gsub(".erb", ''))
+      puts "Config: #{File.basename(template_path)} -> #{File.basename(file_path)}"
+      result = ERB.new(IO.read(template_path)).result(binding)
+      IO.write(file_path, result)
+    end
+
+    def path(file)
+      env = ENV['CALATRAVA_ENV'] || "development"
+      puts "CALATRAVA_ENV = '#{env}'"
+      full_path = artifact_path(File.join(env, file))
+      full_path
+    end
+
+    def install_tasks
+      directory config_result_dir
+
+      %w{local development test automation production}.each do |environment|
+        desc "Create config files for #{environment} environment"
+        task environment.to_sym => [:clean, config_result_dir] do
+          configuration = config_for(environment)
+          templates.each do |template|
+            evaluate_template(template, configuration)
+          end
+          artifact_dir(config_result_dir, environment)
+        end
+      end
+
+      task :clean do
+        rm_rf config_result_dir
+      end
+    end
+  end
+
+end

data/lib/calatrava/droid_app.rb

@@ -0,0 +1,46 @@
+module Calatrava
+  
+  class DroidApp
+    include Rake::DSL
+
+    def initialize(path, proj_name, manifest)
+      @path, @proj_name, @manifest = path, proj_name, manifest
+      @app_builder = AppBuilder.new("droid/#{@proj_name}/assets/calatrava", @manifest)
+    end
+
+    def install_tasks
+      app_task = @app_builder.builder_task
+
+      app_task.prerequisites << file(@app_builder.js_file('droid/app/bridge.coffee') => 'droid/app/bridge.coffee') do
+        coffee 'droid/app/bridge.coffee', @app_builder.build_scripts_dir
+      end
+
+      desc "Builds the Android app"
+      task :build => app_task do
+        cd "droid/#{@proj_name}" do
+          sh "ant clean debug"
+        end
+      end
+
+      desc "Publishes the built Android app as an artifact"
+      task :publish => :build do
+        artifact("droid/#{@proj_name}/bin/#{@proj_name}-debug.apk", ENV['CALATRAVA_ENV'])
+      end
+
+      desc "Deploy app to device/emulator"
+      task :deploy => :publish do
+        sh "adb install -r artifacts/#{ENV['CALATRAVA_ENV']}/#{@proj_name}-debug.apk"
+      end
+
+      desc "Clean droid"
+      task :clean do
+        rm_rf @app_builder.build_dir
+        cd "droid/#{@proj_name}" do
+          sh "ant clean"
+        end
+      end
+      
+    end
+  end
+
+end

data/lib/calatrava/ios_app.rb

@@ -0,0 +1,40 @@
+module Calatrava
+
+  class IosApp
+    include Rake::DSL
+
+    def initialize(path, manifest)
+      @path, @manifest = path, manifest
+      @app_builder = AppBuilder.new('ios/public', @manifest)
+    end
+
+    def install_tasks
+      app_task = @app_builder.builder_task
+
+      desc "Builds the iOS app"
+      task :build => app_task do
+        ENV['CMDLINE_BUILD'] = 'true'
+        proj_name = Calatrava::Project.current.name
+        cd 'ios' do
+          sh "xcodebuild -workspace #{proj_name}.xcworkspace -scheme #{proj_name} -sdk iphonesimulator"
+        end
+      end
+
+      desc "Clean ios public directory"
+      task :clean do
+        sh "rm -rf #{@app_builder.build_dir}"
+      end
+
+      namespace :xcode do
+        task :prebuild do
+          if !ENV['CMDLINE_BUILD']
+            Rake::Task['configure:development'].invoke
+            app_task.invoke
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/lib/calatrava/kernel.rb

@@ -0,0 +1,79 @@
+require 'rake'
+
+module Calatrava
+
+  class Kernel
+    include Rake::DSL
+
+    def initialize(root)
+      @path = root
+    end
+
+    def features
+      Dir.chdir @path do
+        Dir['kernel/app/*'].select { |n| File.directory? n }.collect do |n|
+          {
+            :name => File.basename(n),
+            :coffee => Dir["#{n}/*.coffee"]
+          }
+        end
+      end
+    end
+
+    def coffee_files
+      Dir.chdir @path do
+        Dir["kernel/app/*.coffee"] + Dir["kernel/plugins/*.coffee"]
+      end
+    end
+
+    def coffee_path
+      (['app', 'app/plugins'] + features.collect { |m| "app/#{m[:name]}" }).join(':')
+    end
+
+    def prepare_for_features
+      sh "ln -sFfh kernel/features/step_definitions/ features/step_definitions"
+      sh "ln -sFfh kernel/features/support/ features/support"
+    end
+
+    def node_path_for_features
+      "#{coffee_path}:features/support:../assets/lib:features/step_definitions:../features/testdata"
+    end
+
+    def install_tasks
+      file '.node_updated' => 'package.json' do
+        sh "npm install && touch .node_updated"
+      end
+
+      desc "Run jasmine test. If specs not given in argument, runs all test"
+      task :spec => '.node_updated' do |t, args|
+        cd "kernel" do
+          ENV['NODE_PATH'] = "app:#{coffee_path}:spec:../assets/lib"
+          sh "../node_modules/jasmine-node/bin/jasmine-node --coffee --test-dir spec"
+        end
+      end
+
+      desc "Run cucumber.js features for kernel"
+      task :features, [:file] => '.node_updated' do |t, args|
+        prepare_for_features
+        cd "kernel" do
+          ENV['NODE_PATH'] = node_path_for_features
+          features_to_be_run = args[:file] ? "#{kernel/features}/#{args[:file]}" : "features"
+          sh "../node_modules/cucumber/bin/cucumber.js --tags @all,@kernel --tags ~@wip '#{features_to_be_run}'"
+        end
+      end
+
+      namespace :features do
+        task :wip => '.node_updated' do
+          prepare_for_features
+          cd "kernel" do
+            ENV['NODE_PATH'] = node_path_for_features
+            sh "../node_modules/cucumber/bin/cucumber.js --tags @wip --tags @kernel features"
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/calatrava/manifest.rb

@@ -1,18 +1,15 @@
 module Calatrava
 
   class Manifest
-    def initialize(app_dir)
-      @feature_list = YAML.load(IO.read("#{app_dir}/manifest.yml"))
+    def initialize(path, app_dir, kernel, shell)
+      @path, @kernel, @shell = path, kernel, shell
+      @feature_list = YAML.load(IO.read("#{@path}/#{app_dir}/manifest.yml"))
     end
 
     def features
       @feature_list
     end
 
-    def js_files
-      @feature_list.collect { |f| Dir["build/{kernel,shell}/js/#{f}/*.js"] }.flatten
-    end
-
     def load_file(target_dir, js_load_path, options)
       File.open("#{target_dir}/load_file.#{options[:type]}", "w+") do |f|
         @feature_list.each do |feature|
@@ -24,12 +21,38 @@ module Calatrava
       end
     end
 
-    def coffee_files(feature, opts)
-      coffee_files = Dir["{kernel,shell}/{app,pages}/#{feature}/*.coffee"]
-      if !opts[:include_pages]
-        coffee_files = coffee_files.reject { |f| f =~ /page\./ }
+    def coffee_files
+      [@shell, @kernel].collect do |src|
+        src.coffee_files + feature_files(src, :coffee)
+      end.flatten
+    end
+
+    def kernel_bootstrap
+      @kernel.coffee_files + feature_files(@kernel, :coffee)
+    end
+
+    def haml_files
+      @shell.haml_files + feature_files(@shell, :haml)
+    end
+    
+    def css_files
+      @shell.css_files
+    end
+
+    def css_tasks(output_dir)
+      css_files.collect do |style_file|
+        file "#{output_dir}/#{File.basename(style_file, '.*')}.css" => [output_dir, style_file] do |t|
+          if style_file =~ /css$/
+            cp style_file, output_dir
+          else
+            sh "sass #{style_file} #{t.name}"
+          end
+        end
       end
-      coffee_files
+    end
+
+    def feature_files(source, type)
+      source.features.select { |f| @feature_list.include?(f[:name]) }.collect { |f| f[type] }.flatten
     end
 
     def haml(js_src)

data/lib/calatrava/mobile_web_app.rb

@@ -0,0 +1,74 @@
+module Calatrava
+
+  class MobileWebApp
+    include Rake::DSL
+
+    def initialize(path, manifest)
+      @path, @manifest = path, manifest
+      @apache = Apache.new
+    end
+
+    def build_dir ; "#{@path}/web/public" ; end
+    def scripts_build_dir ; "#{build_dir}/scripts" ; end
+    def styles_build_dir ; "#{build_dir}/styles" ; end
+
+    def coffee_files
+      Dir.chdir @path do
+        core_coffee = ['bridge', 'init'].collect { |l| "web/app/source/#{l}.coffee" }
+        core_coffee += @manifest.coffee_files.select { |cf| cf =~ /calatrava.coffee$/ }
+        web_coffee = Dir['web/app/source/*.coffee'] - core_coffee
+        mf_coffee = @manifest.coffee_files.reject { |cf| cf =~ /calatrava.coffee$/ }
+        core_coffee + web_coffee + [Calatrava::Project.current.config.path('env.coffee')] + mf_coffee
+      end
+    end
+
+    def haml_files
+      Dir.chdir(@path) { @manifest.haml_files }
+    end
+
+    def scripts
+      coffee_files.collect { |cf| "scripts/#{File.basename(cf, '.coffee')}.js" }
+    end
+
+    def install_tasks
+      directory build_dir
+      directory scripts_build_dir
+
+      app_files = coffee_files.collect do |cf|
+        file "#{scripts_build_dir}/#{File.basename(cf, '.coffee')}.js" => [scripts_build_dir, cf] do
+          coffee cf, scripts_build_dir
+        end
+      end
+
+      app_files << file("#{build_dir}/index.html" => ["web/app/views/index.haml"] + haml_files) do
+        HamlSupport::compile "web/app/views/index.haml", build_dir
+      end
+
+      app_files += @manifest.css_tasks(styles_build_dir)
+
+      task :shared do
+        cp_ne "assets/images/*", File.join(build_dir, 'images')
+        cp_ne "assets/lib/*.js", scripts_build_dir
+      end        
+
+      desc "Build the web app"
+      task :build => app_files + [:shared]
+
+      desc "Publishes the built web app as an artifact"
+      task :publish => :build do
+        artifact_dir(build_dir, 'web/public')
+      end
+      
+      desc "Clean web app"
+      task :clean => 'apache:clean' do
+        rm_rf build_dir
+      end
+
+      namespace :apache do
+        @apache.install_tasks
+      end
+
+    end
+  end
+
+end