xot 0.1.12 → 0.1.13

data/lib/xot/rake/alias_task.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rake/task'
+
+
+module Xot
+
+
+  module Rake
+
+
+    class AliasTask < ::Rake::Task
+
+      def timestamp ()
+        prerequisite_tasks.map {|pre| pre.timestamp}.max || ::Rake::EARLY
+      end
+
+    end# AliasTask
+
+
+  end# Rake
+
+
+end# Xot
+
+
+module Rake
+  module DSL
+    def alias_task (*args, &block)
+      Xot::Rake::AliasTask.define_task *args, &block
+    end
+  end
+end

data/lib/xot/rake/escalation.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rake'
+
+
+module Rake
+  class Application
+
+    alias invoke_task_org invoke_task
+
+    def invoke_task (*args, &block)
+      invoke_task_org *args, &block
+    rescue RuntimeError => e
+      if e.message =~ /don't\s+know\s+.*\s+task\s+/i
+        escalate_tasks
+      else
+        raise
+      end
+    end
+
+    def escalate_tasks ()
+      Dir.chdir '..' do
+        cmd = "rake #{ARGV.join ' '}"
+        $stderr.puts "(in #{Dir.pwd}) #{cmd}"
+        system cmd
+      end
+      exit 0
+    end
+
+  end
+end

data/lib/xot/rake/util.rb

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+
+
+require 'erb'
+require 'rbconfig'
+
+
+module Xot
+
+
+  module Rake
+
+
+    def modules ()
+      env(:MODULES, []).map {|m| m::Module}
+    end
+
+    def target ()
+      modules.last
+    end
+
+    def target_name ()
+      env :MODNAME, target.name.downcase
+    end
+
+    def inc_dir ()
+      env :INCDIR, 'include'
+    end
+
+    def src_dir ()
+      env :SRCDIR, 'src'
+    end
+
+    def lib_dir ()
+      env :LIBDIR, 'lib'
+    end
+
+    def doc_dir ()
+      env :DOCDIR, 'doc'
+    end
+
+    def ext_dir ()
+      env :EXTDIR, "ext/#{target_name}"
+    end
+
+    def ext_lib_dir ()
+      env :EXTLIBDIR, "lib/#{target_name}"
+    end
+
+    def test_dir ()
+      env :TESTDIR, 'test'
+    end
+
+    def vendor_dir ()
+      env :VENDORDIR, 'vendor'
+    end
+
+    def inc_dirs ()
+      env_array(:INCDIRS, []) + modules.reverse.map {|m| m.inc_dir}.flatten
+    end
+
+    def src_dirs ()
+      env_array :SRCDIRS, []
+    end
+
+    def src_exts ()
+      env_array(:SRCEXTS, []) + %w[c cc cpp m mm]
+    end
+
+    def excludes ()
+      env_array :EXCLUDES, []
+    end
+
+    def excluded? (path)
+      excludes.any? {|s| path =~ %r{#{s}}}
+    end
+
+    def glob (*patterns)
+      paths = []
+      patterns.each do |pattern|
+        paths.concat Dir.glob(pattern)
+      end
+      paths
+    end
+
+    def compile_erb (path, out)
+      open(path) do |input|
+        open(out, 'w') do |output|
+          output.write compile_erb_str(input.read)
+        end
+      end
+    #rescue
+    end
+
+    def compile_erb_str (str)
+      ERB.new(str, nil, '%').result binding
+    end
+
+    def params (max, sep = '', &block)
+      raise 'block not given.' unless block
+      return '' if max == 0
+      (1..max).map(&block).join(sep)
+    end
+
+    def make_path_map (paths, ext_map)
+      paths = paths.map do |path|
+        newpath = ext_map.inject path do |value, (from, to)|
+          value.sub /#{from.gsub('.', '\.')}$/, to
+        end
+        raise "map to same path" if path == newpath
+        [path, newpath]
+      end
+      Hash[*paths.flatten]
+    end
+
+    def get_env (name, defval = nil)
+      val = ENV[name.to_s] || Object.const_get(name) rescue defval
+      val.dup rescue val
+    end
+
+    def env (name, defval = nil)
+      case val = get_env(name, defval)
+      when /^\d+$/        then val.to_i
+      when 'true',  true  then true
+      when 'false', false then false
+      when nil            then nil
+      else                     val
+      end
+    end
+
+    def env_array (name, defval = nil)
+      val = get_env name, defval
+      val = val.strip.split(/\s+/) if val.kind_of? String
+      val
+    end
+
+    def append_env (name, *args)
+      ENV[name] = (ENV[name] || '') + " #{args.join ' '}"
+    end
+
+    def make_cppflags (flags = '', defs = [], incdirs = [])
+      s  = flags.dup
+      s += make_cppflags_defs(defs)      .map {|s| " -D#{s}"}.join
+      s += make_cppflags_incdirs(incdirs).map {|s| " -I#{s}"}.join
+      s
+    end
+
+    def make_cppflags_defs (defs = [])
+      a  = defs.dup
+      a << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
+      a << (debug? ? '_DEBUG' : 'NDEBUG')
+      a << 'WIN32' if win32?
+      a << 'OSX'   if osx?
+      a << 'IOS'   if ios?
+      a
+    end
+
+    def make_cppflags_incdirs (dirs = [])
+      dirs.dup + ruby_inc_dirs
+    end
+
+    def ruby_inc_dirs ()
+      root = RbConfig::CONFIG['rubyhdrdir']
+      [root, RbConfig::CONFIG['rubyarchhdrdir'] || "#{root}/#{RUBY_PLATFORM}"]
+    end
+
+    def make_cflags (flags = '')
+      s  = flags.dup
+      s << ' -Wno-unknown-pragmas -Wno-reserved-user-defined-literal'
+      s << ' -std=c++11'                                          if gcc?
+      s << ' -std=c++11 -stdlib=libc++ -mmacosx-version-min=10.7' if clang?
+      s << ' ' + RbConfig::CONFIG['debugflags']                   if debug?
+      s.gsub! /-O\d?\w*/, '-O0'                                   if debug?
+      s
+    end
+
+    def make_ldflags (flags = '', libdirs = [], frameworks = [])
+      s  = flags.dup
+      s << libdirs.map    {|s| " -L#{s}"}.join
+      s << frameworks.map {|s| " -framework #{s}"}.join
+      s
+    end
+
+    def debug (state)
+      ENV['DEBUG'] = state.to_s
+    end
+
+    def debug? ()
+      env :DEBUG, false
+    end
+
+    def win32? ()
+      RUBY_PLATFORM =~ /mswin|ming|cygwin/
+    end
+
+    def mswin? ()
+      RUBY_PLATFORM =~ /mswin/
+    end
+
+    def ming? ()
+      RUBY_PLATFORM =~ /ming/
+    end
+
+    def cygwin? ()
+      RUBY_PLATFORM =~ /cygwin/
+    end
+
+    def osx? ()
+      RUBY_PLATFORM =~ /darwin/
+    end
+
+    def ios? ()
+      false
+    end
+
+    def gcc? ()
+      RbConfig::CONFIG['CXX'] =~ /(^|\s)g\+\+/i
+    end
+
+    def clang? ()
+      RbConfig::CONFIG['CXX'] =~ /(^|\s)clang/i
+    end
+
+    def cxx ()
+      env :CXX, RbConfig::CONFIG['CXX'] || 'g++'
+    end
+
+    def ar ()
+      env :AR, RbConfig::CONFIG['AR']  || 'ar'
+    end
+
+    def cppflags ()
+      flags = env :CPPFLAGS, RbConfig::CONFIG['CPPFLAGS']
+      make_cppflags flags, defs, inc_dirs
+    end
+
+    def cxxflags ()
+      flags = env :CXXFLAGS, RbConfig::CONFIG['CXXFLAGS']
+      make_cflags flags
+    end
+
+    def arflags ()
+      env :ARFLAGS, RbConfig::CONFIG['ARFLAGS'] || 'crs'
+    end
+
+
+  end# Rake
+
+
+end# Xot

data/lib/xot/setter.rb

@@ -18,7 +18,8 @@ module Xot
     private
 
       def set_value__ (name, *values)
-        raise ArgumentError unless name && !values.empty?
+        raise ArgumentError, "set '#{values}' to '#{name}'" if
+          !name || name.empty? || values.empty?
         __send__ "#{name}=", *values
       end
 

data/lib/xot/universal_accessor.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+
+module Xot
+
+
+  module UniversalAccessor
+
+    def universal_accessor (*names, **names_with_options)
+      names.each              {|name|       define_universal_accessor name}
+      names_with_options.each {|name, opts| define_universal_accessor name, opts}
+    end
+
+    private
+
+      def define_universal_accessor (name, options = {})
+        set = "ua_set_#{name}__"
+        get = "ua_get_#{name}__"
+        class_eval <<-END
+          alias_method :#{set}, options[:writer] || :#{name}=
+          alias_method :#{get}, options[:reader] || :#{name}
+          private :#{set}, :#{get}
+          def #{name} (*args)
+            #{set} *args unless args.empty?
+            #{get}
+          end
+        END
+      end
+
+  end# UniversalAccessor
+
+
+end# Xot
+
+
+class Module
+
+  include Xot::UniversalAccessor
+
+end# Module

data/src/debug.cpp

@@ -14,14 +14,14 @@ namespace Xot
 {
 
 
-#ifdef _DEBUG
+#ifdef XOT_USE_DOUT
 
 	void
 	dout (const char* format, ...)
 	{
 		va_list args;
 		va_start(args, format);
-		printf("%s", stringf(format, args).c_str());
+		fprintf(stderr, "%s", stringf(format, args).c_str());
 		va_end(args);
 	}
 
@@ -30,7 +30,7 @@ namespace Xot
 	{
 		va_list args;
 		va_start(args, format);
-		printf("%s\n", stringf(format, args).c_str());
+		fprintf(stderr, "%s\n", stringf(format, args).c_str());
 		va_end(args);
 	}
 

data/src/string.cpp

@@ -2,7 +2,8 @@
 
 
 #include <stdio.h>
-#include <boost/scoped_array.hpp>
+#include <algorithm>
+#include <memory>
 
 
 namespace Xot
@@ -18,6 +19,36 @@ namespace Xot
 	{
 	}
 
+	String
+	String::upcase () const
+	{
+		String s = c_str();
+		std::transform(
+			s.begin(), s.end(), s.begin(),
+			[](int c) {return toupper(c);});
+		return s;
+	}
+
+	String
+	String::downcase () const
+	{
+		String s = c_str();
+		std::transform(
+			s.begin(), s.end(), s.begin(),
+			[](int c) {return tolower(c);});
+		return s;
+	}
+
+	String
+	String::strip () const
+	{
+		String s = c_str();
+		auto isspace = [](int c) {return std::isspace(c);};
+		auto head = std::find_if_not(s.begin(), s.end(), isspace);
+		auto tail = std::find_if(    head,      s.end(), isspace);
+		return String(head, tail);
+	}
+
 	String::operator const char* () const
 	{
 		return c_str();
@@ -67,7 +98,7 @@ namespace Xot
 			return &stack[0];
 
 		int bufsize = BUFSIZE;// vscprintf(format, args);
-		boost::scoped_array<char> heap;
+		std::unique_ptr<char[]> heap;
 		while (true)
 		{
 			bufsize *= 2;