remi-andrake 0.1.0

data/lib/android/layout.rb

@@ -0,0 +1,142 @@
+# represents an Android layout .xml file
+class Android::Layout
+
+  attr_accessor :file_path
+
+  def initialize file_path
+    @file_path = file_path
+  end
+
+  def file_name
+    File.basename file_path
+  end
+  alias name file_name
+
+  def render stylesheets
+    layout_xml = get_xml
+    layout_xml = apply_css(layout_xml, stylesheets)
+    layout_xml = androidify_xml_attributes(layout_xml)
+  end
+
+  # get the xml for the layout ... if not .xml, we have to convert -> xml
+  def get_xml
+    if file_path[/\.xml$/]
+      File.read file_path
+    elsif file_path[/\.haml$/]
+      require 'haml'
+      Haml::Engine.new(File.read(file_path)).to_html
+    else
+      raise "Don't know how to get XML for #{ file_path }"
+    end
+  end
+
+  def read_css_file css_file
+    if css_file[/\.sass$/]
+      require 'sass'
+      Sass::Engine.new(File.read(css_file)).to_css
+    elsif css_file[/\.css$/]
+      File.read css_file
+    else
+      ""
+    end
+  end
+
+  def apply_css xml, css_files
+    return xml if css_files.empty?
+
+    require 'css_parser'
+    parser = CssParser::Parser.new
+    css_files.each do |css_file|
+      parser.add_block! read_css_file(css_file)
+    end
+
+    require 'hpricot'
+    doc = Hpricot(xml)
+    parser.each_selector do |selector, declarations, specificity|
+      doc.search(selector.downcase).each do |element|
+        if element.is_a? Hpricot::Elem
+          rules = declarations.split(';').map {|r| r.split(':').map {|x| x.strip }}
+          rules.each do |attribute, value|
+            element.set_attribute attribute, value
+          end
+        end
+      end
+    end
+
+    doc.to_s
+  end
+
+  def androidify_xml_attributes xml
+    require 'hpricot'
+    doc = Hpricot(xml)
+
+    # make sure that something has xmlns:android="http://schemas.android.com/apk/res/android"
+    doc.traverse_element do |first_element|
+      if first_element.is_a?Hpricot::Elem
+        unless first_element.attributes.keys.include?'xmlns:android'
+          first_element.set_attribute 'xmlns:android', 'http://schemas.android.com/apk/res/android'
+        end
+        break
+      end
+    end
+
+    doc.traverse_element {|e|
+      if e.is_a?Hpricot::Elem
+        
+        # fix ID
+        if e.attributes.keys.include?'id'
+          id = e[:id]
+          unless id.include? '@+id/'
+            e.set_attribute 'id', "@+id/#{id}"
+          end
+        end
+
+        # if there's innerText and no text attribute, innerText => text
+        if e.respond_to?:inner_text
+          unless e.inner_text.strip.empty? or e.attributes.keys.include?'text'
+            # e.set_attribute 'text', e.inner_text.strip
+            # e.inner_text = '' # no way to easily get rid of it?  :/
+          end
+        end
+
+        # fix attributes (prepend 'android:')
+        e.attributes.each do |k, v|
+          unless k.include?':'
+            value = e.remove_attribute k
+            e.set_attribute "android:#{k}", "#{value}"
+          end
+        end
+
+      end
+    }
+    fix_case_sensitive_tags(doc.to_s)
+  end
+
+  def fix_case_sensitive_tags xml
+    {
+      'textcolor='     => 'textColor=',
+      '<linearlayout'  => '<LinearLayout',
+      '<textview'      => '<TextView',
+      '<button'        => '<Button',
+
+      # fix these ... should use regexp?
+      '</linearlayout'  => '</LinearLayout',
+      '</textview'      => '</TextView',
+      '</button'        => '</Button'
+
+    }.each do  |k, v|
+      xml.gsub! k, v
+    end
+    xml
+  end
+
+  def self.find_all directory
+    # find directories with 'layout' in the name ... really, we should just do directly to res/layout
+    Dir[ File.join(directory, '**', '*layout*') ].directories.inject([]) do |layouts, dir|
+      layout_xml_files = Dir[ File.join(dir, '**', '*.xml') ] + Dir[ File.join(dir, '**', '*.haml') ]
+      layouts += layout_xml_files.map { |file_path| Android::Layout.new file_path }
+      layouts
+    end
+  end
+
+end

data/lib/javaclass.rb

@@ -0,0 +1,50 @@
+# for parsing Java .java files
+class JavaClass
+
+  attr_accessor :file_path
+
+  def initialize file_path
+    @file_path = file_path
+  end
+
+  def class_name
+    match = /public .*class (\w+)/.match(source_sans_comments)
+    if match
+      match.captures.first
+    else
+      match = /class (\w+)/.match(source_sans_comments)
+      match.captures.first if match
+    end
+  end
+  alias name class_name
+
+  def package_name
+    /package (.*);/.match(source_sans_comments).captures.first
+  end
+  alias package package_name
+
+  def super_class
+    match = /public .*class \w+ extends (\w+)/.match(source_sans_comments)
+    if match then match.captures.first else nil end
+  end
+  alias superclass super_class
+  alias parent super_class
+
+  def source_code
+    File.read file_path
+  end
+  alias source source_code
+
+  def source_code_without_comments
+    # regular expression to find all comments, from: http://ostermiller.org/findcomment.html
+    regular_expression = Regexp.new('(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|(//.*)')
+    source.gsub(regular_expression, '')
+  end
+  alias source_without_comments source_code_without_comments
+  alias source_sans_comments source_code_without_comments
+
+  def self.parse java_file
+    JavaClass.new java_file
+  end
+
+end

data/lib/simplegen.rb

@@ -0,0 +1,236 @@
+$:.unshift ::File.dirname(__FILE__)
+require 'fileutils'
+require 'rubygems'
+
+class SimpleGen
+  class << self
+
+    # paths to look for templates in
+    attr_accessor :template_directories
+    
+    # filtering engines for templates, eg. ERB
+    #
+    # these should be procs (or something callable)
+    #
+    # see SimpleGen::Filter
+    #
+    # this is a Hash, key = the filter name, which will be used for the file extension, eg. 'erb'
+    attr_accessor :filters
+
+    # as opposed to unix PATHs, the LAST template directory (with the same name) wins (if names conflict)
+    def templates
+      template_directories.inject([]) do |all_templates, template_dir|
+        dirs = Dir[::File.join(template_dir, '*')].select {|x| ::File.directory? x }
+        
+        # delete templates that new templates will be overriding
+        dirs.each do |dir|
+          template_to_override = all_templates.find {|t| t.name == ::File.basename(dir) }
+          all_templates.delete template_to_override if template_to_override
+        end
+
+        all_templates += dirs.map {|dir| SimpleGen::Template.new(dir) }
+        all_templates
+      end
+    end
+
+    def [] template_name
+      templates.find {|t| t.name == template_name.to_s }
+    end
+
+    def get_filter name
+      filter = nil
+      [ name.to_s, name.to_s.to_sym, name.to_s.sub(/^_/,''), name.to_s.sub(/^_/,'').to_sym ].each do |possible_key|
+        filter = SimpleGen.filters[possible_key] if SimpleGen.filters.keys.include?possible_key
+      end
+      filter
+    end
+
+    def filter_exists? name
+      get_filter(name) != nil
+    end
+  end
+end
+
+SimpleGen.filters              ||= {}
+SimpleGen.template_directories ||= []
+
+# move to simplegen/template.rb
+class SimpleGen::Template
+
+  attr_accessor :root
+
+  def initialize template_directory = '.'
+    @root = template_directory
+  end
+
+  def name
+    ::File.basename root
+  end
+
+  # THESE SHOULD BE private/protected
+  # handles support for %var% in file and directory names
+  def render_dynamic_path path, variables = { }
+    path.gsub(/%(\w+)%/){|match|
+      match_without_percentage_signs = match.gsub('%','') # can't seem to find a way to just get the (\w+)
+      replace_dynamic_path_variables(match_without_percentage_signs, variables)
+    }
+  end
+  def replace_dynamic_path_variables match, variables = { }
+    replace_with = variables[match.to_s]
+    if replace_with.nil? and not match.to_s.empty?
+      replace_with = variables[match.to_s.to_sym] # try using a symbol
+    end
+    replace_with.to_s
+  end
+
+  def generate! root_path_for_generation = '.', variables = { }
+    files.each do |file|
+      relative_file_path = file.path.sub(root, '') # relative to the template
+      relative_dirname   = ::File.dirname  relative_file_path
+      dir_to_render_in   = ::File.join root_path_for_generation, relative_dirname
+      file_to_render_in  = ::File.join dir_to_render_in, file.filename_to_generate
+
+      # support %var% in file and directory names
+      dir_to_render_in   = render_dynamic_path(dir_to_render_in,  variables)
+      file_to_render_in  = render_dynamic_path(file_to_render_in, variables)
+
+      # puts "relative_file_path => #{ relative_file_path }"
+      # puts "dir_to_render_in   => #{ dir_to_render_in }"
+      # puts "file_to_render_in  => #{ file_to_render_in }"
+
+      FileUtils.mkdir_p dir_to_render_in
+      ::File.open( file_to_render_in, 'w' ) {|f| f << file.render(variables) }
+    end
+
+    # make any directories that haven't been created (empty directories)
+    directories.each do |dir|
+      relative_dir_path = ::File.join root_path_for_generation, dir.sub(root, '')
+      FileUtils.mkdir_p relative_dir_path unless ::File.directory? relative_dir_path
+    end
+  end
+
+  # returns an Array of files (SimpleGen::Template::File)
+  # for this SimpleGen::Template
+  def files
+    files_and_directories.select {|x| ::File.file? x }.map {|f| SimpleGen::Template::File.new f }
+  end
+
+  protected
+
+  # returns an Array of all of the files and directories
+  # in this SimpleGen::Template's #root directory
+  #
+  # currently ignores hidden files and folders
+  #
+  def files_and_directories
+    Dir[ ::File.join(root, '**', '*') ]
+  end
+
+  def directories
+    files_and_directories.select {|x| ::File.directory? x }
+  end
+
+end
+
+# move to 'simplegen/template/file.rb'
+class SimpleGen::Template::File
+
+  attr_accessor :path
+
+  def initialize file_path
+    @path = file_path
+  end
+
+  def filename
+    basename
+  end
+
+  def basename
+    ::File.basename path
+  end
+
+  def extensions
+    _extensions = basename.split('.')
+    _filename_without_extension = _extensions.shift
+    _extensions
+  end
+
+  def filename_without_extension
+    _extensions = basename.split('.')
+    _filename_without_extension = _extensions.shift
+    _filename_without_extension
+  end
+
+  def filter_extensions
+    extensions.select {|x| SimpleGen.filter_exists?(x) }
+  end
+
+  def nonfilter_extensions
+    extensions - filter_extensions
+  end
+
+  def filename_to_generate
+    (nonfilter_extensions.empty?) ? 
+      filename_without_extension  : 
+      (filename_without_extension + '.' + nonfilter_extensions.join('.'))
+  end
+
+  def filters
+    filter_extensions.map {|x| SimpleGen.get_filter x }
+  end
+
+  def source
+    File.read path
+  end
+
+  def render variables = { }
+    _current_simplegen_template_file_output = source
+    
+    # put variables into binding, as instance variables (so they don't raise exceptions with missing)
+    b = lambda {
+      variables.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+      binding
+    }
+
+    filters.each do |filter|
+      _current_simplegen_template_file_output = filter.call(_current_simplegen_template_file_output, b.call)
+    end
+
+    _current_simplegen_template_file_output
+  end
+
+end
+
+# move to 'simplegen/filter.rb'
+#
+# note, a filter doesn't have to be a SimpleGen::Filter, it can be 
+# a Proc, it just needs to respond to #call
+class SimpleGen::Filter
+
+  attr_accessor :proc
+
+  def initialize &block
+    @proc = block
+  end
+
+  def call text, binding = TOPLEVEL_BINDING
+    @proc.call text, binding
+  end
+
+  # include an ERB filter, out of the box, as it comes with the ruby standard library
+  def self.erb_filter
+    # at the moment, there's no reason why this isn't just a simple proc
+    # ... we might do something fancy with SimpleGen::Filter at some point ...
+    # really, though, things should just be simple procs for now
+    SimpleGen::Filter.new do |text, binding|
+      require 'erb'
+      ERB.new(text).result(binding)
+    end
+  end
+
+end
+
+# add ERB filter by default, if not defined
+SimpleGen.filters[:erb] = SimpleGen::Filter.erb_filter unless SimpleGen.filters.keys.include?(:erb)

data/spec/andrake/basic_ui_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'Basic UI' do
+
+  Dir[ File.join(example_dir, 'different_states_of_andrakeness', '*') ].each do |version_of_basicui|
+    it "#{File.basename(version_of_basicui)} should build OK" do
+      puts "Trying to build #{version_of_basicui}"
+      Andrake::Application.new(version_of_basicui).should build_ok
+    end
+  end
+  
+end

data/spec/andrake/hello_android_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Andrake, 'HelloAndroid' do
+  
+  before do
+    @app = Andrake::Application.new andrake_example(:HelloAndroid)
+    @app.delete_android_app if @app.android_app
+  end
+
+  it 'should have a name' do
+    @app.name.should == 'HelloAndroid'
+  end
+
+  it 'should have 1 Java class' do
+    @app.classes.length.should == 1
+  end
+
+  it 'should have the name/package of the Java class' do
+    @app.classes.first.name.should == 'HelloAndroid'
+    @app.classes.first.package.should == 'com.andrake_testing.helloandroid'
+  end
+
+  it 'should have 1 layout' do
+    @app.layouts.length.should == 1
+    @app.layouts.first.should be_a_kind_of(Android::Layout)
+    @app.layouts.first.file_name.should == 'main.xml'
+  end
+
+  it 'should build a Android::Application' do
+    @app.android_app.should be_nil
+    @app.build.should == true # .build now returns a bool for whether the build was successful
+    @app.android_app.should_not be_nil
+    @app.android_app.apk_file.should_not be_nil
+  end
+
+end