batcave 0.0.1 → 0.0.4

data/Gemfile

@@ -1,3 +1,4 @@
 source :rubygems
 
 gem "clamp"
+gem "cabin"

data/README.md

@@ -7,10 +7,22 @@ Wikipedia on "Batcave" uses:
 > ideal to create a stronghold for his war against crime, and has incorporated a
 > plethora of equipment as well as expanding the cave for specific uses.
 
-As in coding, you start with some minimal tools and gradually find better
-tools, better flows, etc.
+Frankly, I write a lot of code in a lot of languages. There's a lot of
+boilerplate, tools, and scripts I copy from project to project. Debugging,
+coding, documentation, tests, etc all are quite similar in goal across projects
+but differ wildly in implementation. I'd like to codify most of this so that,
+when switching between projects, the cost of context switching isn't as painful.
 
-This project is an experiment to try and make batcave construction possible.
+Essentially, I do roughly the same activities regardless of platform or language.
+This project is an experiment in solving the above problem.
+
+Ideally it'd be sweet if this project would also manage my workstation as well
+as my projects. Dotfiles, packages, etc. I'm tired of setting this shit up or
+scripting it sideways every few months.
+
+This project may end up looking a lot like an IDE plus some config management.
+
+## Example
 
 Maybe, for example, I'm writing an HTTP library in Ruby, and I want to:
 
@@ -18,11 +30,38 @@ Maybe, for example, I'm writing an HTTP library in Ruby, and I want to:
 * run tests whenever I modify the code.
 * make sure all methods have docstrings (with YARD)
 * have some useful debugging tools.
+* generate documentation to publish online
 
-But new projects should be easier:
+But new projects should be easier, too:
 
 * create a 'go' project with a layout that works well with 'goinstall'
-* create a 'ruby' project with a standard layout, Gemfile, gemspec, etc
-* etc.
+* create a 'ruby' project with a standard layout, Gemfile, gemspec, etc. A bin
+  file that uses clamp with sample flag code. A namespace file generated for
+  me, etc.
+* automatically create basic tests
+* include tools for debugging
 
 Release management should be easier, too. 
+
+## Idea: boilerplate and project creation
+
+* dk add thing
+
+a 'thing' is a feature, boilerplate, some debug tool, metrics or testing tool, etc.
+
+Example:
+
+* dk add --name example go
+* dk add ruby
+
+Both of the above will generate boilerplate projects for their respective
+languages. It currently uses git to find the root of your project directory
+and puts files based from that location.
+
+Boilerplates should include basic tests, etc.
+
+## Other ideas in command-line form
+
+* dk release - run tests, bump version, build package, run tests, tag it, publish
+* dk add travis-ci - add .travis.yml file with language detection
+* dk debug - run an application inside a debugger (gdb for c/c++, ruby's debugger or pry, etc)

data/batcave.gemspec

@@ -2,9 +2,9 @@ Gem::Specification.new do |spec|
   files = %x{git ls-files}.split("\n")
 
   spec.name = "batcave"
-  spec.version = "0.0.1"
+  spec.version = "0.0.4"
   spec.summary = "Experiments in tools, boilerplatery, debugging, etc."
-  spec.summary = spec.description
+  spec.description = spec.summary
   spec.add_dependency("clamp")
   spec.files = files
   spec.bindir = "bin"

data/lib/batcave/action/add.rb

@@ -0,0 +1,43 @@
+require "batcave/namespace"
+require "batcave/support/git"
+
+class BatCave::Action::Add
+  include BatCave::Support::Git
+
+  private
+
+  # Add a new thing with some arguments.
+  # 
+  # Arguments for each thing are defined in the 'THING' file for each ... thing.
+  def initialize(thing, args)
+    @logger = Cabin::Channel.get("batcave")
+    @thing = thing
+    @args = args
+  end # def initialize
+
+  def find_thing(thing)
+    # look for the 'thing/' or if it's a directory try 'thing/self/'
+    [ @thing, File.join(@thing, "self") ].each do |thing|
+      path = File.join(BatCave::THINGSDIR, thing)
+      config = File.join(path, "THING")
+      return config if File.exists?(config)
+    end
+
+    puts "Could not find any thing '#{@thing}'"
+    return false
+  end # def find_thing
+
+  def execute
+    config = find_thing(@thing)
+    return 1 if config == false
+    dsl = BatCave::DSL.new(config, @thing, @args)
+    dsl.execute
+
+    # TODO(sissel): Record that we've added this thing.
+    puts "Adding #{dsl.environment}/#{@thing}"
+    store = BatCave::Store.new
+    store.store(dsl)
+  end # def execute
+
+  public(:initialize, :execute)
+end # class BatCave::Action::Add

data/lib/batcave/command/add.rb

@@ -1,63 +1,24 @@
 require "clamp"
 require "batcave/namespace"
-require "batcave/support/git"
+require "batcave/action/add"
+require "batcave/dsl"
+require "batcave/store"
 require "fileutils"
 
+# TODO(sissel): Need to track what we've added so we can sync later.
+
 class BatCave::Command::Add < Clamp::Command
-  include BatCave::Support::Git
 
+  # TODO(sissel): Move this to the 'thing' DSL
   option ["-n", "--name"], "NAME",
     "the application or library name", :attribute_name => :name
 
   parameter "THING",
     "The thing to add to your batcave", :attribute_name => :thing
 
-  def execute
-    # TODO(sissel): Move this stuff into a proper batcave library
-
-    found = false
-    # look for the 'thing/' or if it's a directory try 'thing/self/'
-    [ @thing, File.join(@thing, "self") ].each do |thing|
-      path = File.join(BatCave::THINGSDIR, thing)
-      config = File.join(path, "THING")
-      if File.exists?(config)
-        found = true
-        use(path)
-        break
-      end
-    end
+  parameter "[THINGARGS] ...", "arguments to pass to the thing", :attribute_name => :args
 
-    if !found
-      puts "Could not find any thing '#{@thing}'"
-    end
+  def execute
+    BatCave::Action::Add.new(@thing, @args).execute
   end # def execute
-
-  def use(dir)
-    config = File.join(dir, "THING")
-    paths = Dir.glob(File.join(dir, "**", "*"))
-
-    paths.each do |path|
-      next if path == config # skip the 'THING' file
-      localpath = File.join(project_root, path[dir.length + 1 .. -1])
-
-      if localpath.include?("{name}")
-        if @name.nil?
-          raise "Path requires '--name' flag to be set: #{localpath.inspect}"
-        end
-        localpath.gsub!("{name}", @name)
-      end
-
-      # Replace '{...}' in localpath
-
-      # TODO(sissel): if this is a directory, create it.
-      # TODO(sissel): if this a file, copy it.
-      if File.directory?(path)
-        FileUtils.mkdir_p(localpath) unless File.directory?(localpath)
-      else
-        localdir = File.dirname(localpath)
-        FileUtils.mkdir_p(localdir) unless File.directory?(localdir)
-        FileUtils.cp(path, localpath)
-      end
-    end
-  end
 end

data/lib/batcave/command/update.rb

@@ -1,8 +1,16 @@
 require "clamp"
 require "batcave/namespace"
+require "batcave/command/add"
 
 class BatCave::Command::Update < Clamp::Command
+  parameter "ENVIRONMENT", "The environment to update (user, project, etc)",
+    :attribute_name => :environment
+
   def execute
-    p :Updating
+    store = BatCave::Store.new
+    store.each(@environment) do |thing, settings|
+      args = settings["args"]
+      BatCave::Action::Add.new(thing, args).execute
+    end
   end
 end

data/lib/batcave/dsl.rb

@@ -0,0 +1,254 @@
+require "batcave/namespace"
+require "batcave/support/envpath"
+require "fileutils" # stdlib
+require "cabin" # gem 'cabin'
+require "erb" # stdlib
+
+# TODO(sissel): DSL is a poor name for this class. Fix it later.
+# TODO(sissel): Split the 'THING' processor from the 'Thing' instances
+class BatCave::DSL
+  include BatCave::Support::Git
+  include BatCave::Support::EnvPath
+
+  private
+
+  def initialize(configfile, thing, args)
+    @args = args
+    @thing = thing
+    @configfile = configfile
+    @logger = Cabin::Channel.get("batcave")
+
+    # Default environment is project.
+    @environment = :project
+    # Update all files by default
+    @create_only = []
+
+    @target ||= path(@environment)
+    @sourcedir = File.dirname(@configfile)
+    @sync = true
+
+    # Make this 'thing' argument into a command by
+    # dynamically making a new subclass of Clamp::Command
+    @command = Class.new(Clamp::Command).new("<internal dsl thing>")
+    class << @command
+      def execute
+        # nothing to do, we just want to parse flags.
+      end
+    end
+    binding.eval(File.read(@configfile), @configfile)
+  end # def initialize
+
+  # Declare options for this thing. This block will be executed
+  # in the context of a Clamp::Command, so anything valid in a
+  # Clamp::Command definition is valid here. The options will
+  # be parsed immediately after this block is evaluated.
+  #
+  # Example:
+  #
+  #     options do
+  #       parameter "SOURCE", "The source to use", :attribute_name => :foo
+  #     end
+  def options(&block)
+    @command.class.instance_eval(&block)
+    @command.run(@args)
+
+    # Copy related instance variables from the Clamp::Command to this object.
+    @command.instance_variables.each do |ivar|
+      # Skip ones that are part of the Command normally (not attributes)
+      next if [:@invocation_path, :@context, :@remaining_arguments].include?(ivar)
+      instance_variable_set(ivar, @command.instance_variable_get(ivar))
+    end
+  end # def options
+
+  # Set the source to use for this thing
+  def source(upstream)
+    root = File.join(ENV["HOME"], ".batcave", "upstream")
+    FileUtils.mkdir_p(root)
+    Dir.chdir(root) do
+      if !File.directory?(@thing)
+        cmd = "git clone #{upstream} #{@thing}"
+      else
+        #cmd = "cd #{@thing}; git fetch origin master; git reset --hard origin/master"
+        cmd = "cd #{@thing}; git pull origin master"
+      end
+
+      @logger.info("Running", :command => cmd)
+      system(cmd)
+      if $?.exitstatus != 0
+        # TODO(sissel): Do something better than aborting
+        raise "Command exited #{$?.exitstatus}: #{cmd}"
+      end
+    end
+    @sourcedir = File.join(root, @thing)
+  end # def source
+
+  def target(directory)
+    @target = directory
+  end # def target
+
+  # Do path expansion.
+  #
+  # If the path is /foo/bar/{name}
+  # and @names is ["one", "two"], then this will:
+  #
+  # * yield "/foo/bar/one"
+  # * yield "/foo/bar/two"
+  #
+  # A {foo} will check both @foo and @foos
+  def expand(paths, &block)
+    skip_re = /(^|\/)\.(\.|git|svn)/
+    paths.each do |path|
+      next if skip_re.match(path)
+      # find all {...} in the string
+      tokens = path.scan(/{[^}]+}/)
+      if tokens.include?("{name}")
+        names = []
+        names << @name if instance_variable_defined?(:@name)
+        names += @names if instance_variable_defined?(:@names)
+
+        if names.empty?
+          message = [ 
+            "No {name} known, can't expand #{path}",
+            "maybe add this to your THING file: ",
+            "",
+            "options do",
+            "  parameter 'NAME', 'The {name} value', :attribute_name => :name",
+            "end"
+          ].join("\n")
+          raise message
+        end
+
+        names.each do |name|
+          yield path, path.gsub("{name}", name)
+        end
+      else
+        yield path, path
+      end
+    end
+  end # def expand
+
+  def create_only(*paths)
+    if paths.first.is_a?(Array)
+      paths = paths.first
+    end
+
+    @create_only = paths
+  end # def create_only
+
+  # Sync two paths
+  def sync
+    if !instance_variable_defined?(:@sourcedir)
+      @logger.error("Can't sync, no source defined")
+      return
+    end
+
+    paths = Dir.glob(File.join(@sourcedir, "**", "*"), File::FNM_DOTMATCH)
+    expand(paths) do |source, target|
+      next if source == @configfile # skip the 'THING' file
+      originalpath = source[@sourcedir.length + 1 .. -1]
+      localpath = File.join(path(@environment), target[@sourcedir.length + 1 .. -1])
+
+      if localpath =~ /\.erb$/
+        localpath = localpath[0...-4]
+        use_erb = true
+      else
+        use_erb = false
+      end
+
+      # TODO(sissel): if this is a directory, create it.
+      # TODO(sissel): if this a file, copy it.
+      if File.directory?(source)
+        FileUtils.mkdir_p(localpath) unless File.directory?(localpath)
+      else
+        localdir = File.dirname(localpath)
+        FileUtils.mkdir_p(localdir) unless File.directory?(localdir)
+
+        if @create_only.include?(originalpath) and File.exists?(localpath)
+          @logger.info("Skipping existing file due to 'create_only': #{localpath}")
+        else 
+          if use_erb
+            erb = ERB.new(File.read(source))
+            @logger.info("Generating ", :source => source, :target => localpath)
+            File.open(localpath, "w+") do |fd|
+              # Make all ivars available as names in the templates, so I can just do
+              # <%= name %> instead of <%= @name %>
+              ivar = IvarBinding.new(self)
+              fd.write(erb.result(ivar.binding))
+            end
+          else
+            @logger.info("Copying", :source => source, :target => localpath)
+            FileUtils.cp(source, localpath)
+          end
+        end
+      end
+    end
+  end # def sync
+
+  # Set the environment this thing is operating in.
+  #
+  # Valid environments are: :system, :user, :project, :path
+  #
+  # This helps hint batcave update operations so you can just update your user,
+  # project, etc, instead of everything at once.
+  def environment(env=nil)
+    if !env.nil?
+      @environment = env
+    end
+    return @environment
+  end # def environment
+
+  def thing
+    return @thing
+  end # def thing
+
+  def to_hash
+    return {
+      "args" => @args
+    }
+  end # def to_yaml
+
+  def execute
+    sync if @sync
+  end
+
+  def nosync
+    @sync = false
+  end # def nosync
+
+  # Metaprogramming to provide instance variables from a class as
+  # local-variable-like things in a binding. For use with ERB and such.
+  #
+  # This is a fun hack.
+  class IvarBinding
+    def initialize(object)
+      # Make a new Object subclass
+      klass = Class.new(Object)
+
+      # Find all instance variables in 'object' and make
+      # them methods in our new class. Each method will
+      # simply return that named instance variable.
+      object.instance_variables.each do |ivar|
+        meth = ivar.to_s.gsub("@", "")
+        klass.instance_eval do
+          define_method(meth) do
+            object.instance_variable_get(ivar)
+          end
+        end
+      end
+
+      # Make a method that returns the binding for this class
+      klass.instance_eval do
+        define_method(:_binding) do
+          return binding
+        end
+      end
+      @instance = klass.new
+    end # def initialize
+
+    def binding
+      return @instance._binding
+    end # def binding
+  end # class IvarBinding
+
+  public(:initialize, :execute, :environment, :thing, :to_hash)
+end # class BatCave::DSL

data/lib/batcave/main.rb

@@ -2,8 +2,19 @@ require "clamp"
 require "batcave/namespace"
 require "batcave/command/add"
 require "batcave/command/update"
+require "cabin"
 
 class BatCave::Main < Clamp::Command
+  option ["-v", "--verbose"], :flag, "enable verbose logging" do
+    require "logger"
+    logger = Cabin::Channel.get("batcave")
+    p Cabin::Channel.get("batcave").object_id
+    p Cabin::Channel.get("batcave").object_id
+    p Cabin::Channel.get("batcave").object_id
+    logger.subscribe(Logger.new(STDOUT))
+    logger.level = :info
+  end
+
   # Add something to your bat cave. 
   subcommand "add", "Add something to your batcave", BatCave::Command::Add
 

data/lib/batcave/namespace.rb

@@ -1,5 +1,6 @@
 module BatCave
   module Command; end
+  module Action; end
   module Support; end # TODO(sissel): Support is a shitty namespace name.
   THINGSDIR = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "things"))
 end

data/lib/batcave/store.rb

@@ -0,0 +1,74 @@
+require "batcave/namespace"
+require "batcave/support/git"
+require "batcave/support/envpath"
+require "yaml"
+require "fileutils"
+
+class BatCave::Store
+  include BatCave::Support::Git
+  include BatCave::Support::EnvPath
+
+  def lock(path, &block)
+    lockfile = "#{path}.lock"
+    File.open(lockfile, "a+") do |lockfd|
+      locked = lockfd.flock(File::LOCK_EX | File::LOCK_NB)
+      if !locked
+        info = lockfd.read
+        raise "Store is currently locked, cannot write to it. (info: #{info})"
+      end
+      lockfd.rewind
+      lockfd.write("pid:$$")
+      lockfd.flush
+      
+      block.call
+    end
+
+    # This step is not required for flock(2) to work, but it should help to
+    # keep users from being confused.
+    File.delete(lockfile)
+  end # def lock
+
+  def store(dsl)
+    basedir = path(dsl.environment)
+    manifest_path = File.join(basedir, ".batcave", "manifest")
+    FileUtils.mkdir_p(File.join(basedir, ".batcave"))
+
+    lock(manifest_path) do
+      manifest = load(manifest_path)
+      # Store this thing.
+      manifest["things"][dsl.thing] = dsl.to_hash
+
+      # Write the manifest to a tmpfile and rename it.
+      tmpfile = manifest_path + ".tmp"
+      File.open(tmpfile, "w") do |tmp|
+        tmp.write(manifest.to_yaml)
+        tmp.flush
+      end
+      File.rename(tmpfile, manifest_path)
+    end
+  end # def store
+
+  def each(environment, &block)
+    basedir = path(environment)
+    manifest_path = File.join(basedir, ".batcave", "manifest")
+    manifest = load(manifest_path)
+    manifest["things"].each do |thing|
+      yield thing
+    end
+  end # def each
+
+  def load(manifest_path)
+    manifest = {}
+    if File.exists?(manifest_path)
+      fd = File.new(manifest_path, "a+")
+      # Load the current manifest so we can modify it
+      manifest = YAML.load(fd.read)
+      manifest = {} if !manifest
+      fd.close
+    end
+
+    # Handle empty manifest. (YAML.load returns false for empty files)
+    manifest["things"] ||= {}
+    return manifest
+  end # def manifest
+end # class BatCave::Store

data/lib/batcave/support/envpath.rb

@@ -0,0 +1,14 @@
+require "batcave/namespace"
+
+module BatCave::Support::EnvPath
+  def path(environment)
+    case environment.to_sym
+      when :user
+        return ENV["HOME"]
+      when :project
+        return project_root
+      else
+        raise "Unsupported environment '#{environment}'"
+    end
+  end # def path
+end

data/lib/batcave/support/git.rb

@@ -2,10 +2,12 @@ require "batcave/namespace"
 
 module BatCave::Support::Git
   def project_root
+    return @project_root if instance_variable_defined?(:@project_root)
     root = %x{git rev-parse --show-toplevel}.chomp
     if $?.exitstatus != 0
       raise "'git rev-parse --show-toplevel' failed. No project root found. Is this in a git clone?"
     end
+    @project_root = root
     return root
   end # def project_root
 end # class BatCave::Support::Git

data/things/dotfiles/self/THING

@@ -0,0 +1,6 @@
+options do
+  parameter "SOURCE", "The source of your dotfiles (git repo, etc?)", :attribute_name => :source
+end
+
+environment :user
+source @source

data/things/go/self/THING

@@ -0,0 +1,8 @@
+environment :project
+
+# Don't overwrite these files on update
+create_only [ "src/{name}/{name}.go" ]
+
+options do
+  parameter "NAMES ...", "The name of the project", :attribute_name => :names
+end

data/things/ruby/self/THING

@@ -1 +1,10 @@
+environment :project
+
+# Don't overwrite these files on update
+create_only [ "Gemfile", "{name}.gemspec" ]
+
+options do
+  parameter "NAME", "The name of the project", :attribute_name => :name
+end
+
 boilerplate = [ "Gemfile" ]

data/things/ruby/self/{name}.gemspec.erb

@@ -0,0 +1,20 @@
+Gem::Specification.new do |spec|
+  files = %x{git ls-files}
+
+  spec.name = "<%= name %>"
+  spec.version = "0.0.1"
+  spec.summary = "<%= name %>"
+  spec.description = "<%= name %>"
+  spec.license = "none chosen yet"
+
+  # Note: You should set the version explicitly.
+  spec.add_dependency "cabin", ">0" # for logging. apache 2 license
+  spec.files = files
+  spec.require_paths << "lib"
+  spec.bindir = "bin"
+
+  spec.authors = ["<%= %x{git config --global user.name}.chomp %>"]
+  spec.email = ["<%= %x{git config --global user.email}.chomp %>"]
+  #spec.homepage = "..."
+end
+

data/things/user.sh/THING

@@ -0,0 +1,7 @@
+environment :user
+
+options do
+  parameter "COMMAND", "The command to run", :attribute_name => :command
+end
+
+system(@command)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: batcave
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-14 00:00:00.000000000 Z
+date: 2012-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
-  requirement: &17501600 !ruby/object:Gem::Requirement
+  requirement: &4815200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +21,8 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *17501600
-description: 
+  version_requirements: *4815200
+description: Experiments in tools, boilerplatery, debugging, etc.
 email: jls@semicomplete.com
 executables:
 - dk
@@ -35,11 +35,16 @@ files:
 - README.md
 - batcave.gemspec
 - bin/dk
+- lib/batcave/action/add.rb
 - lib/batcave/command/add.rb
 - lib/batcave/command/update.rb
+- lib/batcave/dsl.rb
 - lib/batcave/main.rb
 - lib/batcave/namespace.rb
+- lib/batcave/store.rb
+- lib/batcave/support/envpath.rb
 - lib/batcave/support/git.rb
+- things/dotfiles/self/THING
 - things/go/self/THING
 - things/go/self/src/{name}/{name}.go
 - things/ruby/self/Gemfile
@@ -47,6 +52,8 @@ files:
 - things/ruby/self/test/all.rb
 - things/ruby/self/test/docs.rb
 - things/ruby/self/test/testing.rb
+- things/ruby/self/{name}.gemspec.erb
+- things/user.sh/THING
 homepage: https://github.com/jordansissel/batcave
 licenses: []
 post_install_message: 
@@ -67,9 +74,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-summary: ''
+summary: Experiments in tools, boilerplatery, debugging, etc.
 test_files: []
-has_rdoc: