BxMS 0.0.18

data/src/bxms.rb

@@ -0,0 +1,61 @@
+
+require 'optparse'
+require 'ostruct'
+
+require 'bxms/processor'
+
+
+
+options = OpenStruct.new
+options.site_dir = nil
+options.output_dir = 'output'
+options.verbose = false
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+
+  opts.separator ""
+
+  opts.on( "-i", "--input=dir", String, "Directory containing the site data" ) do |val|
+    options.site_dir = val
+  end
+  opts.on( "-o", "--output=dir", String, "Directory where output should be placed" ) do |val|
+    options.output_dir = val
+  end
+
+  opts.on( "-v", "--verbose", "Run verbosely" ) do |val|
+    options.verbose = true
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!( ARGV )
+
+options.site_dir = ARGV.delete_at( 0 ) if !options.site_dir && ARGV.length > 0
+options.output_dir = ARGV.delete_at( 0 ) if !options.output_dir && ARGV.length > 0
+
+
+def normalize( filename )
+  filename.gsub '\\', '/' if filename
+end
+
+def fail( message )
+  puts "ERROR: #{message}"
+  exit 10
+end
+
+source = normalize options.site_dir
+destination = normalize options.output_dir
+
+fail "Missing input folder" unless source
+fail "Not a valid input folder: #{source}" unless File.directory? source
+
+destination = File.join( destination, File.basename( source ) )
+
+bxms = BxMS::Processor.new
+bxms.verbose = options.verbose
+bxms.process :from => source, :to => destination

data/src/bxms/context.rb

@@ -0,0 +1,96 @@
+
+require 'util/system_logger'
+
+module BxMS
+
+  class Context
+
+    def initialize( input_file, state )
+      @logger = Util::SystemLogger.new 'Context'
+      @input_file = input_file
+      @state = state
+
+      @variables = BxMS::Variables.new @state.variables
+
+      set_variable :input_file, @input_file
+      set_variable :context, self
+
+      define_methods
+    end
+
+    def load_file( file_name )
+      local_file = state.get_local_file( file_name )
+      return IO.read( local_file ) if File.exists? local_file
+
+      root_file = state.get_root_file( file_name )
+      return IO.read( root_file ) if File.exists? root_file
+
+      raise "Unable to find #{file_name}"
+    end
+
+    def run_erb_on( template, file_name )
+      body = template
+      loop do
+        new_body = erbify body, file_name
+        break if new_body == body
+        body = new_body
+      end
+      body
+    end
+
+    def eval_ruby( ruby_code, file_name = @input_file, line = 0 )
+      eval ruby_code, binding, file_name, line
+    end
+
+    def add_method( symbol, &block )
+      self.class.send :define_method, symbol, block
+    end
+
+    def set_variable( key, val )
+      @variables[ key ] = val
+    end
+
+    def set_variables( new_variables )
+      new_variables.each_pair { |k,v| set_variable k, v }
+    end
+
+    def get_binding
+      binding
+    end
+
+    protected
+
+    def erbify( template, file_name )
+      erb = ERB.new template
+      erb.filename = file_name
+      erb.result binding
+    end
+
+    def define_methods
+      @state.tags.each_pair do |name,impl|
+        impl.define_in self
+      end
+      @state.functions.each_pair do |name,impl|
+        impl.define_in self
+      end
+    end
+
+    alias original_missing method_missing
+
+    def method_missing( symbol, *args )
+      original_missing symbol, *args unless @variables.has_key? symbol
+      raise "Variable collides with existing symbol" if self.respond_to? symbol
+
+      self.class.send :define_method, symbol do
+        @variables[ symbol ]
+      end
+      self.class.send :define_method, "#{symbol}=".to_sym do |val|
+        @variables[ symbol ] = val
+      end
+
+      send symbol, *args
+    end
+
+  end
+
+end

data/src/bxms/functions.rb

@@ -0,0 +1,39 @@
+
+require 'util/chained_hash'
+require 'util/system_logger'
+
+module BxMS
+
+  class Functions < Util::ChainedHash
+
+    def initialize( parent = nil )
+      super parent
+      @logger = Util::SystemLogger.new 'BxMS::Functions'
+    end
+
+    def load( file_name )
+      return unless File.file? file_name
+      function_name = File.basename file_name, '.*'
+      function_code = IO.read file_name
+      self[ function_name ] = Function.new function_code, file_name
+      @logger.info "Loaded function #{function_name} from #{file_name}"
+    end
+
+  end
+
+  class Function
+
+    attr_reader :file_name
+
+    def initialize( code, file_name )
+      @code = code
+      @file_name = file_name
+    end
+
+    def define_in( context )
+      eval @code, context.get_binding, @file_name
+    end
+
+  end
+
+end

data/src/bxms/processor.rb

@@ -0,0 +1,53 @@
+
+require 'bxms/root_state'
+require 'bxms/state'
+
+module BxMS
+
+  class Processor
+
+    DIRECT_IGNORES = [ '.', '..', '.functions', '.rules', '.tags', '.templates', '.svn', 'CVS' ]
+
+    attr_writer :verbose
+
+    def process( from_to_hash )
+      from_dir = from_to_hash[ :from ]
+      to_dir = from_to_hash[ :to ]
+
+      root = RootState.new from_dir, to_dir
+      recurse root
+    end
+
+    def recurse( parent_state, directory = nil )
+      state = State.new parent_state, directory
+      puts "Processing #{state.input_dir} to #{state.output_dir}" if @verbose
+
+      sub_dirs = []
+      list state.input_dir do |file|
+        sub_dirs << file if File.directory? file
+        handle_file file, state if File.file? file
+      end
+
+      sub_dirs.each do |dir|
+        recurse state, dir
+      end
+    end
+
+    def list( directory )
+      Dir.foreach( directory ) do |file|
+        next if DIRECT_IGNORES.include? file
+        yield File.join( directory, file )
+      end
+    end
+
+    def handle_file( file_name, state )
+      state.set_variable :current_file_name, file_name
+      state.set_variable :current_file, File.new( file_name )
+      rule = state.rules[ file_name ]
+      puts "#{rule.name} #{file_name} to #{state.output_dir}" if @verbose
+      rule.apply_to file_name, state
+    end
+
+  end
+
+end

data/src/bxms/root_state.rb

@@ -0,0 +1,30 @@
+
+require 'bxms/functions'
+require 'bxms/tags'
+require 'bxms/variables'
+
+module BxMS
+
+  class RootState
+
+    attr_reader :source_dir
+    attr_reader :target_dir
+
+    attr_reader :functions
+    attr_reader :rules
+    attr_reader :tags
+    attr_reader :variables
+
+    def initialize( source_dir, target_dir )
+      @source_dir = source_dir
+      @target_dir = target_dir
+
+      @functions = Functions.new
+      @rules = Rules.new
+      @tags = Tags.new
+      @variables = Variables.new
+    end
+
+  end
+
+end

data/src/bxms/rules.rb

@@ -0,0 +1,82 @@
+
+module BxMS
+
+  RULES_DIR = 'rules'
+
+  class Rules
+
+    def initialize( parent = nil )
+      @logger = Util::SystemLogger.new 'BxMS::Rules'
+      @parent = parent
+      @rules = []
+    end
+
+    def []( filename )
+      @rules.each do |rule|
+        return rule.command if rule.matches? filename
+      end
+      return @parent[ filename ] if @parent
+      raise "No rule for #{filename}"
+    end
+
+    def load( file_name )
+      @logger.info "Loading rules from #{file_name}"
+      lines = File.readlines file_name
+      lines.each { |rule| add_rule rule }
+    end
+
+    def add_rule( rule_spec )
+      pattern, command = rule_spec.chomp.split( /[ \t]+/ )
+      raise "Bad rule spec: #{rule_spec}" unless pattern && command
+      @rules << Rule.new( pattern, command )
+    end
+
+  end
+
+  class Rule
+
+    def initialize( pattern, command )
+      raise "Invalid pattern: #{pattern}" unless is_valid? pattern
+      raise "Invalid command: #{command}" unless is_valid? command
+
+      init_pattern pattern
+      init_command command
+    end
+
+    def matches?( filename )
+      @pattern =~ filename
+    end
+
+    def command
+      @command
+    end
+
+    protected
+
+    def is_valid?( input )
+      input && input.length > 0
+    end
+
+    def init_pattern( pattern )
+      pattern = Regexp.escape( pattern )
+      pattern = pattern.gsub( '\?', '.' ).gsub( '\*', '.*' )
+      @pattern = Regexp.new pattern
+    end
+
+    def init_command( command )
+      command_file = File.join RULES_DIR, ( command + '.rb' )
+      command_class = get_class_name command
+
+      load command_file
+      @command = eval "::Rules::#{command_class}Rule.new", binding
+    end
+
+    def get_class_name( command_name )
+      parts = command_name.split '_'
+      parts.map! { |part| part.capitalize }
+      parts.join ''
+    end
+
+  end
+
+end

data/src/bxms/state.rb

@@ -0,0 +1,105 @@
+
+require 'bxms/root_state'
+require 'bxms/rules'
+
+module BxMS
+
+  class State
+
+    attr_reader :input_dir
+    attr_reader :output_dir
+    attr_reader :relative_root
+
+    attr_reader :variables
+    attr_reader :functions
+    attr_reader :rules
+    attr_reader :tags
+
+    def initialize( parent, directory = nil )
+      @parent = parent
+
+      relative_dir = make_relative source_dir, directory
+
+      @input_dir = make_absolute source_dir, relative_dir
+      @output_dir = make_absolute target_dir, relative_dir
+      @relative_root = get_relative_root relative_dir
+
+      @variables = Variables.new parent.variables
+      @functions = Functions.new parent.functions
+      @rules = Rules.new parent.rules
+      @tags = Tags.new parent.tags
+
+      load_local @functions, '.functions/*.{rb}'
+      load_local @tags, '.tags/*'
+      load_local @rules, '.rules'
+
+      set_variables
+    end
+
+    def source_dir
+      @parent.source_dir
+    end
+
+    def target_dir
+      @parent.target_dir
+    end
+
+    def get_root_file( file_name )
+      File.join source_dir, file_name
+    end
+
+    def get_local_file( file_name )
+      File.join input_dir, file_name
+    end
+
+    def get_output_file_for( input_file )
+      relative_file = make_relative source_dir, input_file
+      output_file = make_absolute target_dir, relative_file
+      FileUtils.mkdir_p File.dirname( output_file )
+      output_file
+    end
+
+    def set_variable( key, val )
+      @variables[ key.to_sym ] = val
+    end
+
+    protected
+
+    def set_variables
+      set_variable :state, self
+      set_variable :input_dir, input_dir
+      set_variable :output_dir, output_dir
+      set_variable :relative_root, relative_root
+    end
+
+    def load_local( container, pattern )
+      full_pattern = get_local_file pattern
+      Dir.glob( full_pattern ) { |file_name| container.load file_name }
+    end
+
+    def make_relative( parent_dir, file_name )
+      return '' unless file_name
+      pattern = Regexp.escape parent_dir
+      get_valid file_name.sub( Regexp.new( "^#{pattern}\/?" ), '' )
+    end
+
+    def make_absolute( parent_dir, file_name )
+      return parent_dir unless file_name
+      get_valid File.join( parent_dir, file_name )
+    end
+
+    def get_relative_root( relative_dir )
+      relative_root = "#{relative_dir}".gsub( /[^\/]+/, '..' )
+      relative_root = '.' unless relative_root.length > 0
+      relative_root
+    end
+
+    def get_valid( directory )
+      raise "Invalid directory" unless directory && directory.size > 1
+      directory.chop! if directory[ -1, 1 ] == File::SEPARATOR
+      directory
+    end
+
+  end
+
+end