overapp 0.4.2 → 0.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjY4MjM5OGZmY2MwN2RhYWJhZjU4YzY5ZGZmNDkwYWEwNDkwYWJkNA==
+    MGVjNDY1MjViY2YwMGE5MzQ1ZGViODNkZGU5YWMwNWZlZjAzYTJhZA==
   data.tar.gz: !binary |-
-    NGZhYjcwNWEzYTg2MDBkZTY2OWRiNTNjMTE4NWE5NjEzYjZkOTNmNw==
+    Njg5MWYwNGY0Yzk0ODFlYWE5OGFlMDIxNjI2NWRlZjU0MThmMTAxYg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZjIzN2MwZWJiNzZiNGE3NWU1MGJkOGJiZWM3YmU1YTU0NDUxNGFlZDhmNGEz
-    OThjNzc3YWNjYzFiMWVjMDA3MDk1NTI5ZmE0MmRkMWQwMDMwZWIzMmViM2I5
-    NTZhOTg2Y2EwODlhMDdmNWI5MjJkMWQ5MGQyNjBlODA2NTY1Y2M=
+    YTgwNjQ0OTI3Y2VjMGVjMWUxZWM1NTVmNDJjMzBhMTYyNGQ2MjIxYTlmOGEw
+    MDExYTM1OWI5YTA0ZWI0ZDJmODExOTYxMjM3NGIzZTAxYzFhZWU4Yzg0YTY2
+    NDVmMzAyMGM0MTg0MGY3MDU4ODIzNzliYjFhZWE0MTA3ZWQzYmE=
   data.tar.gz: !binary |-
-    YWZlNTg4ZmYyZmM3MWYwMjg1YmIwMWMyYWE4MjkzMmJiZWNhNDI3OGM0YmJl
-    NTM4N2M3ZTM3NmIzNjNmM2ViMjhmOWM3MDA5YzUzZDI2Mjk4MjY3MDUzZjc5
-    YTE0NjUzYjU1ZDBjMWU0NjI2OTdhOWFhZTNmNzBlODA0NDU0OGI=
+    ZDg2NTIyNTM1N2UxMTZlOGRkYjQ1OWQwNTE3MzU2MWVjZWRhNTk1YmRhYmVh
+    YzE3ZDViYmZjMjhmZDZlMmM3ODNiY2ZjMGE1ZjYzMjZmNzczMTgxNTQzNjMz
+    YzQ0OGEzNDU3NzliYzc1NjdjNTI5ODg5MmY1YWE4NjU0OTFlM2Y=

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.5.0

data/lib/overapp/files.rb

@@ -3,7 +3,7 @@ module Overapp
     include FromHash
     attr_accessor :top_file, :base
     def message
-      res = "Cannot overlay onto missing file #{top_file.path}\nBase File Count: #{base.files.size}\n"
+      res = "Cannot overlay onto missing file #{top_file.path}\nBase File Count: #{base.files.size}\n#{top_file.params_obj.note_params.inspect}"
       res += base.map { |x| x.path }.join("\n")
       res
     end
@@ -19,9 +19,13 @@ module Overapp
     def size
       files.size
     end
-    def apply(on_top)
+    def apply(on_top,ops={})
       res = files.clone
       on_top.each do |top_file|
+        if ops[:vars] && ops[:vars].size > 0
+          #raise ops[:vars].inspect
+          top_file.vars = ops[:vars]
+        end
         existing = res.find { |x| x.path == top_file.path }
         if existing
           res -= [existing]
@@ -30,7 +34,7 @@ module Overapp
         elsif top_file.has_note?
           raise MissingBaseFileError.new(:top_file => top_file, :base => self)
         else
-          res << top_file
+          res << top_file.parsed
         end
       end
       self.class.new(:files => res)
@@ -46,9 +50,10 @@ module Overapp
       self
     end
 
-    class << self
-      def load_command(cmd,ops)
-        FromCommand.new(:command => cmd, :path => ops[:path]||".").files
+    def with_tmp(&b)
+      Overapp::TmpDir.with do |dir|
+        write_to! dir
+        b[dir]
       end
     end
   end

data/lib/overapp/from_command.rb

@@ -1,13 +0,0 @@
-module Overapp
-  class FromCommand
-    include FromHash
-    attr_accessor :command, :path
-
-    fattr(:files) do
-      Overapp.with_tmp_dir do |dir|
-        Overapp.ec command, :silent => true
-        Files.load [dir,path].select { |x| x.present? }.join("/"), :file_class => BasicFile
-      end
-    end
-  end
-end

data/lib/overapp/load/base.rb

@@ -4,16 +4,21 @@ module Overapp
       include FromHash
       attr_accessor :descriptor
 
-      def apply_to(base,ops)
-        base.apply(load(base,ops))
+      def initialize(ops={})
+        raise "no descriptor" unless ops[:descriptor].present?
+        from_hash(ops)
       end
 
       def commit_message
         "Message Pending"
       end
 
-      def load(*args)
-        raise "load unimplemented"
+      def load_full(base,ops={})
+        res = load(base,ops)
+        while res.kind_of?(Overapp::Load::Base)
+          res = res.load(base,ops)
+        end
+        res
       end
     end
   end

data/lib/overapp/load/instance.rb

@@ -3,14 +3,10 @@ module Overapp
     class Instance
       include FromHash
       attr_accessor :path, :overlays
+      fattr(:vars) { {} }
 
       fattr(:starting_files) do
-        raise "path doesn't exist #{path}" unless FileTest.exist?(path)
-        if Overapp.dir_files(path).empty?
-          Overapp::Files.new
-        else
-          RawDir.new(:descriptor => path).load(nil,{})
-        end
+        Overapp::Files.new
       end
 
       fattr(:combined_files) do
@@ -24,11 +20,7 @@ module Overapp
       end
 
       def apply_overlay(base,overlay)
-        Overapp::Git.commit(path,overlay.commit_message) do
-          overlay.apply_to(base, :path => path).tap do |res|
-            res.write_to! path
-          end
-        end.tap { |res| raise "nil return" unless res }
+        overlay.load_full(base,:vars => vars)
       end
     end
   end

data/lib/overapp/load/types/command.rb

@@ -3,15 +3,19 @@ module Overapp
     class Command < Base
       attr_accessor :relative_output_path
       def command; descriptor; end
-      def load(base,ops={})
+
+      def target_path(dir)
         if relative_output_path.present?
-          TmpDir.with do |dir|
-            Overapp.ec "cd #{dir} && #{command}", :silent => false
-            RawDir.new(:descriptor => "#{dir}/#{relative_output_path}").load(base,ops)
-          end
+          "#{dir}/#{relative_output_path}"
         else
-          Overapp.ec "cd #{ops[:path]} && #{command}", :silent => false
-          RawDir.new(:descriptor => ops[:path]).load(base,ops)
+          dir
+        end
+      end
+
+      def load(base,ops={})
+        base.with_tmp do |dir|
+          Overapp.ec "cd #{dir} && #{command}", :silent => true
+          RawDir.new(:descriptor => target_path(dir))
         end
       end
     end

data/lib/overapp/load/types/empty.rb

@@ -1,9 +0,0 @@
-module Overapp
-  module Load
-    class Empty
-      def load(base,ops)
-        Overapp::Files.new
-      end
-    end
-  end
-end

data/lib/overapp/load/types/local_dir.rb

@@ -5,9 +5,9 @@ module Overapp
 
       def load(base,ops)
         if Overapp::Project.project? path
-          Project.new(:descriptor => path).load(base,ops)
+          Project.new(:descriptor => path)
         else
-          RawDir.new(:descriptor => path).load(base,ops)
+          RawDir.new(:descriptor => path)
         end
       end
     end

data/lib/overapp/load/types/project.rb

@@ -2,10 +2,12 @@ module Overapp
   module Load
     class Project < Base
       def path; descriptor; end
+      fattr(:project) do
+        Overapp::Project.load(:path => path)
+      end
       def load(base,ops={})
-        project = Overapp::Project.new(:path => path)
-        project.write_to! ops[:path]
-        RawDir.new(:descriptor => ops[:path]).load(base,ops)
+        instance = Load::Instance.new(:overlays => project.overapps, :starting_files => base)
+        instance.combined_files
       end
     end
   end

data/lib/overapp/load/types/raw_dir.rb

@@ -2,21 +2,23 @@ module Overapp
   module Load
     class RawDir < Base
       def dir; Overapp.to_proper_dir(descriptor); end
-      def load(base,ops)
+      def load_independent
         ops = {}
         raise "Bad dir" unless dir.present?
-        raise "Dir not there #{dir}" unless FileTest.exist?(dir)
+        
         res = Files.new
         res.file_class = ops[:file_class] if ops[:file_class]
-        Overapp.dir_files(dir).each do |full_file|
-          if FileTest.file?(full_file)
-            f = full_file.gsub("#{dir}/","")
-            raise "bad #{f}" if f == full_file
-            res.add :file => f, :body => File.read(full_file)
-          end
+
+        Overapp.dir_files_full(dir).each do |f|
+          res.add(f)
         end
+
         res
       end
+
+      def load(base,ops={})
+        base.apply(load_independent,ops)
+      end
     end
   end
 end

data/lib/overapp/load/types/repo.rb

@@ -5,7 +5,7 @@ module Overapp
 
       def load(base,ops)
         TmpDir.with_repo_path(url) do |dir|
-          LocalDir.new(:descriptor => dir).load(base,ops)
+          LocalDir.new(:descriptor => dir)
         end
       end
     end

data/lib/overapp/project/config.rb

@@ -3,6 +3,7 @@ module Overapp
     include FromHash
     attr_accessor :body, :base_ops
     fattr(:overapps) { [] }
+    fattr(:vars) { {} }
 
     def base(*args)
       overapp(*args)
@@ -20,6 +21,10 @@ module Overapp
       self.overapps << ConfigEntry.new(:descriptor => cmd, :type => :command, :entry_ops => ops)
     end
 
+    def var(k,v)
+      vars[k] = v
+    end
+
     def load!
       c = self
       eval(body)

data/lib/overapp/project/write.rb

@@ -5,7 +5,7 @@ module Overapp
       attr_accessor :output_path, :project
 
       fattr(:instance) do
-        Load::Instance.new(:path => output_path, :overlays => project.overapps)
+        Load::Instance.new(:overlays => project.overapps, :vars => Overapp::Var.vars.merge(project.vars))
       end
 
       def combined_files

data/lib/overapp/project.rb

@@ -2,6 +2,7 @@ module Overapp
   class Project
     include FromHash
     attr_accessor :path
+    fattr(:vars) { config.vars }
 
     class << self
       def project_files
@@ -9,11 +10,16 @@ module Overapp
       end
 
       def project?(path)
+        raise "checking for project, path doesn't exist #{path}" unless FileTest.exist?(path)
         !!project_files.map { |x| "#{path}/#{x}" }.find { |x| FileTest.exist?(x) }
       end
+
+      def load(*args)
+        new(*args)
+      end
     end
 
-    def config_body
+    fattr(:config_body) do
       file = klass.project_files.map { |x| "#{path}/#{x}" }.find { |x| FileTest.exist?(x) }
       if file
         File.read(file)
@@ -31,7 +37,7 @@ module Overapp
 
     def overapp_entries
       res = config.overapps
-      local = config.overapps.find { |x| x.descriptor == "." }
+      local = config.overapps.find { |x| x.descriptor == "." || x.descriptor == :self }
       if local
         local.descriptor = path
         res
@@ -40,12 +46,15 @@ module Overapp
       end
     end
 
+    fattr(:load_factory_class) { Load::Factory }
+    fattr(:load_raw_dir_class) { Load::RawDir }
+
     def overapps
       overapp_entries.map do |entry|
         if path == entry.descriptor
-          Load::RawDir.new(:descriptor => path)
+          load_raw_dir_class.new(:descriptor => path)
         else
-          Load::Factory.new(:descriptor => entry.descriptor, :type => entry.type, :entry_ops => entry.entry_ops).loader
+          load_factory_class.new(:descriptor => entry.descriptor, :type => entry.type, :entry_ops => entry.entry_ops).loader
         end
       end
     end
@@ -54,9 +63,8 @@ module Overapp
       Write.new(:output_path => output_path, :project => self).write!
     end
 
-    def combined_files(output_path)
-      raise 'here'
-      Write.new(:output_path => output_path, :project => self).combined_files
+    def combined_files
+      Write.new(:project => self).combined_files
     end
   end
 end

data/lib/overapp/template_file/body_mod.rb

@@ -0,0 +1,56 @@
+module Overapp
+  class TemplateFile
+    class BodyMod
+      class Single
+        include FromHash
+        attr_accessor :match, :transform
+        def match?(params)
+          match[params]
+        end
+      end
+
+      class List
+        fattr(:list) { [] }
+        def register(match_proc, transform_proc)
+          self.list << Single.new(match: match_proc, transform: transform_proc)
+        end
+
+        def transform(base_body,body,params)
+          single = list.find { |x| x.match?(params) }
+          raise "bad #{params.inspect}" unless single
+          res = single.transform[base_body,body,params]
+          raise "no change" if res == base_body
+          res
+        end
+      end
+
+      class << self
+        def register(*args)
+          instance.register(*args)
+        end
+        def transform(*args)
+          instance.transform(*args)
+        end
+        fattr(:instance) { List.new }
+      end
+
+
+      register lambda { |params| params[:action] == 'append' }, 
+               lambda { |base_body,body,params| base_body + body }
+
+      register lambda { |params| params[:action] == 'insert' && params[:after] }, 
+               lambda { |base_body,body,params| base_body.gsub(params[:after],"#{params[:after]}#{body}") }  
+
+      register lambda { |params| params[:action] == 'insert' && params[:before] }, 
+               lambda { |base_body,body,params| base_body.gsub(params[:before],"#{body}#{params[:before]}") }  
+
+      register lambda { |params| params[:action] == 'replace' && params[:base] }, 
+               lambda { |base_body,body,params| base_body.gsub(params[:base],body) }  
+
+      register lambda { |params| params[:action] == 'delete' }, 
+               lambda { |base_body,body,params| :delete }  
+
+     
+    end
+  end
+end

data/lib/overapp/template_file/params.rb

@@ -0,0 +1,75 @@
+module Overapp
+  class TemplateFile
+    class Params
+      include FromHash
+      attr_accessor :full_body
+      def body; full_body; end
+      include Enumerable
+      def each(&b)
+        note_params.each(&b)
+      end
+
+      def split_note_and_body
+        res = []
+        remaining_body = full_body
+        while remaining_body
+          if remaining_body =~ /^<over(?:lay|app)>(.+)<\/over(?:lay|app)>(.*)(<over(?:lay|app)>.+)/m
+            note = $1
+            rest = $2
+            remaining_body = $3
+            res << {:note => note, :body => rest}
+          elsif remaining_body =~ /^<over(?:lay|app)>(.+)<\/over(?:lay|app)>(.*)/m
+            note = $1
+            rest = $2
+            remaining_body = nil
+            res << {:note => note, :body => rest}
+          else
+            res << {:note => nil, :body => remaining_body}
+            remaining_body = nil
+          end
+        end
+        res
+      rescue => exp
+        puts "Error in split_note_and_body #{path}"
+        raise exp
+      end
+
+
+      def note_params_single(one)
+        res = {}
+        note = one[:note]
+        res[:body] = one[:body]
+
+        if note
+          lines = note.split("\n").select { |x| x.present? }
+          if (lines.size == 1) && !(lines.first =~ /[a-z]+:/)
+            res[:action] = lines.first.strip
+          else
+            lines.each do |line|
+              parts = line.split(":").select { |x| x.present? }
+              if parts.size > 2
+                parts = [parts[0],parts[1..-1].join(":")]
+              end
+              parts = parts.map { |x| x.strip }
+              raise "bad #{path} #{parts.inspect}" unless parts.size == 2
+              res[parts[0].to_sym] = parts[1]
+            end
+          end
+        end
+        res
+      end
+
+      fattr(:split_parts) { split_note_and_body }
+
+      fattr(:note_params) do
+        split_parts.map do |one|
+          note_params_single(one)
+        end
+      end
+
+      def has_note?
+        note_params.any? { |x| x[:action].present? }
+      end
+    end
+  end
+end

data/lib/overapp/template_file/var_obj.rb

@@ -0,0 +1,24 @@
+module Overapp
+  class TemplateFile
+    class VarObj
+      include FromHash
+      attr_accessor :file
+
+      def method_missing(sym,*args,&b)
+        if file.vars.has_key?(sym)
+          file.vars[sym]
+        elsif file.vars.has_key?(sym.to_s)
+          file.vars[sym.to_s]
+        else
+          raise "not found #{sym}, options are #{file.vars.inspect}"
+        end
+      end
+
+      def render(body)
+        require 'erb'
+        erb = ERB.new(body)
+        erb.result(binding)
+      end
+    end
+  end
+end

data/lib/overapp/template_file.rb

@@ -3,102 +3,38 @@ module Overapp
     include FromHash
     attr_accessor :path, :full_body
 
-    def split_note_and_body
-      res = []
-      remaining_body = full_body
-      while remaining_body
-        if remaining_body =~ /^<over(?:lay|app)>(.+)<\/over(?:lay|app)>(.*)(<over(?:lay|app)>.+)/m
-          note = $1
-          rest = $2
-          remaining_body = $3
-          res << {:note => note, :body => rest}
-        elsif remaining_body =~ /^<over(?:lay|app)>(.+)<\/over(?:lay|app)>(.*)/m
-          note = $1
-          rest = $2
-          remaining_body = nil
-          res << {:note => note, :body => rest}
-        else
-          res << {:note => nil, :body => remaining_body}
-          remaining_body = nil
-        end
-      end
-      res
-    rescue => exp
-      puts "Error in split_note_and_body #{path}"
-      raise exp
+    fattr(:params_obj) do
+      Params.new(:full_body => full_body)
     end
 
-
-    def note_params_single(one)
-      res = {}
-      note = one[:note]
-      res[:body] = one[:body]
-
-      if note
-        lines = note.split("\n").select { |x| x.present? }
-        if lines.size == 1 && !(lines.first =~ /action:/)
-          res[:action] = lines.first.strip
-        else
-          lines.each do |line|
-            parts = line.split(":").select { |x| x.present? }
-            if parts.size > 2
-              parts = [parts[0],parts[1..-1].join(":")]
-            end
-            parts = parts.map { |x| x.strip }
-            raise "bad #{path} #{parts.inspect}" unless parts.size == 2
-            res[parts[0].to_sym] = parts[1]
-          end
-        end
-      else
-        # do nothing
-      end
-      res
+    def has_note?
+      params_obj.has_note?
     end
 
-    def note_params
-      split_parts.map do |one|
-        note_params_single(one)
+    def templated_body(params)
+      body = params[:body]
+      if params[:template] == 'erb'
+        v = VarObj.new(:file => self)
+        body = v.render(body)
       end
+      body
     end
 
+    def body_after_action(base_body,params)
+      body = templated_body(params)
+      BodyMod.transform(base_body,body,params)
+    end
 
     def apply_body_to(base_body)
-      note_params.each do |params|
-        body = params[:body]
-        base_body = if params[:action].blank?
-          body
-        elsif params[:action] == 'append'
-          base_body + body
-        elsif params[:action] == 'insert' && params[:after]
-          base_body.gsub(params[:after],"#{params[:after]}#{body}").tap do |subbed|
-            if subbed == base_body
-              raise "no change, couldn't find #{params[:after]} to insert #{body} in \n#{base_body}"
-            end
-          end
-        elsif params[:action] == 'insert' && params[:before]
-          base_body.gsub(params[:before],"#{body}#{params[:before]}").tap do |subbed|
-            if subbed == base_body
-              raise "no change, couldn't find #{params[:before]} in \n#{base_body}"
-            end
-          end
-        elsif params[:action] == 'replace' && params[:base]
-          base_body.gsub(params[:base],body).tap do |subbed|
-            if subbed == base_body
-              raise "no change, couldn't find #{params[:base]} to replace with #{body} in \n#{base_body}"
-            end
-          end
-        elsif params[:action] == 'delete'
-          :delete
+      params_obj.inject(base_body) do |new_base_body,params|
+        if params[:action].blank?
+          templated_body(params)
+        elsif params[:action]
+          body_after_action(new_base_body,params)
         else
-          raise "bad #{params.inspect}"
+          raise "bad"
         end
       end
-      base_body
-    end
-
-    fattr(:split_parts) { split_note_and_body }   
-    def has_note?
-      split_parts.any? { |x| x[:note].present? }
     end
 
     def body
@@ -120,6 +56,11 @@ module Overapp
       `mkdir -p #{d}`
       File.create "#{dir}/#{path}",body
     end
+
+    fattr(:vars) { {} }
+    def parsed
+      combined(OpenStruct.new(:full_body => ""))
+    end
   end
 
   class BasicFile < TemplateFile

data/lib/overapp/util/dir.rb

@@ -4,8 +4,15 @@ module Overapp
       res = Dir["#{dir}/**/*"] + Dir["#{dir}/**/.*"]
       res = res - [".","..",".git"]
       res.reject { |x| FileTest.file?(x) && File.binary?(x) && !(x =~ /\.txt/) }
-      #raise rej.inspect unless rej.empty?
-      #res - rej
+      res.select { |x| FileTest.file?(x) }
+    end
+    def dir_files_full(dir)
+      raise "Dir not there #{dir}" unless FileTest.exist?(dir)
+      dir_files(dir).map do |full_file|
+        f = full_file.gsub("#{dir}/","")
+        raise "bad #{f}" if f == full_file
+        {:file => f, :body => File.read(full_file)}
+      end
     end
 
     def with_local_path(overapp_path,&b)