imgry 0.1.0 → 0.1.1

data/README.md

@@ -2,7 +2,7 @@
 
 A Ruby gem for fast image resizing/cropping designed for JRuby with MRI support.
 
-Imgry provides an elegant interface and optimizations to third party libraries: Imgscalr, ImageVoodoo and MiniMagick. The library was designed to work as fast as possible under JRuby, and it does, from what we've seen it outperforms any other JRuby image resizing library, if it doesn't, please show us and let's improve it!
+Imgry provides an elegant interface and optimizations to third party libraries: Imgscalr, ImageVoodoo and MiniMagick. The library was designed to work as fast as possible under JRuby, and it does, from what we've seen it outperforms any other JRuby image resizing libraries, if it doesn't, please show us and let's improve it!
 
 It's also convienient for teams that work between MRI and JRuby, working seamlessly across development/production app environments.
 

data/lib/imgry/geometry.rb

@@ -28,12 +28,7 @@ module Imgry
         scale.call
       end
 
-      # In the end, we've determined we don't want to resizie (perhaps due to > or < operations)
-      # return [nil,nil] if new_width.nil? || new_width.nil?
-
-      # binding.pry
-
-      [new_width, new_height]
+      [new_width || orig_width, new_height || orig_height]
     end
 
     def scale_by_width(new_width, aspect_ratio)

data/lib/imgry/processor/image_voodoo.rb

@@ -1,90 +1,43 @@
 module Imgry
   module Processor
 
-    class ImageVoodoo < Adapter
-
-      def self.load_lib!
-        return if @lib_loaded
-
-        if RUBY_ENGINE != 'jruby'
-          raise 'The ImageVoodoo processor is only available on JRuby.'
-        end
-
-        begin
-          require 'image_voodoo'
-        rescue LoadError
-          raise 'Cannot load image_voodoo gem.'
-        end
-
-        # TODO... 
-        # turn on opengl........
-
-        # Add-ons..
-        ::ImageVoodoo.class_eval do
-          def src
-            @src
-          end
-        end
-
-        @lib_loaded = true
-      end
-
-      #-----
-
-      def load_image_blob!
+    class ImageVoodoo < JavaAdapter
+      def load_image!
         begin
-          @image_ref = ::ImageVoodoo.with_bytes(@img_blob)
-          if @image_ref.src.nil?
-            raise InvalidImageError, "Image is either corrupt or unsupported."
-          end
+          @img = ::ImageVoodoo.new(ImageIO.read(@img_blob))
         rescue => ex
           raise InvalidImageError, ex.message
         end
       end
 
-      def resize!(geometry)
-        return if geometry.nil?        
-        @image_ref = @image_ref.resize(*Geometry.scale(width, height, geometry))
-      end
-
-      def width
-        @image_ref.width
+      def src
+        @img.src
       end
 
-      def height
-        @image_ref.height
+      def resize!(geometry)
+        return if geometry.nil?        
+        @img = @img.resize(*Geometry.scale(width, height, geometry))
       end
 
-      def to_blob
-        # TODO: output format is hardcoded, we should get the format
-        # that it is while coming in, and use that on the way out..
-        # we can use jpg by default..
-        @image_ref.bytes('jpg')
+      def crop!
+        # TODO
       end
 
-      def raw
-        @image_ref
-      end
+    end
 
-      def supported_write_formats
-        # Typical formats:
-        # [BMP, bmp, jpg, JPG, wbmp, jpeg, png, JPEG, PNG, WBMP, GIF, gif]
-        ::ImageVoodoo::ImageIO.getReaderFormatNames.to_a
-      end
+  end
+end
 
-      def supported_read_formats
-        # Typical formats:
-        # [BMP, bmp, jpg, JPG, wbmp, jpeg, png, JPEG, PNG, WBMP, GIF, gif]
-        ::ImageVoodoo::ImageIO.getWriterFormatNames.to_a
-      end
+#---
 
-      def clean!
-        @image_ref = nil
-        @src_blob = nil
-      end
+begin
+  require 'image_voodoo'
 
+  # Add-ons..
+  class ImageVoodoo
+    def src
+      @src
     end
-
   end
+rescue LoadError
 end
-

data/lib/imgry/processor/img_scalr.rb

@@ -1,66 +1,34 @@
 module Imgry
   module Processor
 
-    class ImgScalr < Adapter
-
-      def self.load_lib!
-        return if @lib_loaded
-
-        if RUBY_ENGINE != 'jruby'
-          raise 'The ImgScalr processor is only available on JRuby.'
+    class ImgScalr < JavaAdapter
+      require 'java/imgscalr-lib-4.2.jar'
+      java_import org.imgscalr.Scalr
+
+      def load_image!
+        begin
+          @img = ImageIO.read(@img_blob)
+        rescue => ex
+          raise InvalidImageError, ex.message
         end
-
-        self.class_eval do
-          include Java
-
-          require 'java/imgscalr-lib-4.2.jar'
-
-          java_import javax.imageio.ImageIO
-          java_import org.imgscalr.Scalr
-          java_import java.awt.image.BufferedImage
-          java_import java.io.ByteArrayInputStream
-          java_import java.io.ByteArrayOutputStream
-        end
-
-        @lib_loaded = true
-      end
-
-      #-----
-
-      def load_image_blob!
-        @img_blob = @img_blob.to_java_bytes if String === @img_blob
-
-        @image_ref = ImageIO.read(ByteArrayInputStream.new(@img_blob))
-        # TODO .. raise if bullshit... InvalidImageError...
-
-      end
-
-      def resize!(width, height)
-        options = {}
-        method = options[:method] ? options[:method] : Scalr::Method::QUALITY
-        mode   = options[:mode] ? options[:mode] : Scalr::Mode::FIT_EXACT
-        ops    = options[:ops] ? options[:ops] : Scalr::OP_ANTIALIAS
-
-        @image_ref = Scalr.resize(@image_ref, method, mode, width, height, ops)
-      end
-
-      def width
-        @image_ref.width
       end
 
-      def height
-        @image_ref.height
+      def src
+        @img
       end
 
-      def to_blob(format=nil)
-        format ||= 'jpg'
+      def resize!(geometry)
+        new_width, new_height = Geometry.scale(width, height, geometry)
 
-        out = ByteArrayOutputStream.new
-        ImageIO.write(@image_ref, format, out)
-        String.from_java_bytes(out.to_byte_array)
+        @img = Scalr.resize(@img,
+                            Scalr::Method::QUALITY,
+                            Scalr::Mode::FIT_EXACT,
+                            new_width, new_height,
+                            Scalr::OP_ANTIALIAS)
       end
 
-      def clean!
+      def crop!
+        # TODO
       end
 
     end

data/lib/imgry/processor/java_adapter.rb

@@ -0,0 +1,90 @@
+module Imgry
+  module Processor
+
+    class JavaAdapter < Adapter
+      include Java
+
+      java_import javax.imageio.ImageIO
+      java_import java.awt.image.BufferedImage
+      java_import java.io.ByteArrayInputStream
+      java_import java.io.ByteArrayOutputStream
+
+      # Turn on OpenGL .. benchmarks show that with or without
+      # GPU performance is improved
+      java.lang.System.setProperty('sun.java2d.opengl', 'true')
+
+      def self.with_bytes(img_blob, format=nil)
+        bytes = img_blob.to_java_bytes if img_blob.is_a?(String)
+        new(ByteArrayInputStream.new(bytes), format)
+      end
+
+      def self.from_file(path, format=nil)
+        if !File.readable?(path)
+          raise FileUnreadableError, path.to_s
+        end
+
+        # Use the format based on the file's extension
+        ext = File.extname(path)
+        format = !ext.nil? ? ext[1..-1].downcase : nil
+
+        img_blob = IO.read(path.to_s)
+        with_bytes(img_blob, format)
+
+        # TODO: read the file using Java file io instead..?
+        # input_stream = java.io.FileInputStream.new(java.io.File.new(path.to_s))
+      end
+
+      def self.supported_formats
+        @supported_formats ||= begin
+          # NOTE: assuming read and write formats are the same..
+          # Typical formats: bmp, jpg, wbmp, jpeg, png, gif
+          ImageIO.getReaderFormatNames.to_a.map(&:downcase).uniq
+        end
+      end
+
+      def width
+        @img.width
+      end
+
+      def height
+        @img.height
+      end
+
+      def clean!
+        @img = nil
+        @img_blob = nil
+      end
+
+      def to_blob(format=nil)
+        format ||= @format || DEFAULT_OUTPUT_FORMAT
+
+        if !self.class.supported_formats.include?(format.downcase)
+          raise UnsupportedFormatError, format
+        end
+
+        out = ByteArrayOutputStream.new
+        ImageIO.write(src, format, out)
+        String.from_java_bytes(out.to_byte_array)
+      end
+
+      def save(path)
+        if !File.writable?(File.dirname(path))
+          raise FileUnwritableError, path.to_s
+        end
+
+        ext = File.extname(path)
+        format = !ext.nil? ? ext[1..-1].downcase : nil
+        format ||= DEFAULT_OUTPUT_FORMAT
+
+        if !self.class.supported_formats.include?(format)
+          raise UnsupportedFormatError, format
+        end
+
+        ImageIO.write(src, format.downcase, java.io.File.new(path.to_s))
+        true
+      end
+
+    end
+
+  end
+end

data/lib/imgry/processor/mini_magick.rb

@@ -3,51 +3,67 @@ module Imgry
 
     class MiniMagick < Adapter
 
-      def self.load_lib!
-        return if @lib_loaded
+      def self.with_bytes(img_blob, format=nil)
+        new(img_blob, format)
+      end
 
-        begin
-          require 'mini_magick'
-        rescue LoadError
-          raise "Cannot load mini_magick gem"
+      def self.from_file(path, format=nil)
+        if !File.readable?(path)
+          raise FileUnreadableError, path.to_s
         end
 
-        ::MiniMagick.processor = :gm
-        ::MiniMagick.timeout = 45
-
-        @lib_loaded = true
+        new(IO.read(path), format)
       end
 
-      #-----
+      def self.supported_formats
+        # Hardcoded list of supported formats for validity checking..
+        # Image/GraphicsMagick have a much more extensive list.
+        # Submit an issue if this is a problem.
+        ['bmp', 'jpg', 'wbmp', 'jpeg', 'gif', 'png', 'png32', 'png24', 'png8', 'tiff']
+      end
 
-      def load_image_blob!
+      def load_image!
         begin
-          @image_ref = ::MiniMagick::Image.read(@img_blob)
+          @img = ::MiniMagick::Image.read(@img_blob)
         rescue ::MiniMagick::Invalid => ex
           raise InvalidImageError, ex.message
         end
       end
 
       def resize!(geometry)
-        @image_ref.resize(geometry) if !geometry.nil?
+        @img.resize(geometry) if !geometry.nil?
         nil
       end
 
       def width
-        @image_ref['width']
+        @img['width']
       end
 
       def height
-        @image_ref['height']
+        @img['height']
+      end
+
+      def format
+        @img['format']
       end
 
       def to_blob
-        @image_ref.to_blob
+        @img.to_blob
+      end
+
+      def save(path)
+        if !File.writable?(File.dirname(path))
+          raise FileUnwritableError, path.to_s
+        end
+        if !self.class.supported_formats.include?(format.downcase)
+          raise UnsupportedFormatError, format
+        end
+        @img.write(path.to_s)
       end
 
       def clean!
-        @image_ref.destroy!
-        @image_ref = nil
+        @img.destroy!
+        @img = nil
         @img_blob = nil
       end
 
@@ -55,3 +71,31 @@ module Imgry
 
   end
 end
+
+#---
+
+begin
+  require 'mini_magick'
+
+  MiniMagick.processor = :gm
+  MiniMagick.timeout = 45
+
+  # Fix.. this is in mini_magick's github master,
+  # but not in the stable released gem
+  class MiniMagick::Image
+    def run_command(command, *args)
+      # -ping "efficiently determine image characteristics."
+      if command == 'identify'
+        args.unshift '-ping'
+
+        # GraphicsMagick's identify has no -quiet option
+        if MiniMagick.processor.to_s == 'gm'
+          args.delete('-quiet')
+        end
+      end
+
+      run(MiniMagick::CommandBuilder.new(command, *args))
+    end
+  end
+rescue LoadError
+end

data/lib/imgry/processor.rb

@@ -2,25 +2,28 @@ module Imgry
   module Processor
 
     class Adapter
+      DEFAULT_OUTPUT_FORMAT = 'jpg'
 
-      def self.with_bytes(img_blob, format=nil)
-        new(img_blob, format)
+      def self.load_lib!
       end
 
-      def self.from_file(path, format=nil)
-        # TODO: .. get the format from the filepath ... unless specified..
+      def self.with_bytes(img_bytes, format=nil)
+        # Abstract
       end
 
-      def self.lib_loaded?
-        !!@lib_loaded
+      def self.from_file(path, format=nil)
+        # Abstract
       end
 
       def initialize(img_blob, format=nil)
-        self.class.load_lib! if !self.class.lib_loaded?
-
         @img_blob = img_blob
         @format = format
-        load_image_blob!
+        @img = nil
+        load_image!
+      end
+
+      def load_image!
+        # Abstract
       end
 
       def aspect_ratio
@@ -31,13 +34,21 @@ module Imgry
 
     end
 
-    class InvalidImageError < StandardError; end
-
   end
 end
 
+#---
+
+# JRuby processors
+if RUBY_ENGINE == 'jruby'
+  %w(
+    java_adapter
+    image_voodoo
+    img_scalr
+  ).each {|lib| require "imgry/processor/#{lib}" }
+end
+
+# Generic processors
 %w(
-  image_voodoo
-  img_scalr
   mini_magick
 ).each {|lib| require "imgry/processor/#{lib}" }

data/lib/imgry/version.rb

@@ -1,3 +1,3 @@
 module Imgry
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/imgry.rb

@@ -1,24 +1,47 @@
 module Imgry
   extend self
 
+  attr_accessor :processor
+
   def with_bytes(img_blob, format=nil)
+    processor_klass.with_bytes(img_blob, format)
   end
 
   def from_file(img_blob, format=nil)
+    processor_klass.from_file(img_blob, format)
   end
 
-  def default_processor
-    :mini_magick
+  def processor_klass
+    @processor_klass ||= begin
+      k = processor.to_s.split('_').map {|x| x.capitalize }.join('')
+      begin
+        instance_eval("Imgry::Processor::#{k}")
+      rescue
+        raise "Unknown processor #{processor}"
+      end
+    end
   end
 
-  def default_processor=(default_processor)
-    @default_processor = default_processor
+  def processor=(processor)
+    @processor_klass = nil
+    @processor = processor
   end
 
+
+  class InvalidImageError < StandardError; end
+  class UnsupportedFormatError < StandardError; end
+  class FileUnreadableError < StandardError; end
+  class FileUnwritableError < StandardError; end
 end
 
 Imagery = Imgry
 
+if RUBY_ENGINE == 'jruby'
+  Imgry.processor = :img_scalr
+else
+  Imgry.processor = :mini_magick
+end
+
 require 'imgry/version'
 require 'imgry/geometry'
 require 'imgry/processor'

data/spec/imgry/geometry_spec.rb

@@ -19,15 +19,18 @@ describe Imgry::Geometry do
 
   it 'shrinks to a size when dimensions are larger then corresponding width/height' do
     size = Imgry::Geometry.scale(1024, 768, "600x600>")
-    
-    binding.pry
+    size.should == [600, 450]
 
-    # size.should == [400, 300]
+    size = Imgry::Geometry.scale(300, 400, "600x600>")
+    size.should == [300, 400]
   end
 
-  # it 'enlarges to a size when dimensions are smaller then corresponding width/height' do
-  #   geo = "600x600<"
-  #   # TODO..
-  # end
+  it 'enlarges to a size when dimensions are smaller then corresponding width/height' do
+    size = Imgry::Geometry.scale(1024, 768, "600x600<")
+    size.should == [1024, 768]
+
+    size = Imgry::Geometry.scale(300, 400, "600x600<")
+    size.should == [600, 800]
+  end
 
 end

data/spec/imgry/imgry_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Imgry do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "resizes an image from memory through high level interface" do
+      img = Imgry.with_bytes(img_data)
+
+      img.resize!("300x")
+      img.width.should == 300
+    end
+
+    it "loads from a file and resizes an image" do
+      img = Imgry.from_file(SPEC_ROOT.join('support/335is.png'))
+      img.resize!("400x")
+      img.width.should == 400
+    end
+
+    it "raises error if file is bogus" do
+      expect { Imgry.from_file('hi') }.to raise_error(Imgry::FileUnreadableError)
+    end
+
+    it "writes to a file" do
+      img = Imgry.with_bytes(img_data)
+      tmpfile = Dir.tmpdir+'/imgry.jpg'
+      img.save(tmpfile)
+      File.exists?(tmpfile).should == true
+      File.unlink(tmpfile)
+    end
+
+  end
+
+end

data/spec/imgry/processor/image_voodoo_spec.rb

@@ -1,26 +1,28 @@
 require 'spec_helper'
 
-describe Imgry::Processor::ImageVoodoo do
+if RUBY_ENGINE == 'jruby'
+  describe Imgry::Processor::ImageVoodoo do
 
-  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+    let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
 
-  context "a pretty picture" do    
+    context "a pretty picture" do    
 
-    it "basic loading and resizing of an image" do
-      img = Imgry::Processor::ImageVoodoo.with_bytes(img_data)
+      it "basic loading and resizing of an image" do
+        img = Imgry::Processor::ImageVoodoo.with_bytes(img_data)
 
-      img.width.should == 1024
-      img.height.should == 764
+        img.width.should == 1024
+        img.height.should == 764
 
-      img.resize!("512x")
-      img.width.should == 512
-      img.height.should == 382
+        img.resize!("512x")
+        img.width.should == 512
+        img.height.should == 382
+
+        new_img_blob = img.to_blob
+        new_img_blob.length.should < img_data.length
+        new_img_blob.length.should == 32159
+      end
 
-      new_img_blob = img.to_blob
-      new_img_blob.length.should < img_data.length
-      new_img_blob.length.should == 32159
     end
 
   end
-
-end
+end

data/spec/imgry/processor/img_scalr_spec.rb

@@ -1,27 +1,28 @@
 require 'spec_helper'
 
-describe Imgry::Processor::ImgScalr do
+if RUBY_ENGINE == 'jruby'
+  describe Imgry::Processor::ImgScalr do
 
-  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+    let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
 
-  context "a pretty picture" do    
+    context "a pretty picture" do    
 
-    it "basic loading and resizing of an image" do
-      img = Imgry::Processor::ImgScalr.with_bytes(img_data)
+      it "basic loading and resizing of an image" do
+        img = Imgry::Processor::ImgScalr.with_bytes(img_data)
 
-      img.width.should == 1024
-      img.height.should == 764
+        img.width.should == 1024
+        img.height.should == 764
 
-      # img.resize!("512x")
-      img.resize!(512, 382)
-      img.width.should == 512
-      img.height.should == 382
+        img.resize!("512x")
+        img.width.should == 512
+        img.height.should == 382
+
+        new_img_blob = img.to_blob
+        new_img_blob.length.should < img_data.length
+        new_img_blob.length.should == 30319
+      end
 
-      new_img_blob = img.to_blob
-      new_img_blob.length.should < img_data.length
-      new_img_blob.length.should == 30319
     end
 
   end
-
-end
+end

data/spec/imgry_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Imgry do
+
+  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
+
+  context "a pretty picture" do    
+
+    it "should do stuff..." do
+      img = Imgry.with_bytes(img_data)
+
+      img.resize!("300x")
+      img.width.should == 300
+    end
+
+  end
+
+end

metadata

@@ -1,32 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: imgry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+  version: 0.1.1
+  prerelease:
 platform: ruby
 authors:
 - Pressly
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-12-05 00:00:00.000000000 Z
+date: 2012-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.12'
+    none: false
+  prerelease: false
+  type: :development
 description: Fast image resizing/cropping designed for JRuby with MRI support
 email:
 - info@pressly.com
@@ -34,56 +34,59 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/imgry.rb
 - lib/imgry/geometry.rb
+- lib/imgry/processor.rb
+- lib/imgry/version.rb
 - lib/imgry/processor/image_voodoo.rb
 - lib/imgry/processor/img_scalr.rb
+- lib/imgry/processor/java_adapter.rb
 - lib/imgry/processor/mini_magick.rb
-- lib/imgry/processor.rb
-- lib/imgry/version.rb
-- lib/imgry.rb
 - lib/java/imgscalr-lib-4.2.jar
 - README.md
+- spec/imgry_spec.rb
+- spec/spec_helper.rb
 - spec/imgry/geometry_spec.rb
+- spec/imgry/imgry_spec.rb
 - spec/imgry/processor/image_voodoo_spec.rb
 - spec/imgry/processor/img_scalr_spec.rb
 - spec/imgry/processor/mini_magick_spec.rb
-- spec/imgry/processor_spec.rb
-- spec/spec_helper.rb
 - spec/support/335is.gif
 - spec/support/335is.jpg
 - spec/support/335is.png
 homepage: http://github.com/nulayer/imgry
 licenses: []
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+      version: !binary |-
+        MA==
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
+  none: false
 requirements: []
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 1.8.24
-signing_key: 
+signing_key:
 specification_version: 3
 summary: Fast image resizing/cropping designed for JRuby with MRI support
 test_files:
+- spec/imgry_spec.rb
+- spec/spec_helper.rb
 - spec/imgry/geometry_spec.rb
+- spec/imgry/imgry_spec.rb
 - spec/imgry/processor/image_voodoo_spec.rb
 - spec/imgry/processor/img_scalr_spec.rb
 - spec/imgry/processor/mini_magick_spec.rb
-- spec/imgry/processor_spec.rb
-- spec/spec_helper.rb
 - spec/support/335is.gif
 - spec/support/335is.jpg
 - spec/support/335is.png
-has_rdoc: 

data/spec/imgry/processor_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Imgry::Processor do
-
-  let (:img_data) { IO.read(SPEC_ROOT.join('support/335is.jpg')) }
-
-  context "a pretty picture" do    
-
-    it "should do stuff..." do
-      # This will use the best processor for the VM .. etc.
-      # .. what about the format...?
-      img = Imgry.with_bytes(img_data)
-
-      # img.class # .. this will be ImageTools::Processor::MiniMagick or ::ImgScalr etc.
-
-      # img.resize!("300x200!")
-
-      # img = ImageTools.from_file(SPEC_ROOT.join('support/335is.jpg'))
-
-      binding.pry
-      x = 1
-    end
-
-  end
-
-end