pipe_fitter 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56ac5e3871868bdb5e9fb09a961cc24d09627e09
-  data.tar.gz: d1da7aea03341b8bd35c8652c1150984c31c6514
+  metadata.gz: d7fb6064d720bceb50a5f67593a34d8ab88e0265
+  data.tar.gz: 42ad10d0a56aa467273b792ba3e96d0940a2e6a6
 SHA512:
-  metadata.gz: 0ad84d8cc742c4a004c25d0fd0974d68f86e09c040af1b58718e52bb8db876cd7b76cf8d594358b1bfe944e6cc83db8fcfde9b7f046cfbbd5a153bdb59f6b560
-  data.tar.gz: d2de15a6adca24eee47af9e1679de61d067a971cc383f050627eef82cca2e7bc3f0bac87e69743ea71ee736e857d35e9121f39f816bbcf489f7511656fbf3c75
+  metadata.gz: 80191b605a9a17ae25820fbf1a0ab4baa5908e009d8fb96e11b9ad8a1e5bb85d9873e221cd01ebde4ec4b5d912b918df106b1eb9db6fbe5f0b37e7a13c329633
+  data.tar.gz: a4a95adea95583151321ef7eef80f773f0052573f25a7c66abb06e6b1574c07ada735d9b50243876cd9f8a1374b0ee08e5dfd6d97d028f9e7a99a60279b71e3d

data/lib/pipe_fitter/data_pipeline_client.rb

@@ -26,7 +26,7 @@ module PipeFitter
     def definition(pipeline_id)
       res = exec(:get_pipeline_definition, pipeline_id: pipeline_id)
       desc = description(pipeline_id)
-      Pipeline.new(res.to_h, desc.to_h)
+      Pipeline.create(res.to_h, desc.to_h)
     end
 
     def put_definition(pipeline_id, pipeline)
@@ -55,7 +55,7 @@ module PipeFitter
     def sync_tags(pipeline_id, pipeline)
       p = definition(pipeline_id)
       return if p.tags == pipeline.tags
-      exec(:remove_tags, p.remove_tags_opts) unless p.tags.empty?
+      exec(:remove_tags, p.remove_tags_opts(pipeline_id)) unless p.tags.empty?
       exec(:add_tags, pipeline.add_tags_opts(pipeline_id)) unless pipeline.tags.empty?
     end
 

data/lib/pipe_fitter/pipeline.rb

@@ -5,108 +5,198 @@ require "pathname"
 
 module PipeFitter
   class Pipeline
-    class << self
-      def load_yaml(filename)
-        filepath = Pathname.new(filename)
-        desc = YamlLoader.load(filepath)
-        definition = desc.delete("definition")
-        Pipeline.new(definition, desc)
-      end
+    def self.create(definition_from_api, description_from_api)
+      new(PipelineObjects.create(definition_from_api[:pipeline_objects]),
+          ParameterObjects.create(definition_from_api[:parameter_objects]),
+          ParameterValues.create(definition_from_api[:parameter_values]),
+          PipelineDescription.create(description_from_api))
     end
 
-    DESCRIPTION_KEYS = %w(name tags unique_id description).freeze
-    Diffy::Diff.default_options.merge!(diff: "-u", include_diff_info: true)
-
-    def initialize(definition, description = {})
-      @definition = Hashie::Mash.new(definition)
-      @full_description = Hashie::Mash.new(description).tap do |h|
-        if (fs = h[:fields]) && (f = fs.find { |e| e[:key] == "uniqueId" }) && f.key?(:string_value)
-          h.unique_id ||= f[:string_value]
-        end
-      end
-      @description = Hashie::Mash.new(@full_description.select { |k, v| DESCRIPTION_KEYS.include?(k) && !v.nil? })
+    def self.load_yaml(filename)
+      filepath = Pathname.new(filename)
+      yml = YamlLoader.load(filepath)
+      new(PipelineObjects.new(yml["pipeline_objects"]),
+          ParameterObjects.new(yml["parameter_objects"]),
+          ParameterValues.new(yml["parameter_values"]),
+          PipelineDescription.new(yml["pipeline_description"]))
     end
 
-    def to_yaml
-      stringify_keys(@description.merge("definition" => sorted_definition)).to_yaml
+    def initialize(pipeline_objects, parameter_objects, parameter_values, pipeline_description)
+      @pipeline_objects = pipeline_objects
+      @parameter_objects = parameter_objects
+      @parameter_values = parameter_values
+      @pipeline_description = pipeline_description
     end
 
-    def create_opts
-      symbolize_keys(@description)
+    def tags
+      @pipeline_description.tags
     end
 
-    def put_definition_opts(id = nil)
-      base = { pipeline_id: id || pipeline_id }
-      base.merge(symbolize_keys(@definition))
+    def to_yaml
+      {
+        "pipeline_description" => @pipeline_description.to_objs,
+        "pipeline_objects" => @pipeline_objects.to_objs,
+        "parameter_objects" => @parameter_objects.to_objs,
+        "parameter_values" => @parameter_values.to_objs,
+      }.to_yaml
     end
 
-    def add_tags_opts(id = nil)
-      { pipeline_id: id || pipeline_id, tags: @full_description.tags }
+    def put_definition_opts(pipeline_id)
+      {
+        pipeline_id: pipeline_id,
+        pipeline_objects: @pipeline_objects.to_api_opts,
+        parameter_objects: @parameter_objects.to_api_opts,
+        parameter_values: @parameter_values.to_api_opts,
+      }
     end
 
-    def remove_tags_opts(id = nil)
-      { pipeline_id: id || pipeline_id, tag_keys: @full_description.tags.map { |e| e["key"] } }
+    def add_tags_opts(pipeline_id)
+      { pipeline_id: pipeline_id, tags: @pipeline_description.tags_opts }
     end
 
-    def activate_opts(parameter_values, start_timestamp = nil, id = nil)
-      pv = (parameter_values || {}).map { |k, v| { "id" => k.to_s, "string_value" => v.to_s } }
-      { pipeline_id: id || pipeline_id, parameter_values: pv, start_timestamp: start_timestamp }.select { |_, v| !v.nil? }
+    def remove_tags_opts(pipeline_id)
+      { pipeline_id: pipeline_id, tag_keys: @pipeline_description.tag_keys }
     end
 
-    def pipeline_id
-      @full_description.pipeline_id
+    def diff(other, format = nil)
+      Diffy::Diff.new(self.to_yaml, other.to_yaml).to_s(format)
     end
 
-    def name
-      @full_description.name
-    end
+    class PipelineBaseObjects
+      def initialize(objs)
+        @objs = case objs
+                when Array then objs.map { |obj| symbolize_keys(obj) }
+                else symbolize_keys(objs) || {}
+                end
+      end
 
-    def tags
-      @full_description.tags
-    end
+      def to_objs
+        case @objs
+        when Array then @objs.map { |obj| stringify_keys(obj) }
+        else stringify_keys(@objs)
+        end
+      end
 
-    def diff(other, format = nil)
-      Diffy::Diff.new(self.to_yaml, other.to_yaml).to_s(format)
+      private
+
+      def stringify_keys(val)
+        modify_keys_recursively(val, __method__)
+      end
+
+      def symbolize_keys(val)
+        modify_keys_recursively(val, __method__)
+      end
+
+      def modify_keys_recursively(val, method)
+        return val unless val.is_a?(Hash)
+        h = Hashie.send(method, val.to_h)
+        h.each do |k, v|
+          case v
+          when Array then h[k].map! { |e| self.send(method, e) }
+          when Hash then h[k] = self.send(method, v)
+          end
+        end
+        h
+      end
     end
 
-    private
-
-    def sorted_definition
-      top_keys = %w(pipeline_objects parameter_objects parameter_values).freeze
-      obj_keys = %w(id name fields).freeze
-      field_keys = %w(key string_value ref_value).freeze
-
-      d = @definition.sort_by { |k, _| [top_keys.index(k) || top_keys.size, k] }.to_h
-      top_keys.each do |k|
-        next if !d[k].is_a?(Array) || d[k].empty?
-        d[k] = d[k].sort_by { |e| e["id"] }
-        d[k].map! do |v|
-          v["fields"] = v["fields"].sort_by { |e| e["key"] }
-          v["fields"].map! { |vv| vv.sort_by { |kk, _| field_keys.index(kk) }.to_h }
-          v.sort_by { |kk, _| obj_keys.index(kk) }.to_h
+    class PipelineObjects < PipelineBaseObjects
+      def self.create(api_res)
+        objs = api_res.map(&:to_h).sort_by { |obj| obj[:id] }.map do |obj|
+          base = { id: obj[:id], name: obj[:name] }
+          obj[:fields].sort_by { |f| f[:key] }.inject(base) do |a, e|
+            a.update(e[:key].to_sym => (e[:string_value] || { ref: e[:ref_value] } ))
+          end
+        end
+        new(objs)
+      end
+
+      def to_api_opts
+        @objs.map do |obj|
+          base = { id: obj[:id], name: obj[:name], fields: [] }
+          obj.each do |k, v|
+            next if k == :id || k == :name
+            if v.is_a?(Hash) && v.key?(:ref)
+              base[:fields] << { key: k, ref_value: v[:ref] }
+            else
+              base[:fields] << { key: k, string_value: v }
+            end
+          end
+          base
         end
       end
-      d
     end
 
-    def stringify_keys(val)
-      modify_keys_recursively(val, __method__)
+    class ParameterObjects < PipelineBaseObjects
+      def self.create(api_res)
+        objs = api_res.map(&:to_h).sort_by { |obj| obj[:id] }.map do |obj|
+          base = { id: obj[:id] }
+          obj[:attributes].sort_by { |a| a[:key] }.inject(base) do |a, e|
+            a.update(e[:key].to_sym => e[:string_value])
+          end
+        end
+        new(objs)
+      end
+
+      def to_api_opts
+        @objs.map do |obj|
+          base = { id: obj[:id], attributes: [] }
+          obj.each do |k, v|
+            next if k == :id
+            base[:attributes] << { key: k, string_value: v }
+          end
+          base
+        end
+      end
     end
 
-    def symbolize_keys(val)
-      modify_keys_recursively(val, __method__)
+    class ParameterValues < PipelineBaseObjects
+      def self.create(api_res)
+        objs = (api_res || []).sort_by { |obj| [obj[:id], obj[:string_value]] }.map do |obj|
+          { obj[:id].to_sym => obj[:string_value] }
+        end
+        new(objs)
+      end
+
+      def to_api_opts
+        @objs.map do |e|
+          e.map do |k, v|
+            { id: k, string_value: v }
+          end
+        end.flatten
+      end
     end
 
-    def modify_keys_recursively(val, method)
-      return val unless val.is_a?(Hash)
-      h = Hashie.send(method, val.to_h)
-      h.each do |k, v|
-        case v
-        when Array then h[k].map! { |e| self.send(method, e) }
-        when Hash then h[k] = self.send(method, v)
+    class PipelineDescription < PipelineBaseObjects
+      def self.create(api_res)
+        objs = {
+          pipeline_id: api_res[:pipeline_id],
+          name: api_res[:name],
+          description: api_res[:description],
+        }
+        objs[:tags] = api_res[:tags].map { |e| { e[:key].to_sym => e[:value] } }
+        api_res[:fields].inject(objs) do |a, e|
+          a.update(e[:key].to_sym => (e[:string_value] || { ref: e[:ref_value] } ))
         end
+        new(objs)
+      end
+
+      def to_objs
+        keys = %i(name description tags uniqueId)
+        stringify_keys(@objs.select { |k, _| keys.include?(k) })
+      end
+
+      def tags
+        @objs[:tags]
+      end
+
+      def tags_opts
+        @objs[:tags].map { |e| e.map { |k, v| { key: k, value: v } } }.flatten
+      end
+
+      def tag_keys
+        @objs[:tags].map(&keys).flatten
       end
-      h
     end
   end
 end

data/lib/pipe_fitter/version.rb

@@ -1,3 +1,3 @@
 module PipeFitter
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe_fitter
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - masa21kik
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-05 00:00:00.000000000 Z
+date: 2016-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk