sprig 0.1.0

data/lib/sprig/helpers.rb

@@ -0,0 +1,25 @@
+module Sprig
+  module Helpers
+    def seed_directory
+      Sprig.configuration.directory
+    end
+
+    def sprig_environment
+      Rails.env #TODO: make customizable
+    end
+
+    def sprig(directive_definitions)
+      hopper = []
+      DirectiveList.new(directive_definitions).add_seeds_to_hopper(hopper)
+      Planter.new(hopper).sprig
+    end
+
+    def sprig_record(klass, seed_id)
+      SprigRecordStore.instance.get(klass, seed_id)
+    end
+
+    def sprig_file(relative_path)
+      File.new(seed_directory.join('files', relative_path))
+    end
+  end
+end

data/lib/sprig/parser.rb

@@ -0,0 +1,9 @@
+module Sprig
+  module Parser
+    autoload :Base,                  'sprig/parser/base'
+    autoload :Csv,                   'sprig/parser/csv'
+    autoload :Json,                  'sprig/parser/json'
+    autoload :Yml,                   'sprig/parser/yml'
+    autoload :GoogleSpreadsheetJson, 'sprig/parser/google_spreadsheet_json'
+  end
+end

data/lib/sprig/parser/base.rb

@@ -0,0 +1,15 @@
+module Sprig
+  module Parser
+    class Base
+      attr_reader :data_io
+
+      def initialize(data_io)
+        @data_io = data_io
+      end
+
+      def parse
+        raise NotImplementedError, 'Parsers must implement #parse'
+      end
+    end
+  end
+end

data/lib/sprig/parser/csv.rb

@@ -0,0 +1,22 @@
+require 'csv'
+
+module Sprig
+  module Parser
+    class Csv < Base
+
+      def parse
+        { :records => records }
+      end
+
+      private
+
+      def records
+        [].tap do |records|
+          CSV.foreach(data_io, headers: :first_row, skip_blanks: true) do |row|
+            records << row.to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprig/parser/google_spreadsheet_json.rb

@@ -0,0 +1,35 @@
+module Sprig
+  module Parser
+    class GoogleSpreadsheetJson < Base
+
+      def parse
+        { :records => records }
+      end
+
+      private
+
+      def records
+        @records ||= raw_records.map { |record| build_record(record) }
+      end
+
+      def build_record(record)
+        hash = {}
+
+        record.keys.each do |key|
+          attr_name = key.tr('-', '_').scan(/gsx\$([a-z_]+$)/).flatten.first
+          hash[attr_name] = record[key]['$t'] if attr_name
+        end
+
+        hash
+      end
+
+      def raw_records
+        json['feed']['entry']
+      end
+
+      def json
+        @json ||= JSON.load(data_io)
+      end
+    end
+  end
+end

data/lib/sprig/parser/json.rb

@@ -0,0 +1,9 @@
+module Sprig
+  module Parser
+    class Json < Base
+      def parse
+        JSON.load(data_io)
+      end
+    end
+  end
+end

data/lib/sprig/parser/yml.rb

@@ -0,0 +1,9 @@
+module Sprig
+  module Parser
+    class Yml < Base
+      def parse
+        YAML.load(data_io)
+      end
+    end
+  end
+end

data/lib/sprig/planter.rb

@@ -0,0 +1,39 @@
+module Sprig
+  class Planter
+    def initialize(seeds)
+      @seeds = seeds.to_a
+    end
+
+    def sprig
+      dependency_sorted_seeds.each do |seed|
+        plant(seed)
+      end
+
+      logger.log_summary
+    end
+
+    private
+
+    attr_reader :seeds
+
+    def dependency_sorted_seeds
+      DependencySorter.new(seeds).sorted_items
+    end
+
+    def logger
+      @logger ||= SprigLogger.new
+    end
+
+    def plant(seed)
+      logger.processing
+      seed.before_save
+
+      if seed.save_record
+        seed.save_to_store
+        logger.log_success(seed)
+      else
+        logger.log_error(seed)
+      end
+    end
+  end
+end

data/lib/sprig/seed.rb

@@ -0,0 +1,9 @@
+module Sprig
+  module Seed
+    autoload :Attribute,            'sprig/seed/attribute'
+    autoload :AttributeCollection,  'sprig/seed/attribute_collection'
+    autoload :Entry,                'sprig/seed/entry'
+    autoload :Factory,              'sprig/seed/factory'
+    autoload :Record,               'sprig/seed/record'
+  end
+end

data/lib/sprig/seed/attribute.rb

@@ -0,0 +1,54 @@
+module Sprig
+  module Seed
+    class Attribute
+      attr_reader :name, :raw_value, :value
+
+      def initialize(name, raw_value)
+        @name = name.to_s
+        @raw_value = raw_value
+      end
+
+      def dependencies
+        @dependencies ||= determine_dependencies.uniq
+      end
+
+      def value
+        compute_value if @value.nil?
+
+        @value
+      end
+
+      private
+
+      def determine_dependencies
+        if computed_value?
+          matches = raw_value.scan(/(sprig_record\(([A-Z][^,]*), ([\d]*)\))+/)
+          matches.map {|match| Dependency.for(match[1], match[2]) }
+        else
+          []
+        end
+      end
+
+      def string?
+        raw_value.is_a?(String)
+      end
+
+      def computed_value?
+        string? && raw_value =~ computed_value_regex
+      end
+
+      def computed_value_regex
+        /<%[=]?(.*)%>/
+      end
+
+      def compute_value
+        @value = if computed_value?
+          matches = computed_value_regex.match(raw_value)
+          eval(matches[1])
+        else
+          raw_value
+        end
+      end
+    end
+  end
+end

data/lib/sprig/seed/attribute_collection.rb

@@ -0,0 +1,33 @@
+module Sprig
+  module Seed
+    class AttributeCollection
+      include Enumerable
+
+      delegate :each, :to => :attributes
+
+      def initialize(attrs_hash)
+        @attrs_hash = attrs_hash.to_hash
+      end
+
+      def find_by_name(name)
+        attributes.detect {|attribute| attribute.name == name.to_s } || attribute_not_found(name)
+      end
+
+      private
+
+      attr_reader :attrs_hash
+
+      class AttributeNotFoundError < StandardError; end
+
+      def attributes
+        @attributes ||= attrs_hash.map do |name, value|
+          Attribute.new(name, value)
+        end
+      end
+
+      def attribute_not_found(name)
+        raise AttributeNotFoundError, "Attribute '#{name}' is not present."
+      end
+    end
+  end
+end

data/lib/sprig/seed/entry.rb

@@ -0,0 +1,80 @@
+module Sprig
+  module Seed
+    class Entry
+      def initialize(klass, attrs, options)
+        self.klass = klass
+        attrs = attrs.to_hash.with_indifferent_access
+        self.sprig_id = attrs.delete(:sprig_id) || SecureRandom.uuid
+        @attributes = AttributeCollection.new(attrs)
+        @options = options
+      end
+
+      def dependencies
+        @dependencies ||= attributes.map do |attribute|
+          attribute.dependencies
+        end.flatten.uniq
+      end
+
+      def dependency_id
+        @dependency_id ||= Dependency.for(klass, sprig_id).id
+      end
+
+      def before_save
+        # TODO: make these filters take chains like rails before_filters
+        if options[:delete_existing_by]
+          klass.delete_all(options[:delete_existing_by] => attributes.find_by_name(options[:delete_existing_by]).value)
+        end
+      end
+
+      def save_record
+        record.save
+      end
+
+      def save_to_store
+        SprigRecordStore.instance.save(record.orm_record, sprig_id)
+      end
+
+      def success_log_text
+        "#{klass.name} with sprig_id #{sprig_id} successfully saved."
+      end
+
+      def error_log_text
+        "There was an error saving #{klass.name} with sprig_id #{sprig_id}."
+      end
+
+      def record
+        @record ||= new_or_existing_record
+      end
+
+      private
+
+      attr_reader :attributes, :klass, :options, :sprig_id
+
+      def klass=(klass)
+        raise ArgumentError, 'First argument must be a Class' unless klass.is_a?(Class)
+
+        @klass = klass
+      end
+
+      def sprig_id=(sprig_id)
+        @sprig_id = sprig_id.to_s
+      end
+
+      def new_or_existing_record
+        if options[:find_existing_by]
+          Record.new_or_existing(klass, attributes, find_existing_params)
+        else
+          Record.new(klass, attributes)
+        end
+      end
+
+      def find_existing_params
+        Array(options[:find_existing_by]).inject({}) do |hash, attribute_name|
+          hash.merge!(
+            { attribute_name => attributes.find_by_name(attribute_name).value }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sprig/seed/factory.rb

@@ -0,0 +1,56 @@
+module Sprig
+  module Seed
+    class Factory
+      def self.new_from_directive(directive)
+        raise ArgumentError, 'Must provide a Directive' unless directive.is_a? Directive
+
+        klass      = directive.klass
+        datasource = directive.datasource
+        options    = directive.options
+
+        new(klass, datasource, options)
+      end
+
+      def initialize(klass, datasource, options)
+        self.klass             = klass
+        self.datasource        = datasource
+        self.initial_options   = options
+      end
+
+      def add_seeds_to_hopper(hopper)
+        datasource.records.each do |record_data|
+          hopper << Entry.new(klass, record_data, options)
+        end
+      end
+
+      private
+
+      attr_reader :datasource, :initial_options, :klass
+
+      def klass=(klass)
+        raise ArgumentError, 'Must provide a Class as first argument' unless klass.is_a? Class
+
+        @klass = klass
+      end
+
+      def datasource=(datasource)
+        raise ArgumentError, 'Datasource must respond to #records and #options' unless datasource.respond_to?(:records) && datasource.respond_to?(:options)
+
+        @datasource = datasource
+      end
+
+      def initial_options=(initial_options)
+        initial_options ||= {}
+        @initial_options = initial_options.to_hash
+      end
+
+      def options
+        @options ||= datasource.options.merge(initial_options)
+      end
+
+      def data
+        @data ||= datasource.to_hash
+      end
+    end
+  end
+end

data/lib/sprig/seed/record.rb

@@ -0,0 +1,35 @@
+module Sprig
+  module Seed
+    class Record
+      attr_reader :orm_record
+
+      delegate :errors, :to => :orm_record
+
+      def self.new_or_existing(klass, attributes, find_params)
+        orm_record = klass.where(find_params).first
+        new(klass, attributes, orm_record)
+      end
+
+      def initialize(klass, attributes, orm_record = nil)
+        @klass = klass
+        @attributes = attributes
+        @orm_record = orm_record || klass.new
+      end
+
+      def save
+        populate_attributes
+        orm_record.save
+      end
+
+      private
+
+      attr_reader :attributes, :klass
+
+      def populate_attributes
+        attributes.each do |attribute|
+          orm_record.send(:"#{attribute.name}=", attribute.value)
+        end
+      end
+    end
+  end
+end