reactive-dev 0.2.0

data/app_generators/reactive/templates/Rakefile

@@ -0,0 +1,16 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# and they will automatically be available to Rake.
+
+APP_PATH = File.dirname(__FILE__)
+APP_NAME = APP_PATH.split('/').last
+
+require ["#{File.dirname(__FILE__)}/config/boot.rb", "#{File.dirname(__FILE__)}/boot.rb"].find {|path| File.file? path}
+Reactive.load(['--root', APP_PATH])
+Reactive::Initializer.stages.delete(:check_plugins)
+Reactive.init(:configure)
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'reactive-core/tasks/reactive'

data/app_generators/reactive/templates/config/boot.rb

@@ -0,0 +1,118 @@
+module Reactive
+  class << self
+    def load(argv = ARGV)
+      return @bootstrapper if @bootstrapper
+      options = {}
+      options[:root_dir] = if index = argv.rindex(argv.find {|arg| arg == '--root' })
+        argv[index+1]
+      end
+      options[:config_file] = if index = argv.rindex(argv.find {|arg| arg == '--config-file' })
+        argv[index+1]
+      end
+      @argv = argv
+      @bootstrapper ||= Bootstrapper.new(options)
+    end
+  
+    def loaded?
+      @bootstrapper
+    end
+  
+    def init(stage = :final, argv = @argv || ARGV)
+      load(argv)
+      Reactive::Initializer.run(stage, Configuration.new(argv))
+    end
+    
+    def run(argv = @argv || ARGV)
+      init(:final, argv)
+      Dispatcher::Base.dispatch(Reactive.configuration.initial_request.is_a?(Hash) ? Request.new(Reactive.configuration.initial_request) : Reactive.configuration.initial_request)
+    end
+  end
+
+  class Bootstrapper
+    def initialize(options)
+      @config_file = options[:config_file]
+      @root_dir = File.expand_path(options[:root_dir]) if options[:root_dir]
+      load_rubygems
+      
+      # add apps gem directory to load path
+      if @root_dir
+        Gem.clear_paths
+        Gem.path.unshift("#{@root_dir}/gems")
+      end
+      
+      load_reactive_gem
+      require 'reactive-core/initializer'
+    end
+
+    def load_reactive_gem
+      # load activesupport first
+      begin
+        if version = activesupport_gem_version
+          gem 'activesupport', version
+        end
+      rescue Gem::LoadError => load_error
+        $stderr.puts "Missing the activesupport #{version} gem. Either install the required version or choose an appropriate value for the ACTIVESUPPORT_GEM_VERSION setting in config/config.rb"
+        exit 1
+      end
+    
+      if version = reactive_gem_version
+        gem 'reactive-core', version
+      else
+        gem 'reactive-core'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts "Missing the reactive-core #{version} gem. Please `gem install -v=#{version} reactive-core`, update your REACTIVE_GEM_VERSION setting in config/config.rb for the Reactive version you do have installed, or comment out REACTIVE_GEM_VERSION to use the latest version installed."
+      exit 1
+    end
+
+    def rubygems_version
+      Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion
+    end
+
+    def reactive_gem_version
+      if defined? REACTIVE_GEM_VERSION
+        REACTIVE_GEM_VERSION
+      elsif ENV.include?('REACTIVE_GEM_VERSION')
+        ENV['REACTIVE_GEM_VERSION']
+      else
+        parse_gem_version('reactive', read_config_rb)
+      end
+    end
+  
+    def activesupport_gem_version
+      parse_gem_version('activesupport', read_config_rb)
+    end
+
+    def load_rubygems
+      require 'rubygems'
+
+      unless rubygems_version >= '1.1.0'
+        $stderr.puts "Reactive requires RubyGems >= 1.1.0 (you have #{rubygems_version}). Please `gem update --system` and try again."
+        exit 1
+      end
+
+    rescue LoadError
+      $stderr.puts "Reactive requires RubyGems >= 1.1.0. Please install RubyGems and try again: http://rubygems.rubyforge.org"
+      exit 1
+    end
+
+    def parse_gem_version(gem_name, text)
+      $1 if text =~ Regexp.new(%Q{^[^#]*#{gem_name.upcase}_GEM_VERSION\\s*=\\s*["']([!~<>=]*\\s*[\\d.]+)["']})
+    end
+
+    private
+      def read_config_rb
+        return if @config_rb
+        files = [
+          @config_file,
+          @root_dir ? "#{@root_dir}/config/config.rb" : nil,
+          @root_dir ? "#{@root_dir}/config.rb" : nil,
+          "config.rb"
+        ].compact.select {|name| File.file? name}
+        
+        raise StandardError, "No config file found, you may specify it with --config-file" if files.empty?
+        @config_rb = File.read(files.first)
+      end
+  end
+
+end

data/app_generators/reactive/templates/config/config.rb

@@ -0,0 +1,29 @@
+# You may specify the activesupport gem version that will be used.
+# It is provided to resolve dependency issues. Note that the minimum version is 2.0.0
+# ACTIVESUPPORT_GEM_VERSION = "= 2.0.2"
+
+# You may also specifiy the Reactive gem version to use
+# REACTIVE_GEM_VERSION = ">= 0.2.0"
+
+with Reactive.configuration do |config|
+  # Don't forget to specify the default dispatcher which is one of your plugins, ex:
+  #   config.dispatcher.default_dispatcher = :mvc
+  # You also have to configure an inital request like so:
+  #   config.initial_request = {:controller => 'application', :action => 'initial', :format => :wx}
+
+  # put the .gem statements in the order you want them loaded.
+  # You may add a version requirement for each of the gems, like:
+  #   config.gem 'reactive-mvc', '>=0.2.0'
+  <% for plugin in plugins -%>
+  config.gem '<%= plugin %>'<% end %>
+
+  config.app_gem_spec do |s|
+    s.name         = "<%= app_name %>"
+    s.version      = "1.0.0"
+    s.author       = "Your name"
+    s.email        = "you@there.com"
+    s.homepage     = "http://there.com"
+    s.summary      = "My great application"
+    s.description  = "Visit our website for further information"
+  end
+end

data/app_generators/reactive/templates/script/console

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+boot_location = [
+  ["#{File.dirname(__FILE__)}/../config/boot.rb", ".."],
+  ["#{File.dirname(__FILE__)}/boot.rb", "."]
+].find{|path, root| File.file? path}
+
+require boot_location.first
+Reactive.load(['--root', File.join(File.dirname(__FILE__), boot_location.last)])
+
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+
+options = { :sandbox => false, :irb => irb }
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion"
+libs << %( -r "#{boot_location.first}")
+libs << %( -r "#{Gem.loaded_specs['reactive-core'].full_gem_path}/lib/reactive-core/console_app")
+
+if options[:debugger]
+  begin
+    require 'ruby-debug'
+    libs << " -r ruby-debug"
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end
+
+ENV['REACTIVE_ENV'] = case ARGV.first
+  when "p"; "production"
+  when "d"; "development"
+  when "t"; "test"
+  else
+    ARGV.first || ENV['REACTIVE_ENV'] || 'development'
+end
+
+puts "Loading #{ENV['REACTIVE_ENV']} environment (Reactive #{Reactive::VERSION::STRING})"
+exec "#{options[:irb]} #{libs} --simple-prompt"

data/app_generators/reactive/templates/script/destroy

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+boot_location = [
+  ["#{File.dirname(__FILE__)}/../config/boot.rb", ".."],
+  ["#{File.dirname(__FILE__)}/boot.rb", "."]
+].find{|path, root| File.file? path}
+
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), boot_location.last))
+require boot_location.first
+
+Reactive.init(:configure, ARGV + ['--root', APP_ROOT])
+
+require 'rubigen'
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_plugin_sources! [:reactive, :reactive_app, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/app_generators/reactive/templates/script/generate

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+boot_location = [
+  ["#{File.dirname(__FILE__)}/../config/boot.rb", ".."],
+  ["#{File.dirname(__FILE__)}/boot.rb", "."]
+].find{|path, root| File.file? path}
+
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), boot_location.last))
+require boot_location.first
+
+Reactive.init(:configure, ARGV + ['--root', APP_ROOT])
+
+require 'rubigen'
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_plugin_sources! [:reactive, :reactive_app, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/app_generators/reactive/templates/script/run

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+boot_location = [
+  ["#{File.dirname(__FILE__)}/../config/boot.rb", ".."],
+  ["#{File.dirname(__FILE__)}/boot.rb", "."]
+].find{|path, root| File.file? path}
+
+require boot_location.first
+Reactive.run(ARGV + ['--root', File.join(File.dirname(__FILE__), boot_location.last)])

data/app_generators/reactive/templates/script/win_script.cmd

@@ -0,0 +1 @@
+@ruby <%= File.join("script", filename) %> %*

data/bin/reactive

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'reactive-core/version'
+if %w(--version -v).include? ARGV.first
+  puts "Reactive #{Reactive::VERSION::STRING}"
+  exit(0)
+end
+
+require 'reactive-dev'
+require 'rubigen'
+require 'rubigen/scripts/generate'
+RubiGen::Base.reset_sources
+RubiGen::Base.append_sources(RubiGen::PathSource.new(:application, File.join(File.dirname(__FILE__), "../app_generators")))
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'reactive')

data/lib/reactive-dev.rb

@@ -0,0 +1,3 @@
+require 'rubigen'
+require 'reactive-dev/rubigen_plugin_sources'
+require 'reactive-dev/named_base_generator'

data/lib/reactive-dev/code_statistics.rb

@@ -0,0 +1,107 @@
+class CodeStatistics #:nodoc:
+
+  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
+
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if TEST_TYPES.include? name
+        "| #{name.ljust(20)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/reactive-dev/generated_attribute.rb

@@ -0,0 +1,40 @@
+require 'optparse'
+
+module Reactive
+    class GeneratedAttribute # :nodoc:
+      attr_accessor :name, :type, :column
+
+      def initialize(name, type)
+        @name, @type = name, type.to_sym
+        @column = ActiveRecord::ConnectionAdapters::Column.new(name, nil, @type)
+      end
+
+      def field_type
+        @field_type ||= case type
+          when :integer, :float, :decimal   then :text_field
+          when :datetime, :timestamp, :time then :datetime_select
+          when :date                        then :date_select
+          when :string                      then :text_field
+          when :text                        then :text_area
+          when :boolean                     then :check_box
+          else
+            :text_field
+        end      
+      end
+
+      def default
+        @default ||= case type
+          when :integer                     then 1
+          when :float                       then 1.5
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then Time.now.to_s(:db)
+          when :date                        then Date.today.to_s(:db)
+          when :string                      then "MyString"
+          when :text                        then "MyText"
+          when :boolean                     then false
+          else
+            ""
+        end      
+      end
+    end
+end

data/lib/reactive-dev/named_base_generator.rb

@@ -0,0 +1,79 @@
+module Reactive
+    # The base generator for named components: models, controllers, etc.
+    # The target name is taken as the first argument and inflected to
+    # several forms, see the attributes below..
+    #
+    # If no name is provided, the generator raises a usage error with content
+    # optionally read from the USAGE file in the generator's base path.
+    #
+    # For example, the +controller+ generator takes the first argument as 
+    # the name of the class and subsequent arguments as the names of
+    # actions to be generated:
+    #
+    #   ./script/generate controller Article index new create
+    #
+    class NamedBaseGenerator < RubiGen::Base
+      attr_reader   :name, :underscore_name, :singular_name, :plural_name, :class_name, :singular_class_name, :plural_class_name
+
+      # these are arrays containing parts (path parts and module parts respectively)
+      attr_reader   :path, :class_nesting
+      
+      # complete pathname
+      attr_reader   :pathname
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+        
+        # Name argument is required.
+        usage if runtime_args.empty?
+
+        @args = runtime_args.dup
+        assign_names!(@args.shift)
+        
+        self.class.use_plugin_sources! [:reactive, :test_unit]
+      end
+
+      protected
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
+        end
+
+      private
+        def assign_names!(name)
+          @name, @underscore_name = name, name.underscore
+          base_name, @path, @pathname, @class_nesting = extract_modules(@name)
+          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+            @singular_class_name = @class_name_without_nesting.singularize
+            @plural_class_name = @class_name_without_nesting.pluralize
+          else
+            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+            @singular_class_name = "#{@class_nesting}::#{@class_name_without_nesting.singularize}"
+            @plural_class_name = "#{@class_nesting}::#{@class_name_without_nesting.pluralize}"
+          end
+        end
+
+        # Extract modules from filesystem-style or ruby-style path:
+        #   good/fun/stuff
+        #   Good::Fun::Stuff
+        # produce the same results.
+        def extract_modules(name)
+          modules = name.include?('/') ? name.split('/') : name.split('::')
+          name    = modules.pop
+          path    = modules.map { |m| m.underscore }
+          file_path = (path + [name.underscore]).join('/')
+          nesting = modules.map { |m| m.camelize }.join('::')
+          [name, path, file_path, nesting]
+        end
+
+        def inflect_names(name)
+          camel  = name.camelize
+          singular  = camel.underscore.singularize
+          plural = singular.pluralize
+          [camel, singular, plural]
+        end
+    end
+
+end