calatrava 0.5.0 → 0.6.0

data/lib/calatrava/project.rb

@@ -1,19 +1,7 @@
-require 'mustache'
-require 'yaml'
-require 'xcoder'
-require 'xcodeproj'
-
-require 'calatrava/resources_build_phase'
-
 module Calatrava
 
   class Project
 
-    def sh(cmd)
-      $stdout.puts cmd
-      system(cmd)
-    end
-
     def self.here(directory)
       @@current = Project.new(directory)
     end
@@ -22,7 +10,7 @@ module Calatrava
       @@current
     end
 
-    attr_reader :name
+    attr_reader :name, :config, :kernel, :mobile_web, :ios, :droid
 
     def initialize(name, overrides = {})
       @name = name
@@ -35,185 +23,13 @@ module Calatrava
         @name = @options[:project_name]
       end
       @options.merge! overrides
-    end
-
-    def dev?
-      @options[:is_dev]
-    end
-
-    def create(template)
-      create_project(template)
-      create_directory_tree(template)
-      create_files(template)
-
-      create_android_tree(template)
-      create_ios_tree(template)
-    end
-
-    def create_project(template)
-      FileUtils.mkdir_p @name
-      File.open(File.join(@name, 'calatrava.yml'), "w+") do |f|
-        f.print({:project_name => @name}.to_yaml)
-      end
-    end
-
-    def target_item(item)
-      item.gsub("CALATRAVA_TMPL", @name)
-    end
-
-    def create_directory_tree(template)
-      template.walk_directories do |dir|
-        FileUtils.mkdir_p(File.join(@name, target_item(dir)))
-      end
-    end
-
-    def create_files(template)
-      template.walk_files do |file_info|
-        target_name = target_item(file_info[:name])
-        if File.extname(file_info[:name]) == ".calatrava"
-          File.open(File.join(@name, target_name.gsub(".calatrava", "")), "w+") do |f|
-            expanded = Mustache.render(IO.read(file_info[:path]),
-                                       :project_name => @name,
-                                       :project_slug => @slug,
-                                       :project_title => @title,
-                                       :dev? => dev?)
-            f.print(expanded)
-          end
-        else
-          FileUtils.cp(file_info[:path], File.join(@name, target_name))
-        end
-      end
-    end
-
-    def create_android_tree(template)
-      Dir.chdir(File.join(@name, "droid")) do
-        sh "android create project --name '#{@slug}' --path '#{@name}' --package com.#{@slug} --target android-10 --activity #{@title}"
-
-        Dir.walk("calatrava") do |item|
-          target_item = item.sub('calatrava', @name)
-          FileUtils.mkdir_p(target_item) if File.directory? item
-          FileUtils.cp(item, target_item) if File.file? item
-        end
-        Dir.chdir "#{@name}" do
-          Dir.chdir "#{@name}" do
-            FileUtils.mv "build.xml", "../build.xml"
-            FileUtils.mv "AndroidManifest.xml", "../AndroidManifest.xml"
-          end
-          FileUtils.rm_rf "#{@name}"
-          Dir.chdir "src/com/#{@name}" do
-            FileUtils.mv "Title.java", "#{@title}.java"
-          end
-        end
-
-        FileUtils.rm_rf "calatrava"
-      end
-    end
-
-    def create_ios_project
-      Xcodeproj::Project.new.tap do |proj|
-        %w{Foundation UIKit CoreGraphics}.each { |fw| proj.add_system_framework fw }
-      end
-    end
-
-    def create_ios_project_groups(base_dir, proj, target)
-      source_files_for_target = []
-
-      walker = lambda do |item, group|
-        if item.directory?
-          group_name = item.basename
-          child_group = group.create_group group_name
-          item.each_child { |item| walker.call(item, child_group) }
-        elsif item.file?
-          file_path = item.relative_path_from(base_dir)
-          group.create_file file_path.to_s
-          source_files_for_target << Xcodeproj::Project::Object::PBXNativeTarget::SourceFileDescription.new(file_path, "", nil)
-        else
-          raise 'what is it then?!'
-        end
-      end
-      (base_dir + "src").each_child { |item| walker.call(item, proj.main_group) }
-      target.add_source_files source_files_for_target
-    end
-
-    def create_ios_folder_references(base_dir, proj, target)
-      FileUtils.mkdir_p "ios/public"
-      public_folder = proj.main_group.create_file "public"
-      public_folder.last_known_file_type = 'folder'
-      build_file = public_folder.build_files.new 
-
-      shared_phase = Xcodeproj::Project::Object::PBXResourcesBuildPhase.new(proj,nil,{})
-
-      shared_phase << build_file
-      target.build_phases << shared_phase
-
-    end
-
-    def create_ios_project_target(proj)
-      target = Xcodeproj::Project::Object::PBXNativeTarget.new(proj,
-        nil,
-        'productType' => 'com.apple.product-type.application',
-        'productName' => @name)
-
-      target.build_configurations.each do |config|
-        config.build_settings.merge!(Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[:ios])
-
-        # E.g. [:ios, :release]
-        extra_settings_key = [:ios, config.name.downcase.to_sym]
-        if extra_settings = Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[extra_settings_key]
-          config.build_settings.merge!(extra_settings)
-        end
-
-        config.build_settings.merge!({
-          "GCC_PREFIX_HEADER" => "src/#{@name}-Prefix.pch",
-          "OTHER_LDFLAGS" => ['-ObjC', '-all_load'],
-          "INFOPLIST_FILE" => "src/#{@name}-Info.plist",
-          "SKIP_INSTALL" => "NO",
-          "IPHONEOS_DEPLOYMENT_TARGET" => "5.0",
-        })
-        config.build_settings.delete "DSTROOT"
-        config.build_settings.delete "INSTALL_PATH"
-
-      end
-
-      calatrava_phase = Xcodeproj::Project::Object::PBXShellScriptBuildPhase.new(proj,nil,{})
-      target.build_phase_references.insert(0,calatrava_phase.uuid) # hacky manual way to get build phase inserted in the right place
-
-      calatrava_phase.name = "Build Calatrava Kernel & Shell"
-      calatrava_phase.shell_script = <<-EOS.split("\n").collect(&:strip).join("\n")
-        source ${SRCROOT}/../build_env.sh
-        bundle exec rake ios:xcode:prebuild
-      EOS
-
-      proj.targets << target
-      target
-    end
-
-    def create_ios_tree(template)
-      proj = create_ios_project
-      base_dir = Pathname.new(@name) + "ios"
-
-      target = create_ios_project_target(proj)
-      create_ios_project_groups(base_dir, proj, target)
-      create_ios_folder_references(base_dir, proj, target)
-
-      proj.save_as (base_dir + "#{@name}.xcodeproj").to_s
-    end
-
-    def modules
-      Dir[File.join(@path, 'kernel/app/*')].select { |n| File.directory? n }.collect { |n| File.basename n }
-    end
-
-    def src_paths
-      modules.collect { |m| "app/#{m}" }.join(':')
-    end
 
-    def build_ios(options = {})
-      proj = Xcode.project("ios/#{@name}.xcworkspace")
-      builder = proj.target(@name).config('Debug').builder
-      builder.clean
-      builder.sdk = options[:sdk] || :iphonesimulator
-      builder.build
-      builder.package
+      @config = Configuration.new
+      @kernel = Kernel.new(@path)
+      @shell = Shell.new(@path)
+      @mobile_web = MobileWebApp.new(@path, Manifest.new(@path, 'web', @kernel, @shell))
+      @ios = IosApp.new(@path, Manifest.new(@path, 'ios', @kernel, @shell))
+      @droid = DroidApp.new(@path, @name, Manifest.new(@path, 'droid', @kernel, @shell))
     end
 
   end

data/lib/calatrava/project_script.rb

@@ -0,0 +1,186 @@
+require 'mustache'
+require 'yaml'
+require 'xcodeproj'
+
+module Calatrava
+
+  class ProjectScript
+
+    attr_reader :name
+
+    def initialize(name, overrides = {})
+      @name = name
+      @slug = name.gsub(" ", "_").downcase
+      @title = @name[0..0].upcase + @name[1..-1]
+      @options = overrides
+    end
+
+    def sh(cmd)
+      $stdout.puts cmd
+      system(cmd)
+    end
+
+    def dev?
+      @options[:is_dev]
+    end
+
+    def create(template)
+      create_project(template)
+      create_directory_tree(template)
+      create_files(template)
+
+      create_android_tree(template)
+      create_ios_tree(template)
+    end
+
+    def create_project(template)
+      FileUtils.mkdir_p @name
+      File.open(File.join(@name, 'calatrava.yml'), "w+") do |f|
+        f.print({:project_name => @name}.to_yaml)
+      end
+    end
+
+    def target_item(item)
+      item.gsub("CALATRAVA_TMPL", @name)
+    end
+
+    def create_directory_tree(template)
+      template.walk_directories do |dir|
+        FileUtils.mkdir_p(File.join(@name, target_item(dir)))
+      end
+    end
+
+    def create_files(template)
+      template.walk_files do |file_info|
+        target_name = target_item(file_info[:name])
+        if File.extname(file_info[:name]) == ".calatrava"
+          File.open(File.join(@name, target_name.gsub(".calatrava", "")), "w+") do |f|
+            expanded = Mustache.render(IO.read(file_info[:path]),
+                                       :project_name => @name,
+                                       :project_slug => @slug,
+                                       :project_title => @title,
+                                       :dev? => dev?)
+            f.print(expanded)
+          end
+        else
+          FileUtils.cp(file_info[:path], File.join(@name, target_name))
+        end
+      end
+    end
+
+    def create_android_tree(template)
+      Dir.chdir(File.join(@name, "droid")) do
+        sh "android create project --name '#{@slug}' --path '#{@name}' --package com.#{@slug} --target android-10 --activity #{@title}"
+
+        Dir.walk("calatrava") do |item|
+          target_item = item.sub('calatrava', @name)
+          FileUtils.mkdir_p(target_item) if File.directory? item
+          FileUtils.cp(item, target_item) if File.file? item
+        end
+        Dir.chdir "#{@name}" do
+          Dir.chdir "#{@name}" do
+            FileUtils.mv "build.xml", "../build.xml"
+            FileUtils.mv "AndroidManifest.xml", "../AndroidManifest.xml"
+          end
+          FileUtils.rm_rf "#{@name}"
+          Dir.chdir "src/com/#{@name}" do
+            FileUtils.mv "Title.java", "#{@title}.java"
+          end
+        end
+
+        FileUtils.rm_rf "calatrava"
+      end
+    end
+
+    def create_ios_project
+      Xcodeproj::Project.new.tap do |proj|
+        %w{Foundation UIKit CoreGraphics}.each { |fw| proj.add_system_framework fw }
+      end
+    end
+
+    def create_ios_project_groups(base_dir, proj, target)
+      source_files_for_target = []
+
+      walker = lambda do |item, group|
+        if item.directory?
+          group_name = item.basename
+          child_group = group.create_group group_name
+          item.each_child { |item| walker.call(item, child_group) }
+        elsif item.file?
+          file_path = item.relative_path_from(base_dir)
+          group.create_file file_path.to_s
+          source_files_for_target << Xcodeproj::Project::Object::PBXNativeTarget::SourceFileDescription.new(file_path, "", nil)
+        else
+          raise 'what is it then?!'
+        end
+      end
+      (base_dir + "src").each_child { |item| walker.call(item, proj.main_group) }
+      target.add_source_files source_files_for_target
+    end
+
+    def create_ios_folder_references(base_dir, proj, target)
+      public_folder = proj.main_group.create_file "public"
+      public_folder.last_known_file_type = 'folder'
+      build_file = public_folder.build_files.new 
+
+      shared_phase = Xcodeproj::Project::Object::PBXResourcesBuildPhase.new(proj,nil,{})
+
+      shared_phase << build_file
+      target.build_phases << shared_phase
+
+    end
+
+    def create_ios_project_target(proj)
+      target = Xcodeproj::Project::Object::PBXNativeTarget.new(proj,
+        nil,
+        'productType' => 'com.apple.product-type.application',
+        'productName' => @name)
+
+      target.build_configurations.each do |config|
+        config.build_settings.merge!(Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[:ios])
+
+        # E.g. [:ios, :release]
+        extra_settings_key = [:ios, config.name.downcase.to_sym]
+        if extra_settings = Xcodeproj::Project::Object::XCBuildConfiguration::COMMON_BUILD_SETTINGS[extra_settings_key]
+          config.build_settings.merge!(extra_settings)
+        end
+
+        config.build_settings.merge!({
+          "GCC_PREFIX_HEADER" => "src/#{@name}-Prefix.pch",
+          "OTHER_LDFLAGS" => ['-ObjC', '-all_load'],
+          "INFOPLIST_FILE" => "src/#{@name}-Info.plist",
+          "SKIP_INSTALL" => "NO",
+          "IPHONEOS_DEPLOYMENT_TARGET" => "5.0",
+        })
+        config.build_settings.delete "DSTROOT"
+        config.build_settings.delete "INSTALL_PATH"
+
+      end
+
+      calatrava_phase = Xcodeproj::Project::Object::PBXShellScriptBuildPhase.new(proj,nil,{})
+      target.build_phase_references.insert(0,calatrava_phase.uuid) # hacky manual way to get build phase inserted in the right place
+
+      calatrava_phase.name = "Build Calatrava Kernel & Shell"
+      calatrava_phase.shell_path = '/bin/bash'
+      calatrava_phase.shell_script = <<-EOS.split("\n").collect(&:strip).join("\n")
+        source ${SRCROOT}/../build_env.sh
+        bundle exec rake ios:xcode:prebuild
+      EOS
+
+      proj.targets << target
+      target
+    end
+
+    def create_ios_tree(template)
+      proj = create_ios_project
+      base_dir = Pathname.new(@name) + "ios"
+
+      target = create_ios_project_target(proj)
+      create_ios_project_groups(base_dir, proj, target)
+      create_ios_folder_references(base_dir, proj, target)
+
+      proj.save_as (base_dir + "#{@name}.xcodeproj").to_s
+    end
+  end
+
+end

data/lib/calatrava/shell.rb

@@ -0,0 +1,43 @@
+module Calatrava
+
+  class Shell
+    def initialize(proj_path)
+      @path = proj_path
+    end
+
+    def coffee_files
+      Dir.chdir @path do
+        Dir["shell/support/*.coffee"] + Dir["shell/support/*.coffee"]
+      end
+    end
+
+    def haml_files
+      Dir.chdir @path do
+        Dir["shell/support/*.haml"]
+      end
+    end
+
+    def css_files
+      Dir.chdir @path do
+        Dir["shell/stylesheets/*.sass"] + Dir["shell/stylesheets/*.css"]
+      end
+    end
+
+    def features
+      Dir.chdir @path do
+        Dir["shell/pages/*"].collect do |f|
+          if File.directory?(f)
+            {
+              :name => File.basename(f),
+              :coffee => Dir["#{f}/*.coffee"],
+              :haml => Dir["#{f}/*.haml"]
+            }
+          else
+            nil
+          end
+        end.compact
+      end
+    end
+  end
+
+end

data/lib/calatrava/tasks/assets.rb

@@ -1,3 +1,7 @@
+def cp_ne(source, dest_dir)
+  cp Dir[source], dest_dir
+end
+
 def coffee(in_dir_or_file, out_dir)
   if !Dir["#{in_dir_or_file}/**/*.coffee"].empty? || File.exists?(in_dir_or_file)
     $stdout.puts "coffee #{in_dir_or_file} -> #{out_dir}"

data/lib/calatrava/tasks/automation.rb

@@ -1,21 +1,15 @@
+FEATURES_DIR = File.join('.', 'features').freeze
+FEATURE_RESULTS_DIR = File.join('.', 'results').freeze
+
 namespace :automation do
   namespace :web do
     desc "Runs cucumber tests against the web app"
-    task :features, [:file] => [:apache_for_features, :create_sim_link, :copy_steps_file, :clean_up_results_dir] do |t, args|
+    task :features, [:file] => [:create_sim_link, :copy_steps_file, :clean_up_results_dir] do |t, args|
       ENV['PATH'] = "#{ROOT_DIR}/web/features:#{ENV['PATH']}"
       features_to_be_run = args[:file] ? "#{FEATURES_DIR}/#{args[:file]}" : FEATURES_DIR
       sh "cucumber --strict --tags @all,@web --tags ~@wip #{features_to_be_run} --format html --out #{FEATURE_RESULTS_DIR}/report.html --format pretty"
     end
 
-    desc "launch a daemon apache instance on port 8888 which will serve the features and mock the backend services"
-    task :apache_for_features => ['web:build', APACHE_LOGS_DIR] do
-      create_plist
-      configure_apache
-      `launchctl unload #{APACHE_DIR}/com.jenkins.calatrava.apache.plist`
-      `launchctl load -w #{APACHE_DIR}/com.jenkins.calatrava.apache.plist`
-      `sleep 5`
-    end
-
     desc "create sim link for the ios step_definitions and support folder"
     task :create_sim_link do
       sh "rm -rf #{FEATURES_DIR}/step_definitions"

data/lib/calatrava/tasks/haml.rb

@@ -6,9 +6,9 @@ module HamlSupport
     
     attr_reader :page_name
 
-    def initialize(feature = nil, page = nil)
-      @feature = feature
-      @page_name = page
+    def initialize(page_path = nil)
+      @page_path = page_path
+      @page_name = File.basename(@page_path, '.haml') if @page_path
     end
 
     def content_for(named_chunk)
@@ -23,13 +23,13 @@ module HamlSupport
     end
 
     def render_partial(partial_name, locals = {})
-      partial_template = IO.read("#{partial_name}.haml")
+      partial_name = "#{partial_name}.haml" unless partial_name =~ /haml$/
+      partial_template = IO.read partial_name
       Haml::Engine.new(partial_template).render(self, locals)
     end
 
-    def render_page(page_name = nil, locals = {})
-      page_name = File.join(@feature, @page_name) unless page_name
-      page_template = IO.read(File.join('shell/pages', "#{page_name}.haml"))
+    def render_page(locals = {})
+      page_template = IO.read(@page_path)
       Haml::Engine.new(page_template).render(self, locals)
     end
 
@@ -37,10 +37,10 @@ module HamlSupport
 
   class << self
 
-    def compile_hybrid_page(feature, page_path, output_path, options = {})
+    def compile_hybrid_page(page_path, output_path, options = {})
       puts "haml page: #{page_path} -> #{output_path}"
 
-      options[:helper] = Helper.new(feature, File.basename(page_path, ".haml"))
+      options[:helper] = Helper.new(page_path)
       options[:template] = "shell/layouts/single_page.haml"
       options[:out] = File.join(output_path, File.basename(page_path, '.*') + '.html')
 
@@ -63,7 +63,6 @@ module HamlSupport
 
       html = Haml::Engine.new(template).render(options[:helper])
 
-      html.gsub!("file:///android_asset/hybrid", "../assets") if options[:platform] == 'ios'
       IO.write(html_path, html)
     end
   end

data/lib/calatrava/tasks.rb

@@ -3,91 +3,15 @@ require 'calatrava'
 
 Calatrava::Project.here('.')
 
-def cp_ne(source, dest_dir)
-  cp Dir[source], dest_dir
-end
-
-ROOT_DIR         = "."
-BUILD_DIR        = File.join(ROOT_DIR, 'build').freeze
-
-SHELL_DIR          = File.join(ROOT_DIR, 'shell').freeze
-SHELL_LAYOUTS_DIR  = File.join(SHELL_DIR, 'layouts').freeze
-SHELL_VIEWS_DIR    = File.join(SHELL_DIR, 'views').freeze
-SHELL_PARTIALS_DIR = File.join(SHELL_DIR, 'partials').freeze
-SHELL_JS_DIR       = File.join(SHELL_DIR, 'support').freeze
-
-FEATURES_DIR = File.join(ROOT_DIR, 'features').freeze
-FEATURE_RESULTS_DIR = File.join(ROOT_DIR, 'results').freeze
-
-
-KERNEL_DIR          = File.join(ROOT_DIR, 'kernel').freeze
-KERNEL_JS_DIR       = File.join(KERNEL_DIR, 'app').freeze
-KERNEL_SPEC_DIR     = File.join(KERNEL_DIR, 'spec').freeze
-
-BUILD_CORE_DIR         = File.join(BUILD_DIR, 'core').freeze
-BUILD_CORE_KERNEL_DIR  = File.join(BUILD_CORE_DIR, 'kernel').freeze
-BUILD_CORE_CSS_DIR     = File.join(BUILD_CORE_DIR, 'stylesheets').freeze
-
-ASSETS_DIR       = File.join(ROOT_DIR, 'assets').freeze
-ASSETS_IMG_DIR   = File.join(ASSETS_DIR, 'images').freeze
-ASSETS_LIB_DIR   = File.join(ASSETS_DIR, 'lib').freeze
-ASSETS_CSS_DIR   = File.join(ASSETS_DIR, 'stylesheets').freeze
-ASSETS_FONTS_DIR = File.join(ASSETS_DIR, 'fonts').freeze
-
-APACHE_DIR      = File.join(ROOT_DIR, 'web', 'apache').freeze
-WEB_DIR         = File.join(ROOT_DIR, 'web').freeze
-APACHE_LOGS_DIR = File.join(APACHE_DIR, 'logs').freeze
-
-CONFIG_DIR          = File.join(ROOT_DIR, 'config').freeze
-CONFIG_YAML         = File.join(CONFIG_DIR, 'environments.yml').freeze
-CONFIG_TEMPLATE_DIR = File.join(CONFIG_DIR, 'templates').freeze
-CONFIG_RESULT_DIR   = File.join(CONFIG_DIR, 'result').freeze
-directory CONFIG_RESULT_DIR
-
-CONFIG = {}
-
-[:ios, :droid, :web].each do |os|
-  CONFIG[os] = {}
-  CONFIG[os][:root]   = File.join(ROOT_DIR, os.to_s)
-  CONFIG[os][:public] = case os
-  when :droid
-    File.join(CONFIG[os][:root], Calatrava::Project.current.name, 'assets', 'hybrid').freeze
-  else
-    File.join(CONFIG[os][:root], 'public').freeze
-  end
-  CONFIG[os][:html]   = File.join(CONFIG[os][:public], 'views').freeze
-  CONFIG[os][:assets] = case os 
-  when :ios
-    File.join(CONFIG[os][:public], 'assets').freeze
-  else
-    CONFIG[os][:public]
-  end
-  CONFIG[os][:imgs]   = File.join(CONFIG[os][:assets], 'images').freeze
-  CONFIG[os][:js]     = File.join(CONFIG[os][:assets], 'scripts').freeze
-  CONFIG[os][:css]    = File.join(CONFIG[os][:assets], 'styles').freeze
-  CONFIG[os][:fonts]  = File.join(CONFIG[os][:assets], 'fonts').freeze
-  CONFIG[os][:layout] = File.join(CONFIG[os][:root], "app", "views").freeze
-
-  directory CONFIG[os][:public]
-  directory CONFIG[os][:html]
-  directory CONFIG[os][:assets]
-  directory CONFIG[os][:imgs]
-  directory CONFIG[os][:js]
-  directory CONFIG[os][:css]
-  directory CONFIG[os][:fonts]
-end
-
-CONFIG[:ios][:project_name] = Calatrava::Project.current.name
-CONFIG[:ios][:app_dir]      = File.join(CONFIG[:ios][:root], 'Source', Calatrava::Project.current.name)
-CONFIG[:ios][:cucumber]     = FEATURES_DIR
+Dir["#{File.join(File.dirname(__FILE__), 'tasks')}/*.rb"].each { |t| require t }
 
-directory BUILD_CORE_DIR
-directory BUILD_CORE_CSS_DIR
-directory BUILD_CORE_KERNEL_DIR
+namespace(:kernel)    { Calatrava::Project.current.kernel.install_tasks }
+namespace(:configure) { Calatrava::Project.current.config.install_tasks }
+namespace(:droid)     { Calatrava::Project.current.droid.install_tasks }
+namespace(:ios)       { Calatrava::Project.current.ios.install_tasks }
+namespace(:web)       { Calatrava::Project.current.mobile_web.install_tasks }
 
-Dir["#{File.join(File.dirname(__FILE__), 'tasks')}/*.rb"].each { |t| require t }
+desc "Clean all apps"
+task :clean => ['web:clean', 'ios:clean', 'droid:clean']
 
-desc "Clean all directories"
-task :clean => ["core:clean", "ios:clean", "bb:clean", "web:clean", "artifact:clean", "droid:clean"] do
-  rm_rf BUILD_DIR
-end
+task :build => ['web:build', 'ios:build', 'droid:build']

data/lib/calatrava/templates/config/templates/httpd.conf.erb

@@ -1,13 +1,13 @@
-LoadModule ssl_module        <%=MODULES_PATH%>/mod_ssl.so
-LoadModule proxy_module      <%=MODULES_PATH%>/mod_proxy.so
-LoadModule proxy_http_module <%=MODULES_PATH%>/mod_proxy_http.so
-LoadModule headers_module    <%=MODULES_PATH%>/mod_headers.so
-<% if LOAD_LOG_MODULE %>
-LoadModule log_config_module <%=MODULES_PATH%>/mod_log_config.so
+LoadModule ssl_module        <%=configuration[:modules_path]%>/mod_ssl.so
+LoadModule proxy_module      <%=configuration[:modules_path]%>/mod_proxy.so
+LoadModule proxy_http_module <%=configuration[:modules_path]%>/mod_proxy_http.so
+LoadModule headers_module    <%=configuration[:modules_path]%>/mod_headers.so
+<% if configuration[:load_log_module] %>
+LoadModule log_config_module <%=configuration[:modules_path]%>/mod_log_config.so
 <% end %>
-LoadModule mime_module       <%=MODULES_PATH%>/mod_mime.so
-LoadModule dir_module        <%=MODULES_PATH%>/mod_dir.so
-LoadModule alias_module      <%=MODULES_PATH%>/mod_alias.so
+LoadModule mime_module       <%=configuration[:modules_path]%>/mod_mime.so
+LoadModule dir_module        <%=configuration[:modules_path]%>/mod_dir.so
+LoadModule alias_module      <%=configuration[:modules_path]%>/mod_alias.so
 
 ErrorLog "logs/error.log"
 LogLevel Debug

data/lib/calatrava/templates/droid/app/bridge.coffee

@@ -28,4 +28,7 @@ calatrava.bridge.runtime = (() ->
       options.method,
       options.body,
       options.headers)
+
+  callPlugin: (plugin, method, args) ->
+    pluginRegistry.call(plugin, method, JSON.stringify(args))
 )()

data/lib/calatrava/templates/droid/calatrava/src/com/calatrava/CalatravaPlugin.java

@@ -0,0 +1,13 @@
+package com.calatrava;
+
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CalatravaPlugin
+{
+  String name();
+}