skeptick 0.1.0

data/test/convert_test.rb

@@ -0,0 +1,177 @@
+require_relative 'test_helper'
+
+# DISCLAIMER
+# These tests are not examples of proper usage of ImageMagick.
+# In fact, most of them are entirely invalid. The point is to
+# test the logic of building strings.
+class ConvertTest < Skeptick::TestCase
+  include Skeptick
+
+  def test_dsl_method_available
+    assert_respond_to self, :convert
+  end
+
+  def test_lvars_from_external_context_are_accessible
+    foo = '-test'
+    cmd = convert { set foo }
+    assert_equal 'convert -test miff:-', cmd.to_s
+  end
+
+  def test_methods_from_external_context_are_accessible
+    context = Class.new do
+      include Skeptick
+      def foo; :foo end
+      def cmd; convert { set foo } end
+    end
+
+    assert_equal 'convert -foo miff:-', context.new.cmd.to_s
+  end
+
+  def test_minimal_convert
+    cmd = convert
+    assert_equal 'convert miff:-', cmd.to_s
+  end
+
+  def test_convert_with_input
+    cmd = convert('foo')
+    assert_equal 'convert foo miff:-', cmd.to_s
+  end
+
+  def test_convert_with_2_inputs
+    cmd = convert('foo', 'bar')
+    assert_equal 'convert foo bar miff:-', cmd.to_s
+  end
+
+  def test_convert_with_output
+    cmd = convert(to: 'foo')
+    assert_equal 'convert foo', cmd.to_s
+  end
+
+  def test_convert_with_input_and_output
+    cmd =  convert('foo', to: 'bar')
+    assert_equal 'convert foo bar', cmd.to_s
+  end
+
+  def test_convert_with_2_inputs_and_output
+    cmd = convert('foo', 'bar', to: 'baz')
+    assert_equal 'convert foo bar baz', cmd.to_s
+  end
+
+  def test_convert_with_input_in_block
+    cmd = convert { image 'foo' }
+    assert_equal 'convert foo miff:-', cmd.to_s
+  end
+
+  def test_convert_with_input_in_block_and_output
+    cmd = convert(to: 'bar') { image 'foo' }
+    assert_equal 'convert foo bar', cmd.to_s
+  end
+
+  def test_convert_with_2_input_styles
+    cmd = convert('foo') { image 'bar' }
+    assert_equal 'convert foo bar miff:-', cmd.to_s
+  end
+
+  def test_convert_with_2_input_styles_and_output
+    cmd = convert('foo', to: 'baz') { image 'bar' }
+    assert_equal 'convert foo bar baz', cmd.to_s
+  end
+
+  def test_convert_with_ops
+    cmd = convert { with '-foo' }
+    assert_equal 'convert -foo miff:-', cmd.to_s
+  end
+
+  def test_convert_with_concatenated_ops
+    cmd = convert { with '-foo', 'bar' }
+    assert_equal 'convert -foo bar miff:-', cmd.to_s
+  end
+
+  def test_convert_with_multiple_ops
+    cmd = convert { with '-foo'; with '+bar' }
+    assert_equal 'convert -foo +bar miff:-', cmd.to_s
+  end
+
+  def test_convert_with_multiple_concatenated_ops
+    cmd = convert { with '-foo', 'bar'; with '+baz', 'qux' }
+    assert_equal 'convert -foo bar +baz qux miff:-', cmd.to_s
+  end
+
+  def test_convert_with_ops_inputs_and_output
+    cmd = convert('foo', 'bar', to: 'baz') do
+      image 'qux'
+      with '+quux'
+      with '-corge', 'grault'
+    end
+
+    assert_equal 'convert foo bar qux +quux -corge grault baz', cmd.to_s
+  end
+
+  def test_nested_convert
+    cmd = convert(to: 'baz') do
+      convert('foo') { with 'bar' }
+    end
+
+    assert_equal 'convert ( foo bar ) baz', cmd.to_s
+  end
+
+  def test_nested_convert_ignores_output
+    cmd = convert(to: 'baz') do
+      convert('foo', to: 'nowhere') { with 'bar' }
+    end
+
+    assert_equal 'convert ( foo bar ) baz', cmd.to_s
+  end
+
+  def test_multi_image_nested_convert
+    cmd = convert('foo', to: 'bar') do
+      convert('qux') do
+        with '+asdf'
+        with '+fdsa'
+      end
+
+      image 'bleh'
+      with '-resize'
+    end
+
+    assert_equal 'convert foo ( qux +asdf +fdsa ) bleh -resize bar', cmd.to_s
+  end
+
+  def test_convert_composition
+    complex_image = convert('qux') do
+      with '+asdf'
+      with '+fdsa'
+    end
+
+    cmd = convert('foo', to: 'bar') do
+      image complex_image
+      image 'bleh'
+      with '-resize'
+    end
+
+    assert_equal 'convert foo ( qux +asdf +fdsa ) bleh -resize bar', cmd.to_s
+  end
+
+  def test_convert_double_nesting_with_composition
+    complex_image = convert('foo', to: 'nowhere') do
+      convert('bar', to: 'nowhere') do
+        convert('baz') do
+          image 'image1'
+          with '-option', 'qux'
+        end
+
+        image 'image2'
+        with '+option'
+      end
+    end
+
+    cmd = convert('image3') do
+      image complex_image
+      image 'image4'
+      with '-option', 'quux'
+    end
+
+    assert_equal 'convert image3 ( foo ( bar ( baz image1 -option qux ) ' +
+      'image2 +option ) ) image4 -option quux miff:-', cmd.to_s
+  end
+end

data/test/image_test.rb

@@ -0,0 +1,145 @@
+require_relative 'test_helper'
+
+class ImageTest < Skeptick::TestCase
+  include Skeptick
+
+  def test_dsl_method_available
+    assert_respond_to self, :image
+  end
+
+  def test_set_prepends_to_image_segment
+    cmd = convert do
+      image do
+        image 'bar'
+        set '-foo'
+      end
+    end
+
+    assert_equal 'convert -foo bar miff:-', cmd.to_s
+  end
+
+  def test_apply_appends_to_image_segment
+    cmd = convert do
+      image do
+        apply '-foo'
+        image 'bar'
+      end
+    end
+
+    assert_equal 'convert bar -foo miff:-', cmd.to_s
+  end
+
+  def test_lvars_from_external_context_are_accessible
+    foo = '-test'
+
+    cmd = convert do
+      image do
+        apply foo
+        image 'bar'
+      end
+    end
+
+    assert_equal 'convert bar -test miff:-', cmd.to_s
+  end
+
+  def test_methods_from_external_context_are_accessible
+    context = Class.new do
+      include Skeptick
+      def foo; :foo end
+      def cmd
+        convert do
+          image do
+            apply foo
+            image 'bar'
+          end
+        end
+      end
+    end
+
+    assert_equal 'convert bar -foo miff:-', context.new.cmd.to_s
+  end
+
+  def test_inject_image_into_convert
+    sample = image do
+      set   :size, '400x400'
+      image 'tile:granite:'
+      apply '-brightness-contrast', '38x-33'
+      apply :blur, '0x0.5'
+    end
+
+    cmd = convert do
+      set '-foo'
+      image sample
+      set '-bar'
+    end
+
+    assert_equal 'convert -foo -size 400x400 tile:granite: ' +
+      '-brightness-contrast 38x-33 -blur 0x0.5 -bar miff:-', cmd.to_s
+  end
+
+  def test_inject_image_into_convert_as_argument
+    sample = image do
+      set   :size, '400x400'
+      image 'tile:granite:'
+      apply '-brightness-contrast', '38x-33'
+      apply :blur, '0x0.5'
+    end
+
+    cmd = convert(sample)
+    assert_equal 'convert -size 400x400 tile:granite: -brightness-contrast ' +
+      '38x-33 -blur 0x0.5 miff:-', cmd.to_s
+  end
+
+  def test_declare_image_inside_convert
+    cmd = convert do
+      set '-foo'
+      image do
+        set   :size, '400x400'
+        image 'tile:granite:'
+        apply '-brightness-contrast', '38x-33'
+        apply :blur, '0x0.5'
+      end
+      set '-bar'
+    end
+
+    assert_equal 'convert -foo -size 400x400 tile:granite: ' +
+      '-brightness-contrast 38x-33 -blur 0x0.5 -bar miff:-', cmd.to_s
+  end
+
+  def test_nested_image
+    sample = image do
+      set :foo
+      image 'bar'
+      apply :baz
+    end
+
+    cmd = convert do
+      image do
+        set :size, '400x400'
+        image sample
+        apply '-brightness-contrast', '38x-33'
+        apply :blur, '0x0.5'
+      end
+    end
+
+    assert_equal 'convert -size 400x400 -foo bar -baz -brightness-contrast ' +
+      '38x-33 -blur 0x0.5 miff:-', cmd.to_s
+  end
+
+  def test_convert_as_image_object
+    sample = convert('foo', to: 'bar') do
+      set :baz
+    end
+
+    cmd = convert do
+      image do
+        set '-setting'
+        image sample
+        apply '-operation'
+      end
+    end
+
+    assert_equal 'convert -setting ( foo -baz ) -operation miff:-',
+      cmd.to_s
+  end
+end

data/test/sugar/composition_test.rb

@@ -0,0 +1,273 @@
+require_relative '../test_helper'
+require 'skeptick/sugar/composition'
+
+# DISCLAIMER
+# These tests are not examples of proper usage of ImageMagick.
+# In fact, most of them are entirely invalid. The point is to
+# test the logic of building strings.
+class CompositionTest < Skeptick::TestCase
+  include Skeptick
+
+  def test_compose_with_blending
+    cmd = compose(:over)
+    assert_equal 'convert -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_input
+    cmd = compose(:over, 'foo')
+    assert_equal 'convert foo -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_2_inputs
+    cmd = compose(:over, 'foo', 'bar')
+    assert_equal 'convert foo bar -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_output
+    cmd = compose(:over, to: 'foo')
+    assert_equal 'convert -compose over -composite foo', cmd.to_s
+  end
+
+  def test_compose_with_input_and_output
+    cmd = compose(:over, 'foo', to: 'bar')
+    assert_equal 'convert foo -compose over -composite bar', cmd.to_s
+  end
+
+  def test_compose_with_2_inputs_and_output
+    cmd = compose(:over, 'foo', 'bar', to: 'baz')
+    assert_equal 'convert foo bar -compose over -composite baz', cmd.to_s
+  end
+
+  def test_compose_with_input_in_block
+    cmd = compose(:over) { image 'foo' }
+    assert_equal 'convert foo -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_input_in_block_and_output
+    cmd = compose(:over, to: 'bar') { image 'foo' }
+    assert_equal 'convert foo -compose over -composite bar', cmd.to_s
+  end
+
+  def test_compose_with_2_input_styles
+    cmd = compose(:over, 'foo') { image 'bar' }
+    assert_equal 'convert foo bar -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_2_input_styles_and_output
+    cmd = compose(:over, 'foo', to: 'baz') { image 'bar' }
+    assert_equal 'convert foo bar -compose over -composite baz', cmd.to_s
+  end
+
+  def test_compose_with_ops
+    cmd = compose(:over) { with '-foo' }
+    assert_equal 'convert -foo -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_concatenated_ops
+    cmd = compose(:over) { with '-foo', 'bar' }
+    assert_equal 'convert -foo bar -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_multiple_ops
+    cmd = compose(:over) { with '-foo'; with '+bar' }
+    assert_equal 'convert -foo +bar -compose over -composite miff:-', cmd.to_s
+  end
+
+  def test_compose_with_multiple_concatenated_ops
+    cmd = compose(:over) { with '-foo', 'bar'; with '+baz', 'qux' }
+    assert_equal 'convert -foo bar +baz qux -compose over -composite miff:-',
+      cmd.to_s
+  end
+
+  def test_compose_with_ops_inputs_and_output
+    cmd = compose(:over, 'foo', 'bar', to: 'baz') do
+      image 'qux'
+      with '+quux'
+      with '-corge', 'grault'
+    end
+
+    assert_equal 'convert foo bar qux +quux -corge grault -compose over ' +
+      '-composite baz', cmd.to_s
+  end
+
+  def test_nested_compose
+    cmd = compose(:over, to: 'baz') do
+      compose(:multiply, 'foo') { with 'bar' }
+    end
+
+    assert_equal 'convert ( foo bar -compose multiply -composite ) -compose ' +
+      'over -composite baz', cmd.to_s
+  end
+
+  def test_nested_compose_ignores_output
+    cmd = compose(:over, to: 'baz') do
+      compose(:multiply, 'foo', to: 'nowhere') { with 'bar' }
+    end
+
+    assert_equal 'convert ( foo bar -compose multiply -composite ) -compose ' +
+      'over -composite baz', cmd.to_s
+  end
+
+  def test_multi_image_nested_compose
+    cmd = compose(:over, 'foo', to: 'bar') do
+      compose(:multiply, 'qux') do
+        with '+asdf'
+        with '+fdsa'
+      end
+
+      image 'bleh'
+      with '-resize'
+    end
+
+    assert_equal 'convert foo ( qux +asdf +fdsa -compose multiply ' +
+      '-composite ) bleh -resize -compose over -composite bar', cmd.to_s
+  end
+
+  def test_compose_composition
+    complex_image = compose(:over, 'qux') do
+      with '+asdf'
+      with '+fdsa'
+    end
+
+    cmd = compose(:multiply, 'foo', to: 'bar') do
+      image complex_image
+      image 'bleh'
+      with '-resize'
+    end
+
+    assert_equal 'convert foo ( qux +asdf +fdsa -compose over -composite ) ' +
+      'bleh -resize -compose multiply -composite bar', cmd.to_s
+  end
+
+  def test_compose_double_nesting_with_composition
+    complex_image = compose('foo', to: 'nowhere') do
+      compose('bar', to: 'nowhere') do
+        compose('baz') do
+          image 'image1'
+          with '-option', 'qux'
+        end
+
+        image 'image2'
+        with '+option'
+      end
+    end
+
+    cmd = compose('image3') do
+      image complex_image
+      image 'image4'
+      with '-option', 'quux'
+    end
+
+    assert_equal 'convert ( ( ( image1 -option qux -compose baz -composite ' +
+      ') image2 +option -compose bar -composite ) -compose foo -composite ) ' +
+      'image4 -option quux -compose image3 -composite miff:-', cmd.to_s
+  end
+
+  def test_plus_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs + rhs)
+
+    assert_equal 'convert ( foo bar -compose over -composite ) miff:-',
+      result.to_s
+  end
+
+  def test_minus_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs - rhs)
+
+    assert_equal 'convert ( foo bar -compose dstout -composite ) miff:-',
+      result.to_s
+  end
+
+  def test_multiply_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs * rhs)
+
+    assert_equal 'convert ( foo bar -compose multiply -composite ) miff:-',
+      result.to_s
+  end
+
+  def test_divide_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs / rhs)
+
+    assert_equal 'convert ( foo bar -compose divide -composite ) miff:-',
+      result.to_s
+  end
+
+  def test_and_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs & rhs)
+
+    assert_equal 'convert ( foo bar -alpha Set -compose dstin -composite ) ' +
+      'miff:-', result.to_s
+  end
+
+  def test_or_operator_on_image
+    lhs = image('foo')
+    rhs = image('bar')
+    result = convert(lhs | rhs)
+
+    assert_equal 'convert ( foo bar -compose dstover -composite ) miff:-',
+      result.to_s
+  end
+
+  def test_plus_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs + rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -compose over -composite miff:-',
+      result.to_s
+  end
+
+  def test_minus_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs - rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -compose dstout -composite miff:-',
+      result.to_s
+  end
+
+  def test_multiply_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs * rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -compose multiply -composite miff:-',
+      result.to_s
+  end
+
+  def test_divide_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs / rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -compose divide -composite miff:-',
+      result.to_s
+  end
+
+  def test_and_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs & rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -alpha Set -compose dstin ' +
+      '-composite miff:-', result.to_s
+  end
+
+  def test_or_operator_on_convert
+    lhs = convert('foo')
+    rhs = convert('bar')
+    result = lhs | rhs
+
+    assert_equal 'convert ( foo ) ( bar ) -compose dstover -composite miff:-',
+      result.to_s
+  end
+end