win32-captureie 0.1.0

data/lib/win32/capture_ie/cli/prt_ie.rb

@@ -0,0 +1,100 @@
+require "optparse"
+
+require "win32/capture_ie/cli/base"
+require "win32/capture_ie/commands/prt_ie"
+
+
+module Win32::CaptureIE::CLI
+  class PrtIE #:nodoc:
+
+    DEFAULT_ARGUMENTS = %W(--output-digest=MD5)
+
+    def self.start(args)
+      self.new.perform(args)
+    end
+
+
+    def arguable(arr_or_arguable)
+      case arr_or_arguable
+      when OptionParser::Arguable
+        arr_or_arguable
+      when Array
+        arr_or_arguable.dup.extend(OptionParser::Arguable)
+      else
+        raise ArgumentError, "Invalid option `#{arr_or_arguable.inspect}:#{arr_or_arguable.class}'" +
+                             " (expected Array or OptionParser::Arguable)"
+      end
+    end
+
+    def usage_and_exit(exit_code, message, parser, out=$stdout)
+      m = message.sub(/\.?\z/, ".")
+      out.puts "Error: #{m}"
+      out.puts parser
+      exit(2)
+    end
+
+    def perform(args)
+      opt, parser = parse_options(arguable(args))
+      act = Win32::CaptureIE::Commands::PrtIE::Action.new
+      begin
+        act.perform(opt)
+      rescue ArgumentError => e
+        usage_and_exit(2, e.message, parser)
+      end
+    end
+
+    def option_parser(opt)
+      Proc.new do |parser|
+        parser.program_name = "prtie"
+        parser.version = Win32::CaptureIE::VERSION::STRING
+        parser.banner = "Usage: #{parser.program_name} [options] URL"
+        parser.separator ""
+        parser.on("-w", "--wait=SECONDS", Float, "wait SECONDS between retrievals") {|v|
+          opt.wait = v
+        }
+        parser.on("-d", "--output-directory=DIRECTORY", "save capture to DIRECTORY/...") {|v|
+          opt.outdir = v
+        }
+        parser.on("-o", "--output=FILE", "save capture to FILE") {|v|
+          opt.output = v
+        }
+        parser.on("-D", "--output-digest=ALGORITHM",
+                  "use output filename as hex-encoded version",
+                  "of a given URL",
+                  "ALGORITHM: MD5, SHA1, SHA512 ...") {|v|
+          opt.output_digest = v
+        }
+
+        parser.separator ""
+        parser.on("-v", "--version", "print the version"){
+          puts parser.ver
+          exit 0
+        }
+        parser.on("-h", "--help", "print this message"){
+          puts parser
+          exit 0
+        }
+
+        parser.separator ""
+        parser.separator "  Default options:"
+        parser.separator "    #{DEFAULT_ARGUMENTS * ' '}"
+        parser
+      end
+    end
+
+    def parse_options(args)
+      opt = Win32::CaptureIE::Commands::PrtIE::Option.new
+      proc = option_parser(opt)
+      arguable(DEFAULT_ARGUMENTS).options(&proc).parse!
+      parser = args.options(&proc)
+      begin
+        parser.parse!
+      rescue OptionParser::ParseError => e
+        usage_and_exit(2, e.message, parser)
+      end
+      opt.url = ARGV.shift
+      [opt, parser]
+    end
+
+  end
+end

data/lib/win32/capture_ie/commands/base.rb

@@ -0,0 +1,39 @@
+module Win32
+  module CaptureIE
+    module Commands #:nodoc:
+    end
+  end
+end
+
+module Win32::CaptureIE::Commands
+  class OptionBase #:nodoc:
+    def self.define_option_category(name)
+      class_eval %Q{
+        @@#{name} = Hash.new{|h,k| h[k] = []}
+        def self.#{name}(*names)
+          attr_accessor *names
+          @@#{name}[self].concat(names)
+        end
+
+        def self.#{name}s
+          @@#{name}[self]
+        end
+
+        def init_#{name}s
+          self.class.#{name}s.each do |e|
+            instance_variable_set("@\#{e}", nil)
+          end
+        end
+      }
+    end
+
+    define_option_category(:local_option)
+    define_option_category(:global_option)
+
+    def initialize
+      init_local_options
+      init_global_options
+    end
+
+  end
+end

data/lib/win32/capture_ie/commands/prt_ie.rb

@@ -0,0 +1,66 @@
+require "fileutils"
+require "digest/md5"
+
+require "win32/capture_ie"
+require "win32/capture_ie/commands/base"
+
+
+module Win32::CaptureIE::Commands
+  module PrtIE #:nodoc:
+
+    class Option < OptionBase #:nodoc:
+      global_option :outdir, :wait, :output_digest
+      local_option :output, :url
+      attr_reader :ext
+
+      def initialize
+        @ext = "bmp"
+      end
+
+      def check_options
+        raise_arg_error(url, "missing url argument")
+        raise_arg_error(output || output_digest, "missing output or output-digest argument")
+        if output_digest
+          begin
+            Digest(output_digest)
+          rescue => e
+            raise ArgumentError, e.message
+          end
+        end
+      end
+
+      def raise_arg_error(ok, msg)
+        raise ArgumentError, msg unless ok
+      end
+
+      def digest_url
+        Digest(output_digest).hexdigest(url)
+      end
+
+      def fixup!
+        self.wait = 0 if wait.nil? or wait < 0
+      end
+
+      def outfile
+        base = output || "#{digest_url}.#{ext}"
+        r = File.expand_path(base, outdir)
+        dir = File.dirname(r)
+        ::FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        r
+      end
+    end
+
+    class Action #:nodoc:
+      def perform(opt)
+        opt.fixup!
+        opt.check_options
+        Win32::CaptureIE.start do |ie|
+          ie.navigate(opt.url, true)
+          sleep(opt.wait) if opt.wait > 0
+          ie.capture_page(opt.outfile)
+        end
+      end
+    end
+
+  end
+end

data/lib/win32/capture_ie/ffi/base.rb

@@ -0,0 +1,22 @@
+require "Win32API"
+
+module Win32::CaptureIE
+  module FFI #:nodoc:
+  end
+
+  class Win32APIError < StandardError #:nodoc:
+  end
+end
+
+module Win32::CaptureIE::FFI
+  module Base #:nodoc:
+    def define_ffi_entry(const, args, ret, lib, entry=const.to_s)
+      api = ::Win32API.new(lib, entry, args, ret)
+      const_set(const, api)
+      define_method(const) do |*args|
+        api.call(*args)
+      end
+      module_function const
+    end
+  end
+end

data/lib/win32/capture_ie/ffi/gdi32.rb

@@ -0,0 +1,165 @@
+require "win32/capture_ie/ffi/base"
+require "win32/capture_ie/ffi/struct"
+
+module Win32::CaptureIE::FFI
+  module GDI32 #:nodoc:
+    extend Win32::CaptureIE::FFI::Base
+    extend Win32::CaptureIE::FFI::CStruct
+
+    define_c_type(:uint8, :BYTE)
+    define_c_type(:uint16, :WORD)
+    define_c_type(:uint32, :DWORD)
+    define_c_type(:int32, :LONG)
+
+    define_c_struct(:RGBQUAD) {
+      BYTE :rgbBlue
+      BYTE :rgbGreen
+      BYTE :rgbRed
+      BYTE :rgbReserved
+    }
+
+    define_c_struct(:BITMAPINFOHEADER) {
+      DWORD      :biSize
+      LONG       :biWidth
+      LONG       :biHeight
+      WORD       :biPlanes
+      WORD       :biBitCount
+      DWORD      :biCompression
+      DWORD      :biSizeImage
+      LONG       :biXPelsPerMeter
+      LONG       :biYPelsPerMeter
+      DWORD      :biClrUsed
+      DWORD      :biClrImportant
+    }
+
+    define_c_struct(:BITMAPINFO) {
+      BITMAPINFOHEADER    :bmiHeader
+      RGBQUAD             :bmiColors, :dim => 1
+    }
+
+    define_c_struct(:BITMAPFILEHEADER) {
+      WORD    :bfType
+      DWORD   :bfSize, :offset => 2
+      WORD    :bfReserved1
+      WORD    :bfReserved2
+      DWORD   :bfOffBits, :offset => 10
+    }
+
+    DRIVERVERSION = 0
+    TECHNOLOGY    = 2
+    HORZSIZE      = 4
+    VERTSIZE      = 6
+    HORZRES       = 8
+    VERTRES       = 10
+    BITSPIXEL     = 12
+    PLANES        = 14
+    NUMBRUSHES    = 16
+    NUMPENS       = 18
+    NUMMARKERS    = 20
+    NUMFONTS      = 22
+    NUMCOLORS     = 24
+    PDEVICESIZE   = 26
+    CURVECAPS     = 28
+    LINECAPS      = 30
+    POLYGONALCAPS = 32
+    TEXTCAPS      = 34
+    CLIPCAPS      = 36
+    RASTERCAPS    = 38
+    ASPECTX       = 40
+    ASPECTY       = 42
+    ASPECTXY      = 44
+
+    DIB_RGB_COLORS = 0
+    DIB_PAL_COLORS = 1
+
+    # Raster operations
+    SRCCOPY      = 0x00CC0020
+    SRCPAINT     = 0x00EE0086
+    SRCAND       = 0x008800C6
+    SRCINVERT    = 0x00660046
+    SRCERASE     = 0x00440328
+    NOTSRCCOPY   = 0x00330008
+    NOTSRCERASE  = 0x001100A6
+    MERGECOPY    = 0x00C000CA
+    MERGEPAINT   = 0x00BB0226
+    PATCOPY      = 0x00F00021
+    PATPAINT     = 0x00FB0A09
+    PATINVERT    = 0x005A0049
+    DSTINVERT    = 0x00550009
+    BLACKNESS    = 0x00000042
+    WHITENESS    = 0x00FF0062
+
+    # constants for the biCompression field
+    BI_RGB       = 0
+    BI_RLE8      = 1
+    BI_RLE4      = 2
+    BI_BITFIELDS = 3
+    BI_JPEG      = 4
+    BI_PNG       = 5
+
+    define_ffi_entry(:BitBlt, "LIIIILIIL", "B", "gdi32")
+    define_ffi_entry(:CreateCompatibleDC, "L", "L", "gdi32")
+    define_ffi_entry(:CreateCompatibleBitmap, "LII", "L", "gdi32")
+    define_ffi_entry(:DeleteDC, "L", "B", "gdi32")
+    define_ffi_entry(:DeleteObject, "L", "B", "gdi32")
+    define_ffi_entry(:GetDIBits, "LLIIPPI", "I", "gdi32")
+    define_ffi_entry(:SelectObject, "LL", "L", "gdi32")
+
+    module_function
+
+    def with_delete_dc(hdc)
+      begin
+        yield hdc
+      ensure
+        DeleteDC(hdc)
+      end
+    end
+
+    def with_delete_object(obj)
+      begin
+        yield obj
+      ensure
+        DeleteObject(obj)
+      end
+    end
+
+  end
+end
+
+
+__END__
+from WinGDI.h
+
+typedef struct tagBITMAPINFOHEADER{
+        DWORD      biSize;
+        LONG       biWidth;
+        LONG       biHeight;
+        WORD       biPlanes;
+        WORD       biBitCount;
+        DWORD      biCompression;
+        DWORD      biSizeImage;
+        LONG       biXPelsPerMeter;
+        LONG       biYPelsPerMeter;
+        DWORD      biClrUsed;
+        DWORD      biClrImportant;
+} BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;
+
+typedef struct tagRGBQUAD {
+        BYTE    rgbBlue;
+        BYTE    rgbGreen;
+        BYTE    rgbRed;
+        BYTE    rgbReserved;
+} RGBQUAD;
+
+typedef struct tagBITMAPINFO {
+    BITMAPINFOHEADER    bmiHeader;
+    RGBQUAD             bmiColors[1];
+} BITMAPINFO, FAR *LPBITMAPINFO, *PBITMAPINFO;
+
+typedef struct tagBITMAPFILEHEADER {
+        WORD    bfType;
+        DWORD   bfSize;
+        WORD    bfReserved1;
+        WORD    bfReserved2;
+        DWORD   bfOffBits;
+} BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;

data/lib/win32/capture_ie/ffi/struct.rb

@@ -0,0 +1,246 @@
+require "win32/capture_ie/ffi/base"
+
+module Win32::CaptureIE::FFI
+
+  class Type #:nodoc:
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class PrimitiveType < Type #:nodoc:
+    BASE_TYPES = {
+      :int8    => ["c", 1],
+      :uint8   => ["C", 1],
+      :int16   => ["s", 2],
+      :uint16  => ["S", 2],
+      :int32   => ["l", 4],
+      :uint32  => ["L", 4],
+      :float   => ["f", 4],
+      :double  => ["d", 8],
+      :string  => ["p", 4],
+      :pointer => ["P", 4],
+    }
+
+    attr_reader :size, :format
+    def initialize(name, size=guess_size(name), format=guess_format(name))
+      super(name)
+      @size = size
+      @format = format
+    end
+
+    def pack(value)
+      [value].pack(format)
+    end
+
+    def guess_format(name)
+      BASE_TYPES[name][0]
+    end
+    private :guess_format
+
+    def guess_size(name)
+      BASE_TYPES[name][1]
+    end
+    private :guess_size
+  end
+
+  class StructureType < Type #:nodoc:
+    PACKING_ALIGN = 4
+
+    attr_reader :name, :size, :ruby_class, :fields
+    def initialize(name, size=nil)
+      super(name)
+      @ruby_class = nil
+      @fields = []
+      @size = size
+    end
+
+    def calc_offsets
+      offset = 0
+      @fields.each do |f|
+        align = [f.type.size, PACKING_ALIGN].min
+        offset = (offset.to_f / align).ceil * align
+        size = f.size
+        if f.offset.nil?
+          f.offset = offset
+          offset += size
+        else
+          offset = f.offset
+          offset += size
+        end
+      end
+    end
+
+    def calc_size
+      return @size if @size
+      if @fields.empty?
+        @size = 0
+        return
+      end
+      align = [@fields.first.type.size, PACKING_ALIGN].min
+      offset = @fields.last.offset + @fields.last.size
+      @size = (offset.to_f / align).ceil * align
+    end
+
+    def pack(value)
+      packed = @fields.zip(value.values).map{|f,v| [f.offset, f.pack(v)] }
+      r = ""
+      packed.each do |offset,c|
+        align!(r, offset)
+        r << c
+      end
+      align!(r, size)
+      r
+    end
+
+    def align!(r, offset)
+      if offset < r.length
+        raise "buffer over flow: expected offset #{offset}, but was #{r.length}"
+      end
+      if r.length < offset
+        r << "\0" * (offset - r.length)
+      end
+    end
+
+    def define!(ns)
+      calc_offsets
+      calc_size
+      define_ruby_class(ns)
+    end
+
+    def define_ruby_class(ns)
+      types = self
+      name = @name
+      clazz = Class.new
+      clazz.instance_eval {
+        types.fields.each {|f|
+          attr_accessor f.name
+        }
+        define_method(:initialize) {|*args|
+          types.fields.zip(args).each {|f,arg|
+            instance_variable_set(f.var, arg || f.init)
+          }
+        }
+        define_method(:pack) {
+          types.pack(self)
+        }
+      }
+      clazz.class_eval %Q{
+        def names
+          [#{types.fields.map{|f| ":#{f.name}"} * ','}]
+        end
+        def values
+          [#{types.fields.map{|f| f.var} * ','}]
+        end
+      }
+      (class <<clazz; self; end).instance_eval {
+        define_method(:packed_size) {
+          CStruct.sizeof(name)
+        }
+        define_method(:c_type) {
+          CStruct.c_type(name)
+        }
+      }
+      @ruby_class = clazz
+      ns.const_set(@name, clazz)
+    end
+  end
+
+  class Field #:nodoc:
+    attr_reader :type, :name, :count, :var
+    attr_accessor :offset
+    def initialize(type, name, opts=nil)
+      @type = type
+      @name = name
+      @var = "@#{name}".to_sym
+      @opts = opts || {}
+      @offset = @opts[:offset] || nil
+      @count = @opts[:dim] || 1
+    end
+
+    def array?
+      count > 0
+    end
+
+    def init
+      if array?
+        init_one
+      else
+        (0...count).map{ init_one }
+      end
+    end
+
+    def size
+      @type.size * count
+    end
+
+    def pack(value)
+      if count == 1
+        @type.pack(value)
+      else
+        raise "hoge" unless Array === value
+        raise "foo" unless value.length == count
+        value.map{|e| @type.pack(e) }.join
+      end
+    end
+
+    def init_one
+      if PrimitiveType === @type
+        0
+      else
+        @type.ruby_class.new
+      end
+    end
+    private :init_one
+  end
+
+  module CStruct #:nodoc:
+    TYPES = PrimitiveType::BASE_TYPES.inject({}){|h,t|
+      h[t[0]] = PrimitiveType.new(t[0])
+      h
+    }
+
+    def define_c_struct(name, size=nil, &block)
+      define_c_struct_under(self, name, size, &block)
+    end
+
+    module_function
+
+    def define_c_struct_under(ns, name, size=nil, &block)
+      dsl = DSL.new(name, size)
+      dsl.instance_eval(&block)
+      dsl.struct.define!(ns)
+      TYPES[name] = dsl.struct
+      dsl.struct
+    end
+
+    def sizeof(type)
+      c_type(type).size
+    end
+
+    def c_type(type)
+      TYPES[type]
+    end
+
+    def define_c_type(type, decl)
+      TYPES[decl] = TYPES[type]
+    end
+
+    class DSL #:nodoc:
+      attr_reader :struct
+
+      def initialize(name, size)
+        @struct = StructureType.new(name, size)
+      end
+
+      def method_missing(name, *args)
+        type = CStruct.c_type(name)
+        raise "unknown type: #{name}" unless type
+        name = args.shift
+        @struct.fields << Field.new(type, name, *args)
+      end
+    end
+  end
+
+end