rapid-core 0.1

data/lib/rapid/template/parser.rb

@@ -0,0 +1,167 @@
+module Rapid
+  module Template
+    
+    class Parser
+      
+      def initialize content
+        @content = content.clone
+        @is_first = true
+      end
+      
+      def parse
+        Engine.new(@content).root
+      end
+      
+      class Engine < Erubis::Basic::Engine
+        
+        def initialize *args
+          @nodes = []
+          @stack = [@nodes]
+          super *args
+        end
+        
+        def root
+          Template::Node::Root.new @nodes
+        end
+        
+        protected
+        
+        def add_preamble buf
+          
+        end
+        
+        def add_postamble buf
+          
+        end
+        
+        def add_text buf, text
+          push_node Node::Static.new(text) unless text.empty?
+        end
+        
+        def add_expr buf, e, indicator
+          case indicator
+          when "="
+            push_variable e.strip
+          else
+            raise UnknownMethodTemplateError.new("unknown method #{indicator} #{e}")
+          end
+        end
+        
+        def add_stmt buf, code
+          code.strip!
+          
+          if code == "end"
+            pop_node
+            
+          elsif code =~ /^if /
+            push_if $'
+            
+          elsif code =~ /^elsif /
+            push_elsif $'
+            
+            
+          elsif code =~ /^else/
+            push_else
+            
+          elsif code.empty?
+            # do nothing
+            
+          else
+            raise UnknownMethodTemplateError.new("unknown method #{code.inspect}")
+          end
+        end
+        
+        def push_node node
+          array = nil
+          
+          current = @stack.last
+          if current.is_a? Array
+            array = current
+            
+          elsif current.is_a? Hash
+            case current[:type]
+            when :if
+              
+              if current[:else] != nil
+                array = current[:else]
+              elsif current[:elsif].last
+                array = current[:elsif].last[:then]
+              else
+                array = current[:then]
+              end
+              
+            end
+          end
+          
+          if node.is_a?(Node::Static) && array.last.is_a?(Node::Static)
+            prev = array.pop
+            node = Node::Static.new(prev.content + node.content)
+          end
+          
+          array.push node
+        end
+        
+        def push_variable code
+          if code =~ /^comment_unless /
+            node = Node::CommentNode.new(false, $')
+          elsif code =~ /^comment_if /
+            node = Node::CommentNode.new(true, $')
+          else
+            node = Node::Variable.new(code)
+          end
+          
+          push_node node
+        end
+        
+        def pop_node
+          node = build_node @stack.pop
+          push_node node
+        end
+        
+        def build_node node
+          case node[:type]
+          when :if
+            build_if_node node
+          end
+        end
+        
+        def build_if_node node
+          else_node = node[:else]
+          
+          node[:elsif].reverse_each do |n|
+            else_node = Node::IfNode.new n[:statement], n[:then], else_node
+          end
+          
+          Node::IfNode.new node[:statement], node[:then], else_node
+        end
+        
+        def push_if statement
+          @stack.push :type => :if, :statement => statement, :then => [], :elsif => []
+        end
+        
+        def push_elsif statement
+          if_node = self.current_if
+          if_node[:elsif].push :statement => statement, :then => []
+        end
+        
+        def push_else
+          if_node = self.current_if
+          if_node[:else] ||= [] if if_node
+        end
+        
+        def current_if
+          if_node = nil
+          @stack.reverse_each do |d|
+            if d.is_a?(Hash) && d[:type] == :if
+              if_node ||= d
+            end
+          end
+          if_node
+        end
+        
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/template/pulling/base.rb

@@ -0,0 +1,91 @@
+module Rapid
+  module Template
+    module Pulling
+      
+      class Base
+        
+        attr_reader :result, :previous_content
+        
+        delegate :[],  :to => :result
+        delegate :[]=, :to => :result
+        
+        def initialize content
+          @result = {}
+          @previous_content = ""
+        end
+        
+        def key? key
+          @result.key? key
+        end
+        
+        def to_hash
+          remove_covered_namespaces!
+          @result
+        end
+        
+        def raise_not_matching content
+          raise Rapid::NotMatchingTemplateError.new(result, content, self.content, :previous => previous_content)
+        end
+        
+        def content
+          raise NotImplementedError.new
+        end
+        
+        def index content
+          raise NotImplementedError.new
+        end
+        
+        def starts_with? content
+          raise NotImplementedError.new
+        end
+        
+        def starts_with content
+          raise NotImplementedError.new
+        end
+        
+        def move! count
+          raise NotImplementedError.new
+        end
+        
+        def match content
+          raise NotImplementedError.new
+        end
+        
+        def match! content
+          raise NotImplementedError.new
+        end
+        
+        def empty!
+          raise NotImplementedError.new
+        end
+        
+        protected
+        
+        # remove results that cover other nested results:
+        # {"app.author"=>true, "app.author.name"=>"Dan"}
+        # would remove app.author
+        def remove_covered_namespaces!
+          # TODO clean up
+          
+          remove = []
+          @result.keys.each do |key|
+            is_covering = false
+            start = "#{key}."
+            
+            covered_keys = @result.keys.each do |k| 
+              is_covering = is_covering || k.starts_with?(start)
+            end
+            
+            remove.push key if is_covering
+          end
+          
+          remove.each do |key|
+            @result.delete key
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/template/pulling/explicit.rb

@@ -0,0 +1,92 @@
+module Rapid
+  module Template
+    module Pulling
+      
+      class Explicit < Base
+        
+        attr_reader :content, :previous_content
+        
+        def initialize content
+          super
+          @content = content.clone
+          @previous_content = ""
+        end
+        
+        def index content
+          @content.index content
+        end
+        
+        def starts_with? content
+          @content.starts_with? content
+        end
+        
+        def starts_with content
+          content.length if @content.starts_with? content
+        end
+        
+        def move! count
+          return 0 if count == 0
+          
+          matched = @content.slice!(0..count-1)
+          @previous_content << matched
+          @previous_content = @previous_content[@previous_content.length - 50..-1] if @previous_content.length > 50
+          count
+        end
+        
+        def match content
+          internal_match @content, content
+        end
+        
+        def match! content
+          result, a, b = match content
+          unless result
+            raise_not_matching content
+          end
+          
+          move! a
+        end
+        
+        def empty!
+          unless @content.nil? || @content.empty?
+            raise_not_matching ""
+          end
+        end
+        
+        def raise_not_matching content
+          failure, a_count, b_count = internal_match_miss @content, content
+          
+          if a_count > 0
+            move! a_count
+          end
+          
+          if b_count > 0
+            content = content[b_count..-1]
+          end
+          
+          raise Rapid::NotMatchingTemplateError.new(result, content, @content, :previous => @previous_content)
+        end
+        
+        protected
+        
+        def internal_match a, b
+          if a.starts_with? b
+            return true, b.length, b.length
+          else
+            internal_match_miss a, b
+          end
+        end
+        
+        def internal_match_miss a, b
+          count = 0
+          while a.length > count && b.length > count && a[count] == b[count]
+            count += 1
+          end
+          
+          return false, count, count
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/template/pulling/forgiving.rb

@@ -0,0 +1,58 @@
+module Rapid
+  module Template
+    module Pulling
+      
+      class Forgiving < Explicit
+        
+        def match content
+          result, a, b = super content
+          return result, a, b if result
+          
+          if @content =~ starts_with_newline_regex
+            len = $1.length
+            result, a, b = internal_match $', content
+            a += len
+            return result, a, b
+            
+          elsif content =~ starts_with_newline_regex
+            len = $1.length
+            result, a, b = internal_match @content, $'
+            b += len
+            return result, a, b
+            
+          else
+            return result, a, b
+          end
+        end
+        
+        protected
+        
+        def starts_with_newline_regex
+          /\A([\ ]*[\n]+)/
+        end
+        
+        def internal_match_miss a, b
+          a_count = 0
+          b_count = 0
+          
+          if a =~ starts_with_newline_regex
+            a_count += $1.length
+          end
+          
+          if b =~ starts_with_newline_regex
+            b_count += $1.length
+          end
+          
+          while a.length > a_count && b.length > b_count && a[a_count] == b[b_count]
+            a_count += 1
+            b_count += 1
+          end
+          
+          return false, a_count, b_count
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/version.rb

@@ -0,0 +1,3 @@
+module Rapid
+  VERSION = "0.1"
+end

data/lib/rapid.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/rapid-core.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rapid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rapid-core"
+  s.version     = Rapid::VERSION
+  s.authors     = ["Dan Cunning"]
+  s.email       = ["dancunning@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Code that understands code and can change it programmatically}
+  s.description = %q{Code that understands code and can change it programmatically}
+
+  s.rubyforge_project = "rapid-core"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_dependency("activesupport", ">= 3.0")
+  s.add_dependency("activemodel", ">= 3.0")
+  s.add_dependency("i18n")
+  s.add_dependency("erubis")
+end

data/spec/rapid/check_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rapid::Check do
+  
+  after do
+    Rapid::Check.instance_variable_set :@current, nil
+  end
+  
+  describe "new_with_detection" do
+    
+    after do
+      FileUtils.rm_rf('rapid.rb')
+      FileUtils.rm_rf('foo.rb')
+      Rapid::Check.file = nil
+    end
+    
+    it "should raise an error when nothing is setup" do
+      lambda { Rapid::Check.new_with_detection }.should raise_error(Rapid::FileNotFoundCheckError)
+    end
+    
+    it "should be Rapid::Check.file if it's set" do
+      File.open('foo.rb', 'w') {|f| f.write('hi') }
+      Rapid::Check.file = 'foo.rb'
+      Rapid::Check.new_with_detection.code.should == 'hi'
+    end
+    
+    it "should be one of the custom files if it exists" do
+      File.open('rapid.rb', 'w') {|f| f.write('hi') }
+      Rapid::Check.new_with_detection.code.should == 'hi'
+    end
+    
+  end
+  
+  describe "valid?" do
+    
+    after do
+      FileUtils.rm_rf('rapid.rb')
+    end
+    
+    it "should allow the code to add errors" do
+      @check = Rapid::Check.new "Rapid::Check.current.error 'config.rb', 'is missing'"
+      @check.valid?.should == false
+    end
+    
+    it "should not let Rapid::Check.current linger" do
+      @check = Rapid::Check.new ""
+      @check.valid?.should == true
+      Rapid::Check.current.should == nil
+    end
+    
+    it "should not catch problems in the code" do
+      @check = Rapid::Check.new "foo"
+      lambda { @check.valid? }.should raise_error(NameError)
+    end
+    
+    it "should output to the console if asked" do
+      @check = Rapid::Check.new %(
+        Rapid::Check.current.ok    'config.rb', 'is great!'
+        Rapid::Check.current.warning  'config.rb', 'is missing'
+        Rapid::Check.current.error 'config.rb', 'is broken!'
+      ), :console => true
+      
+      Rapid.should_receive(:color_puts).exactly(5).times
+      @check.valid?.should == false
+      @check.check_count.should == 3
+    end
+    
+    it "should accept exceptions" do
+      Rapid.should_receive(:color_puts).exactly(9).times
+      
+      @exception = Rapid::NotMatchingTemplateError.new({"foo" => "bar" * 40, 4 => "foo"}, "", "bar")
+      @check = Rapid::Check.new "", :console => true
+      @check.exception "my.rb", @exception
+    end
+    
+    it "should output with indention" do
+      @check = Rapid::Check.new %(
+        Rapid::Check.current.with_section("app") do
+          Rapid::Check.current.ok 'config.rb', 'is great!'
+        end
+      ), :console => true
+      
+      @check.should_receive(:puts).with("")
+      @check.should_receive(:puts).with("app")
+      Rapid.should_receive(:color_puts).with(:ok, "  config.rb is great!")
+      @check.valid?.should == true
+    end
+    
+    it "should track the amount of calls" do
+      @check = Rapid::Check.new %(
+        Rapid::Check.current.ok    'config.rb', 'is great!'
+        Rapid::Check.current.ok    'config.rb', 'is great!'
+        Rapid::Check.current.ok    'config.rb', 'is great!'
+        
+        Rapid::Check.current.warning  'config.rb', 'is missing'
+        Rapid::Check.current.warning  'config.rb', 'is missing'
+        
+        Rapid::Check.current.error 'config.rb', 'is broken!'
+      )
+      
+      @check.valid?.should == false
+      @check.ok_count.should == 3
+      @check.warning_count.should == 2
+      @check.error_count.should == 1
+    end
+    
+  end
+  
+  it "should tell whether encounters an error" do
+    @check = Rapid::Check.new ""
+    Rapid::Check.current = @check
+    Rapid::Check.encounters_error? { @check.error 'hi', 'hi' }.should == true
+    
+    @check = Rapid::Check.new ""
+    Rapid::Check.current = @check
+    Rapid::Check.encounters_error? { @check.warning 'hi', 'hi' }.should == false
+  end
+  
+end

data/spec/rapid/error_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rapid::Exception do
+  
+  describe "NotMatchingTemplateError" do
+    
+    it "should have a message" do
+      @error = Rapid::NotMatchingTemplateError.new({}, "", "")
+      @error.message.class.should == String
+    end
+    
+  end
+  
+end

data/spec/rapid/module_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rapid do
+  
+  describe "puts" do
+    
+    it "should puts ok" do
+      Rapid.should_receive(:puts).with("\e[32mhi\e[0m")
+      Rapid.color_puts :ok, "hi"
+    end
+    
+    it "should puts warning" do
+      Rapid.should_receive(:puts).with("\e[33mhi\e[0m")
+      Rapid.color_puts :warning, "hi"
+    end
+    
+    it "should puts error" do
+      Rapid.should_receive(:puts).with("\e[31mhi\e[0m")
+      Rapid.color_puts :error, "hi"
+    end
+    
+    it "should raise an error when invalid type" do
+      lambda { Rapid.color_puts(:invalid, "hi") }.should raise_error
+    end
+    
+  end
+  
+end

data/spec/rapid/setting/base_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Setting::Base do
+  
+  it "should throw an error when loading" do
+    lambda { Rapid::Setting::Base.new("foo").load("hi") }.should raise_error
+  end
+  
+  it "should not allow settings named _root" do
+    lambda { Rapid::Setting::Base.new("_root") }.should raise_error(ArgumentError)
+  end
+  
+  it "should not allow settings named valid" do
+    lambda { Rapid::Setting::Base.new("valid") }.should raise_error(ArgumentError)
+  end
+  
+end