artisan-memory-repository 0.0.1

data/lib/artisan-memory-repository/artisan_memory_repository.rb

@@ -0,0 +1,42 @@
+require 'artisan-memory-repository/story_repository'
+require 'artisan-memory-repository/project_repository'
+require 'artisan-memory-repository/iteration_repository'
+require 'artisan-memory-repository/user_repository'
+require 'artisan-memory-repository/future_user_repository'
+require 'artisan-memory-repository/project_configuration_repository'
+require 'artisan-memory-repository/change_repository'
+require 'artisan-memory-repository/member_repository'
+
+module ArtisanMemoryRepository
+  def self.story
+    @story_repo ||= StoryRepository.new
+  end
+
+  def self.project
+    @project_repo ||= ProjectRepository.new
+  end
+
+  def self.iteration
+    @iteration_repo ||= IterationRepository.new
+  end
+
+  def self.user
+    @user_repo ||= UserRepository.new
+  end
+
+  def self.future_user
+    @future_user_repo ||= FutureUserRepository.new
+  end
+
+  def self.project_configuration
+    @project_config_repo ||= ProjectConfigurationRepository.new
+  end
+
+  def self.member
+    @member_repo ||= MemberRepository.new
+  end
+  
+  def self.change
+    @change ||= ChangeRepository.new
+  end
+end

data/lib/artisan-memory-repository/base_repository.rb

@@ -0,0 +1,57 @@
+module ArtisanMemoryRepository
+
+  module BaseRepository
+    def save(object)
+      clone = object.dup
+
+      if clone.id
+        records[clone.id] = clone
+      else
+        clone.id = records.size + 1
+        records[clone.id] = clone
+      end
+
+      return clone
+    end
+
+    #def create!(attrs = {})
+    #  project = model_class.new(attrs)
+    #  self.save(project)
+    #end
+
+    def create(attrs = {})
+      project = model_class.new(attrs)
+      self.save(project)
+    end
+
+    def find(id)
+      record = records[id.to_i]
+      raise Artisan::RecordNotFound unless record
+      record
+    end
+
+    def find_each(&block)
+      records.each do |id, model|
+        block.call(model)
+      end
+    end
+
+    def delete(id)
+      records.delete(id)
+    end
+
+    def destroy_all
+      @records = {}
+    end
+
+    def records
+      @records ||= {}
+    end
+
+    def where(attributes)
+      records.values.select do |record|
+        attributes.all? { |key, value| record.send(key) == value }
+      end
+    end
+  end
+end

data/lib/artisan-memory-repository/change_repository.rb

@@ -0,0 +1,31 @@
+require 'artisan-memory-repository/base_repository'
+require 'artisan-memory-repository/models/change'
+
+module ArtisanMemoryRepository
+  class ChangeRepository
+    include BaseRepository
+    
+    def model_class
+      ArtisanMemoryRepository::Change
+    end
+    
+    def create_project_change(attributes = {})
+      create(attributes.merge({:type => "ProjectChange"}))
+    end
+    
+    def create_iteration_change(attributes = {})
+      create(attributes.merge({:type => "IterationChange"}))
+    end
+    
+    
+    def create_story_change(attributes = {})
+      create(attributes.merge({:type => "StoryChange"}))
+    end
+    
+    
+    def find_all_by_project_id(project_id)
+      records.values.find_all {|r| r.project_id == project_id}.sort_by(&:created_at).reverse
+    end
+    
+  end
+end

data/lib/artisan-memory-repository/future_user_repository.rb

@@ -0,0 +1,39 @@
+require 'artisan-memory-repository/models/future_user'
+require 'artisan-memory-repository/base_repository'
+
+module ArtisanMemoryRepository
+  class FutureUserRepository
+    include BaseRepository
+
+    def new(attrs = {})
+      ArtisanMemoryRepository::FutureUser.new(attrs)
+    end
+
+    def create(attrs = {})
+      future_user = new(attrs)
+      unique_email = validate_unique_email(attrs[:email])
+      if unique_email
+        save(future_user)
+      else
+        future_user.add_errors(:email => "This email has already been taken")
+        raise ArgumentError.new('The record has errors.')
+      end
+      future_user
+    end
+
+    def find_by_email(email)
+      records.values.find { |r| r.email == email }
+    end
+
+    def find_by_project_id(project_id)
+      records.values.find { |r| r.project_id == project_id }
+    end
+
+    private
+
+    def validate_unique_email(email)
+      return false if email.nil?
+      !records.values.any? { |r| r.email == email }
+    end
+  end
+end

data/lib/artisan-memory-repository/iteration_repository.rb

@@ -0,0 +1,36 @@
+require 'artisan-memory-repository/base_repository'
+require 'artisan-memory-repository/models/iteration'
+
+module ArtisanMemoryRepository
+  class IterationRepository
+    include BaseRepository
+
+    def model_class
+      ArtisanMemoryRepository::Iteration
+    end
+
+    def new(attributes = {})
+      model_class.new(attributes)
+    end
+
+    def create_for_project(project, attrs)
+      iteration = model_class.new(attrs)
+      iteration.project = project
+      project.iterations << iteration
+      save(iteration)
+    end
+
+    def find_by_number(project, number)
+      records.values.find {|r| r.project == project && r.number = number}
+    end
+
+    def by_project(project, options = {})
+      records.values.find_all {|r| r.project == project}.sort_by(&:number).reverse
+    end
+
+    def by_project_by_finish_date(project)
+      self.by_project(project).sort_by!{ |iteration| Date.parse(iteration.finish_date) }.reverse
+    end
+
+  end
+end

data/lib/artisan-memory-repository/member_repository.rb

@@ -0,0 +1,13 @@
+require 'artisan-memory-repository/models/member'
+
+module ArtisanMemoryRepository
+  class MemberRepository
+    def model_name
+      Member
+    end
+
+    def new(attributes = {})
+      model_name.new(attributes)
+    end
+  end
+end

data/lib/artisan-memory-repository/models/base.rb

@@ -0,0 +1,85 @@
+module ArtisanMemoryRepository
+  class Base
+    def initialize(options = {})
+      self.class._collections.each {|field| set(field, [])}
+      options.each { |key, value| set(key, value) }
+      set(:id, random_int) if saves?
+      self.init
+    end
+
+    def init; end
+
+    def self.data_attributes(*fields)
+      @_fields = fields
+      (fields + [:id, :saves]).each {|field| attr_accessor field }
+    end
+
+    def self._fields
+      @_fields ||= []
+    end
+
+    def self.boolean(*fields)
+      (fields).each do |field|
+        define_method("#{field}?".to_sym) { !!get(field) }
+      end
+    end
+
+    def self.collections(*collections)
+      @_collections = collections
+      collections.each do |collection|
+        attr_accessor collection
+      end
+    end
+
+    def self._collections
+      @_collections ||= []
+    end
+
+    def saves?
+      get(:saves).nil? ? true : !!get(:saves)
+    end
+
+    def get(key)
+      instance_variable_get("@#{key}")
+    end
+
+    def set(key, value)
+      instance_variable_set("@#{key}", value)
+    end
+
+    def attributes
+      self.class._fields.inject({}) do |attributes, key|
+        attributes[key] = get(key)
+        attributes
+      end
+    end
+
+    alias :update_attribute :set
+
+    def update_attributes(options = {})
+      return false unless saves?
+      return attributes if options.nil?
+      options.each { |key, value| set(key, value) }
+    end
+
+    alias :update_attributes! :update_attributes
+
+    def ==(other)
+      return false if other.nil?
+      return false if other.class != self.class
+      self.class._fields.each do |attr|
+        return false if self.send(attr) != other.send(attr)
+      end
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    private
+
+    def random_int
+      return (Time.now.to_i + rand(1000))
+    end
+  end
+end

data/lib/artisan-memory-repository/models/change.rb

@@ -0,0 +1,15 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class Change < Base
+    data_attributes :type, 
+                    :source_id, 
+                    :user_id, 
+                    :event, 
+                    :project_id, 
+                    :created_at,
+                    :original_fields,
+                    :changed_fields
+                    
+  end
+end

data/lib/artisan-memory-repository/models/future_user.rb

@@ -0,0 +1,21 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class FutureUser < Base
+    data_attributes :id, :email, :project_id, :login
+
+    attr_reader :errors
+
+    def init
+      @errors = {}
+    end
+
+    def add_errors(errors_hash)
+      errors_hash.each_pair do |key, value|
+        @errors[key] = @errors[key] || []
+        @errors[key] << value
+      end
+    end
+
+  end
+end

data/lib/artisan-memory-repository/models/iteration.rb

@@ -0,0 +1,24 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class Iteration < Base
+    data_attributes :completed_total,
+      :story_tags,
+      :start_date,
+      :finish_date,
+      :number,
+      :complete,
+      :completed_at,
+      :committed_points_at_completion,
+      :errors,
+      :total_billed_points,
+      :committed_points,
+      :total_points,
+      :project,
+      :days
+
+    boolean :complete
+
+    collections :stories, :users
+  end
+end

data/lib/artisan-memory-repository/models/member.rb

@@ -0,0 +1,4 @@
+module ArtisanMemoryRepository
+  class Member < Base
+  end
+end

data/lib/artisan-memory-repository/models/project.rb

@@ -0,0 +1,13 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class Project < Base
+    data_attributes :id, :name, :life_cycle, :archived, :description,
+      :api_key, :project_configuration
+
+    boolean :archived
+
+    collections :iterations, :stories, :members, :owners, :users
+
+  end
+end

data/lib/artisan-memory-repository/models/project_configuration.rb

@@ -0,0 +1,7 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class ProjectConfiguration < Base
+    data_attributes :estimate_mode
+  end
+end

data/lib/artisan-memory-repository/models/story.rb

@@ -0,0 +1,23 @@
+require "artisan-memory-repository/models/base"
+
+module ArtisanMemoryRepository
+  class Story < Base
+
+    data_attributes :assigned_user_id, :billed,
+      :complete, :completed_at, :created_at, :creator,
+      :creator_id, :deleted, :estimate, :incomplete, :name,
+      :number, :nonbillable, :optimistic, :pessimistic,
+      :position, :realistic, :standard_deviation, :tags,
+      :tag_list, :assigned_user, :iteration, :project
+
+    boolean :complete, :nonbillable, :deleted
+
+    def to_json(*args)
+      attributes.to_json
+    end
+
+    def valid?
+      true
+    end
+  end
+end

data/lib/artisan-memory-repository/models/user.rb

@@ -0,0 +1,30 @@
+require "artisan-memory-repository/models/base"
+require "active_model"
+
+module ArtisanMemoryRepository
+  class User < ArtisanMemoryRepository::Base
+    data_attributes :full_name, :projects, :members,
+      :login, :email, :gravatar_url, :password,
+      :password_confirmation
+
+    def initialize(*args)
+      @external_errors = []
+      super(*args)
+    end
+
+    include ActiveModel::Validations
+
+    validates :full_name, :presence => true
+    validates_length_of :login, :minimum => 3
+    validates_format_of :login, :with => /\A\w[\w\.+\-_@ ]+$/, :message => "should use only letters, numbers, spaces, and .-_@ please."
+
+    validate do
+      @external_errors.each { |error| errors.add *error }
+      true
+    end
+
+    def add_error(*args)
+      @external_errors << args
+    end
+  end
+end

data/lib/artisan-memory-repository/project_configuration_repository.rb

@@ -0,0 +1,15 @@
+require 'artisan-memory-repository/models/project_configuration'
+
+module ArtisanMemoryRepository
+  class ProjectConfigurationRepository
+    include BaseRepository
+
+    def model_class
+      ArtisanMemoryRepository::ProjectConfiguration
+    end
+
+    def new(attributes = {})
+      model_class.new(attributes)
+    end
+  end
+end

data/lib/artisan-memory-repository/project_repository.rb

@@ -0,0 +1,70 @@
+require 'artisan-memory-repository/base_repository'
+require 'artisan-memory-repository/models/project'
+require "artisan-memory-repository/models/project_configuration"
+
+module ArtisanMemoryRepository
+  class ProjectRepository
+    include BaseRepository
+
+    def model_class
+      ArtisanMemoryRepository::Project
+    end
+
+    def new(attributes = {})
+      model_class.new(attributes)
+    end
+
+    def order_by_name
+      records.values.sort_by { |r| r.name }
+    end
+
+    def unarchived
+      records.values.select { |r| !r.archived  }.sort_by(&:name)
+    end
+
+    def archived
+      records.values.select { |r| r.archived  }.sort_by(&:name)
+    end
+
+    def find_by_api_key(api_key)
+      records.values.find { |r| r.api_key == api_key }
+    end
+
+    def find_by_name(name)
+      records.values.find{|r| r.name == name}
+    end
+
+    def add_iteration(project, iteration)
+      project.iterations << iteration
+      project.iterations.sort! { |i| i.number }
+      iteration
+    end
+
+    def add_member(project, user, owner)
+      project.users << user
+      project.owners << user if owner
+    end
+
+    def remove_member(project, user)
+      project.users.delete(user)
+      project.owners.delete(user)
+    end
+
+    def is_member?(project, user)
+      project.users.include?(user)
+    end
+
+    def is_owner?(project, user)
+      project.owners.include?(user)
+    end
+
+    def owners(project)
+      project.owners
+    end
+
+    def create_project_configuration(project)
+      project.project_configuration = ArtisanMemoryRepository::ProjectConfiguration.new
+    end
+  end
+end
+

data/lib/artisan-memory-repository/story_repository.rb

@@ -0,0 +1,86 @@
+require 'artisan-memory-repository/base_repository'
+require 'artisan-memory-repository/models/story'
+
+module ArtisanMemoryRepository
+  class StoryRepository
+    include BaseRepository
+
+    def model_class
+      ArtisanMemoryRepository::Story
+    end
+
+    def new(attributes = {})
+      model_class.new(attributes)
+    end
+
+    def find(number, project)
+      result = records.values.find do |record|
+        record.project == project && record.number == number
+      end
+
+      raise Artisan::RecordNotFound.new if result.nil?
+      return result
+    end
+
+    def create!(attributes = {})
+      save model_class.new(attributes)
+    end
+
+    def for_user(user)
+      records.values.select{|r| r.assigned_user == user}
+    end
+
+    def by_project(project)
+      records.values.select{|r| r.project.nil? ? false : r.project.id == project.id }
+    end
+
+    def create_for_project(project, attrs = {})
+      story = create(attrs)
+      project.stories << story
+      story.project = project
+      Artisan::Repository.project.save(project)
+      story
+    end
+
+    def add_to_iteration(iteration, story)
+      iteration.stories.delete_if { |s| s.id == story.id }
+      iteration.stories << story
+      story.iteration = iteration
+      Artisan::Repository.iteration.save(iteration)
+    end
+
+    def remove_from_iteration(story)
+      iteration = story.iteration
+      story.iteration = nil
+      iteration.stories.delete_if { |s| s.id == story.id }
+    end
+
+    def delete(story)
+      deleted = records.delete(story.id)
+      deleted.deleted = true
+      deleted
+    end
+
+    def all(iteration)
+      iteration.stories
+    end
+
+    def ready(iteration)
+      iteration.stories.select{|r| r.assigned_user.nil? && !r.complete}
+    end
+
+    def working(iteration)
+      iteration.stories.select{|r| !r.assigned_user.nil? &&
+        !r.complete}
+    end
+
+    def completed(iteration)
+      iteration.stories.select(&:complete)
+    end
+
+    def backlog(project)
+      records.values.select { |r| r.iteration.nil? }
+    end
+  end
+end
+

data/lib/artisan-memory-repository/user_repository.rb

@@ -0,0 +1,44 @@
+require 'artisan-memory-repository/models/user'
+require 'artisan-memory-repository/base_repository'
+
+module ArtisanMemoryRepository
+  class UserRepository
+    include BaseRepository
+
+    def new(attrs = {})
+      ArtisanMemoryRepository::User.new(attrs)
+    end
+
+    def create(attrs = {})
+      user = new(attrs)
+      if !existing_login?(user.login) && user.valid?
+        save(user)
+      else
+        user.add_error(:login, 'has already been taken')
+        raise ArgumentError.new('The record has errors.')
+      end
+      user
+    end
+
+    def find_by_email(email)
+      records.values.find { |r| r.email == email  }
+    end
+
+    def find_by_login(login)
+      return nil if login.nil?
+      records.values.find { |r| r.login.downcase == login.downcase  }
+    end
+
+    def active_stories_for(user)
+      story_repository = Artisan::Repository.story
+      stories = story_repository.for_user(user)
+      stories.reject { |story| story.complete }
+    end
+
+    private
+
+    def existing_login?(login)
+      !find_by_login(login).nil?
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: artisan-memory-repository
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- 8th Light Craftsmen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-10 00:00:00 Z
+dependencies: []
+
+description: An interface to the Artisan in memory persistance layer
+email: paul@8thlight.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/artisan-memory-repository/artisan_memory_repository.rb
+- lib/artisan-memory-repository/base_repository.rb
+- lib/artisan-memory-repository/change_repository.rb
+- lib/artisan-memory-repository/future_user_repository.rb
+- lib/artisan-memory-repository/iteration_repository.rb
+- lib/artisan-memory-repository/member_repository.rb
+- lib/artisan-memory-repository/models/base.rb
+- lib/artisan-memory-repository/models/change.rb
+- lib/artisan-memory-repository/models/future_user.rb
+- lib/artisan-memory-repository/models/iteration.rb
+- lib/artisan-memory-repository/models/member.rb
+- lib/artisan-memory-repository/models/project.rb
+- lib/artisan-memory-repository/models/project_configuration.rb
+- lib/artisan-memory-repository/models/story.rb
+- lib/artisan-memory-repository/models/user.rb
+- lib/artisan-memory-repository/project_configuration_repository.rb
+- lib/artisan-memory-repository/project_repository.rb
+- lib/artisan-memory-repository/story_repository.rb
+- lib/artisan-memory-repository/user_repository.rb
+homepage: http://8thlight.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 4406370865731914395
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Artisan Memory Repository
+test_files: []
+