rapid-core 0.1

data/features/templates/static.feature

@@ -0,0 +1,37 @@
+Feature: push and pull a static template
+  
+  Background:
+    Given a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+    end
+    """
+    And a template "static.erb":
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+  
+  Scenario: Push and Pull Template
+    When I push the skeleton through "static.erb" with:
+    """
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "foo"
+      end
+      
+    end
+    """
+    And vice versa
+  

data/features/templates/variables.feature

@@ -0,0 +1,61 @@
+Feature: template with a variable
+  
+  Background:
+    Given a skeleton with settings "my_settings.rb":
+    """
+    class MySettings
+      include Rapid::Settings
+      
+      setting.string  :name, :default => "Dan"
+      setting.integer  :id, :default => 5
+      setting.string  'foo.bar', :default => 'hey'
+      setting.integer 'foo.baz', :default => 20
+      
+    end
+    """
+    And a template "variables.erb":
+    """
+    class <%= name %> < ActiveRecord::Base
+      
+      def inspect
+        "<%= id %> <%= foo.bar %> <%= foo.baz %>"
+      end
+      
+    end
+    """
+  
+  @wip
+  Scenario: Push/Pull Template
+    When I push the skeleton through "variables.erb" with:
+    """
+    name: Foo
+    foo.baz: 10
+    foo.bar: hi
+    id: 5
+    """
+    Then I should get:
+    """
+    class Foo < ActiveRecord::Base
+      
+      def inspect
+        "5 hi 10"
+      end
+      
+    end
+    """
+    And vice versa
+  
+  Scenario: obey defaults
+    When I push the skeleton through "variables.erb" with:
+    """
+    """
+    Then I should get:
+    """
+    class Dan < ActiveRecord::Base
+      
+      def inspect
+        "5 hey 20"
+      end
+      
+    end
+    """

data/lib/rapid/check.rb

@@ -0,0 +1,162 @@
+module Rapid
+  
+  class Check
+    
+    attr_reader :code, :ok_count, :warning_count, :error_count
+    
+    def initialize code, options = {}
+      @code = code
+      @console_output = options[:console]
+      @ok_count = 0
+      @warning_count = 0
+      @error_count = 0
+      @sections = []
+    end
+    
+    def check_count
+      ok_count + warning_count + error_count
+    end
+    
+    def valid?
+      @valid = true
+      @ok_count = 0
+      @warning_count = 0
+      @error_count = 0
+      
+      as_current { eval code }
+      @valid
+    end
+    
+    def ok filename, message
+      @ok_count += 1
+      log :ok, filename, message
+    end
+    
+    def warning filename, message
+      @warning_count += 1
+      log :warning, filename, message
+    end
+    
+    def error filename, message
+      @error_count += 1
+      @valid = false
+      log :error, "", ""
+      log :error, filename, message
+      log :error, "", ""
+    end
+    
+    def exception filename, e
+      @error_count += 1
+      @valid = false
+      
+      log :error, "", ""
+      log :error, filename, ""
+      log :error, "", ""
+      log :error, "  problem: ", "content doesn't match"
+      log :error, "  after:   ", pretty_code(e.previous_content, "START OF FILE")
+      log :error, "  expected:", pretty_code(e.expected_content, "END OF FILE")
+      log :error, "  received:", pretty_code(e.content, "END OF FILE")
+      log :error, "  current: ", clean_hash(e.result)
+      log :error, "", ""
+    end
+    
+    def with_section name
+      puts "" if @sections.empty?
+      
+      indention = "  " * @sections.length
+      puts "#{indention}#{name}"
+      
+      @sections.push name
+      yield
+    ensure
+      @sections.pop
+    end
+    
+    protected
+    
+    def clean_hash hash
+      h = {}
+      
+      hash.each do |key, value|
+        if String === value && value.length > 50
+          value = value[0..25] + "..." + value[-25..25]
+        end
+        
+        h[key] = value
+      end
+      
+      h.inspect
+    end
+    
+    def pretty_code code, blank_replace
+      if code.blank?
+        blank_replace
+      else
+        code[0..100].inspect
+      end
+    end
+    
+    def log type, filename, message
+      return unless @console_output
+      
+      indention = "  " * @sections.length
+      
+      output = "#{indention}#{filename} #{message}"
+      Rapid.color_puts type, output
+    end
+    
+    def as_current
+      self.class.current = self
+      yield
+      
+    ensure
+      self.class.current = nil
+    end
+    
+    class << self
+      attr_accessor :current, :file
+      
+      def possible_files
+        [
+          '.rapid',
+          'rapid.rb',
+          File.join('config', 'rapid.rb')
+        ]
+      end
+      
+      def new_with_detection *args
+        filename = file
+        
+        if filename.nil?
+          possible_files.each do |name|
+            if File.exists?(name) && !File.directory?(name)
+              filename ||= name
+            end
+          end
+        end
+        
+        unless filename
+          raise FileNotFoundCheckError.new("could not locate your rapid.rb check file [#{Rapid::Check.possible_files.join(', ')}]. " +
+                  "Please create it or set the location using Rapid::Check.file = '/config/checks.rb'.")
+        end
+        
+        code = File.open(filename) {|f| f.read }
+        new code, *args
+      end
+      
+      def encounters_error?
+        if current.nil?
+          yield
+          false
+        else
+          old_count = current.error_count
+          yield
+          old_count != current.error_count
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rapid/core.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+require 'erubis'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_model'
+
+require "rapid/version"
+require "rapid/error"
+require "rapid/module"
+
+require "rapid/settings"
+require "rapid/check"
+
+require "rapid/skeleton/helpers/directory"
+require "rapid/skeleton/helpers/gem"
+require "rapid/skeleton/helpers/migration"
+require "rapid/skeleton/helpers/route"
+require "rapid/skeleton/helpers/script"
+require "rapid/skeleton/helpers/template"
+require "rapid/skeleton/helpers/view"
+require "rapid/skeleton/base"
+
+require "rapid/template/base"
+require "rapid/template/parser"
+
+require "rapid/template/pulling/base"
+require "rapid/template/pulling/explicit"
+require "rapid/template/pulling/forgiving"
+
+require "rapid/template/node/base"
+require "rapid/template/node/root"
+require "rapid/template/node/static"
+require "rapid/template/node/variable"
+require "rapid/template/node/if_node"
+require "rapid/template/node/comment_node"
+
+require 'rapid/railtie' if defined? Rails

data/lib/rapid/error.rb

@@ -0,0 +1,84 @@
+module Rapid
+  
+  class Exception < ::Exception ; end
+  
+  class SettingError < Exception ; end
+  class SettingLoadError < Exception ; end
+  class InvalidYamlError < SettingLoadError ; end
+  
+  class UnknownSettingError < SettingLoadError
+    attr_reader :setting_name
+    
+    def initialize full_setting_name
+      @setting_name = full_setting_name
+      super "Can't find #{full_setting_name.inspect} setting"
+    end
+    
+    def validation_message
+      "can't be found"
+    end
+    
+  end
+  
+  class InvalidSettingError < SettingLoadError
+    attr_reader :setting, :value
+    
+    def initialize setting, value
+      @setting = setting
+      @value = value
+      super "Can't assign #{value.inspect} to #{setting.full_name}"
+    end
+    
+    def validation_message
+      "doesn't allow values of that type"
+    end
+    
+  end
+  
+  class SkeletonError < Exception ; end
+  class InvalidSkeletonError < SkeletonError ; end
+  
+  class TemplateError < Exception ; end
+  class InvalidTemplateError < TemplateError ; end
+  class NotMatchingTemplateError < TemplateError ; end
+  class TemplateNotFoundError < TemplateError ; end
+  class UnknownMethodTemplateError < TemplateError ; end
+  
+  class NotMatchingTemplateError < TemplateError
+    
+    attr_reader :result, :expected_content, :content, :previous_content
+    
+    def initialize result, expected_content, content, options = {}
+      @result, @expected_content, @content = result, expected_content, content
+      @previous_content = options[:previous]
+    end
+    
+    def message
+      messages = [
+        "after:    #{previous_content.nil? ? "nil" : previous_content[0..100].inspect}",
+        "expected: #{expected_content[0..100].inspect}",
+        "received: #{content[0..100].inspect}",
+        "current:  #{result.inspect}"
+      ]
+      
+      messages.join("\n")
+    end
+    
+  end
+  
+  class TemplateRenderError < TemplateError
+    
+    attr_reader :template_path, :original_exception
+    
+    def initialize template_path, e
+      super "Error rendering #{template_path}: #{e.message}"
+      @template_path = template_path
+      @original_exception = e
+    end
+    
+  end
+  
+  class CheckError < Exception ; end
+  class FileNotFoundCheckError < CheckError ; end
+  
+end

data/lib/rapid/module.rb

@@ -0,0 +1,35 @@
+module Rapid
+  
+  class << self
+    
+    attr_accessor :view_path
+    
+    # from rspec
+    
+    def colorize(text, color_code)
+      "#{color_code}#{text}\e[0m"
+    end
+    
+    def red(text); colorize(text, "\e[31m"); end
+    def green(text); colorize(text, "\e[32m"); end
+    def yellow(text); colorize(text, "\e[33m"); end
+    
+    def color_puts type, message
+      case type
+      when :ok
+        puts green(message)
+        
+      when :warning
+        puts yellow(message)
+        
+      when :error
+        puts red(message)
+        
+      else
+        raise "Invalid type: #{type.inspect}"
+      end
+    end
+    
+  end
+  
+end

data/lib/rapid/railtie.rb

@@ -0,0 +1,18 @@
+module Rapid
+  
+  class Railtie < Rails::Railtie
+    
+    rake_tasks do
+      load "rapid/tasks.rb"
+    end
+    
+    initializer "rapid.view_paths" do
+      Rapid.view_path ||= File.join 'lib', 'rapid', 'views'
+      
+      ActionController::Base.append_view_path Rapid.view_path
+      ActionMailer::Base.append_view_path Rapid.view_path
+    end
+    
+  end
+  
+end

data/lib/rapid/setting/base.rb

@@ -0,0 +1,35 @@
+module Rapid
+  module Setting
+    
+    class Base
+      
+      attr_reader :namespace, :full_name, :name, :default_value
+      
+      def initialize name, options = {}
+        @name = name.to_sym
+        @namespace = options[:namespace]
+        @default_value = options[:default]
+        @full_name = @namespace ? "#{@namespace.full_name}.#{name}" : name.to_s
+        
+        if Rapid::Settings.reserved_name? @name
+          raise ArgumentError.new("#{@name} is a reserved setting name")
+        end
+      end
+      
+      def load value
+        raise "Subclass should override this method"
+      end
+      
+      def get_helper_name
+        name
+      end
+      
+      def set_helper_name
+        "#{name}="
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rapid/setting/boolean_setting.rb

@@ -0,0 +1,17 @@
+module Rapid
+  module Setting
+    
+    class BooleanSetting < Base
+      
+      def load value
+        if [0, "0", false, "false"].include?(value)
+          false
+        elsif [1, "1", true, "true"].include?(value)
+          true
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/setting/class_hash.rb

@@ -0,0 +1,34 @@
+module Rapid
+  module Setting
+    
+    class ClassHash
+      
+      attr_reader :delegate
+      
+      delegate :[],      :to => :delegate
+      delegate :[]=,     :to => :delegate
+      delegate :empty?,  :to => :delegate
+      delegate :each,    :to => :delegate
+      delegate :keys,    :to => :delegate
+      delegate :values,  :to => :delegate
+      delegate :to_hash, :to => :delegate
+      
+      def initialize
+        @delegate = HashWithIndifferentAccess.new
+      end
+      
+      def namespaces
+        values = self.values.delete_if {|v| not v.is_a? Namespace::Base }
+        values
+      end
+      
+      def scalars
+        values = self.values.delete_if {|v| v.is_a? Namespace::Base }
+        values
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rapid/setting/comments.rb

@@ -0,0 +1,25 @@
+module Rapid
+  module Setting
+    
+    module Comments
+      
+      def comment_unless boolean
+        if boolean
+          nil
+        else
+          "# "
+        end
+      end
+      
+      def comment_if boolean
+        if boolean
+          "# "
+        else
+          nil
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/setting/definer.rb

@@ -0,0 +1,151 @@
+module Rapid
+  module Setting
+    
+    class Definer
+      
+      def initialize klass, options = {}
+        @klass = klass
+        @delimiter = '.'
+      end
+      
+      def boolean full_name, options = {}
+        namespace, name = find_namespace_and_name full_name
+        setting = BooleanSetting.new name, options.merge(:namespace => namespace)
+        define_setting setting
+      end
+      
+      def string full_name, options = {}
+        namespace, name = find_namespace_and_name full_name
+        setting = StringSetting.new name, options.merge(:namespace => namespace)
+        define_setting setting
+      end
+      
+      def integer full_name, options = {}
+        namespace, name = find_namespace_and_name full_name
+        setting = IntegerSetting.new name, options.merge(:namespace => namespace)
+        define_setting setting
+      end
+      
+      def namespace full_name, options = {}
+        namespace, name = find_namespace_and_name full_name
+        setting = Namespace::Base.new name, options.merge(:namespace => namespace, :class => @klass)
+        define_setting setting
+      end
+      
+      def code full_name, options = {}
+        namespace, name = find_namespace_and_name full_name
+        setting = StringSetting.new name, options.merge(:namespace => namespace)
+        define_setting setting
+      end
+      
+      def class_eval namespace_name, &block
+        names = namespace_name.to_s.split('.')
+        namespace = find_namespace *names
+        raise ArgumentError.new("namespace not found: #{namespace_name.inspect}") unless namespace
+        raise ArgumentError.new("namespace does not have a custom class") unless namespace.instance_class
+        namespace.instance_class.class_eval &block
+      end
+      
+      def find_namespace *names
+        namespace = nil
+        names.each_with_index do |name, index|
+          if index == 0
+            namespace = @klass.settings[name]
+          else
+            namespace = namespace[name]
+          end
+        end
+        namespace
+      end
+      
+      def inspect
+        %(#<Rapid::Setting::Definer>)
+      end
+      
+      protected
+      
+      def find_or_create_namespace *names
+        namespace = nil
+        
+        names.each_with_index do |name, index|
+          if index == 0
+            new_namespace = @klass.settings[name]
+          else
+            new_namespace = namespace[name]
+          end
+          
+          if new_namespace.nil?
+            new_namespace = Namespace::Base.new name, :namespace => namespace, :class => @klass
+            define_setting new_namespace
+          end
+          
+          namespace = new_namespace
+        end
+        
+        namespace
+      end
+      
+      def find_namespace_and_name full_name
+        names = full_name.to_s.split(@delimiter)
+        setting_name = names.pop.to_sym
+        
+        namespace = find_or_create_namespace *names
+        return namespace, setting_name
+      end
+      
+      def define_setting setting
+        if setting.namespace.nil?
+          define_base_setting setting
+        else
+          setting.namespace.define_setting setting
+        end
+        
+        setting
+      end
+      
+      def define_base_setting setting
+        define_methods setting
+        push_setting setting
+      end
+      
+      def define_methods setting
+        name = setting.name
+        getter = setting.get_helper_name
+        setter = setting.set_helper_name
+        
+        @klass.class_eval do
+          define_method getter do
+            settings[name]
+          end
+          
+          define_method setter do |value|
+            settings[name] = value
+          end
+          
+          if setting.is_a? BooleanSetting
+            define_method "#{getter}?" do
+              settings[name] == true
+            end
+          elsif setting.is_a? Namespace::Base
+            define_method "#{getter}?" do
+              settings[name] != nil && !settings[name].empty?
+            end
+          else
+            define_method "#{getter}?" do
+              settings[name] != nil
+            end
+          end
+        end
+        
+        true
+      end
+      
+      def push_setting setting
+        @klass.settings[setting.name] = setting
+      end
+      
+    end
+    
+  end
+  
+end