skeptick 0.1.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/foo.rb

@@ -0,0 +1 @@
+require 'minitest/autorun'; class FooTest < MiniTest::Unit::TestCase; def test_foo; assert_equal('0x0', '0x1') end end

data/lib/skeptick.rb

@@ -0,0 +1,2 @@
+require 'skeptick/core'
+require 'skeptick/sugar'

data/lib/skeptick/chain.rb

@@ -0,0 +1,55 @@
+require 'skeptick/helper'
+require 'skeptick/convert'
+require 'skeptick/chain/dsl_context'
+require 'skeptick/command'
+
+module Skeptick
+  class Chain
+    include Command::Executable
+
+    PIPE = 'miff:-'
+
+    def initialize(context, *args, &blk)
+      options = Helper.extract_options!(args)
+      @to = options[:to]
+      @context = context
+      @block = blk
+      reset
+    end
+
+    def convert(*args, &blk)
+      @executables << Convert.new(@context, *args, &blk)
+    end
+
+    def piping?
+      @executables.last && @executables.last.piping?
+    end
+
+    def process_method_missing(*args, &blk)
+      @context.send(*args, &blk)
+    end
+
+    def to_s
+      process_dsl
+      @executables.map(&:command).join(' | ')
+    end
+
+    def inspect
+      "Skeptick::Chain(#{to_s})"
+    end
+
+    private
+      def reset
+        @executables = []
+      end
+
+      def process_dsl
+        reset
+        DslContext.new(self).instance_eval(&@block)
+
+        if @executables.size > 0 && @to && piping?
+          @executables.last.destination = @to
+        end
+      end
+  end
+end

data/lib/skeptick/chain/dsl_context.rb

@@ -0,0 +1,21 @@
+module Skeptick
+  class Chain
+    class DslContext
+      def initialize(chain)
+        @chain = chain
+      end
+
+      def convert(*args, &blk)
+        @chain.convert(*args, &blk)
+      end
+
+      def pipe_or(path)
+        @chain.piping? ? :pipe : path
+      end
+
+      def method_missing(*args, &blk)
+        @chain.process_method_missing(*args, &blk)
+      end
+    end
+  end
+end

data/lib/skeptick/command.rb

@@ -0,0 +1,46 @@
+require 'shellwords'
+require 'posix/spawn'
+require 'skeptick/error'
+
+module Skeptick
+  class Command
+    module Executable
+      def command
+        Command.new(self)
+      end
+
+      def execute
+        command.run
+      end
+      alias_method :build, :execute
+      alias_method :run,   :execute
+    end
+
+    def initialize(command_obj)
+      @command_obj = command_obj
+    end
+
+    def command
+      @command_obj.to_s.shellsplit.shelljoin
+    end
+    alias_method :to_s, :command
+
+    def run
+      opts = {}
+      opts[:chdir] = Skeptick.cd_path.to_s if Skeptick.cd_path
+
+      if Skeptick.debug_mode?
+        Skeptick.log("Skeptick Command: #{command}")
+      end
+
+      im_process = POSIX::Spawn::Child.new(command, opts)
+
+      if !im_process.success?
+        raise ImageMagickError,
+          "ImageMagick error\nCommand: #{command}\nSTDERR:\n#{im_process.err}"
+      end
+
+      im_process.status
+    end
+  end
+end

data/lib/skeptick/convert.rb

@@ -0,0 +1,109 @@
+require 'skeptick/helper'
+require 'skeptick/image'
+require 'skeptick/chain'
+require 'skeptick/convert/dsl_context'
+require 'skeptick/command'
+
+module Skeptick
+  class Convert
+    include Command::Executable
+
+    attr_accessor :prepends, :appends
+
+    def initialize(context, *args, &blk)
+      @context = context
+      @options = Helper.extract_options!(args)
+      @args    = args.map {|a| Image.new(@context, a)}
+      @block   = blk
+      @to      = parse_pipe(@options[:to])
+      @inner   = false
+
+      @beginning = nil
+      @ending    = nil
+      @prepends  = []
+      @appends   = []
+
+      reset
+    end
+
+    def prepend(*args)
+      @prepends << Helper.process_args(*args)
+    end
+
+    def append(*args)
+      @appends << Helper.process_args(*args)
+    end
+
+    def set(*args)
+      @objects << Helper.process_args(*args)
+    end
+    alias_method :apply, :set
+    alias_method :with,  :set
+
+
+    def convert(*args, &blk)
+      Convert.new(@context, *args, &blk).tap do |c_obj|
+        @objects << Image.new(@context, c_obj)
+      end
+    end
+
+    def image(obj = nil, &blk)
+      @objects << Image.new(@context, obj, &blk)
+    end
+
+    def destination=(to)
+      if inner?
+        raise 'cannot assign output to parentheses-wrapped image conversion'
+      else
+        @to = to
+      end
+    end
+
+    def piping?
+      !inner? && parts.last == Chain::PIPE
+    end
+
+    def become_inner
+      @inner = true
+      self
+    end
+
+    def parts
+      reset
+      @objects = []
+      DslContext.new(self).instance_eval(&@block) if @block
+      wrap
+      [@beginning, *@prepends, *@args, *@objects, *@appends, @ending].compact
+    end
+
+    def to_s
+      parts.join(' ')
+    end
+
+    def inspect
+      "Skeptick::Convert(#{to_s})"
+    end
+
+    def process_method_missing(*args, &blk)
+      @context.send(*args, &blk)
+    end
+
+    private
+      def reset
+        @objects = []
+      end
+
+      def inner?
+        @inner
+      end
+
+      def wrap
+        @beginning = inner? ? '(' : 'convert'
+        @ending    = inner? ? ')' : @to || Chain::PIPE
+      end
+
+      def parse_pipe(obj)
+        obj == :pipe ? Chain::PIPE : obj
+      end
+  end
+end

data/lib/skeptick/convert/dsl_context.rb

@@ -0,0 +1,27 @@
+module Skeptick
+  class Convert
+    class DslContext
+      def initialize(convert)
+        @convert = convert
+      end
+
+      def set(*args)
+        @convert.set(*args)
+      end
+      alias_method :apply, :set
+      alias_method :with,  :set
+
+      def convert(*args, &blk)
+        @convert.convert(*args, &blk)
+      end
+
+      def image(obj = nil, &blk)
+        @convert.image(obj, &blk)
+      end
+
+      def method_missing(*args, &blk)
+        @convert.process_method_missing(*args, &blk)
+      end
+    end
+  end
+end

data/lib/skeptick/core.rb

@@ -0,0 +1,46 @@
+require 'skeptick/version'
+require 'skeptick/convert'
+require 'skeptick/image'
+require 'skeptick/chain'
+require 'skeptick/railtie' if defined?(Rails)
+
+module Skeptick
+  class << self
+    attr_writer :debug_mode,
+                :logger,
+                :logger_method,
+                :cd_path
+
+    def log(message)
+      @logger ||= ::STDOUT
+
+      @logger_method ||=
+        if    @logger.respond_to?(:debug); :debug
+        elsif @logger.respond_to?(:puts);  :puts
+        else  :write
+        end
+
+      @logger.public_send(@logger_method, message)
+    end
+
+    def debug_mode?
+      @debug_mode
+    end
+
+    def cd_path
+      @cd_path
+    end
+  end
+
+  def convert(*args, &blk)
+    Skeptick::Convert.new(self, *args, &blk)
+  end
+
+  def image(*args, &blk)
+    Skeptick::Image.new(self, *args, &blk)
+  end
+
+  def chain(*args, &blk)
+    Skeptick::Chain.new(self, *args, &blk)
+  end
+end

data/lib/skeptick/error.rb

@@ -0,0 +1,4 @@
+module Skeptick
+  class ImageMagickError < RuntimeError
+  end
+end

data/lib/skeptick/helper.rb

@@ -0,0 +1,26 @@
+module Skeptick
+  module Helper
+    module_function
+
+    def extract_options!(array)
+      array.last.is_a?(Hash) ? array.pop : {}
+    end
+
+    def object_to_index_range_list(obj)
+      case obj
+      when Integer, String
+        obj
+      when Range
+        "#{obj.min}-#{obj.max}"
+      when Array
+        obj.join(',')
+      else
+        raise "invalid sequence reference"
+      end
+    end
+
+    def process_args(*args)
+      args.map{ |arg| arg.is_a?(Symbol) ? "-#{arg.to_s}" : arg }.join(' ')
+    end
+  end
+end

data/lib/skeptick/image.rb

@@ -0,0 +1,69 @@
+require 'skeptick/helper'
+require 'skeptick/convert'
+require 'skeptick/chain'
+require 'skeptick/image/dsl_context'
+
+module Skeptick
+  class Image
+    attr_accessor :prepends, :appends
+
+    def initialize(context, obj = nil, &blk)
+      @context = context
+      @obj = obj || blk
+      reset
+    end
+
+    def set(*args)
+      @prepends << Helper.process_args(*args)
+    end
+
+    def apply(*args)
+      @appends << Helper.process_args(*args)
+    end
+
+    def image(obj, &blk)
+      @image = Image.new(@context, obj, &blk)
+    end
+
+    def convert(*args, &blk)
+      @image = Convert.new(@context, *args, &blk).become_inner
+    end
+
+    def process_method_missing(*args, &blk)
+      @context.send(*args, &blk)
+    end
+
+    def to_s
+      parts.join(' ')
+    end
+
+    def inspect
+      "Skeptick::Image(#{to_s})"
+    end
+
+    def parts
+      case @obj
+      when :pipe   then [ Chain::PIPE ]
+      when Convert then @obj.become_inner.parts
+      when Image   then @obj.parts
+      when Array   then @obj
+      when Proc    then build_parts
+      else         [ @obj ]
+      end
+    end
+
+    private
+
+      def build_parts
+        reset
+        DslContext.new(self).instance_eval(&@obj)
+        [*@prepends, @image, *@appends].compact
+      end
+
+      def reset
+        @image    = nil
+        @prepends = []
+        @appends  = []
+      end
+  end
+end

data/lib/skeptick/image/dsl_context.rb

@@ -0,0 +1,29 @@
+module Skeptick
+  class Image
+    class DslContext
+      def initialize(image)
+        @image = image
+      end
+
+      def set(*args)
+        @image.set(*args)
+      end
+
+      def apply(*args)
+        @image.apply(*args)
+      end
+
+      def image(obj)
+        @image.image(obj)
+      end
+
+      def convert(*args, &blk)
+        @image.convert(*args, &blk)
+      end
+
+      def method_missing(*args, &blk)
+        @image.process_method_missing(*args, &blk)
+      end
+    end
+  end
+end